X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSMESH_SWIG%2FsmeshDC.py;h=49235f848589fa6f4c2cb912e51288e75796e61d;hb=0f85ac62f79aa38648f03cf4155baece51fbf14c;hp=54adbb7d268202b77cf5772f6356ee595e92459a;hpb=1eedac41d2618ae1cda842b043ed760252ebc499;p=modules%2Fsmesh.git diff --git a/src/SMESH_SWIG/smeshDC.py b/src/SMESH_SWIG/smeshDC.py index 54adbb7d2..49235f848 100644 --- a/src/SMESH_SWIG/smeshDC.py +++ b/src/SMESH_SWIG/smeshDC.py @@ -1,4 +1,4 @@ -# Copyright (C) 2007-2011 CEA/DEN, EDF R&D, OPEN CASCADE +# Copyright (C) 2007-2013 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 @@ -20,10 +20,8 @@ # Author : Francis KLOSS, OCC # Module : SMESH -""" - \namespace smesh - \brief Module smesh -""" +## @package smesh +# Python API for SALOME %Mesh module ## @defgroup l1_auxiliary Auxiliary methods and structures ## @defgroup l1_creating Creating meshes @@ -44,10 +42,6 @@ ## @defgroup l3_hypos_1dhyps 1D Meshing Hypotheses ## @defgroup l3_hypos_2dhyps 2D Meshing Hypotheses ## @defgroup l3_hypos_maxvol Max Element Volume hypothesis -## @defgroup l3_hypos_netgen Netgen 2D and 3D hypotheses -## @defgroup l3_hypos_ghs3dh GHS3D Parameters hypothesis -## @defgroup l3_hypos_blsurf BLSURF Parameters hypothesis -## @defgroup l3_hypos_hexotic Hexotic Parameters hypothesis ## @defgroup l3_hypos_quad Quadrangle Parameters hypothesis ## @defgroup l3_hypos_additi Additional Hypotheses @@ -93,77 +87,14 @@ import geompyDC import SMESH # This is necessary for back compatibility from SMESH import * - -import StdMeshers +from smesh_algorithm import Mesh_Algorithm import SALOME import SALOMEDS -# import NETGENPlugin module if possible -noNETGENPlugin = 0 -try: - import NETGENPlugin -except ImportError: - noNETGENPlugin = 1 - pass - -# import GHS3DPlugin module if possible -noGHS3DPlugin = 0 -try: - import GHS3DPlugin -except ImportError: - noGHS3DPlugin = 1 - pass - -# import GHS3DPRLPlugin module if possible -noGHS3DPRLPlugin = 0 -try: - import GHS3DPRLPlugin -except ImportError: - noGHS3DPRLPlugin = 1 - pass - -# import HexoticPlugin module if possible -noHexoticPlugin = 0 -try: - import HexoticPlugin -except ImportError: - noHexoticPlugin = 1 - pass - -# import BLSURFPlugin module if possible -noBLSURFPlugin = 0 -try: - import BLSURFPlugin -except ImportError: - noBLSURFPlugin = 1 - pass - ## @addtogroup l1_auxiliary ## @{ -# Types of algorithms -REGULAR = 1 -PYTHON = 2 -COMPOSITE = 3 -SOLE = 0 -SIMPLE = 1 - -MEFISTO = 3 -NETGEN = 4 -GHS3D = 5 -FULL_NETGEN = 6 -NETGEN_2D = 7 -NETGEN_1D2D = NETGEN -NETGEN_1D2D3D = FULL_NETGEN -NETGEN_FULL = FULL_NETGEN -Hexa = 8 -Hexotic = 9 -BLSURF = 10 -GHS3DPRL = 11 -QUADRANGLE = 0 -RADIAL_QUAD = 1 - # MirrorType enumeration POINT = SMESH_MeshEditor.POINT AXIS = SMESH_MeshEditor.AXIS @@ -173,26 +104,6 @@ PLANE = SMESH_MeshEditor.PLANE LAPLACIAN_SMOOTH = SMESH_MeshEditor.LAPLACIAN_SMOOTH CENTROIDAL_SMOOTH = SMESH_MeshEditor.CENTROIDAL_SMOOTH -# Fineness enumeration (for NETGEN) -VeryCoarse = 0 -Coarse = 1 -Moderate = 2 -Fine = 3 -VeryFine = 4 -Custom = 5 - -# Optimization level of GHS3D -# V3.1 -None_Optimization, Light_Optimization, Medium_Optimization, Strong_Optimization = 0,1,2,3 -# V4.1 (partialy redefines V3.1). Issue 0020574 -None_Optimization, Light_Optimization, Standard_Optimization, StandardPlus_Optimization, Strong_Optimization = 0,1,2,3,4 - -# Topology treatment way of BLSURF -FromCAD, PreProcess, PreProcessPlus, PreCAD = 0,1,2,3 - -# Element size flag of BLSURF -DefaultSize, DefaultGeom, BLSURF_Custom, SizeMap = 0,0,1,2 - PrecisionConfusion = 1e-07 # TopAbs_State enumeration @@ -201,196 +112,65 @@ PrecisionConfusion = 1e-07 # Methods of splitting a hexahedron into tetrahedra Hex_5Tet, Hex_6Tet, Hex_24Tet = 1, 2, 3 -# import items of enum QuadType -for e in StdMeshers.QuadType._items: exec('%s = StdMeshers.%s'%(e,e)) - ## Converts an angle from degrees to radians def DegreesToRadians(AngleInDegrees): from math import pi return AngleInDegrees * pi / 180.0 +import salome_notebook +notebook = salome_notebook.notebook # Salome notebook variable separator var_separator = ":" -# Parametrized substitute for PointStruct -class PointStructStr: - - x = 0 - y = 0 - z = 0 - xStr = "" - yStr = "" - zStr = "" - - def __init__(self, xStr, yStr, zStr): - self.xStr = xStr - self.yStr = yStr - self.zStr = zStr - if isinstance(xStr, str) and notebook.isVariable(xStr): - self.x = notebook.get(xStr) - else: - self.x = xStr - if isinstance(yStr, str) and notebook.isVariable(yStr): - self.y = notebook.get(yStr) - else: - self.y = yStr - if isinstance(zStr, str) and notebook.isVariable(zStr): - self.z = notebook.get(zStr) - else: - self.z = zStr - -# Parametrized substitute for PointStruct (with 6 parameters) -class PointStructStr6: - - x1 = 0 - y1 = 0 - z1 = 0 - x2 = 0 - y2 = 0 - z2 = 0 - xStr1 = "" - yStr1 = "" - zStr1 = "" - xStr2 = "" - yStr2 = "" - zStr2 = "" - - def __init__(self, x1Str, x2Str, y1Str, y2Str, z1Str, z2Str): - self.x1Str = x1Str - self.x2Str = x2Str - self.y1Str = y1Str - self.y2Str = y2Str - self.z1Str = z1Str - self.z2Str = z2Str - if isinstance(x1Str, str) and notebook.isVariable(x1Str): - self.x1 = notebook.get(x1Str) - else: - self.x1 = x1Str - if isinstance(x2Str, str) and notebook.isVariable(x2Str): - self.x2 = notebook.get(x2Str) - else: - self.x2 = x2Str - if isinstance(y1Str, str) and notebook.isVariable(y1Str): - self.y1 = notebook.get(y1Str) - else: - self.y1 = y1Str - if isinstance(y2Str, str) and notebook.isVariable(y2Str): - self.y2 = notebook.get(y2Str) - else: - self.y2 = y2Str - if isinstance(z1Str, str) and notebook.isVariable(z1Str): - self.z1 = notebook.get(z1Str) - else: - self.z1 = z1Str - if isinstance(z2Str, str) and notebook.isVariable(z2Str): - self.z2 = notebook.get(z2Str) - else: - self.z2 = z2Str - -# Parametrized substitute for AxisStruct -class AxisStructStr: - - x = 0 - y = 0 - z = 0 - dx = 0 - dy = 0 - dz = 0 - xStr = "" - yStr = "" - zStr = "" - dxStr = "" - dyStr = "" - dzStr = "" - - def __init__(self, xStr, yStr, zStr, dxStr, dyStr, dzStr): - self.xStr = xStr - self.yStr = yStr - self.zStr = zStr - self.dxStr = dxStr - self.dyStr = dyStr - self.dzStr = dzStr - if isinstance(xStr, str) and notebook.isVariable(xStr): - self.x = notebook.get(xStr) - else: - self.x = xStr - if isinstance(yStr, str) and notebook.isVariable(yStr): - self.y = notebook.get(yStr) - else: - self.y = yStr - if isinstance(zStr, str) and notebook.isVariable(zStr): - self.z = notebook.get(zStr) - else: - self.z = zStr - if isinstance(dxStr, str) and notebook.isVariable(dxStr): - self.dx = notebook.get(dxStr) - else: - self.dx = dxStr - if isinstance(dyStr, str) and notebook.isVariable(dyStr): - self.dy = notebook.get(dyStr) - else: - self.dy = dyStr - if isinstance(dzStr, str) and notebook.isVariable(dzStr): - self.dz = notebook.get(dzStr) - else: - self.dz = dzStr - -# Parametrized substitute for DirStruct -class DirStructStr: - - def __init__(self, pointStruct): - self.pointStruct = pointStruct - -# Returns list of variable values from salome notebook -def ParsePointStruct(Point): - Parameters = 2*var_separator - if isinstance(Point, PointStructStr): - Parameters = str(Point.xStr) + var_separator + str(Point.yStr) + var_separator + str(Point.zStr) - Point = PointStruct(Point.x, Point.y, Point.z) - return Point, Parameters - -# Returns list of variable values from salome notebook -def ParseDirStruct(Dir): - Parameters = 2*var_separator - if isinstance(Dir, DirStructStr): - pntStr = Dir.pointStruct - if isinstance(pntStr, PointStructStr6): - Parameters = str(pntStr.x1Str) + var_separator + str(pntStr.x2Str) + var_separator - Parameters += str(pntStr.y1Str) + var_separator + str(pntStr.y2Str) + var_separator - Parameters += str(pntStr.z1Str) + var_separator + str(pntStr.z2Str) - Point = PointStruct(pntStr.x2 - pntStr.x1, pntStr.y2 - pntStr.y1, pntStr.z2 - pntStr.z1) - else: - Parameters = str(pntStr.xStr) + var_separator + str(pntStr.yStr) + var_separator + str(pntStr.zStr) - Point = PointStruct(pntStr.x, pntStr.y, pntStr.z) - Dir = DirStruct(Point) - return Dir, Parameters - -# Returns list of variable values from salome notebook -def ParseAxisStruct(Axis): - Parameters = 5*var_separator - if isinstance(Axis, AxisStructStr): - Parameters = str(Axis.xStr) + var_separator + str(Axis.yStr) + var_separator + str(Axis.zStr) + var_separator - Parameters += str(Axis.dxStr) + var_separator + str(Axis.dyStr) + var_separator + str(Axis.dzStr) - Axis = AxisStruct(Axis.x, Axis.y, Axis.z, Axis.dx, Axis.dy, Axis.dz) - return Axis, Parameters - -## Return list of variable values from salome notebook -def ParseAngles(list): +## Return list of variable values from salome notebook. +# The last argument, if is callable, is used to modify values got from notebook +def ParseParameters(*args): Result = [] Parameters = "" - for parameter in list: - if isinstance(parameter,str) and notebook.isVariable(parameter): - Result.append(DegreesToRadians(notebook.get(parameter))) - pass - else: - Result.append(parameter) + hasVariables = False + varModifFun=None + if args and callable( args[-1] ): + args, varModifFun = args[:-1], args[-1] + for parameter in args: + + Parameters += str(parameter) + var_separator + + if isinstance(parameter,str): + # check if there is an inexistent variable name + if not notebook.isVariable(parameter): + raise ValueError, "Variable with name '" + parameter + "' doesn't exist!!!" + parameter = notebook.get(parameter) + hasVariables = True + if varModifFun: + parameter = varModifFun(parameter) + pass pass + Result.append(parameter) - Parameters = Parameters + str(parameter) - Parameters = Parameters + var_separator pass - Parameters = Parameters[:len(Parameters)-1] - return Result, Parameters + Parameters = Parameters[:-1] + Result.append( Parameters ) + Result.append( hasVariables ) + return Result + +# Parse parameters converting variables to radians +def ParseAngles(*args): + return ParseParameters( *( args + (DegreesToRadians, ))) + +# Substitute PointStruct.__init__() to create SMESH.PointStruct using notebook variables. +# Parameters are stored in PointStruct.parameters attribute +def __initPointStruct(point,*args): + point.x, point.y, point.z, point.parameters,hasVars = ParseParameters(*args) + pass +SMESH.PointStruct.__init__ = __initPointStruct + +# Substitute AxisStruct.__init__() to create SMESH.AxisStruct using notebook variables. +# Parameters are stored in AxisStruct.parameters attribute +def __initAxisStruct(ax,*args): + ax.x, ax.y, ax.z, ax.vx, ax.vy, ax.vz, ax.parameters,hasVars = ParseParameters(*args) + pass +SMESH.AxisStruct.__init__ = __initAxisStruct + def IsEqual(val1, val2, tol=PrecisionConfusion): if abs(val1 - val2) < tol: @@ -406,7 +186,10 @@ def GetName(obj): if isinstance(obj, SALOMEDS._objref_SObject): # study object return obj.GetName() - ior = salome.orb.object_to_string(obj) + try: + ior = salome.orb.object_to_string(obj) + except: + ior = None if ior: # CORBA object studies = salome.myStudyManager.GetOpenStudies() @@ -450,7 +233,7 @@ def TreatHypoStatus(status, hypName, geomName, isAlgo): elif status == HYP_CONCURENT : reason = "there are concurrent hypotheses on sub-shapes" elif status == HYP_BAD_SUBSHAPE : - reason = "the shape is neither the main one, nor its subshape, nor a valid group" + reason = "the shape is neither the main one, nor its sub-shape, nor a valid group" elif status == HYP_BAD_GEOMETRY: reason = "geometry mismatches the expectation of the algorithm" elif status == HYP_HIDDEN_ALGO: @@ -471,30 +254,12 @@ def TreatHypoStatus(status, hypName, geomName, isAlgo): print hypName, "was not assigned:", reason pass -## Check meshing plugin availability -def CheckPlugin(plugin): - if plugin == NETGEN and noNETGENPlugin: - print "Warning: NETGENPlugin module unavailable" - return False - elif plugin == GHS3D and noGHS3DPlugin: - print "Warning: GHS3DPlugin module unavailable" - return False - elif plugin == GHS3DPRL and noGHS3DPRLPlugin: - print "Warning: GHS3DPRLPlugin module unavailable" - return False - elif plugin == Hexotic and noHexoticPlugin: - print "Warning: HexoticPlugin module unavailable" - return False - elif plugin == BLSURF and noBLSURFPlugin: - print "Warning: BLSURFPlugin module unavailable" - return False - return True - ## Private method. Add geom (sub-shape of the main shape) into the study if not yet there def AssureGeomPublished(mesh, geom, name=''): if not isinstance( geom, geompyDC.GEOM._objref_GEOM_Object ): return - if not geom.IsSame( mesh.geom ) and not geom.GetStudyEntry(): + if not geom.GetStudyEntry() and \ + mesh.smeshpyD.GetCurrentStudy(): ## set the study studyID = mesh.smeshpyD.GetCurrentStudy()._get_StudyId() if studyID != mesh.geompyD.myStudyId: @@ -511,15 +276,15 @@ def AssureGeomPublished(mesh, geom, name=''): ## Return the first vertex of a geomertical edge by ignoring orienation def FirstVertexOnCurve(edge): - from geompy import SubShapeAll, ShapeType, KindOfShape, PointCoordinates + from geompy import SubShapeAll, ShapeType, MakeVertexOnCurve, PointCoordinates vv = SubShapeAll( edge, ShapeType["VERTEX"]) if not vv: raise TypeError, "Given object has no vertices" if len( vv ) == 1: return vv[0] - info = KindOfShape(edge) - xyz = info[1:4] # coords of the first vertex - xyz1 = PointCoordinates( vv[0] ) - xyz2 = PointCoordinates( vv[1] ) + v0 = MakeVertexOnCurve(edge,0.) + xyz = PointCoordinates( v0 ) # coords of the first vertex + xyz1 = PointCoordinates( vv[0] ) + xyz2 = PointCoordinates( vv[1] ) dist1, dist2 = 0,0 for i in range(3): dist1 += abs( xyz[i] - xyz1[i] ) @@ -540,6 +305,16 @@ class smeshDC(SMESH._objref_SMESH_Gen): def DumpPython(self, theStudy, theIsPublished=True, theIsMultiFile=True): return SMESH._objref_SMESH_Gen.DumpPython(self, theStudy, theIsPublished, theIsMultiFile) + ## Set mode of DumpPython(), \a historical or \a snapshot. + # In the \a historical mode, the Python Dump script includes all commands + # performed by SMESH engine. In the \a snapshot mode, commands + # relating to objects removed from the Study are excluded from the script + # as well as commands not influencing the current state of meshes + def SetDumpPythonHistorical(self, isHistorical): + if isHistorical: val = "true" + else: val = "false" + SMESH._objref_SMESH_Gen.SetOption(self, "historical_python_dump", val) + ## Sets the current study and Geometry component # @ingroup l1_auxiliary def init_smesh(self,theStudy,geompyD): @@ -557,7 +332,6 @@ class smeshDC(SMESH._objref_SMESH_Gen): return Mesh(self,self.geompyD,obj,name) ## Returns a long value from enumeration - # Should be used for SMESH.FunctorType enumeration # @ingroup l1_controls def EnumToLong(self,theItem): return theItem._v @@ -671,6 +445,11 @@ class smeshDC(SMESH._objref_SMESH_Gen): self.geompyD=geompyD self.SetGeomEngine(geompyD) SMESH._objref_SMESH_Gen.SetCurrentStudy(self,theStudy) + global notebook + if theStudy: + notebook = salome_notebook.NoteBook( theStudy ) + else: + notebook = salome_notebook.NoteBook( salome_notebook.PseudoStudyForNoteBook() ) ## Gets the current study # @ingroup l1_auxiliary @@ -727,6 +506,16 @@ class smeshDC(SMESH._objref_SMESH_Gen): aMeshes.append(aMesh) return aMeshes, aStatus + ## Creates a Mesh object importing data from the given GMF file + # @return [ an instance of Mesh class, SMESH::ComputeError ] + # @ingroup l2_impexp + def CreateMeshesFromGMF( self, theFileName ): + aSmeshMesh, error = SMESH._objref_SMESH_Gen.CreateMeshesFromGMF(self, + theFileName, + True) + if error.comment: print "*** CreateMeshesFromGMF() errors:\n", error.comment + return Mesh(self, self.geompyD, aSmeshMesh), error + ## Concatenate the given meshes into one mesh. # @return an instance of Mesh class # @param meshes the meshes to combine into one mesh @@ -734,20 +523,23 @@ class smeshDC(SMESH._objref_SMESH_Gen): # @param mergeNodesAndElements if true, equal nodes and elements aremerged # @param mergeTolerance tolerance for merging nodes # @param allGroups forces creation of groups of all elements + # @param name name of a new mesh def Concatenate( self, meshes, uniteIdenticalGroups, - mergeNodesAndElements = False, mergeTolerance = 1e-5, allGroups = False): - mergeTolerance,Parameters = geompyDC.ParseParameters(mergeTolerance) + mergeNodesAndElements = False, mergeTolerance = 1e-5, allGroups = False, + name = ""): + if not meshes: return None for i,m in enumerate(meshes): if isinstance(m, Mesh): meshes[i] = m.GetMesh() + mergeTolerance,Parameters,hasVars = ParseParameters(mergeTolerance) + meshes[0].SetParameters(Parameters) if allGroups: aSmeshMesh = SMESH._objref_SMESH_Gen.ConcatenateWithGroups( self,meshes,uniteIdenticalGroups,mergeNodesAndElements,mergeTolerance) else: aSmeshMesh = SMESH._objref_SMESH_Gen.Concatenate( self,meshes,uniteIdenticalGroups,mergeNodesAndElements,mergeTolerance) - aSmeshMesh.SetParameters(Parameters) - aMesh = Mesh(self, self.geompyD, aSmeshMesh) + aMesh = Mesh(self, self.geompyD, aSmeshMesh, name=name) return aMesh ## Create a mesh by copying a part of another mesh. @@ -810,7 +602,7 @@ class smeshDC(SMESH._objref_SMESH_Gen): # @param elementType the type of elements(NODE, EDGE, FACE, VOLUME) # @param CritType the type of criterion (FT_Taper, FT_Area, FT_RangeOfIds, FT_LyingOnGeom etc.) # @param Compare belongs to {FT_LessThan, FT_MoreThan, FT_EqualTo} - # @param Treshold the threshold value (range of ids as string, shape, numeric) + # @param Threshold the threshold value (range of ids as string, shape, numeric) # @param UnaryOp FT_LogicalNOT or FT_Undefined # @param BinaryOp a binary logical operation FT_LogicalAND, FT_LogicalOR or # FT_Undefined (must be for the last criterion of all criteria) @@ -823,7 +615,7 @@ class smeshDC(SMESH._objref_SMESH_Gen): def GetCriterion(self,elementType, CritType, Compare = FT_EqualTo, - Treshold="", + Threshold="", UnaryOp=FT_Undefined, BinaryOp=FT_Undefined, Tolerance=1e-07): @@ -834,7 +626,7 @@ class smeshDC(SMESH._objref_SMESH_Gen): aCriterion.Type = self.EnumToLong(CritType) aCriterion.Tolerance = Tolerance - aTreshold = Treshold + aThreshold = Threshold if Compare in [FT_LessThan, FT_MoreThan, FT_EqualTo]: aCriterion.Compare = self.EnumToLong(Compare) @@ -846,84 +638,105 @@ class smeshDC(SMESH._objref_SMESH_Gen): aCriterion.Compare = self.EnumToLong(FT_MoreThan) elif Compare != FT_Undefined: aCriterion.Compare = self.EnumToLong(FT_EqualTo) - aTreshold = Compare + aThreshold = Compare if CritType in [FT_BelongToGeom, FT_BelongToPlane, FT_BelongToGenSurface, FT_BelongToCylinder, FT_LyingOnGeom]: - # Checks the treshold - if isinstance(aTreshold, geompyDC.GEOM._objref_GEOM_Object): - aCriterion.ThresholdStr = GetName(aTreshold) - aCriterion.ThresholdID = salome.ObjectToID(aTreshold) + # Checks that Threshold is GEOM object + if isinstance(aThreshold, geompyDC.GEOM._objref_GEOM_Object): + aCriterion.ThresholdStr = GetName(aThreshold) + aCriterion.ThresholdID = aThreshold.GetStudyEntry() + if not aCriterion.ThresholdID: + name = aCriterion.ThresholdStr + if not name: + name = "%s_%s"%(aThreshold.GetShapeType(), id(aThreshold)%10000) + aCriterion.ThresholdID = self.geompyD.addToStudy( aThreshold, name ) + #raise RuntimeError, "Threshold shape must be published" else: - print "Error: The treshold should be a shape." + print "Error: The Threshold should be a shape." return None if isinstance(UnaryOp,float): aCriterion.Tolerance = UnaryOp UnaryOp = FT_Undefined pass elif CritType == FT_RangeOfIds: - # Checks the treshold - if isinstance(aTreshold, str): - aCriterion.ThresholdStr = aTreshold + # Checks that Threshold is string + if isinstance(aThreshold, str): + aCriterion.ThresholdStr = aThreshold else: - print "Error: The treshold should be a string." + print "Error: The Threshold should be a string." return None elif CritType == FT_CoplanarFaces: - # Checks the treshold - if isinstance(aTreshold, int): - aCriterion.ThresholdID = "%s"%aTreshold - elif isinstance(aTreshold, str): - ID = int(aTreshold) + # Checks the Threshold + if isinstance(aThreshold, int): + aCriterion.ThresholdID = str(aThreshold) + elif isinstance(aThreshold, str): + ID = int(aThreshold) if ID < 1: - raise ValueError, "Invalid ID of mesh face: '%s'"%aTreshold - aCriterion.ThresholdID = aTreshold + raise ValueError, "Invalid ID of mesh face: '%s'"%aThreshold + aCriterion.ThresholdID = aThreshold else: raise ValueError,\ - "The treshold should be an ID of mesh face and not '%s'"%aTreshold + "The Threshold should be an ID of mesh face and not '%s'"%aThreshold elif CritType == FT_ElemGeomType: - # Checks the treshold + # Checks the Threshold try: - aCriterion.Threshold = self.EnumToLong(aTreshold) - assert( aTreshold in SMESH.GeometryType._items ) + aCriterion.Threshold = self.EnumToLong(aThreshold) + assert( aThreshold in SMESH.GeometryType._items ) except: - if isinstance(aTreshold, int): - aCriterion.Threshold = aTreshold + if isinstance(aThreshold, int): + aCriterion.Threshold = aThreshold else: - print "Error: The treshold should be an integer or SMESH.GeometryType." + print "Error: The Threshold should be an integer or SMESH.GeometryType." return None pass pass + elif CritType == FT_EntityType: + # Checks the Threshold + try: + aCriterion.Threshold = self.EnumToLong(aThreshold) + assert( aThreshold in SMESH.EntityType._items ) + except: + if isinstance(aThreshold, int): + aCriterion.Threshold = aThreshold + else: + print "Error: The Threshold should be an integer or SMESH.EntityType." + return None + pass + pass + elif CritType == FT_GroupColor: - # Checks the treshold + # Checks the Threshold try: - aCriterion.ThresholdStr = self.ColorToString(aTreshold) + aCriterion.ThresholdStr = self.ColorToString(aThreshold) except: print "Error: The threshold value should be of SALOMEDS.Color type" return None pass - elif CritType in [FT_FreeBorders, FT_FreeEdges, FT_BadOrientedVolume, FT_FreeNodes, - FT_FreeFaces, FT_LinearOrQuadratic, + elif CritType in [FT_FreeBorders, FT_FreeEdges, FT_FreeNodes, FT_FreeFaces, + FT_LinearOrQuadratic, FT_BadOrientedVolume, FT_BareBorderFace, FT_BareBorderVolume, - FT_OverConstrainedFace, FT_OverConstrainedVolume]: - # At this point the treshold is unnecessary - if aTreshold == FT_LogicalNOT: + FT_OverConstrainedFace, FT_OverConstrainedVolume, + FT_EqualNodes,FT_EqualEdges,FT_EqualFaces,FT_EqualVolumes ]: + # At this point the Threshold is unnecessary + if aThreshold == FT_LogicalNOT: aCriterion.UnaryOp = self.EnumToLong(FT_LogicalNOT) - elif aTreshold in [FT_LogicalAND, FT_LogicalOR]: - aCriterion.BinaryOp = aTreshold + elif aThreshold in [FT_LogicalAND, FT_LogicalOR]: + aCriterion.BinaryOp = aThreshold else: - # Check treshold + # Check Threshold try: - aTreshold = float(aTreshold) - aCriterion.Threshold = aTreshold + aThreshold = float(aThreshold) + aCriterion.Threshold = aThreshold except: - print "Error: The treshold should be a number." + print "Error: The Threshold should be a number." return None - if Treshold == FT_LogicalNOT or UnaryOp == FT_LogicalNOT: + if Threshold == FT_LogicalNOT or UnaryOp == FT_LogicalNOT: aCriterion.UnaryOp = self.EnumToLong(FT_LogicalNOT) - if Treshold in [FT_LogicalAND, FT_LogicalOR]: - aCriterion.BinaryOp = self.EnumToLong(Treshold) + if Threshold in [FT_LogicalAND, FT_LogicalOR]: + aCriterion.BinaryOp = self.EnumToLong(Threshold) if UnaryOp in [FT_LogicalAND, FT_LogicalOR]: aCriterion.BinaryOp = self.EnumToLong(UnaryOp) @@ -937,10 +750,10 @@ class smeshDC(SMESH._objref_SMESH_Gen): # @param elementType the type of elements in the group # @param CritType the type of criterion ( FT_Taper, FT_Area, FT_RangeOfIds, FT_LyingOnGeom etc. ) # @param Compare belongs to {FT_LessThan, FT_MoreThan, FT_EqualTo} - # @param Treshold the threshold value (range of id ids as string, shape, numeric) + # @param Threshold the threshold value (range of id ids as string, shape, numeric) # @param UnaryOp FT_LogicalNOT or FT_Undefined # @param Tolerance the tolerance used by FT_BelongToGeom, FT_BelongToSurface, - # FT_LyingOnGeom, FT_CoplanarFaces criteria + # FT_LyingOnGeom, FT_CoplanarFaces and FT_EqualNodes criteria # @return SMESH_Filter # # Example of Filters usage @@ -948,10 +761,10 @@ class smeshDC(SMESH._objref_SMESH_Gen): def GetFilter(self,elementType, CritType=FT_Undefined, Compare=FT_EqualTo, - Treshold="", + Threshold="", UnaryOp=FT_Undefined, Tolerance=1e-07): - aCriterion = self.GetCriterion(elementType, CritType, Compare, Treshold, UnaryOp, FT_Undefined,Tolerance) + aCriterion = self.GetCriterion(elementType, CritType, Compare, Threshold, UnaryOp, FT_Undefined,Tolerance) aFilterMgr = self.CreateFilterManager() aFilter = aFilterMgr.CreateFilter() aCriteria = [] @@ -978,44 +791,63 @@ class smeshDC(SMESH._objref_SMESH_Gen): # @return SMESH_NumericalFunctor # @ingroup l1_controls def GetFunctor(self,theCriterion): + if isinstance( theCriterion, SMESH._objref_NumericalFunctor ): + return theCriterion aFilterMgr = self.CreateFilterManager() + functor = None if theCriterion == FT_AspectRatio: - return aFilterMgr.CreateAspectRatio() + functor = aFilterMgr.CreateAspectRatio() elif theCriterion == FT_AspectRatio3D: - return aFilterMgr.CreateAspectRatio3D() + functor = aFilterMgr.CreateAspectRatio3D() elif theCriterion == FT_Warping: - return aFilterMgr.CreateWarping() + functor = aFilterMgr.CreateWarping() elif theCriterion == FT_MinimumAngle: - return aFilterMgr.CreateMinimumAngle() + functor = aFilterMgr.CreateMinimumAngle() elif theCriterion == FT_Taper: - return aFilterMgr.CreateTaper() + functor = aFilterMgr.CreateTaper() elif theCriterion == FT_Skew: - return aFilterMgr.CreateSkew() + functor = aFilterMgr.CreateSkew() elif theCriterion == FT_Area: - return aFilterMgr.CreateArea() + functor = aFilterMgr.CreateArea() elif theCriterion == FT_Volume3D: - return aFilterMgr.CreateVolume3D() + functor = aFilterMgr.CreateVolume3D() elif theCriterion == FT_MaxElementLength2D: - return aFilterMgr.CreateMaxElementLength2D() + functor = aFilterMgr.CreateMaxElementLength2D() elif theCriterion == FT_MaxElementLength3D: - return aFilterMgr.CreateMaxElementLength3D() + functor = aFilterMgr.CreateMaxElementLength3D() elif theCriterion == FT_MultiConnection: - return aFilterMgr.CreateMultiConnection() + functor = aFilterMgr.CreateMultiConnection() elif theCriterion == FT_MultiConnection2D: - return aFilterMgr.CreateMultiConnection2D() + functor = aFilterMgr.CreateMultiConnection2D() elif theCriterion == FT_Length: - return aFilterMgr.CreateLength() + functor = aFilterMgr.CreateLength() elif theCriterion == FT_Length2D: - return aFilterMgr.CreateLength2D() + functor = aFilterMgr.CreateLength2D() else: - print "Error: given parameter is not numerucal functor type." + print "Error: given parameter is not numerical functor type." + aFilterMgr.UnRegister() + return functor ## Creates hypothesis # @param theHType mesh hypothesis type (string) # @param theLibName mesh plug-in library name # @return created hypothesis instance def CreateHypothesis(self, theHType, theLibName="libStdMeshersEngine.so"): - return SMESH._objref_SMESH_Gen.CreateHypothesis(self, theHType, theLibName ) + hyp = SMESH._objref_SMESH_Gen.CreateHypothesis(self, theHType, theLibName ) + + if isinstance( hyp, SMESH._objref_SMESH_Algo ): + return hyp + + # wrap hypothesis methods + #print "HYPOTHESIS", theHType + for meth_name in dir( hyp.__class__ ): + if not meth_name.startswith("Get") and \ + not meth_name in dir ( SMESH._objref_SMESH_Hypothesis ): + method = getattr ( hyp.__class__, meth_name ) + if callable(method): + setattr( hyp, meth_name, hypMethodWrapper( hyp, method )) + + return hyp ## Gets the mesh statistic # @return dictionary "element type" - "count of elements" @@ -1168,16 +1000,22 @@ class Mesh: self.geompyD=geompyD if obj is None: obj = 0 + objHasName = False if obj != 0: if isinstance(obj, geompyDC.GEOM._objref_GEOM_Object): self.geom = obj + objHasName = True # publish geom of mesh (issue 0021122) - if not self.geom.GetStudyEntry(): + if not self.geom.GetStudyEntry() and smeshpyD.GetCurrentStudy(): + objHasName = False studyID = smeshpyD.GetCurrentStudy()._get_StudyId() if studyID != geompyD.myStudyId: geompyD.init_geom( smeshpyD.GetCurrentStudy()) pass - geo_name = "%s_%s"%(self.geom.GetShapeType(), id(self.geom)%100) + if name: + geo_name = name + " shape" + else: + geo_name = "%s_%s to mesh"%(self.geom.GetShapeType(), id(self.geom)%100) geompyD.addToStudy( self.geom, geo_name ) self.mesh = self.smeshpyD.CreateMesh(self.geom) @@ -1185,22 +1023,32 @@ class Mesh: self.SetMesh(obj) else: self.mesh = self.smeshpyD.CreateEmptyMesh() - if name != 0: + if name: self.smeshpyD.SetName(self.mesh, name) - elif obj != 0: - self.smeshpyD.SetName(self.mesh, GetName(obj)) + elif objHasName: + self.smeshpyD.SetName(self.mesh, GetName(obj)) # + " mesh" if not self.geom: self.geom = self.mesh.GetShapeToMesh() - self.editor = self.mesh.GetMeshEditor() + self.editor = self.mesh.GetMeshEditor() + self.functors = [None] * SMESH.FT_Undefined._v + + # set self to algoCreator's + for attrName in dir(self): + attr = getattr( self, attrName ) + if isinstance( attr, algoCreator ): + setattr( self, attrName, attr.copy( self )) ## Initializes the Mesh object from an instance of SMESH_Mesh interface # @param theMesh a SMESH_Mesh object # @ingroup l2_construct def SetMesh(self, theMesh): + if self.mesh: self.mesh.UnRegister() self.mesh = theMesh - self.geom = self.mesh.GetShapeToMesh() + if self.mesh: + self.mesh.Register() + self.geom = self.mesh.GetShapeToMesh() ## Returns the mesh, that is an instance of SMESH_Mesh interface # @return a SMESH_Mesh object @@ -1244,8 +1092,12 @@ class Mesh: def SetShape(self, geom): self.mesh = self.smeshpyD.CreateMesh(geom) + ## Loads mesh from the study after opening the study + def Load(self): + self.mesh.Load() + ## Returns true if the hypotheses are defined well - # @param theSubObject a subshape of a mesh shape + # @param theSubObject a sub-shape of a mesh shape # @return True or False # @ingroup l2_construct def IsReadyToCompute(self, theSubObject): @@ -1253,7 +1105,7 @@ class Mesh: ## Returns errors of hypotheses definition. # The list of errors is empty if everything is OK. - # @param theSubObject a subshape of a mesh shape + # @param theSubObject a sub-shape of a mesh shape # @return a list of errors # @ingroup l2_construct def GetAlgoState(self, theSubObject): @@ -1270,217 +1122,25 @@ class Mesh: return self.smeshpyD.GetGeometryByMeshElement( self.mesh, theElementID, theGeomName ) ## Returns the mesh dimension depending on the dimension of the underlying shape + # or, if the mesh is not based on any shape, basing on deimension of elements # @return mesh dimension as an integer value [0,3] # @ingroup l1_auxiliary def MeshDimension(self): - shells = self.geompyD.SubShapeAllIDs( self.geom, geompyDC.ShapeType["SHELL"] ) - if len( shells ) > 0 : - return 3 - elif self.geompyD.NumberOfFaces( self.geom ) > 0 : - return 2 - elif self.geompyD.NumberOfEdges( self.geom ) > 0 : - return 1 - else: - return 0; - pass - - ## Creates a segment discretization 1D algorithm. - # If the optional \a algo parameter is not set, this algorithm is REGULAR. - # \n If the optional \a geom parameter is not set, this algorithm is global. - # Otherwise, this algorithm defines a submesh based on \a geom subshape. - # @param algo the type of the required algorithm. Possible values are: - # - smesh.REGULAR, - # - smesh.PYTHON for discretization via a python function, - # - smesh.COMPOSITE for meshing a set of edges on one face side as a whole. - # @param geom If defined is the subshape to be meshed - # @return an instance of Mesh_Segment or Mesh_Segment_Python, or Mesh_CompositeSegment class - # @ingroup l3_algos_basic - def Segment(self, algo=REGULAR, geom=0): - ## if Segment(geom) is called by mistake - if isinstance( algo, geompyDC.GEOM._objref_GEOM_Object): - algo, geom = geom, algo - if not algo: algo = REGULAR - pass - if algo == REGULAR: - return Mesh_Segment(self, geom) - elif algo == PYTHON: - return Mesh_Segment_Python(self, geom) - elif algo == COMPOSITE: - return Mesh_CompositeSegment(self, geom) - else: - return Mesh_Segment(self, geom) - - ## Creates 1D algorithm importing segments conatined in groups of other mesh. - # If the optional \a geom parameter is not set, this algorithm is global. - # Otherwise, this algorithm defines a submesh based on \a geom subshape. - # @param geom If defined the subshape is to be meshed - # @return an instance of Mesh_UseExistingElements class - # @ingroup l3_algos_basic - def UseExisting1DElements(self, geom=0): - return Mesh_UseExistingElements(1,self, geom) - - ## Creates 2D algorithm importing faces conatined in groups of other mesh. - # If the optional \a geom parameter is not set, this algorithm is global. - # Otherwise, this algorithm defines a submesh based on \a geom subshape. - # @param geom If defined the subshape is to be meshed - # @return an instance of Mesh_UseExistingElements class - # @ingroup l3_algos_basic - def UseExisting2DElements(self, geom=0): - return Mesh_UseExistingElements(2,self, geom) - - ## Enables creation of nodes and segments usable by 2D algoritms. - # The added nodes and segments must be bound to edges and vertices by - # SetNodeOnVertex(), SetNodeOnEdge() and SetMeshElementOnShape() - # If the optional \a geom parameter is not set, this algorithm is global. - # \n Otherwise, this algorithm defines a submesh based on \a geom subshape. - # @param geom the subshape to be manually meshed - # @return StdMeshers_UseExisting_1D algorithm that generates nothing - # @ingroup l3_algos_basic - def UseExistingSegments(self, geom=0): - algo = Mesh_UseExisting(1,self,geom) - return algo.GetAlgorithm() - - ## Enables creation of nodes and faces usable by 3D algoritms. - # The added nodes and faces must be bound to geom faces by SetNodeOnFace() - # and SetMeshElementOnShape() - # If the optional \a geom parameter is not set, this algorithm is global. - # \n Otherwise, this algorithm defines a submesh based on \a geom subshape. - # @param geom the subshape to be manually meshed - # @return StdMeshers_UseExisting_2D algorithm that generates nothing - # @ingroup l3_algos_basic - def UseExistingFaces(self, geom=0): - algo = Mesh_UseExisting(2,self,geom) - return algo.GetAlgorithm() - - ## Creates a triangle 2D algorithm for faces. - # If the optional \a geom parameter is not set, this algorithm is global. - # \n Otherwise, this algorithm defines a submesh based on \a geom subshape. - # @param algo values are: smesh.MEFISTO || smesh.NETGEN_1D2D || smesh.NETGEN_2D || smesh.BLSURF - # @param geom If defined, the subshape to be meshed (GEOM_Object) - # @return an instance of Mesh_Triangle algorithm - # @ingroup l3_algos_basic - def Triangle(self, algo=MEFISTO, geom=0): - ## if Triangle(geom) is called by mistake - if (isinstance(algo, geompyDC.GEOM._objref_GEOM_Object)): - geom = algo - algo = MEFISTO - return Mesh_Triangle(self, algo, geom) - - ## Creates a quadrangle 2D algorithm for faces. - # If the optional \a geom parameter is not set, this algorithm is global. - # \n Otherwise, this algorithm defines a submesh based on \a geom subshape. - # @param geom If defined, the subshape to be meshed (GEOM_Object) - # @param algo values are: smesh.QUADRANGLE || smesh.RADIAL_QUAD - # @return an instance of Mesh_Quadrangle algorithm - # @ingroup l3_algos_basic - def Quadrangle(self, geom=0, algo=QUADRANGLE): - if algo==RADIAL_QUAD: - return Mesh_RadialQuadrangle1D2D(self,geom) + if self.mesh.HasShapeToMesh(): + shells = self.geompyD.SubShapeAllIDs( self.geom, geompyDC.ShapeType["SOLID"] ) + if len( shells ) > 0 : + return 3 + elif self.geompyD.NumberOfFaces( self.geom ) > 0 : + return 2 + elif self.geompyD.NumberOfEdges( self.geom ) > 0 : + return 1 + else: + return 0; else: - return Mesh_Quadrangle(self, geom) - - ## Creates a tetrahedron 3D algorithm for solids. - # The parameter \a algo permits to choose the algorithm: NETGEN or GHS3D - # If the optional \a geom parameter is not set, this algorithm is global. - # \n Otherwise, this algorithm defines a submesh based on \a geom subshape. - # @param algo values are: smesh.NETGEN, smesh.GHS3D, smesh.GHS3DPRL, smesh.FULL_NETGEN - # @param geom If defined, the subshape to be meshed (GEOM_Object) - # @return an instance of Mesh_Tetrahedron algorithm - # @ingroup l3_algos_basic - def Tetrahedron(self, algo=NETGEN, geom=0): - ## if Tetrahedron(geom) is called by mistake - if ( isinstance( algo, geompyDC.GEOM._objref_GEOM_Object)): - algo, geom = geom, algo - if not algo: algo = NETGEN - pass - return Mesh_Tetrahedron(self, algo, geom) - - ## Creates a hexahedron 3D algorithm for solids. - # If the optional \a geom parameter is not set, this algorithm is global. - # \n Otherwise, this algorithm defines a submesh based on \a geom subshape. - # @param algo possible values are: smesh.Hexa, smesh.Hexotic - # @param geom If defined, the subshape to be meshed (GEOM_Object) - # @return an instance of Mesh_Hexahedron algorithm - # @ingroup l3_algos_basic - def Hexahedron(self, algo=Hexa, geom=0): - ## if Hexahedron(geom, algo) or Hexahedron(geom) is called by mistake - if ( isinstance(algo, geompyDC.GEOM._objref_GEOM_Object) ): - if geom in [Hexa, Hexotic]: algo, geom = geom, algo - elif geom == 0: algo, geom = Hexa, algo - return Mesh_Hexahedron(self, algo, geom) - - ## Deprecated, used only for compatibility! - # @return an instance of Mesh_Netgen algorithm - # @ingroup l3_algos_basic - def Netgen(self, is3D, geom=0): - return Mesh_Netgen(self, is3D, geom) - - ## Creates a projection 1D algorithm for edges. - # If the optional \a geom parameter is not set, this algorithm is global. - # Otherwise, this algorithm defines a submesh based on \a geom subshape. - # @param geom If defined, the subshape to be meshed - # @return an instance of Mesh_Projection1D algorithm - # @ingroup l3_algos_proj - def Projection1D(self, geom=0): - return Mesh_Projection1D(self, geom) - - ## Creates a projection 1D-2D algorithm for faces. - # If the optional \a geom parameter is not set, this algorithm is global. - # Otherwise, this algorithm defines a submesh based on \a geom subshape. - # @param geom If defined, the subshape to be meshed - # @return an instance of Mesh_Projection2D algorithm - # @ingroup l3_algos_proj - def Projection1D2D(self, geom=0): - return Mesh_Projection2D(self, geom, "Projection_1D2D") - - ## Creates a projection 2D algorithm for faces. - # If the optional \a geom parameter is not set, this algorithm is global. - # Otherwise, this algorithm defines a submesh based on \a geom subshape. - # @param geom If defined, the subshape to be meshed - # @return an instance of Mesh_Projection2D algorithm - # @ingroup l3_algos_proj - def Projection2D(self, geom=0): - return Mesh_Projection2D(self, geom, "Projection_2D") - - ## Creates a projection 3D algorithm for solids. - # If the optional \a geom parameter is not set, this algorithm is global. - # Otherwise, this algorithm defines a submesh based on \a geom subshape. - # @param geom If defined, the subshape to be meshed - # @return an instance of Mesh_Projection3D algorithm - # @ingroup l3_algos_proj - def Projection3D(self, geom=0): - return Mesh_Projection3D(self, geom) - - ## Creates a 3D extrusion (Prism 3D) or RadialPrism 3D algorithm for solids. - # If the optional \a geom parameter is not set, this algorithm is global. - # Otherwise, this algorithm defines a submesh based on \a geom subshape. - # @param geom If defined, the subshape to be meshed - # @return an instance of Mesh_Prism3D or Mesh_RadialPrism3D algorithm - # @ingroup l3_algos_radialp l3_algos_3dextr - def Prism(self, geom=0): - shape = geom - if shape==0: - shape = self.geom - nbSolids = len( self.geompyD.SubShapeAll( shape, geompyDC.ShapeType["SOLID"] )) - nbShells = len( self.geompyD.SubShapeAll( shape, geompyDC.ShapeType["SHELL"] )) - if nbSolids == 0 or nbSolids == nbShells: - return Mesh_Prism3D(self, geom) - return Mesh_RadialPrism3D(self, geom) - - ## Creates a "Body Fitted" 3D algorithm for solids, which generates - # 3D structured Cartesian mesh in the internal part of a solid shape - # and polyhedral volumes near the shape boundary. - # If the optional \a geom parameter is not set, this algorithm is global. - # Otherwise, this algorithm defines a submesh based on \a geom subshape. - # The algorithm does not support submeshes. - # Generally usage of this algorithm as a local one is useless since - # it does not discretize 1D and 2D subshapes in a usual way acceptable - # for other algorithms. - # @param geom If defined, the subshape to be meshed - # @return an instance of Mesh_Cartesian_3D algorithm - # @ingroup l3_algos_basic - def BodyFitted(self, geom=0): - return Mesh_Cartesian_3D(self, geom) + if self.NbVolumes() > 0: return 3 + if self.NbFaces() > 0: return 2 + if self.NbEdges() > 0: return 1 + return 0 ## Evaluates size of prospective mesh on a shape # @return a list where i-th element is a number of elements of i-th SMESH.EntityType @@ -1558,15 +1218,18 @@ class Mesh: except: shapeText = " on subshape #%s" % (err.subShapeID) errText = "" - stdErrors = ["OK", #COMPERR_OK - "Invalid input mesh", #COMPERR_BAD_INPUT_MESH - "std::exception", #COMPERR_STD_EXCEPTION - "OCC exception", #COMPERR_OCC_EXCEPTION - "SALOME exception", #COMPERR_SLM_EXCEPTION - "Unknown exception", #COMPERR_EXCEPTION + stdErrors = ["OK", #COMPERR_OK + "Invalid input mesh", #COMPERR_BAD_INPUT_MESH + "std::exception", #COMPERR_STD_EXCEPTION + "OCC exception", #COMPERR_OCC_EXCEPTION + "..", #COMPERR_SLM_EXCEPTION + "Unknown exception", #COMPERR_EXCEPTION "Memory allocation problem", #COMPERR_MEMORY_PB - "Algorithm failed", #COMPERR_ALGO_FAILED - "Unexpected geometry"]#COMPERR_BAD_SHAPE + "Algorithm failed", #COMPERR_ALGO_FAILED + "Unexpected geometry", #COMPERR_BAD_SHAPE + "Warning", #COMPERR_WARNING + "Computation cancelled",#COMPERR_CANCELED + "No mesh on sub-shape"] #COMPERR_NO_MESH_ON_SHAPE if err.code > 0: if err.code < len(stdErrors): errText = stdErrors[err.code] else: @@ -1574,7 +1237,7 @@ class Mesh: if errText: errText += ". " errText += err.comment if allReasons != "":allReasons += "\n" - allReasons += '"%s" failed%s. Error: %s' %(err.algoName, shapeText, errText) + allReasons += '- "%s" failed%s. Error: %s' %(err.algoName, shapeText, errText) pass # Treat hyp errors @@ -1600,22 +1263,27 @@ class Mesh: elif err.state == HYP_BAD_GEOMETRY: reason = ('%s %sD algorithm "%s" is assigned to mismatching' 'geometry' % ( glob, dim, name )) + elif err.state == HYP_HIDDEN_ALGO: + reason = ('%s %sD algorithm "%s" is ignored due to presence of a %s ' + 'algorithm of upper dimension generating %sD mesh' + % ( glob, dim, name, glob, dim )) else: - reason = "For unknown reason."+\ - " Revise Mesh.Compute() implementation in smeshDC.py!" + reason = ("For unknown reason. " + "Developer, revise Mesh.Compute() implementation in smeshDC.py!") pass if allReasons != "":allReasons += "\n" - allReasons += reason + allReasons += "- " + reason pass - if allReasons != "": - print '"' + GetName(self.mesh) + '"',"has not been computed:" + if not ok or allReasons != "": + msg = '"' + GetName(self.mesh) + '"' + if ok: msg += " has been computed with warnings" + else: msg += " has not been computed" + if allReasons != "": msg += ":" + else: msg += "." + print msg print allReasons - ok = False - elif not ok: - print '"' + GetName(self.mesh) + '"',"has not been computed." - pass pass - if salome.sg.hasDesktop(): + if salome.sg.hasDesktop() and self.mesh.GetStudyId() >= 0: smeshgui = salome.ImportComponentGUI("SMESH") smeshgui.Init(self.mesh.GetStudyId()) smeshgui.SetMeshIcon( salome.ObjectToID( self.mesh ), ok, (self.NbNodes()==0) ) @@ -1639,7 +1307,8 @@ class Mesh: # @ingroup l2_construct def Clear(self): self.mesh.Clear() - if salome.sg.hasDesktop(): + if ( salome.sg.hasDesktop() and + salome.myStudyManager.GetStudyByID( self.mesh.GetStudyId() )): smeshgui = salome.ImportComponentGUI("SMESH") smeshgui.Init(self.mesh.GetStudyId()) smeshgui.SetMeshIcon( salome.ObjectToID( self.mesh ), False, True ) @@ -1668,6 +1337,7 @@ class Mesh: self.Triangle().LengthFromEdges() pass if dim > 2 : + from NETGENPluginDC import NETGEN self.Tetrahedron(NETGEN) pass return self.Compute() @@ -1703,6 +1373,7 @@ class Mesh: if not geom: geom = self.mesh.GetShapeToMesh() pass + AssureGeomPublished( self, geom, "shape for %s" % hyp.GetName()) status = self.mesh.AddHypothesis(geom, hyp) isAlgo = hyp._narrow( SMESH_Algo ) hyp_name = GetName( hyp ) @@ -1712,23 +1383,45 @@ class Mesh: TreatHypoStatus( status, hyp_name, geom_name, isAlgo ) return status + ## Return True if an algorithm of hypothesis is assigned to a given shape + # @param hyp a hypothesis to check + # @param geom a subhape of mesh geometry + # @return True of False + # @ingroup l2_hypotheses + def IsUsedHypothesis(self, hyp, geom): + if not hyp: # or not geom + return False + if isinstance( hyp, Mesh_Algorithm ): + hyp = hyp.GetAlgorithm() + pass + hyps = self.GetHypothesisList(geom) + for h in hyps: + if h.GetId() == hyp.GetId(): + return True + return False + ## Unassigns a hypothesis # @param hyp a hypothesis to unassign - # @param geom a subshape of mesh geometry + # @param geom a sub-shape of mesh geometry # @return SMESH.Hypothesis_Status # @ingroup l2_hypotheses def RemoveHypothesis(self, hyp, geom=0): if isinstance( hyp, Mesh_Algorithm ): hyp = hyp.GetAlgorithm() pass - if not geom: - geom = self.geom + shape = geom + if not shape: + shape = self.geom pass - status = self.mesh.RemoveHypothesis(geom, hyp) - return status + if self.IsUsedHypothesis( hyp, shape ): + return self.mesh.RemoveHypothesis( shape, hyp ) + hypName = GetName( hyp ) + geoName = GetName( shape ) + print "WARNING: RemoveHypothesis() failed as '%s' is not assigned to '%s' shape" % ( hypName, geoName ) + return None ## Gets the list of hypotheses added on a geometry - # @param geom a subshape of mesh geometry + # @param geom a sub-shape of mesh geometry # @return the sequence of SMESH_Hypothesis # @ingroup l2_hypotheses def GetHypothesisList(self, geom): @@ -1743,19 +1436,7 @@ class Mesh: pass pass - ## Deprecated, used only for compatibility! Please, use ExportToMEDX() method instead. - # Exports the mesh in a file in MED format and chooses the \a version of MED format - ## allowing to overwrite the file if it exists or add the exported data to its contents - # @param f the file name - # @param version values are SMESH.MED_V2_1, SMESH.MED_V2_2 - # @param opt boolean parameter for creating/not creating - # the groups Group_On_All_Nodes, Group_On_All_Faces, ... - # @param overwrite boolean parameter for overwriting/not overwriting the file - # @ingroup l2_impexp - def ExportToMED(self, f, version, opt=0, overwrite=1): - self.mesh.ExportToMEDX(f, opt, version, overwrite) - - ## Exports the mesh in a file in MED format and chooses the \a version of MED format + ## Exports the mesh in a file in MED format and chooses the \a version of MED format ## allowing to overwrite the file if it exists or add the exported data to its contents # @param f is the file name # @param auto_groups boolean parameter for creating/not creating @@ -1833,6 +1514,31 @@ class Mesh: meshPart = self.mesh self.mesh.ExportCGNS(meshPart, f, overwrite) + ## Exports the mesh in a file in GMF format + # @param f is the file name + # @param meshPart a part of mesh (group, sub-mesh) to export instead of the mesh + # @ingroup l2_impexp + def ExportGMF(self, f, meshPart=None): + if isinstance( meshPart, list ): + meshPart = self.GetIDSource( meshPart, SMESH.ALL ) + if isinstance( meshPart, Mesh ): + meshPart = meshPart.mesh + elif not meshPart: + meshPart = self.mesh + self.mesh.ExportGMF(meshPart, f, True) + + ## Deprecated, used only for compatibility! Please, use ExportToMEDX() method instead. + # Exports the mesh in a file in MED format and chooses the \a version of MED format + ## allowing to overwrite the file if it exists or add the exported data to its contents + # @param f the file name + # @param version values are SMESH.MED_V2_1, SMESH.MED_V2_2 + # @param opt boolean parameter for creating/not creating + # the groups Group_On_All_Nodes, Group_On_All_Faces, ... + # @param overwrite boolean parameter for overwriting/not overwriting the file + # @ingroup l2_impexp + def ExportToMED(self, f, version, opt=0, overwrite=1): + self.mesh.ExportToMEDX(f, opt, version, overwrite) + # Operations with groups: # ---------------------- @@ -1920,7 +1626,7 @@ class Mesh: # @param elementType the type of elements in the group # @param CritType the type of criterion( FT_Taper, FT_Area, FT_RangeOfIds, FT_LyingOnGeom etc. ) # @param Compare belongs to {FT_LessThan, FT_MoreThan, FT_EqualTo} - # @param Treshold the threshold value (range of id ids as string, shape, numeric) + # @param Threshold the threshold value (range of id ids as string, shape, numeric) # @param UnaryOp FT_LogicalNOT or FT_Undefined # @param Tolerance the tolerance used by FT_BelongToGeom, FT_BelongToSurface, # FT_LyingOnGeom, FT_CoplanarFaces criteria @@ -1931,10 +1637,10 @@ class Mesh: elementType, CritType=FT_Undefined, Compare=FT_EqualTo, - Treshold="", + Threshold="", UnaryOp=FT_Undefined, Tolerance=1e-07): - aCriterion = self.smeshpyD.GetCriterion(elementType, CritType, Compare, Treshold, UnaryOp, FT_Undefined,Tolerance) + aCriterion = self.smeshpyD.GetCriterion(elementType, CritType, Compare, Threshold, UnaryOp, FT_Undefined,Tolerance) group = self.MakeGroupByCriterion(groupName, aCriterion) return group @@ -1977,26 +1683,6 @@ class Mesh: group.AddFrom( theFilter ) return group - ## Passes mesh elements through the given filter and return IDs of fitting elements - # @param theFilter SMESH_Filter - # @return a list of ids - # @ingroup l1_controls - def GetIdsFromFilter(self, theFilter): - theFilter.SetMesh( self.mesh ) - return theFilter.GetIDs() - - ## Verifies whether a 2D mesh element has free edges (edges connected to one face only)\n - # Returns a list of special structures (borders). - # @return a list of SMESH.FreeEdges.Border structure: edge id and ids of two its nodes. - # @ingroup l1_controls - def GetFreeBorders(self): - aFilterMgr = self.smeshpyD.CreateFilterManager() - aPredicate = aFilterMgr.CreateFreeEdges() - aPredicate.SetMesh(self.mesh) - aBorders = aPredicate.GetBorders() - aFilterMgr.UnRegister() - return aBorders - ## Removes a group # @ingroup l2_grps_delete def RemoveGroup(self, group): @@ -2148,14 +1834,14 @@ class Mesh: # @return an instance of SMESH_MeshEditor # @ingroup l1_modifying def GetMeshEditor(self): - return self.mesh.GetMeshEditor() + return self.editor ## Wrap a list of IDs of elements or nodes into SMESH_IDSource which - # can be passed as argument to accepting mesh, group or sub-mesh + # can be passed as argument to a method accepting mesh, group or sub-mesh # @return an instance of SMESH_IDSource # @ingroup l1_auxiliary def GetIDSource(self, ids, elemType): - return self.GetMeshEditor().MakeIDSource(ids, elemType) + return self.editor.MakeIDSource(ids, elemType) ## Gets MED Mesh # @return an instance of SALOME_MED::MESH @@ -2192,6 +1878,12 @@ class Mesh: def Nb0DElements(self): return self.mesh.Nb0DElements() + ## Returns the number of ball discrete elements in the mesh + # @return an integer value + # @ingroup l1_meshinfo + def NbBalls(self): + return self.mesh.NbBalls() + ## Returns the number of edges in the mesh # @return an integer value # @ingroup l1_meshinfo @@ -2248,6 +1940,12 @@ class Mesh: def NbQuadranglesOfOrder(self, elementOrder): return self.mesh.NbQuadranglesOfOrder(elementOrder) + ## Returns the number of biquadratic quadrangles in the mesh + # @return an integer value + # @ingroup l1_meshinfo + def NbBiQuadQuadrangles(self): + return self.mesh.NbBiQuadQuadrangles() + ## Returns the number of polygons in the mesh # @return an integer value # @ingroup l1_meshinfo @@ -2296,6 +1994,12 @@ class Mesh: def NbHexasOfOrder(self, elementOrder): return self.mesh.NbHexasOfOrder(elementOrder) + ## Returns the number of triquadratic hexahedrons in the mesh + # @return an integer value + # @ingroup l1_meshinfo + def NbTriQuadraticHexas(self): + return self.mesh.NbTriQuadraticHexas() + ## Returns the number of pyramids in the mesh # @return an integer value # @ingroup l1_meshinfo @@ -2324,6 +2028,12 @@ class Mesh: def NbPrismsOfOrder(self, elementOrder): return self.mesh.NbPrismsOfOrder(elementOrder) + ## Returns the number of hexagonal prisms in the mesh + # @return an integer value + # @ingroup l1_meshinfo + def NbHexagonalPrisms(self): + return self.mesh.NbHexagonalPrisms() + ## Returns the number of polyhedrons in the mesh # @return an integer value # @ingroup l1_meshinfo @@ -2371,8 +2081,8 @@ class Mesh: return self.mesh.GetElementGeomType(id) ## Returns the list of submesh elements IDs - # @param Shape a geom object(subshape) IOR - # Shape must be the subshape of a ShapeToMesh() + # @param Shape a geom object(sub-shape) IOR + # Shape must be the sub-shape of a ShapeToMesh() # @return the list of integer values # @ingroup l1_meshinfo def GetSubMeshElementsId(self, Shape): @@ -2383,21 +2093,21 @@ class Mesh: return self.mesh.GetSubMeshElementsId(ShapeID) ## Returns the list of submesh nodes IDs - # @param Shape a geom object(subshape) IOR - # Shape must be the subshape of a ShapeToMesh() + # @param Shape a geom object(sub-shape) IOR + # Shape must be the sub-shape of a ShapeToMesh() # @param all If true, gives all nodes of submesh elements, otherwise gives only submesh nodes # @return the list of integer values # @ingroup l1_meshinfo def GetSubMeshNodesId(self, Shape, all): if ( isinstance( Shape, geompyDC.GEOM._objref_GEOM_Object)): - ShapeID = Shape.GetSubShapeIndices()[0] + ShapeID = self.geompyD.GetSubShapeID( self.geom, Shape ) else: ShapeID = Shape return self.mesh.GetSubMeshNodesId(ShapeID, all) ## Returns type of elements on given shape - # @param Shape a geom object(subshape) IOR - # Shape must be a subshape of a ShapeToMesh() + # @param Shape a geom object(sub-shape) IOR + # Shape must be a sub-shape of a ShapeToMesh() # @return element type # @ingroup l1_meshinfo def GetSubMeshElementType(self, Shape): @@ -2437,6 +2147,12 @@ class Mesh: def GetNodePosition(self,NodeID): return self.mesh.GetNodePosition(NodeID) + ## @brief Returns the position of an element on the shape + # @return SMESH::ElementPosition + # @ingroup l1_meshinfo + def GetElementPosition(self,ElemID): + return self.mesh.GetElementPosition(ElemID) + ## If the given element is a node, returns the ID of shape # \n If there is no node for the given ID - returns -1 # @return an integer value @@ -2459,7 +2175,7 @@ class Mesh: def GetElemNbNodes(self, id): return self.mesh.GetElemNbNodes(id) - ## Returns the node ID the given index for the given element + ## Returns the node ID the given (zero based) index for the given element # \n If there is no element for the given ID - returns -1 # \n If there is no node for the given index - returns -2 # @return an integer value @@ -2513,6 +2229,11 @@ class Mesh: def IsQuadratic(self, id): return self.mesh.IsQuadratic(id) + ## Returns diameter of a ball discrete element or zero in case of an invalid \a id + # @ingroup l1_meshinfo + def GetBallDiameter(self, id): + return self.mesh.GetBallDiameter(id) + ## Returns XYZ coordinates of the barycenter of the given element # \n If there is no element for the given ID - returns an empty list # @return a list of three double values @@ -2520,6 +2241,26 @@ class Mesh: def BaryCenter(self, id): return self.mesh.BaryCenter(id) + ## Passes mesh elements through the given filter and return IDs of fitting elements + # @param theFilter SMESH_Filter + # @return a list of ids + # @ingroup l1_controls + def GetIdsFromFilter(self, theFilter): + theFilter.SetMesh( self.mesh ) + return theFilter.GetIDs() + + ## Verifies whether a 2D mesh element has free edges (edges connected to one face only)\n + # Returns a list of special structures (borders). + # @return a list of SMESH.FreeEdges.Border structure: edge id and ids of two its nodes. + # @ingroup l1_controls + def GetFreeBorders(self): + aFilterMgr = self.smeshpyD.CreateFilterManager() + aPredicate = aFilterMgr.CreateFreeEdges() + aPredicate.SetMesh(self.mesh) + aBorders = aPredicate.GetBorders() + aFilterMgr.UnRegister() + return aBorders + # Get mesh measurements information: # ------------------------------------ @@ -2637,8 +2378,8 @@ class Mesh: # @return Id of the new node # @ingroup l2_modif_add def AddNode(self, x, y, z): - x,y,z,Parameters = geompyDC.ParseParameters(x,y,z) - self.mesh.SetParameters(Parameters) + x,y,z,Parameters,hasVars = ParseParameters(x,y,z) + if hasVars: self.mesh.SetParameters(Parameters) return self.editor.AddNode( x, y, z) ## Creates a 0D element on a node with given number. @@ -2648,6 +2389,32 @@ class Mesh: def Add0DElement(self, IDOfNode): return self.editor.Add0DElement(IDOfNode) + ## Create 0D elements on all nodes of the given elements except those + # nodes on which a 0D element already exists. + # @param theObject an object on whose nodes 0D elements will be created. + # It can be mesh, sub-mesh, group, list of element IDs or a holder + # of nodes IDs created by calling mesh.GetIDSource( nodes, SMESH.NODE ) + # @param theGroupName optional name of a group to add 0D elements created + # and/or found on nodes of \a theObject. + # @return an object (a new group or a temporary SMESH_IDSource) holding + # IDs of new and/or found 0D elements. IDs of 0D elements + # can be retrieved from the returned object by calling GetIDs() + # @ingroup l2_modif_add + def Add0DElementsToAllNodes(self, theObject, theGroupName=""): + if isinstance( theObject, Mesh ): + theObject = theObject.GetMesh() + if isinstance( theObject, list ): + theObject = self.GetIDSource( theObject, SMESH.ALL ) + return self.editor.Create0DElementsOnAllNodes( theObject, theGroupName ) + + ## Creates a ball element on a node with given ID. + # @param IDOfNode the ID of node for creation of the element. + # @param diameter the bal diameter. + # @return the Id of the new ball element + # @ingroup l2_modif_add + def AddBall(self, IDOfNode, diameter): + return self.editor.AddBall( IDOfNode, diameter ) + ## Creates a linear or quadratic edge (this is determined # by the number of given nodes). # @param IDsOfNodes the list of node IDs for creation of the element. @@ -2801,8 +2568,8 @@ class Mesh: # @return True if succeed else False # @ingroup l2_modif_movenode def MoveNode(self, NodeID, x, y, z): - x,y,z,Parameters = geompyDC.ParseParameters(x,y,z) - self.mesh.SetParameters(Parameters) + x,y,z,Parameters,hasVars = ParseParameters(x,y,z) + if hasVars: self.mesh.SetParameters(Parameters) return self.editor.MoveNode(NodeID, x, y, z) ## Finds the node closest to a point and moves it to a point location @@ -2814,8 +2581,8 @@ class Mesh: # @return the ID of a node # @ingroup l2_modif_throughp def MoveClosestNodeToPoint(self, x, y, z, NodeID): - x,y,z,Parameters = geompyDC.ParseParameters(x,y,z) - self.mesh.SetParameters(Parameters) + x,y,z,Parameters,hasVars = ParseParameters(x,y,z) + if hasVars: self.mesh.SetParameters(Parameters) return self.editor.MoveClosestNodeToPoint(x, y, z, NodeID) ## Finds the node closest to a point @@ -2834,7 +2601,7 @@ class Mesh: # @param y the Y coordinate of a point # @param z the Z coordinate of a point # @param elementType type of elements to find (SMESH.ALL type - # means elements of any type excluding nodes and 0D elements) + # means elements of any type excluding nodes, discrete and 0D elements) # @param meshPart a part of mesh (group, sub-mesh) to search within # @return list of IDs of found elements # @ingroup l2_modif_throughp @@ -2844,7 +2611,8 @@ class Mesh: else: return self.editor.FindElementsByPoint(x, y, z, elementType) - # Return point state in a closed 2D mesh in terms of TopAbs_State enumeration. + # Return point state in a closed 2D mesh in terms of TopAbs_State enumeration: + # 0-IN, 1-OUT, 2-ON, 3-UNKNOWN # TopAbs_UNKNOWN state means that either mesh is wrong or the analysis fails. def GetPointState(self, x, y, z): @@ -2895,62 +2663,105 @@ class Mesh: theObject = theObject.GetMesh() return self.editor.ReorientObject(theObject) + ## Reorient faces contained in \a the2DObject. + # @param the2DObject is a mesh, sub-mesh, group or list of IDs of 2D elements + # @param theDirection is a desired direction of normal of \a theFace. + # It can be either a GEOM vector or a list of coordinates [x,y,z]. + # @param theFaceOrPoint defines a face of \a the2DObject whose normal will be + # compared with theDirection. It can be either ID of face or a point + # by which the face will be found. The point can be given as either + # a GEOM vertex or a list of point coordinates. + # @return number of reoriented faces + # @ingroup l2_modif_changori + def Reorient2D(self, the2DObject, theDirection, theFaceOrPoint ): + # check the2DObject + if isinstance( the2DObject, Mesh ): + the2DObject = the2DObject.GetMesh() + if isinstance( the2DObject, list ): + the2DObject = self.GetIDSource( the2DObject, SMESH.FACE ) + # check theDirection + if isinstance( theDirection, geompyDC.GEOM._objref_GEOM_Object): + theDirection = self.smeshpyD.GetDirStruct( theDirection ) + if isinstance( theDirection, list ): + theDirection = self.smeshpyD.MakeDirStruct( *theDirection ) + # prepare theFace and thePoint + theFace = theFaceOrPoint + thePoint = PointStruct(0,0,0) + if isinstance( theFaceOrPoint, geompyDC.GEOM._objref_GEOM_Object): + thePoint = self.smeshpyD.GetPointStruct( theFaceOrPoint ) + theFace = -1 + if isinstance( theFaceOrPoint, list ): + thePoint = PointStruct( *theFaceOrPoint ) + theFace = -1 + if isinstance( theFaceOrPoint, PointStruct ): + thePoint = theFaceOrPoint + theFace = -1 + return self.editor.Reorient2D( the2DObject, theDirection, theFace, thePoint ) + ## Fuses the neighbouring triangles into quadrangles. # @param IDsOfElements The triangles to be fused, - # @param theCriterion is FT_...; used to choose a neighbour to fuse with. + # @param theCriterion is a numerical functor, in terms of enum SMESH.FunctorType, used to + # choose a neighbour to fuse with. # @param MaxAngle is the maximum angle between element normals at which the fusion # is still performed; theMaxAngle is mesured in radians. # Also it could be a name of variable which defines angle in degrees. # @return TRUE in case of success, FALSE otherwise. # @ingroup l2_modif_unitetri def TriToQuad(self, IDsOfElements, theCriterion, MaxAngle): - flag = False - if isinstance(MaxAngle,str): - flag = True - MaxAngle,Parameters = geompyDC.ParseParameters(MaxAngle) - if flag: - MaxAngle = DegreesToRadians(MaxAngle) - if IDsOfElements == []: - IDsOfElements = self.GetElementsId() + MaxAngle,Parameters,hasVars = ParseAngles(MaxAngle) self.mesh.SetParameters(Parameters) - Functor = 0 - if ( isinstance( theCriterion, SMESH._objref_NumericalFunctor ) ): - Functor = theCriterion - else: - Functor = self.smeshpyD.GetFunctor(theCriterion) + if not IDsOfElements: + IDsOfElements = self.GetElementsId() + Functor = self.smeshpyD.GetFunctor(theCriterion) return self.editor.TriToQuad(IDsOfElements, Functor, MaxAngle) ## Fuses the neighbouring triangles of the object into quadrangles # @param theObject is mesh, submesh or group - # @param theCriterion is FT_...; used to choose a neighbour to fuse with. + # @param theCriterion is a numerical functor, in terms of enum SMESH.FunctorType, used to + # choose a neighbour to fuse with. # @param MaxAngle a max angle between element normals at which the fusion # is still performed; theMaxAngle is mesured in radians. # @return TRUE in case of success, FALSE otherwise. # @ingroup l2_modif_unitetri def TriToQuadObject (self, theObject, theCriterion, MaxAngle): - if ( isinstance( theObject, Mesh )): + MaxAngle,Parameters,hasVars = ParseAngles(MaxAngle) + self.mesh.SetParameters(Parameters) + if isinstance( theObject, Mesh ): theObject = theObject.GetMesh() - return self.editor.TriToQuadObject(theObject, self.smeshpyD.GetFunctor(theCriterion), MaxAngle) + Functor = self.smeshpyD.GetFunctor(theCriterion) + return self.editor.TriToQuadObject(theObject, Functor, MaxAngle) ## Splits quadrangles into triangles. + # # @param IDsOfElements the faces to be splitted. - # @param theCriterion FT_...; used to choose a diagonal for splitting. + # @param theCriterion is a numerical functor, in terms of enum SMESH.FunctorType, used to + # choose a diagonal for splitting. If @a theCriterion is None, which is a default + # value, then quadrangles will be split by the smallest diagonal. # @return TRUE in case of success, FALSE otherwise. # @ingroup l2_modif_cutquadr - def QuadToTri (self, IDsOfElements, theCriterion): + def QuadToTri (self, IDsOfElements, theCriterion = None): if IDsOfElements == []: IDsOfElements = self.GetElementsId() - return self.editor.QuadToTri(IDsOfElements, self.smeshpyD.GetFunctor(theCriterion)) + if theCriterion is None: + theCriterion = FT_MaxElementLength2D + Functor = self.smeshpyD.GetFunctor(theCriterion) + return self.editor.QuadToTri(IDsOfElements, Functor) ## Splits quadrangles into triangles. - # @param theObject the object from which the list of elements is taken, this is mesh, submesh or group - # @param theCriterion FT_...; used to choose a diagonal for splitting. + # @param theObject the object from which the list of elements is taken, + # this is mesh, submesh or group + # @param theCriterion is a numerical functor, in terms of enum SMESH.FunctorType, used to + # choose a diagonal for splitting. If @a theCriterion is None, which is a default + # value, then quadrangles will be split by the smallest diagonal. # @return TRUE in case of success, FALSE otherwise. # @ingroup l2_modif_cutquadr - def QuadToTriObject (self, theObject, theCriterion): + def QuadToTriObject (self, theObject, theCriterion = None): if ( isinstance( theObject, Mesh )): theObject = theObject.GetMesh() - return self.editor.QuadToTriObject(theObject, self.smeshpyD.GetFunctor(theCriterion)) + if theCriterion is None: + theCriterion = FT_MaxElementLength2D + Functor = self.smeshpyD.GetFunctor(theCriterion) + return self.editor.QuadToTriObject(theObject, Functor) ## Splits quadrangles into triangles. # @param IDsOfElements the faces to be splitted @@ -2963,7 +2774,8 @@ class Mesh: return self.editor.SplitQuad(IDsOfElements, Diag13) ## Splits quadrangles into triangles. - # @param theObject the object from which the list of elements is taken, this is mesh, submesh or group + # @param theObject the object from which the list of elements is taken, + # this is mesh, submesh or group # @param Diag13 is used to choose a diagonal for splitting. # @return TRUE in case of success, FALSE otherwise. # @ingroup l2_modif_cutquadr @@ -2974,7 +2786,8 @@ class Mesh: ## Finds a better splitting of the given quadrangle. # @param IDOfQuad the ID of the quadrangle to be splitted. - # @param theCriterion FT_...; a criterion to choose a diagonal for splitting. + # @param theCriterion is a numerical functor, in terms of enum SMESH.FunctorType, used to + # choose a diagonal for splitting. # @return 1 if 1-3 diagonal is better, 2 if 2-4 # diagonal is better, 0 if error occurs. # @ingroup l2_modif_cutquadr @@ -3148,7 +2961,7 @@ class Mesh: MaxNbOfIterations, MaxAspectRatio, Method): if IDsOfElements == []: IDsOfElements = self.GetElementsId() - MaxNbOfIterations,MaxAspectRatio,Parameters = geompyDC.ParseParameters(MaxNbOfIterations,MaxAspectRatio) + MaxNbOfIterations,MaxAspectRatio,Parameters,hasVars = ParseParameters(MaxNbOfIterations,MaxAspectRatio) self.mesh.SetParameters(Parameters) return self.editor.Smooth(IDsOfElements, IDsOfFixedNodes, MaxNbOfIterations, MaxAspectRatio, Method) @@ -3182,7 +2995,7 @@ class Mesh: MaxNbOfIterations, MaxAspectRatio, Method): if IDsOfElements == []: IDsOfElements = self.GetElementsId() - MaxNbOfIterations,MaxAspectRatio,Parameters = geompyDC.ParseParameters(MaxNbOfIterations,MaxAspectRatio) + MaxNbOfIterations,MaxAspectRatio,Parameters,hasVars = ParseParameters(MaxNbOfIterations,MaxAspectRatio) self.mesh.SetParameters(Parameters) return self.editor.SmoothParametric(IDsOfElements, IDsOfFixedNodes, MaxNbOfIterations, MaxAspectRatio, Method) @@ -3203,19 +3016,23 @@ class Mesh: return self.editor.SmoothParametricObject(theObject, IDsOfFixedNodes, MaxNbOfIterations, MaxAspectRatio, Method) - ## Converts the mesh to quadratic, deletes old elements, replacing + ## Converts the mesh to quadratic or bi-quadratic, deletes old elements, replacing # them with quadratic with the same id. # @param theForce3d new node creation method: # 0 - the medium node lies at the geometrical entity from which the mesh element is built # 1 - the medium node lies at the middle of the line segments connecting start and end node of a mesh element # @param theSubMesh a group or a sub-mesh to convert; WARNING: in this case the mesh can become not conformal + # @param theToBiQuad If True, converts the mesh to bi-quadratic # @ingroup l2_modif_tofromqu - def ConvertToQuadratic(self, theForce3d, theSubMesh=None): - if theSubMesh: - self.editor.ConvertToQuadraticObject(theForce3d,theSubMesh) + def ConvertToQuadratic(self, theForce3d, theSubMesh=None, theToBiQuad=False): + if theToBiQuad: + self.editor.ConvertToBiQuadratic(theForce3d,theSubMesh) else: - self.editor.ConvertToQuadratic(theForce3d) - + if theSubMesh: + self.editor.ConvertToQuadraticObject(theForce3d,theSubMesh) + else: + self.editor.ConvertToQuadratic(theForce3d) + ## Converts the mesh from quadratic to ordinary, # deletes old quadratic elements, \n replacing # them with ordinary mesh elements with the same id. @@ -3309,22 +3126,16 @@ class Mesh: # @ingroup l2_modif_extrurev def RotationSweep(self, IDsOfElements, Axis, AngleInRadians, NbOfSteps, Tolerance, MakeGroups=False, TotalAngle=False): - flag = False - if isinstance(AngleInRadians,str): - flag = True - AngleInRadians,AngleParameters = geompyDC.ParseParameters(AngleInRadians) - if flag: - AngleInRadians = DegreesToRadians(AngleInRadians) if IDsOfElements == []: IDsOfElements = self.GetElementsId() if ( isinstance( Axis, geompyDC.GEOM._objref_GEOM_Object)): Axis = self.smeshpyD.GetAxisStruct(Axis) - Axis,AxisParameters = ParseAxisStruct(Axis) + AngleInRadians,AngleParameters,hasVars = ParseAngles(AngleInRadians) + NbOfSteps,Tolerance,Parameters,hasVars = ParseParameters(NbOfSteps,Tolerance) + Parameters = Axis.parameters + var_separator + AngleParameters + var_separator + Parameters + self.mesh.SetParameters(Parameters) if TotalAngle and NbOfSteps: AngleInRadians /= NbOfSteps - NbOfSteps,Tolerance,Parameters = geompyDC.ParseParameters(NbOfSteps,Tolerance) - Parameters = AxisParameters + var_separator + AngleParameters + var_separator + Parameters - self.mesh.SetParameters(Parameters) if MakeGroups: return self.editor.RotationSweepMakeGroups(IDsOfElements, Axis, AngleInRadians, NbOfSteps, Tolerance) @@ -3345,22 +3156,16 @@ class Mesh: # @ingroup l2_modif_extrurev def RotationSweepObject(self, theObject, Axis, AngleInRadians, NbOfSteps, Tolerance, MakeGroups=False, TotalAngle=False): - flag = False - if isinstance(AngleInRadians,str): - flag = True - AngleInRadians,AngleParameters = geompyDC.ParseParameters(AngleInRadians) - if flag: - AngleInRadians = DegreesToRadians(AngleInRadians) if ( isinstance( theObject, Mesh )): theObject = theObject.GetMesh() if ( isinstance( Axis, geompyDC.GEOM._objref_GEOM_Object)): Axis = self.smeshpyD.GetAxisStruct(Axis) - Axis,AxisParameters = ParseAxisStruct(Axis) + AngleInRadians,AngleParameters,hasVars = ParseAngles(AngleInRadians) + NbOfSteps,Tolerance,Parameters,hasVars = ParseParameters(NbOfSteps,Tolerance) + Parameters = Axis.parameters + var_separator + AngleParameters + var_separator + Parameters + self.mesh.SetParameters(Parameters) if TotalAngle and NbOfSteps: AngleInRadians /= NbOfSteps - NbOfSteps,Tolerance,Parameters = geompyDC.ParseParameters(NbOfSteps,Tolerance) - Parameters = AxisParameters + var_separator + AngleParameters + var_separator + Parameters - self.mesh.SetParameters(Parameters) if MakeGroups: return self.editor.RotationSweepObjectMakeGroups(theObject, Axis, AngleInRadians, NbOfSteps, Tolerance) @@ -3381,22 +3186,16 @@ class Mesh: # @ingroup l2_modif_extrurev def RotationSweepObject1D(self, theObject, Axis, AngleInRadians, NbOfSteps, Tolerance, MakeGroups=False, TotalAngle=False): - flag = False - if isinstance(AngleInRadians,str): - flag = True - AngleInRadians,AngleParameters = geompyDC.ParseParameters(AngleInRadians) - if flag: - AngleInRadians = DegreesToRadians(AngleInRadians) if ( isinstance( theObject, Mesh )): theObject = theObject.GetMesh() if ( isinstance( Axis, geompyDC.GEOM._objref_GEOM_Object)): Axis = self.smeshpyD.GetAxisStruct(Axis) - Axis,AxisParameters = ParseAxisStruct(Axis) + AngleInRadians,AngleParameters,hasVars = ParseAngles(AngleInRadians) + NbOfSteps,Tolerance,Parameters,hasVars = ParseParameters(NbOfSteps,Tolerance) + Parameters = Axis.parameters + var_separator + AngleParameters + var_separator + Parameters + self.mesh.SetParameters(Parameters) if TotalAngle and NbOfSteps: AngleInRadians /= NbOfSteps - NbOfSteps,Tolerance,Parameters = geompyDC.ParseParameters(NbOfSteps,Tolerance) - Parameters = AxisParameters + var_separator + AngleParameters + var_separator + Parameters - self.mesh.SetParameters(Parameters) if MakeGroups: return self.editor.RotationSweepObject1DMakeGroups(theObject, Axis, AngleInRadians, NbOfSteps, Tolerance) @@ -3417,22 +3216,16 @@ class Mesh: # @ingroup l2_modif_extrurev def RotationSweepObject2D(self, theObject, Axis, AngleInRadians, NbOfSteps, Tolerance, MakeGroups=False, TotalAngle=False): - flag = False - if isinstance(AngleInRadians,str): - flag = True - AngleInRadians,AngleParameters = geompyDC.ParseParameters(AngleInRadians) - if flag: - AngleInRadians = DegreesToRadians(AngleInRadians) if ( isinstance( theObject, Mesh )): theObject = theObject.GetMesh() if ( isinstance( Axis, geompyDC.GEOM._objref_GEOM_Object)): Axis = self.smeshpyD.GetAxisStruct(Axis) - Axis,AxisParameters = ParseAxisStruct(Axis) + AngleInRadians,AngleParameters,hasVars = ParseAngles(AngleInRadians) + NbOfSteps,Tolerance,Parameters,hasVars = ParseParameters(NbOfSteps,Tolerance) + Parameters = Axis.parameters + var_separator + AngleParameters + var_separator + Parameters + self.mesh.SetParameters(Parameters) if TotalAngle and NbOfSteps: AngleInRadians /= NbOfSteps - NbOfSteps,Tolerance,Parameters = geompyDC.ParseParameters(NbOfSteps,Tolerance) - Parameters = AxisParameters + var_separator + AngleParameters + var_separator + Parameters - self.mesh.SetParameters(Parameters) if MakeGroups: return self.editor.RotationSweepObject2DMakeGroups(theObject, Axis, AngleInRadians, NbOfSteps, Tolerance) @@ -3441,28 +3234,40 @@ class Mesh: ## Generates new elements by extrusion of the elements with given ids # @param IDsOfElements the list of elements ids for extrusion - # @param StepVector vector or DirStruct, defining the direction and value of extrusion for one step (the total extrusion length will be NbOfSteps * ||StepVector||) + # @param StepVector vector or DirStruct or 3 vector components, defining + # the direction and value of extrusion for one step (the total extrusion + # length will be NbOfSteps * ||StepVector||) # @param NbOfSteps the number of steps # @param MakeGroups forces the generation of new groups from existing ones + # @param IsNodes is True if elements with given ids are nodes # @return the list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise # @ingroup l2_modif_extrurev - def ExtrusionSweep(self, IDsOfElements, StepVector, NbOfSteps, MakeGroups=False): + def ExtrusionSweep(self, IDsOfElements, StepVector, NbOfSteps, MakeGroups=False, IsNodes = False): if IDsOfElements == []: IDsOfElements = self.GetElementsId() - if ( isinstance( StepVector, geompyDC.GEOM._objref_GEOM_Object)): + if isinstance( StepVector, geompyDC.GEOM._objref_GEOM_Object): StepVector = self.smeshpyD.GetDirStruct(StepVector) - StepVector,StepVectorParameters = ParseDirStruct(StepVector) - NbOfSteps,Parameters = geompyDC.ParseParameters(NbOfSteps) - Parameters = StepVectorParameters + var_separator + Parameters + if isinstance( StepVector, list ): + StepVector = self.smeshpyD.MakeDirStruct(*StepVector) + NbOfSteps,Parameters,hasVars = ParseParameters(NbOfSteps) + Parameters = StepVector.PS.parameters + var_separator + Parameters self.mesh.SetParameters(Parameters) if MakeGroups: - return self.editor.ExtrusionSweepMakeGroups(IDsOfElements, StepVector, NbOfSteps) - self.editor.ExtrusionSweep(IDsOfElements, StepVector, NbOfSteps) + if(IsNodes): + return self.editor.ExtrusionSweepMakeGroups0D(IDsOfElements, StepVector, NbOfSteps) + else: + return self.editor.ExtrusionSweepMakeGroups(IDsOfElements, StepVector, NbOfSteps) + if(IsNodes): + self.editor.ExtrusionSweep0D(IDsOfElements, StepVector, NbOfSteps) + else: + self.editor.ExtrusionSweep(IDsOfElements, StepVector, NbOfSteps) return [] ## Generates new elements by extrusion of the elements with given ids # @param IDsOfElements is ids of elements - # @param StepVector vector, defining the direction and value of extrusion + # @param StepVector vector or DirStruct or 3 vector components, defining + # the direction and value of extrusion for one step (the total extrusion + # length will be NbOfSteps * ||StepVector||) # @param NbOfSteps the number of steps # @param ExtrFlags sets flags for extrusion # @param SewTolerance uses for comparing locations of nodes if flag @@ -3474,6 +3279,8 @@ class Mesh: ExtrFlags, SewTolerance, MakeGroups=False): if ( isinstance( StepVector, geompyDC.GEOM._objref_GEOM_Object)): StepVector = self.smeshpyD.GetDirStruct(StepVector) + if isinstance( StepVector, list ): + StepVector = self.smeshpyD.MakeDirStruct(*StepVector) if MakeGroups: return self.editor.AdvancedExtrusionMakeGroups(IDsOfElements, StepVector, NbOfSteps, ExtrFlags, SewTolerance) @@ -3484,29 +3291,41 @@ class Mesh: ## Generates new elements by extrusion of the elements which belong to the object # @param theObject the object which elements should be processed. # It can be a mesh, a sub mesh or a group. - # @param StepVector vector, defining the direction and value of extrusion for one step (the total extrusion length will be NbOfSteps * ||StepVector||) + # @param StepVector vector or DirStruct or 3 vector components, defining + # the direction and value of extrusion for one step (the total extrusion + # length will be NbOfSteps * ||StepVector||) # @param NbOfSteps the number of steps # @param MakeGroups forces the generation of new groups from existing ones + # @param IsNodes is True if elements which belong to the object are nodes # @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise # @ingroup l2_modif_extrurev - def ExtrusionSweepObject(self, theObject, StepVector, NbOfSteps, MakeGroups=False): + def ExtrusionSweepObject(self, theObject, StepVector, NbOfSteps, MakeGroups=False, IsNodes=False): if ( isinstance( theObject, Mesh )): theObject = theObject.GetMesh() if ( isinstance( StepVector, geompyDC.GEOM._objref_GEOM_Object)): StepVector = self.smeshpyD.GetDirStruct(StepVector) - StepVector,StepVectorParameters = ParseDirStruct(StepVector) - NbOfSteps,Parameters = geompyDC.ParseParameters(NbOfSteps) - Parameters = StepVectorParameters + var_separator + Parameters + if isinstance( StepVector, list ): + StepVector = self.smeshpyD.MakeDirStruct(*StepVector) + NbOfSteps,Parameters,hasVars = ParseParameters(NbOfSteps) + Parameters = StepVector.PS.parameters + var_separator + Parameters self.mesh.SetParameters(Parameters) if MakeGroups: - return self.editor.ExtrusionSweepObjectMakeGroups(theObject, StepVector, NbOfSteps) - self.editor.ExtrusionSweepObject(theObject, StepVector, NbOfSteps) + if(IsNodes): + return self.editor.ExtrusionSweepObject0DMakeGroups(theObject, StepVector, NbOfSteps) + else: + return self.editor.ExtrusionSweepObjectMakeGroups(theObject, StepVector, NbOfSteps) + if(IsNodes): + self.editor.ExtrusionSweepObject0D(theObject, StepVector, NbOfSteps) + else: + self.editor.ExtrusionSweepObject(theObject, StepVector, NbOfSteps) return [] ## Generates new elements by extrusion of the elements which belong to the object # @param theObject object which elements should be processed. # It can be a mesh, a sub mesh or a group. - # @param StepVector vector, defining the direction and value of extrusion for one step (the total extrusion length will be NbOfSteps * ||StepVector||) + # @param StepVector vector or DirStruct or 3 vector components, defining + # the direction and value of extrusion for one step (the total extrusion + # length will be NbOfSteps * ||StepVector||) # @param NbOfSteps the number of steps # @param MakeGroups to generate new groups from existing ones # @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise @@ -3516,9 +3335,10 @@ class Mesh: theObject = theObject.GetMesh() if ( isinstance( StepVector, geompyDC.GEOM._objref_GEOM_Object)): StepVector = self.smeshpyD.GetDirStruct(StepVector) - StepVector,StepVectorParameters = ParseDirStruct(StepVector) - NbOfSteps,Parameters = geompyDC.ParseParameters(NbOfSteps) - Parameters = StepVectorParameters + var_separator + Parameters + if isinstance( StepVector, list ): + StepVector = self.smeshpyD.MakeDirStruct(*StepVector) + NbOfSteps,Parameters,hasVars = ParseParameters(NbOfSteps) + Parameters = StepVector.PS.parameters + var_separator + Parameters self.mesh.SetParameters(Parameters) if MakeGroups: return self.editor.ExtrusionSweepObject1DMakeGroups(theObject, StepVector, NbOfSteps) @@ -3528,7 +3348,9 @@ class Mesh: ## Generates new elements by extrusion of the elements which belong to the object # @param theObject object which elements should be processed. # It can be a mesh, a sub mesh or a group. - # @param StepVector vector, defining the direction and value of extrusion for one step (the total extrusion length will be NbOfSteps * ||StepVector||) + # @param StepVector vector or DirStruct or 3 vector components, defining + # the direction and value of extrusion for one step (the total extrusion + # length will be NbOfSteps * ||StepVector||) # @param NbOfSteps the number of steps # @param MakeGroups forces the generation of new groups from existing ones # @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise @@ -3538,9 +3360,10 @@ class Mesh: theObject = theObject.GetMesh() if ( isinstance( StepVector, geompyDC.GEOM._objref_GEOM_Object)): StepVector = self.smeshpyD.GetDirStruct(StepVector) - StepVector,StepVectorParameters = ParseDirStruct(StepVector) - NbOfSteps,Parameters = geompyDC.ParseParameters(NbOfSteps) - Parameters = StepVectorParameters + var_separator + Parameters + if isinstance( StepVector, list ): + StepVector = self.smeshpyD.MakeDirStruct(*StepVector) + NbOfSteps,Parameters,hasVars = ParseParameters(NbOfSteps) + Parameters = StepVector.PS.parameters + var_separator + Parameters self.mesh.SetParameters(Parameters) if MakeGroups: return self.editor.ExtrusionSweepObject2DMakeGroups(theObject, StepVector, NbOfSteps) @@ -3570,12 +3393,11 @@ class Mesh: def ExtrusionAlongPathX(self, Base, Path, NodeStart, HasAngles, Angles, LinearVariation, HasRefPoint, RefPoint, MakeGroups, ElemType): - Angles,AnglesParameters = ParseAngles(Angles) - RefPoint,RefPointParameters = ParsePointStruct(RefPoint) if ( isinstance( RefPoint, geompyDC.GEOM._objref_GEOM_Object)): RefPoint = self.smeshpyD.GetPointStruct(RefPoint) pass - Parameters = AnglesParameters + var_separator + RefPointParameters + Angles,AnglesParameters,hasVars = ParseAngles(Angles) + Parameters = AnglesParameters + var_separator + RefPoint.parameters self.mesh.SetParameters(Parameters) if (isinstance(Path, Mesh)): Path = Path.GetMesh() @@ -3618,8 +3440,6 @@ class Mesh: def ExtrusionAlongPath(self, IDsOfElements, PathMesh, PathShape, NodeStart, HasAngles, Angles, HasRefPoint, RefPoint, MakeGroups=False, LinearVariation=False): - Angles,AnglesParameters = ParseAngles(Angles) - RefPoint,RefPointParameters = ParsePointStruct(RefPoint) if IDsOfElements == []: IDsOfElements = self.GetElementsId() if ( isinstance( RefPoint, geompyDC.GEOM._objref_GEOM_Object)): @@ -3627,11 +3447,12 @@ class Mesh: pass if ( isinstance( PathMesh, Mesh )): PathMesh = PathMesh.GetMesh() + Angles,AnglesParameters,hasVars = ParseAngles(Angles) + Parameters = AnglesParameters + var_separator + RefPoint.parameters + self.mesh.SetParameters(Parameters) if HasAngles and Angles and LinearVariation: Angles = self.editor.LinearAnglesVariation( PathMesh, PathShape, Angles ) pass - Parameters = AnglesParameters + var_separator + RefPointParameters - self.mesh.SetParameters(Parameters) if MakeGroups: return self.editor.ExtrusionAlongPathMakeGroups(IDsOfElements, PathMesh, PathShape, NodeStart, HasAngles, @@ -3661,19 +3482,18 @@ class Mesh: def ExtrusionAlongPathObject(self, theObject, PathMesh, PathShape, NodeStart, HasAngles, Angles, HasRefPoint, RefPoint, MakeGroups=False, LinearVariation=False): - Angles,AnglesParameters = ParseAngles(Angles) - RefPoint,RefPointParameters = ParsePointStruct(RefPoint) if ( isinstance( theObject, Mesh )): theObject = theObject.GetMesh() if ( isinstance( RefPoint, geompyDC.GEOM._objref_GEOM_Object)): RefPoint = self.smeshpyD.GetPointStruct(RefPoint) if ( isinstance( PathMesh, Mesh )): PathMesh = PathMesh.GetMesh() + Angles,AnglesParameters,hasVars = ParseAngles(Angles) + Parameters = AnglesParameters + var_separator + RefPoint.parameters + self.mesh.SetParameters(Parameters) if HasAngles and Angles and LinearVariation: Angles = self.editor.LinearAnglesVariation( PathMesh, PathShape, Angles ) pass - Parameters = AnglesParameters + var_separator + RefPointParameters - self.mesh.SetParameters(Parameters) if MakeGroups: return self.editor.ExtrusionAlongPathObjectMakeGroups(theObject, PathMesh, PathShape, NodeStart, HasAngles, @@ -3704,19 +3524,18 @@ class Mesh: def ExtrusionAlongPathObject1D(self, theObject, PathMesh, PathShape, NodeStart, HasAngles, Angles, HasRefPoint, RefPoint, MakeGroups=False, LinearVariation=False): - Angles,AnglesParameters = ParseAngles(Angles) - RefPoint,RefPointParameters = ParsePointStruct(RefPoint) if ( isinstance( theObject, Mesh )): theObject = theObject.GetMesh() if ( isinstance( RefPoint, geompyDC.GEOM._objref_GEOM_Object)): RefPoint = self.smeshpyD.GetPointStruct(RefPoint) if ( isinstance( PathMesh, Mesh )): PathMesh = PathMesh.GetMesh() + Angles,AnglesParameters,hasVars = ParseAngles(Angles) + Parameters = AnglesParameters + var_separator + RefPoint.parameters + self.mesh.SetParameters(Parameters) if HasAngles and Angles and LinearVariation: Angles = self.editor.LinearAnglesVariation( PathMesh, PathShape, Angles ) pass - Parameters = AnglesParameters + var_separator + RefPointParameters - self.mesh.SetParameters(Parameters) if MakeGroups: return self.editor.ExtrusionAlongPathObject1DMakeGroups(theObject, PathMesh, PathShape, NodeStart, HasAngles, @@ -3747,19 +3566,18 @@ class Mesh: def ExtrusionAlongPathObject2D(self, theObject, PathMesh, PathShape, NodeStart, HasAngles, Angles, HasRefPoint, RefPoint, MakeGroups=False, LinearVariation=False): - Angles,AnglesParameters = ParseAngles(Angles) - RefPoint,RefPointParameters = ParsePointStruct(RefPoint) if ( isinstance( theObject, Mesh )): theObject = theObject.GetMesh() if ( isinstance( RefPoint, geompyDC.GEOM._objref_GEOM_Object)): RefPoint = self.smeshpyD.GetPointStruct(RefPoint) if ( isinstance( PathMesh, Mesh )): PathMesh = PathMesh.GetMesh() + Angles,AnglesParameters,hasVars = ParseAngles(Angles) + Parameters = AnglesParameters + var_separator + RefPoint.parameters + self.mesh.SetParameters(Parameters) if HasAngles and Angles and LinearVariation: Angles = self.editor.LinearAnglesVariation( PathMesh, PathShape, Angles ) pass - Parameters = AnglesParameters + var_separator + RefPointParameters - self.mesh.SetParameters(Parameters) if MakeGroups: return self.editor.ExtrusionAlongPathObject2DMakeGroups(theObject, PathMesh, PathShape, NodeStart, HasAngles, @@ -3782,8 +3600,7 @@ class Mesh: IDsOfElements = self.GetElementsId() if ( isinstance( Mirror, geompyDC.GEOM._objref_GEOM_Object)): Mirror = self.smeshpyD.GetAxisStruct(Mirror) - Mirror,Parameters = ParseAxisStruct(Mirror) - self.mesh.SetParameters(Parameters) + self.mesh.SetParameters(Mirror.parameters) if Copy and MakeGroups: return self.editor.MirrorMakeGroups(IDsOfElements, Mirror, theMirrorType) self.editor.Mirror(IDsOfElements, Mirror, theMirrorType, Copy) @@ -3803,10 +3620,9 @@ class Mesh: IDsOfElements = self.GetElementsId() if ( isinstance( Mirror, geompyDC.GEOM._objref_GEOM_Object)): Mirror = self.smeshpyD.GetAxisStruct(Mirror) - Mirror,Parameters = ParseAxisStruct(Mirror) + self.mesh.SetParameters(Mirror.parameters) mesh = self.editor.MirrorMakeMesh(IDsOfElements, Mirror, theMirrorType, MakeGroups, NewMeshName) - mesh.SetParameters(Parameters) return Mesh(self.smeshpyD,self.geompyD,mesh) ## Creates a symmetrical copy of the object @@ -3823,8 +3639,7 @@ class Mesh: theObject = theObject.GetMesh() if ( isinstance( Mirror, geompyDC.GEOM._objref_GEOM_Object)): Mirror = self.smeshpyD.GetAxisStruct(Mirror) - Mirror,Parameters = ParseAxisStruct(Mirror) - self.mesh.SetParameters(Parameters) + self.mesh.SetParameters(Mirror.parameters) if Copy and MakeGroups: return self.editor.MirrorObjectMakeGroups(theObject, Mirror, theMirrorType) self.editor.MirrorObject(theObject, Mirror, theMirrorType, Copy) @@ -3844,15 +3659,14 @@ class Mesh: theObject = theObject.GetMesh() if (isinstance(Mirror, geompyDC.GEOM._objref_GEOM_Object)): Mirror = self.smeshpyD.GetAxisStruct(Mirror) - Mirror,Parameters = ParseAxisStruct(Mirror) + self.mesh.SetParameters(Mirror.parameters) mesh = self.editor.MirrorObjectMakeMesh(theObject, Mirror, theMirrorType, MakeGroups, NewMeshName) - mesh.SetParameters(Parameters) return Mesh( self.smeshpyD,self.geompyD,mesh ) ## Translates the elements # @param IDsOfElements list of elements ids - # @param Vector the direction of translation (DirStruct or vector) + # @param Vector the direction of translation (DirStruct or vector or 3 vector components) # @param Copy allows copying the translated elements # @param MakeGroups forces the generation of new groups from existing ones (if Copy) # @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise @@ -3862,8 +3676,9 @@ class Mesh: IDsOfElements = self.GetElementsId() if ( isinstance( Vector, geompyDC.GEOM._objref_GEOM_Object)): Vector = self.smeshpyD.GetDirStruct(Vector) - Vector,Parameters = ParseDirStruct(Vector) - self.mesh.SetParameters(Parameters) + if isinstance( Vector, list ): + Vector = self.smeshpyD.MakeDirStruct(*Vector) + self.mesh.SetParameters(Vector.PS.parameters) if Copy and MakeGroups: return self.editor.TranslateMakeGroups(IDsOfElements, Vector) self.editor.Translate(IDsOfElements, Vector, Copy) @@ -3871,7 +3686,7 @@ class Mesh: ## Creates a new mesh of translated elements # @param IDsOfElements list of elements ids - # @param Vector the direction of translation (DirStruct or vector) + # @param Vector the direction of translation (DirStruct or vector or 3 vector components) # @param MakeGroups forces the generation of new groups from existing ones # @param NewMeshName the name of the newly created mesh # @return instance of Mesh class @@ -3881,14 +3696,15 @@ class Mesh: IDsOfElements = self.GetElementsId() if ( isinstance( Vector, geompyDC.GEOM._objref_GEOM_Object)): Vector = self.smeshpyD.GetDirStruct(Vector) - Vector,Parameters = ParseDirStruct(Vector) + if isinstance( Vector, list ): + Vector = self.smeshpyD.MakeDirStruct(*Vector) + self.mesh.SetParameters(Vector.PS.parameters) mesh = self.editor.TranslateMakeMesh(IDsOfElements, Vector, MakeGroups, NewMeshName) - mesh.SetParameters(Parameters) return Mesh ( self.smeshpyD, self.geompyD, mesh ) ## Translates the object # @param theObject the object to translate (mesh, submesh, or group) - # @param Vector direction of translation (DirStruct or geom vector) + # @param Vector direction of translation (DirStruct or geom vector or 3 vector components) # @param Copy allows copying the translated elements # @param MakeGroups forces the generation of new groups from existing ones (if Copy) # @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise @@ -3898,8 +3714,9 @@ class Mesh: theObject = theObject.GetMesh() if ( isinstance( Vector, geompyDC.GEOM._objref_GEOM_Object)): Vector = self.smeshpyD.GetDirStruct(Vector) - Vector,Parameters = ParseDirStruct(Vector) - self.mesh.SetParameters(Parameters) + if isinstance( Vector, list ): + Vector = self.smeshpyD.MakeDirStruct(*Vector) + self.mesh.SetParameters(Vector.PS.parameters) if Copy and MakeGroups: return self.editor.TranslateObjectMakeGroups(theObject, Vector) self.editor.TranslateObject(theObject, Vector, Copy) @@ -3907,19 +3724,20 @@ class Mesh: ## Creates a new mesh from the translated object # @param theObject the object to translate (mesh, submesh, or group) - # @param Vector the direction of translation (DirStruct or geom vector) + # @param Vector the direction of translation (DirStruct or geom vector or 3 vector components) # @param MakeGroups forces the generation of new groups from existing ones # @param NewMeshName the name of the newly created mesh # @return instance of Mesh class # @ingroup l2_modif_trsf def TranslateObjectMakeMesh(self, theObject, Vector, MakeGroups=False, NewMeshName=""): - if (isinstance(theObject, Mesh)): + if isinstance( theObject, Mesh ): theObject = theObject.GetMesh() - if (isinstance(Vector, geompyDC.GEOM._objref_GEOM_Object)): + if isinstance( Vector, geompyDC.GEOM._objref_GEOM_Object ): Vector = self.smeshpyD.GetDirStruct(Vector) - Vector,Parameters = ParseDirStruct(Vector) + if isinstance( Vector, list ): + Vector = self.smeshpyD.MakeDirStruct(*Vector) + self.mesh.SetParameters(Vector.PS.parameters) mesh = self.editor.TranslateObjectMakeMesh(theObject, Vector, MakeGroups, NewMeshName) - mesh.SetParameters(Parameters) return Mesh( self.smeshpyD, self.geompyD, mesh ) @@ -3938,9 +3756,12 @@ class Mesh: theObject = theObject.GetMesh() if ( isinstance( theObject, list )): theObject = self.GetIDSource(theObject, SMESH.ALL) + if ( isinstance( theScaleFact, float )): + theScaleFact = [theScaleFact] + if ( isinstance( theScaleFact, int )): + theScaleFact = [ float(theScaleFact)] - thePoint, Parameters = ParsePointStruct(thePoint) - self.mesh.SetParameters(Parameters) + self.mesh.SetParameters(thePoint.parameters) if Copy and MakeGroups: return self.editor.ScaleMakeGroups(theObject, thePoint, theScaleFact) @@ -3959,10 +3780,14 @@ class Mesh: theObject = theObject.GetMesh() if ( isinstance( theObject, list )): theObject = self.GetIDSource(theObject,SMESH.ALL) + if ( isinstance( theScaleFact, float )): + theScaleFact = [theScaleFact] + if ( isinstance( theScaleFact, int )): + theScaleFact = [ float(theScaleFact)] + self.mesh.SetParameters(thePoint.parameters) mesh = self.editor.ScaleMakeMesh(theObject, thePoint, theScaleFact, MakeGroups, NewMeshName) - #mesh.SetParameters(Parameters) return Mesh( self.smeshpyD, self.geompyD, mesh ) @@ -3976,18 +3801,12 @@ class Mesh: # @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise # @ingroup l2_modif_trsf def Rotate (self, IDsOfElements, Axis, AngleInRadians, Copy, MakeGroups=False): - flag = False - if isinstance(AngleInRadians,str): - flag = True - AngleInRadians,Parameters = geompyDC.ParseParameters(AngleInRadians) - if flag: - AngleInRadians = DegreesToRadians(AngleInRadians) if IDsOfElements == []: IDsOfElements = self.GetElementsId() if ( isinstance( Axis, geompyDC.GEOM._objref_GEOM_Object)): Axis = self.smeshpyD.GetAxisStruct(Axis) - Axis,AxisParameters = ParseAxisStruct(Axis) - Parameters = AxisParameters + var_separator + Parameters + AngleInRadians,Parameters,hasVars = ParseAngles(AngleInRadians) + Parameters = Axis.parameters + var_separator + Parameters self.mesh.SetParameters(Parameters) if Copy and MakeGroups: return self.editor.RotateMakeGroups(IDsOfElements, Axis, AngleInRadians) @@ -4003,21 +3822,15 @@ class Mesh: # @return instance of Mesh class # @ingroup l2_modif_trsf def RotateMakeMesh (self, IDsOfElements, Axis, AngleInRadians, MakeGroups=0, NewMeshName=""): - flag = False - if isinstance(AngleInRadians,str): - flag = True - AngleInRadians,Parameters = geompyDC.ParseParameters(AngleInRadians) - if flag: - AngleInRadians = DegreesToRadians(AngleInRadians) if IDsOfElements == []: IDsOfElements = self.GetElementsId() if ( isinstance( Axis, geompyDC.GEOM._objref_GEOM_Object)): Axis = self.smeshpyD.GetAxisStruct(Axis) - Axis,AxisParameters = ParseAxisStruct(Axis) - Parameters = AxisParameters + var_separator + Parameters + AngleInRadians,Parameters,hasVars = ParseAngles(AngleInRadians) + Parameters = Axis.parameters + var_separator + Parameters + self.mesh.SetParameters(Parameters) mesh = self.editor.RotateMakeMesh(IDsOfElements, Axis, AngleInRadians, MakeGroups, NewMeshName) - mesh.SetParameters(Parameters) return Mesh( self.smeshpyD, self.geompyD, mesh ) ## Rotates the object @@ -4029,18 +3842,12 @@ class Mesh: # @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise # @ingroup l2_modif_trsf def RotateObject (self, theObject, Axis, AngleInRadians, Copy, MakeGroups=False): - flag = False - if isinstance(AngleInRadians,str): - flag = True - AngleInRadians,Parameters = geompyDC.ParseParameters(AngleInRadians) - if flag: - AngleInRadians = DegreesToRadians(AngleInRadians) if (isinstance(theObject, Mesh)): theObject = theObject.GetMesh() if (isinstance(Axis, geompyDC.GEOM._objref_GEOM_Object)): Axis = self.smeshpyD.GetAxisStruct(Axis) - Axis,AxisParameters = ParseAxisStruct(Axis) - Parameters = AxisParameters + ":" + Parameters + AngleInRadians,Parameters,hasVars = ParseAngles(AngleInRadians) + Parameters = Axis.parameters + ":" + Parameters self.mesh.SetParameters(Parameters) if Copy and MakeGroups: return self.editor.RotateObjectMakeGroups(theObject, Axis, AngleInRadians) @@ -4056,21 +3863,15 @@ class Mesh: # @return instance of Mesh class # @ingroup l2_modif_trsf def RotateObjectMakeMesh(self, theObject, Axis, AngleInRadians, MakeGroups=0,NewMeshName=""): - flag = False - if isinstance(AngleInRadians,str): - flag = True - AngleInRadians,Parameters = geompyDC.ParseParameters(AngleInRadians) - if flag: - AngleInRadians = DegreesToRadians(AngleInRadians) if (isinstance( theObject, Mesh )): theObject = theObject.GetMesh() if (isinstance(Axis, geompyDC.GEOM._objref_GEOM_Object)): Axis = self.smeshpyD.GetAxisStruct(Axis) - Axis,AxisParameters = ParseAxisStruct(Axis) - Parameters = AxisParameters + ":" + Parameters + AngleInRadians,Parameters,hasVars = ParseAngles(AngleInRadians) + Parameters = Axis.parameters + ":" + Parameters mesh = self.editor.RotateObjectMakeMesh(theObject, Axis, AngleInRadians, MakeGroups, NewMeshName) - mesh.SetParameters(Parameters) + self.mesh.SetParameters(Parameters) return Mesh( self.smeshpyD, self.geompyD, mesh ) ## Finds groups of ajacent nodes within Tolerance. @@ -4260,12 +4061,20 @@ class Mesh: # @param theAffectedElems - group of elements to which the replicated nodes # should be associated to. # @param theMakeGroup forces the generation of a group containing new elements. - # @return TRUE or a created group if operation has been completed successfully, + # @param theMakeNodeGroup forces the generation of a group containing new nodes. + # @return TRUE or created groups (one or two) if operation has been completed successfully, # FALSE or None otherwise # @ingroup l2_modif_edit - def DoubleNodeElemGroup(self, theElems, theNodesNot, theAffectedElems, theMakeGroup=False): - if theMakeGroup: - return self.editor.DoubleNodeElemGroupNew(theElems, theNodesNot, theAffectedElems) + def DoubleNodeElemGroup(self, theElems, theNodesNot, theAffectedElems, + theMakeGroup=False, theMakeNodeGroup=False): + if theMakeGroup or theMakeNodeGroup: + twoGroups = self.editor.DoubleNodeElemGroup2New(theElems, theNodesNot, + theAffectedElems, + theMakeGroup, theMakeNodeGroup) + if theMakeGroup and theMakeNodeGroup: + return twoGroups + else: + return twoGroups[ int(theMakeNodeGroup) ] return self.editor.DoubleNodeElemGroup(theElems, theNodesNot, theAffectedElems) ## Creates a hole in a mesh by doubling the nodes of some particular elements @@ -4286,12 +4095,20 @@ class Mesh: # @param theAffectedElems - group of elements to which the replicated nodes # should be associated to. # @param theMakeGroup forces the generation of a group containing new elements. - # @return TRUE or a created group if operation has been completed successfully, + # @param theMakeNodeGroup forces the generation of a group containing new nodes. + # @return TRUE or created groups (one or two) if operation has been completed successfully, # FALSE or None otherwise # @ingroup l2_modif_edit - def DoubleNodeElemGroups(self, theElems, theNodesNot, theAffectedElems, theMakeGroup=False): - if theMakeGroup: - return self.editor.DoubleNodeElemGroupsNew(theElems, theNodesNot, theAffectedElems) + def DoubleNodeElemGroups(self, theElems, theNodesNot, theAffectedElems, + theMakeGroup=False, theMakeNodeGroup=False): + if theMakeGroup or theMakeNodeGroup: + twoGroups = self.editor.DoubleNodeElemGroups2New(theElems, theNodesNot, + theAffectedElems, + theMakeGroup, theMakeNodeGroup) + if theMakeGroup and theMakeNodeGroup: + return twoGroups + else: + return twoGroups[ int(theMakeNodeGroup) ] return self.editor.DoubleNodeElemGroups(theElems, theNodesNot, theAffectedElems) ## Creates a hole in a mesh by doubling the nodes of some particular elements @@ -4306,6 +4123,18 @@ class Mesh: def DoubleNodeElemGroupsInRegion(self, theElems, theNodesNot, theShape): return self.editor.DoubleNodeElemGroupsInRegion(theElems, theNodesNot, theShape) + ## Identify the elements that will be affected by node duplication (actual duplication is not performed. + # This method is the first step of DoubleNodeElemGroupsInRegion. + # @param theElems - list of groups of elements (edges or faces) to be replicated + # @param theNodesNot - list of groups of nodes not to replicated + # @param theShape - shape to detect affected elements (element which geometric center + # located on or inside shape). + # The replicated nodes should be associated to affected elements. + # @return groups of affected elements + # @ingroup l2_modif_edit + def AffectedElemGroupsInRegion(self, theElems, theNodesNot, theShape): + return self.editor.AffectedElemGroupsInRegion(theElems, theNodesNot, theShape) + ## Double nodes on shared faces between groups of volumes and create flat elements on demand. # The list of groups must describe a partition of the mesh volumes. # The nodes of the internal faces at the boundaries of the groups are doubled. @@ -4326,10 +4155,22 @@ class Mesh: # @return TRUE if operation has been completed successfully, FALSE otherwise def CreateFlatElementsOnFacesGroups(self, theGroupsOfFaces ): return self.editor.CreateFlatElementsOnFacesGroups( theGroupsOfFaces ) + + ## identify all the elements around a geom shape, get the faces delimiting the hole + # + def CreateHoleSkin(self, radius, theShape, groupName, theNodesCoords): + return self.editor.CreateHoleSkin( radius, theShape, groupName, theNodesCoords ) + + def _getFunctor(self, funcType ): + fn = self.functors[ funcType._v ] + if not fn: + fn = self.smeshpyD.GetFunctor(funcType) + fn.SetMesh(self.mesh) + self.functors[ funcType._v ] = fn + return fn def _valueFromFunctor(self, funcType, elemId): - fn = self.smeshpyD.GetFunctor(funcType) - fn.SetMesh(self.mesh) + fn = self._getFunctor( funcType ) if fn.GetElementType() == self.GetElementType(elemId, True): val = fn.GetValue(elemId) else: @@ -4407,2503 +4248,95 @@ class Mesh: def GetSkew(self, elemId): return self._valueFromFunctor(SMESH.FT_Skew, elemId) -## The mother class to define algorithm, it is not recommended to use it directly. + pass # end of Mesh class + +## Helper class for wrapping of SMESH.SMESH_Pattern CORBA class # -# More details. -# @ingroup l2_algorithms -class Mesh_Algorithm: - # @class Mesh_Algorithm - # @brief Class Mesh_Algorithm - - #def __init__(self,smesh): - # self.smesh=smesh - def __init__(self): - self.mesh = None - self.geom = None - self.subm = None - self.algo = None - - ## Finds a hypothesis in the study by its type name and parameters. - # Finds only the hypotheses created in smeshpyD engine. - # @return SMESH.SMESH_Hypothesis - def FindHypothesis (self, hypname, args, CompareMethod, smeshpyD): - study = smeshpyD.GetCurrentStudy() - #to do: find component by smeshpyD object, not by its data type - scomp = study.FindComponent(smeshpyD.ComponentDataType()) - if scomp is not None: - res,hypRoot = scomp.FindSubObject(SMESH.Tag_HypothesisRoot) - # Check if the root label of the hypotheses exists - if res and hypRoot is not None: - iter = study.NewChildIterator(hypRoot) - # Check all published hypotheses - while iter.More(): - hypo_so_i = iter.Value() - attr = hypo_so_i.FindAttribute("AttributeIOR")[1] - if attr is not None: - anIOR = attr.Value() - hypo_o_i = salome.orb.string_to_object(anIOR) - if hypo_o_i is not None: - # Check if this is a hypothesis - hypo_i = hypo_o_i._narrow(SMESH.SMESH_Hypothesis) - if hypo_i is not None: - # Check if the hypothesis belongs to current engine - if smeshpyD.GetObjectId(hypo_i) > 0: - # Check if this is the required hypothesis - if hypo_i.GetName() == hypname: - # Check arguments - if CompareMethod(hypo_i, args): - # found!!! - return hypo_i - pass - pass - pass - pass - pass - iter.Next() - pass - pass - pass - return None - - ## Finds the algorithm in the study by its type name. - # Finds only the algorithms, which have been created in smeshpyD engine. - # @return SMESH.SMESH_Algo - def FindAlgorithm (self, algoname, smeshpyD): - study = smeshpyD.GetCurrentStudy() - #to do: find component by smeshpyD object, not by its data type - scomp = study.FindComponent(smeshpyD.ComponentDataType()) - if scomp is not None: - res,hypRoot = scomp.FindSubObject(SMESH.Tag_AlgorithmsRoot) - # Check if the root label of the algorithms exists - if res and hypRoot is not None: - iter = study.NewChildIterator(hypRoot) - # Check all published algorithms - while iter.More(): - algo_so_i = iter.Value() - attr = algo_so_i.FindAttribute("AttributeIOR")[1] - if attr is not None: - anIOR = attr.Value() - algo_o_i = salome.orb.string_to_object(anIOR) - if algo_o_i is not None: - # Check if this is an algorithm - algo_i = algo_o_i._narrow(SMESH.SMESH_Algo) - if algo_i is not None: - # Checks if the algorithm belongs to the current engine - if smeshpyD.GetObjectId(algo_i) > 0: - # Check if this is the required algorithm - if algo_i.GetName() == algoname: - # found!!! - return algo_i - pass - pass - pass - pass - iter.Next() - pass - pass - pass - return None - - ## If the algorithm is global, returns 0; \n - # else returns the submesh associated to this algorithm. - def GetSubMesh(self): - return self.subm - - ## Returns the wrapped mesher. - def GetAlgorithm(self): - return self.algo - - ## Gets the list of hypothesis that can be used with this algorithm - def GetCompatibleHypothesis(self): - mylist = [] - if self.algo: - mylist = self.algo.GetCompatibleHypothesis() - return mylist - - ## Gets the name of the algorithm - def GetName(self): - GetName(self.algo) - - ## Sets the name to the algorithm - def SetName(self, name): - self.mesh.smeshpyD.SetName(self.algo, name) - - ## Gets the id of the algorithm - def GetId(self): - return self.algo.GetId() - - ## Private method. - def Create(self, mesh, geom, hypo, so="libStdMeshersEngine.so"): - if geom is None: - raise RuntimeError, "Attemp to create " + hypo + " algoritm on None shape" - algo = self.FindAlgorithm(hypo, mesh.smeshpyD) - if algo is None: - algo = mesh.smeshpyD.CreateHypothesis(hypo, so) - pass - self.Assign(algo, mesh, geom) - return self.algo - - ## Private method - def Assign(self, algo, mesh, geom): - if geom is None: - raise RuntimeError, "Attemp to create " + algo + " algoritm on None shape" - self.mesh = mesh - name = "" - if not geom: - self.geom = mesh.geom - else: - self.geom = geom - AssureGeomPublished( mesh, geom ) - try: - name = GetName(geom) - pass - except: - pass - self.subm = mesh.mesh.GetSubMesh(geom, algo.GetName()) - self.algo = algo - status = mesh.mesh.AddHypothesis(self.geom, self.algo) - TreatHypoStatus( status, algo.GetName(), name, True ) - return - - def CompareHyp (self, hyp, args): - print "CompareHyp is not implemented for ", self.__class__.__name__, ":", hyp.GetName() - return False - - def CompareEqualHyp (self, hyp, args): - return True - - ## Private method - def Hypothesis (self, hyp, args=[], so="libStdMeshersEngine.so", - UseExisting=0, CompareMethod=""): - hypo = None - if UseExisting: - if CompareMethod == "": CompareMethod = self.CompareHyp - hypo = self.FindHypothesis(hyp, args, CompareMethod, self.mesh.smeshpyD) - pass - if hypo is None: - hypo = self.mesh.smeshpyD.CreateHypothesis(hyp, so) - a = "" - s = "=" - for arg in args: - argStr = str(arg) - if isinstance( arg, geompyDC.GEOM._objref_GEOM_Object ): - argStr = arg.GetStudyEntry() - if not argStr: argStr = "GEOM_Obj_%s", arg.GetEntry() - a = a + s + argStr - s = "," - pass - self.mesh.smeshpyD.SetName(hypo, hyp + a) - pass - geomName="" - if self.geom: - geomName = GetName(self.geom) - status = self.mesh.mesh.AddHypothesis(self.geom, hypo) - TreatHypoStatus( status, GetName(hypo), geomName, 0 ) - return hypo - - ## Returns entry of the shape to mesh in the study - def MainShapeEntry(self): - entry = "" - if not self.mesh or not self.mesh.GetMesh(): return entry - if not self.mesh.GetMesh().HasShapeToMesh(): return entry - study = self.mesh.smeshpyD.GetCurrentStudy() - ior = salome.orb.object_to_string( self.mesh.GetShape() ) - sobj = study.FindObjectIOR(ior) - if sobj: entry = sobj.GetID() - if not entry: return "" - return entry - - ## Defines "ViscousLayers" hypothesis to give parameters of layers of prisms to build - # near mesh boundary. This hypothesis can be used by several 3D algorithms: - # NETGEN 3D, GHS3D, Hexahedron(i,j,k) - # @param thickness total thickness of layers of prisms - # @param numberOfLayers number of layers of prisms - # @param stretchFactor factor (>1.0) of growth of layer thickness towards inside of mesh - # @param ignoreFaces list of geometrical faces (or their ids) not to generate layers on - # @ingroup l3_hypos_additi - def ViscousLayers(self, thickness, numberOfLayers, stretchFactor, ignoreFaces=[]): - 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(): - raise TypeError, "ViscousLayers are not supported by %s"%self.algo.GetName() - if ignoreFaces and isinstance( ignoreFaces[0], geompyDC.GEOM._objref_GEOM_Object ): - ignoreFaces = [ self.mesh.geompyD.GetSubShapeID(self.mesh.geom, f) for f in ignoreFaces ] - hyp = self.Hypothesis("ViscousLayers", - [thickness, numberOfLayers, stretchFactor, ignoreFaces]) - hyp.SetTotalThickness(thickness) - hyp.SetNumberLayers(numberOfLayers) - hyp.SetStretchFactor(stretchFactor) - hyp.SetIgnoreFaces(ignoreFaces) - return hyp - - ## Transform a list of ether edges or tuples (edge 1st_vertex_of_edge) - # into a list acceptable to SetReversedEdges() of some 1D hypotheses - # @ingroupl3_hypos_1dhyps - def ReversedEdgeIndices(self, reverseList): - resList = [] - geompy = self.mesh.geompyD - for i in reverseList: - if isinstance( i, int ): - s = geompy.SubShapes(self.mesh.geom, [i])[0] - if s.GetShapeType() != geompyDC.GEOM.EDGE: - raise TypeError, "Not EDGE index given" - resList.append( i ) - elif isinstance( i, geompyDC.GEOM._objref_GEOM_Object ): - if i.GetShapeType() != geompyDC.GEOM.EDGE: - raise TypeError, "Not an EDGE given" - resList.append( geompy.GetSubShapeID(self.mesh.geom, i )) - elif len( i ) > 1: - e = i[0] - v = i[1] - if not isinstance( e, geompyDC.GEOM._objref_GEOM_Object ) or \ - not isinstance( v, geompyDC.GEOM._objref_GEOM_Object ): - raise TypeError, "A list item must be a tuple (edge 1st_vertex_of_edge)" - if v.GetShapeType() == geompyDC.GEOM.EDGE and \ - e.GetShapeType() == geompyDC.GEOM.VERTEX: - v,e = e,v - if e.GetShapeType() != geompyDC.GEOM.EDGE or \ - v.GetShapeType() != geompyDC.GEOM.VERTEX: - raise TypeError, "A list item must be a tuple (edge 1st_vertex_of_edge)" - vFirst = FirstVertexOnCurve( e ) - tol = geompy.Tolerance( vFirst )[-1] - if geompy.MinDistance( v, vFirst ) > 1.5*tol: - resList.append( geompy.GetSubShapeID(self.mesh.geom, e )) - else: - raise TypeError, "Item must be either an edge or tuple (edge 1st_vertex_of_edge)" - return resList - -# Public class: Mesh_Segment -# -------------------------- - -## Class to define a segment 1D algorithm for discretization -# -# More details. -# @ingroup l3_algos_basic -class Mesh_Segment(Mesh_Algorithm): - - ## Private constructor. - def __init__(self, mesh, geom=0): - Mesh_Algorithm.__init__(self) - self.Create(mesh, geom, "Regular_1D") - - ## Defines "LocalLength" hypothesis to cut an edge in several segments with the same length - # @param l for the length of segments that cut an edge - # @param UseExisting if ==true - searches for an existing hypothesis created with - # the same parameters, else (default) - creates a new one - # @param 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: - # nb = ceil((edge_length / l) - p) - # Function ceil rounds its argument to the higher integer. - # So, p=0 means rounding of (edge_length / l) to the higher integer, - # p=0.5 means rounding of (edge_length / l) to the nearest integer, - # p=1 means rounding of (edge_length / l) to the lower integer. - # Default value is 1e-07. - # @return an instance of StdMeshers_LocalLength hypothesis - # @ingroup l3_hypos_1dhyps - def LocalLength(self, l, UseExisting=0, p=1e-07): - hyp = self.Hypothesis("LocalLength", [l,p], UseExisting=UseExisting, - CompareMethod=self.CompareLocalLength) - hyp.SetLength(l) - hyp.SetPrecision(p) - return hyp - - ## Private method - ## Checks if the given "LocalLength" hypothesis has the same parameters as the given arguments - def CompareLocalLength(self, hyp, args): - if IsEqual(hyp.GetLength(), args[0]): - return IsEqual(hyp.GetPrecision(), args[1]) - return False - - ## Defines "MaxSize" hypothesis to cut an edge into segments not longer than given value - # @param length is optional maximal allowed length of segment, if it is omitted - # the preestimated length is used that depends on geometry size - # @param UseExisting if ==true - searches for an existing hypothesis created with - # the same parameters, else (default) - create a new one - # @return an instance of StdMeshers_MaxLength hypothesis - # @ingroup l3_hypos_1dhyps - def MaxSize(self, length=0.0, UseExisting=0): - hyp = self.Hypothesis("MaxLength", [length], UseExisting=UseExisting) - if length > 0.0: - # set given length - hyp.SetLength(length) - if not UseExisting: - # set preestimated length - gen = self.mesh.smeshpyD - initHyp = gen.GetHypothesisParameterValues("MaxLength", "libStdMeshersEngine.so", - self.mesh.GetMesh(), self.mesh.GetShape(), - False) # <- byMesh - preHyp = initHyp._narrow(StdMeshers.StdMeshers_MaxLength) - if preHyp: - hyp.SetPreestimatedLength( preHyp.GetPreestimatedLength() ) - pass - pass - hyp.SetUsePreestimatedLength( length == 0.0 ) - return hyp - - ## Defines "NumberOfSegments" hypothesis to cut an edge in a fixed number of segments - # @param n for the number of segments that cut an edge - # @param s for the scale factor (optional) - # @param reversedEdges is a list of edges to mesh using reversed orientation. - # A list item can also be a tuple (edge 1st_vertex_of_edge) - # @param UseExisting if ==true - searches for an existing hypothesis created with - # the same parameters, else (default) - create a new one - # @return an instance of StdMeshers_NumberOfSegments hypothesis - # @ingroup l3_hypos_1dhyps - def NumberOfSegments(self, n, s=[], reversedEdges=[], UseExisting=0): - if not isinstance(reversedEdges,list): #old version script, before adding reversedEdges - reversedEdges, UseExisting = [], reversedEdges - entry = self.MainShapeEntry() - reversedEdgeInd = self.ReversedEdgeIndices(reversedEdges) - if s == []: - hyp = self.Hypothesis("NumberOfSegments", [n, reversedEdgeInd, entry], - UseExisting=UseExisting, - CompareMethod=self.CompareNumberOfSegments) - else: - hyp = self.Hypothesis("NumberOfSegments", [n,s, reversedEdgeInd, entry], - UseExisting=UseExisting, - CompareMethod=self.CompareNumberOfSegments) - hyp.SetDistrType( 1 ) - hyp.SetScaleFactor(s) - hyp.SetNumberOfSegments(n) - hyp.SetReversedEdges( reversedEdgeInd ) - hyp.SetObjectEntry( entry ) - return hyp - - ## Private method - ## Checks if the given "NumberOfSegments" hypothesis has the same parameters as the given arguments - def CompareNumberOfSegments(self, hyp, args): - if hyp.GetNumberOfSegments() == args[0]: - if len(args) == 3: - if hyp.GetReversedEdges() == args[1]: - if not args[1] or hyp.GetObjectEntry() == args[2]: - return True - else: - if hyp.GetReversedEdges() == args[2]: - if not args[2] or hyp.GetObjectEntry() == args[3]: - if hyp.GetDistrType() == 1: - if IsEqual(hyp.GetScaleFactor(), args[1]): - return True - return False - - ## 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 - # @param reversedEdges is a list of edges to mesh using reversed orientation. - # A list item can also be a tuple (edge 1st_vertex_of_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_Arithmetic1D hypothesis - # @ingroup l3_hypos_1dhyps - def Arithmetic1D(self, start, end, reversedEdges=[], UseExisting=0): - if not isinstance(reversedEdges,list): #old version script, before adding reversedEdges - reversedEdges, UseExisting = [], reversedEdges - reversedEdgeInd = self.ReversedEdgeIndices(reversedEdges) - entry = self.MainShapeEntry() - hyp = self.Hypothesis("Arithmetic1D", [start, end, reversedEdgeInd, entry], - UseExisting=UseExisting, - CompareMethod=self.CompareArithmetic1D) - hyp.SetStartLength(start) - hyp.SetEndLength(end) - hyp.SetReversedEdges( reversedEdgeInd ) - hyp.SetObjectEntry( entry ) - return hyp - - ## Private method - ## Check if the given "Arithmetic1D" hypothesis has the same parameters as the given arguments - def CompareArithmetic1D(self, hyp, args): - if IsEqual(hyp.GetLength(1), args[0]): - if IsEqual(hyp.GetLength(0), args[1]): - if hyp.GetReversedEdges() == args[2]: - if not args[2] or hyp.GetObjectEntry() == args[3]: - return True - return False - - - ## Defines "FixedPoints1D" hypothesis to cut an edge using parameter - # on curve from 0 to 1 (additionally it is neecessary to check - # orientation of edges and create list of reversed edges if it is - # needed) and sets numbers of segments between given points (default - # values are equals 1 - # @param points defines the list of parameters on curve - # @param nbSegs defines the list of numbers of segments - # @param reversedEdges is a list of edges to mesh using reversed orientation. - # A list item can also be a tuple (edge 1st_vertex_of_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_Arithmetic1D hypothesis - # @ingroup l3_hypos_1dhyps - def FixedPoints1D(self, points, nbSegs=[1], reversedEdges=[], UseExisting=0): - if not isinstance(reversedEdges,list): #old version script, before adding reversedEdges - reversedEdges, UseExisting = [], reversedEdges - reversedEdgeInd = self.ReversedEdgeIndices(reversedEdges) - entry = self.MainShapeEntry() - hyp = self.Hypothesis("FixedPoints1D", [points, nbSegs, reversedEdgeInd, entry], - UseExisting=UseExisting, - CompareMethod=self.CompareFixedPoints1D) - hyp.SetPoints(points) - hyp.SetNbSegments(nbSegs) - hyp.SetReversedEdges(reversedEdgeInd) - hyp.SetObjectEntry(entry) - return hyp - - ## Private method - ## Check if the given "FixedPoints1D" hypothesis has the same parameters - ## as the given arguments - def CompareFixedPoints1D(self, hyp, args): - if hyp.GetPoints() == args[0]: - if hyp.GetNbSegments() == args[1]: - if hyp.GetReversedEdges() == args[2]: - if not args[2] or hyp.GetObjectEntry() == args[3]: - return True - return False - - - - ## Defines "StartEndLength" hypothesis to cut an edge in several segments with increasing geometric length - # @param start defines the length of the first segment - # @param end defines the length of the last segment - # @param reversedEdges is a list of edges to mesh using reversed orientation. - # A list item can also be a tuple (edge 1st_vertex_of_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_StartEndLength hypothesis - # @ingroup l3_hypos_1dhyps - def StartEndLength(self, start, end, reversedEdges=[], UseExisting=0): - if not isinstance(reversedEdges,list): #old version script, before adding reversedEdges - reversedEdges, UseExisting = [], reversedEdges - reversedEdgeInd = self.ReversedEdgeIndices(reversedEdges) - entry = self.MainShapeEntry() - hyp = self.Hypothesis("StartEndLength", [start, end, reversedEdgeInd, entry], - UseExisting=UseExisting, - CompareMethod=self.CompareStartEndLength) - hyp.SetStartLength(start) - hyp.SetEndLength(end) - hyp.SetReversedEdges( reversedEdgeInd ) - hyp.SetObjectEntry( entry ) - return hyp - - ## Check if the given "StartEndLength" hypothesis has the same parameters as the given arguments - def CompareStartEndLength(self, hyp, args): - if IsEqual(hyp.GetLength(1), args[0]): - if IsEqual(hyp.GetLength(0), args[1]): - if hyp.GetReversedEdges() == args[2]: - if not args[2] or hyp.GetObjectEntry() == args[3]: - return True - return False - - ## Defines "Deflection1D" hypothesis - # @param d for the deflection - # @param UseExisting if ==true - searches for an existing hypothesis created with - # the same parameters, else (default) - create a new one - # @ingroup l3_hypos_1dhyps - def Deflection1D(self, d, UseExisting=0): - hyp = self.Hypothesis("Deflection1D", [d], UseExisting=UseExisting, - CompareMethod=self.CompareDeflection1D) - hyp.SetDeflection(d) - return hyp - - ## Check if the given "Deflection1D" hypothesis has the same parameters as the given arguments - def CompareDeflection1D(self, hyp, args): - return IsEqual(hyp.GetDeflection(), args[0]) - - ## Defines "Propagation" hypothesis that propagates all other hypotheses on all other edges that are at - # the opposite side in case of quadrangular faces - # @ingroup l3_hypos_additi - def Propagation(self): - return self.Hypothesis("Propagation", UseExisting=1, CompareMethod=self.CompareEqualHyp) - - ## Defines "AutomaticLength" hypothesis - # @param fineness for the fineness [0-1] - # @param UseExisting if ==true - searches for an existing hypothesis created with the - # same parameters, else (default) - create a new one - # @ingroup l3_hypos_1dhyps - def AutomaticLength(self, fineness=0, UseExisting=0): - hyp = self.Hypothesis("AutomaticLength",[fineness],UseExisting=UseExisting, - CompareMethod=self.CompareAutomaticLength) - hyp.SetFineness( fineness ) - return hyp - - ## Checks if the given "AutomaticLength" hypothesis has the same parameters as the given arguments - def CompareAutomaticLength(self, hyp, args): - return IsEqual(hyp.GetFineness(), args[0]) - - ## Defines "SegmentLengthAroundVertex" hypothesis - # @param length for the segment length - # @param vertex for the length localization: the vertex index [0,1] | vertex object. - # Any other integer value means that the hypothesis will be set on the - # whole 1D shape, where Mesh_Segment algorithm is assigned. - # @param UseExisting if ==true - searches for an existing hypothesis created with - # the same parameters, else (default) - creates a new one - # @ingroup l3_algos_segmarv - def LengthNearVertex(self, length, vertex=0, UseExisting=0): - import types - store_geom = self.geom - if type(vertex) is types.IntType: - if vertex == 0 or vertex == 1: - vertex = self.mesh.geompyD.ExtractShapes(self.geom, geompyDC.ShapeType["VERTEX"],True)[vertex] - self.geom = vertex - pass - pass - else: - self.geom = vertex - pass - ### 0D algorithm - if self.geom is None: - raise RuntimeError, "Attemp to create SegmentAroundVertex_0D algoritm on None shape" - AssureGeomPublished( self.mesh, self.geom ) - name = GetName(self.geom) - - algo = self.FindAlgorithm("SegmentAroundVertex_0D", self.mesh.smeshpyD) - if algo is None: - algo = self.mesh.smeshpyD.CreateHypothesis("SegmentAroundVertex_0D", "libStdMeshersEngine.so") - pass - status = self.mesh.mesh.AddHypothesis(self.geom, algo) - TreatHypoStatus(status, "SegmentAroundVertex_0D", name, True) - ### - hyp = self.Hypothesis("SegmentLengthAroundVertex", [length], UseExisting=UseExisting, - CompareMethod=self.CompareLengthNearVertex) - self.geom = store_geom - hyp.SetLength( length ) - return hyp - - ## Checks if the given "LengthNearVertex" hypothesis has the same parameters as the given arguments - # @ingroup l3_algos_segmarv - def CompareLengthNearVertex(self, hyp, args): - return IsEqual(hyp.GetLength(), args[0]) - - ## Defines "QuadraticMesh" hypothesis, forcing construction of quadratic edges. - # If the 2D mesher sees that all boundary edges are quadratic, - # it generates quadratic faces, else it generates linear faces using - # medium nodes as if they are vertices. - # The 3D mesher generates quadratic volumes only if all boundary faces - # are quadratic, else it fails. - # - # @ingroup l3_hypos_additi - def QuadraticMesh(self): - hyp = self.Hypothesis("QuadraticMesh", UseExisting=1, CompareMethod=self.CompareEqualHyp) - return hyp - -# Public class: Mesh_CompositeSegment -# -------------------------- - -## Defines a segment 1D algorithm for discretization -# -# @ingroup l3_algos_basic -class Mesh_CompositeSegment(Mesh_Segment): - - ## Private constructor. - def __init__(self, mesh, geom=0): - self.Create(mesh, geom, "CompositeSegment_1D") - - -# Public class: Mesh_Segment_Python -# --------------------------------- - -## Defines a segment 1D algorithm for discretization with python function -# -# @ingroup l3_algos_basic -class Mesh_Segment_Python(Mesh_Segment): - - ## Private constructor. - def __init__(self, mesh, geom=0): - import Python1dPlugin - self.Create(mesh, geom, "Python_1D", "libPython1dEngine.so") - - ## Defines "PythonSplit1D" hypothesis - # @param n for the number of segments that cut an edge - # @param func for the python function that calculates the length of all segments - # @param UseExisting if ==true - searches for the existing hypothesis created with - # the same parameters, else (default) - creates a new one - # @ingroup l3_hypos_1dhyps - def PythonSplit1D(self, n, func, UseExisting=0): - hyp = self.Hypothesis("PythonSplit1D", [n], "libPython1dEngine.so", - UseExisting=UseExisting, CompareMethod=self.ComparePythonSplit1D) - hyp.SetNumberOfSegments(n) - hyp.SetPythonLog10RatioFunction(func) - return hyp - - ## Checks if the given "PythonSplit1D" hypothesis has the same parameters as the given arguments - def ComparePythonSplit1D(self, hyp, args): - #if hyp.GetNumberOfSegments() == args[0]: - # if hyp.GetPythonLog10RatioFunction() == args[1]: - # return True - return False - -# Public class: Mesh_Triangle -# --------------------------- - -## Defines a triangle 2D algorithm -# -# @ingroup l3_algos_basic -class Mesh_Triangle(Mesh_Algorithm): - - # default values - algoType = 0 - params = 0 - - _angleMeshS = 8 - _gradation = 1.1 - - ## Private constructor. - def __init__(self, mesh, algoType, geom=0): - Mesh_Algorithm.__init__(self) - - if algoType == MEFISTO: - self.Create(mesh, geom, "MEFISTO_2D") - pass - elif algoType == BLSURF: - CheckPlugin(BLSURF) - self.Create(mesh, geom, "BLSURF", "libBLSURFEngine.so") - #self.SetPhysicalMesh() - PAL19680 - elif algoType == NETGEN: - CheckPlugin(NETGEN) - self.Create(mesh, geom, "NETGEN_2D", "libNETGENEngine.so") - pass - elif algoType == NETGEN_2D: - CheckPlugin(NETGEN) - self.Create(mesh, geom, "NETGEN_2D_ONLY", "libNETGENEngine.so") - pass - - self.algoType = algoType - - ## Defines "MaxElementArea" hypothesis basing on the definition of the maximum area of each triangle - # @param area for the maximum area of each triangle - # @param UseExisting if ==true - searches for an existing hypothesis created with the - # same parameters, else (default) - creates a new one - # - # Only for algoType == MEFISTO || NETGEN_2D - # @ingroup l3_hypos_2dhyps - def MaxElementArea(self, area, UseExisting=0): - if self.algoType == MEFISTO or self.algoType == NETGEN_2D: - hyp = self.Hypothesis("MaxElementArea", [area], UseExisting=UseExisting, - CompareMethod=self.CompareMaxElementArea) - elif self.algoType == NETGEN: - hyp = self.Parameters(SIMPLE) - hyp.SetMaxElementArea(area) - return hyp - - ## Checks if the given "MaxElementArea" hypothesis has the same parameters as the given arguments - def CompareMaxElementArea(self, hyp, args): - return IsEqual(hyp.GetMaxElementArea(), args[0]) - - ## Defines "LengthFromEdges" hypothesis to build triangles - # based on the length of the edges taken from the wire - # - # Only for algoType == MEFISTO || NETGEN_2D - # @ingroup l3_hypos_2dhyps - def LengthFromEdges(self): - if self.algoType == MEFISTO or self.algoType == NETGEN_2D: - hyp = self.Hypothesis("LengthFromEdges", UseExisting=1, CompareMethod=self.CompareEqualHyp) - return hyp - elif self.algoType == NETGEN: - hyp = self.Parameters(SIMPLE) - hyp.LengthFromEdges() - return hyp - - ## Sets a way to define size of mesh elements to generate. - # @param thePhysicalMesh is: DefaultSize, BLSURF_Custom or SizeMap. - # @ingroup l3_hypos_blsurf - def SetPhysicalMesh(self, thePhysicalMesh=DefaultSize): - if self.Parameters(): - # Parameter of BLSURF algo - self.params.SetPhysicalMesh(thePhysicalMesh) - - ## Sets size of mesh elements to generate. - # @ingroup l3_hypos_blsurf - def SetPhySize(self, theVal): - if self.Parameters(): - # Parameter of BLSURF algo - self.params.SetPhySize(theVal) - - ## Sets lower boundary of mesh element size (PhySize). - # @ingroup l3_hypos_blsurf - def SetPhyMin(self, theVal=-1): - if self.Parameters(): - # Parameter of BLSURF algo - self.params.SetPhyMin(theVal) - - ## Sets upper boundary of mesh element size (PhySize). - # @ingroup l3_hypos_blsurf - def SetPhyMax(self, theVal=-1): - if self.Parameters(): - # Parameter of BLSURF algo - self.params.SetPhyMax(theVal) - - ## Sets a way to define maximum angular deflection of mesh from CAD model. - # @param theGeometricMesh is: 0 (None) or 1 (Custom) - # @ingroup l3_hypos_blsurf - def SetGeometricMesh(self, theGeometricMesh=0): - if self.Parameters(): - # Parameter of BLSURF algo - if self.params.GetPhysicalMesh() == 0: theGeometricMesh = 1 - self.params.SetGeometricMesh(theGeometricMesh) - - ## Sets angular deflection (in degrees) of a mesh face from CAD surface. - # @ingroup l3_hypos_blsurf - def SetAngleMeshS(self, theVal=_angleMeshS): - if self.Parameters(): - # Parameter of BLSURF algo - if self.params.GetGeometricMesh() == 0: theVal = self._angleMeshS - self.params.SetAngleMeshS(theVal) - - ## Sets angular deflection (in degrees) of a mesh edge from CAD curve. - # @ingroup l3_hypos_blsurf - def SetAngleMeshC(self, theVal=_angleMeshS): - if self.Parameters(): - # Parameter of BLSURF algo - if self.params.GetGeometricMesh() == 0: theVal = self._angleMeshS - self.params.SetAngleMeshC(theVal) - - ## Sets lower boundary of mesh element size computed to respect angular deflection. - # @ingroup l3_hypos_blsurf - def SetGeoMin(self, theVal=-1): - if self.Parameters(): - # Parameter of BLSURF algo - self.params.SetGeoMin(theVal) - - ## Sets upper boundary of mesh element size computed to respect angular deflection. - # @ingroup l3_hypos_blsurf - def SetGeoMax(self, theVal=-1): - if self.Parameters(): - # Parameter of BLSURF algo - self.params.SetGeoMax(theVal) - - ## Sets maximal allowed ratio between the lengths of two adjacent edges. - # @ingroup l3_hypos_blsurf - def SetGradation(self, theVal=_gradation): - if self.Parameters(): - # Parameter of BLSURF algo - if self.params.GetGeometricMesh() == 0: theVal = self._gradation - self.params.SetGradation(theVal) - - ## Sets topology usage way. - # @param way defines how mesh conformity is assured