X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSMESH_SWIG%2FsmeshDC.py;h=7b99c3519cef48b027250ccb4f5b8c83850a1763;hb=ce15afc1f3705f11a6c79c303666b1ee4cf663a3;hp=54adbb7d268202b77cf5772f6356ee595e92459a;hpb=1eedac41d2618ae1cda842b043ed760252ebc499;p=modules%2Fsmesh.git diff --git a/src/SMESH_SWIG/smeshDC.py b/src/SMESH_SWIG/smeshDC.py index 54adbb7d2..7b99c3519 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-2012 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 @@ -94,76 +88,12 @@ import geompyDC import SMESH # This is necessary for back compatibility from SMESH import * -import StdMeshers - 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 +103,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 +111,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: @@ -450,7 +229,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 +250,13 @@ 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.IsSame( mesh.geom ) and \ + not geom.GetStudyEntry() and \ + mesh.smeshpyD.GetCurrentStudy(): ## set the study studyID = mesh.smeshpyD.GetCurrentStudy()._get_StudyId() if studyID != mesh.geompyD.myStudyId: @@ -540,6 +302,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): @@ -671,6 +443,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 @@ -736,17 +513,18 @@ class smeshDC(SMESH._objref_SMESH_Gen): # @param allGroups forces creation of groups of all elements def Concatenate( self, meshes, uniteIdenticalGroups, mergeNodesAndElements = False, mergeTolerance = 1e-5, allGroups = False): - mergeTolerance,Parameters = geompyDC.ParseParameters(mergeTolerance) + 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) return aMesh @@ -810,7 +588,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 +601,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 +612,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 +624,87 @@ 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: + 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_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 +718,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 +729,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 = [] @@ -1008,14 +789,28 @@ class smeshDC(SMESH._objref_SMESH_Gen): elif theCriterion == FT_Length2D: return aFilterMgr.CreateLength2D() else: - print "Error: given parameter is not numerucal functor type." + print "Error: given parameter is not numerical functor type." ## 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" @@ -1169,15 +964,17 @@ class Mesh: if obj is None: obj = 0 if obj != 0: + objHasName = True if isinstance(obj, geompyDC.GEOM._objref_GEOM_Object): self.geom = obj # 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) + geo_name = "%s_%s_for_meshing"%(self.geom.GetShapeType(), id(self.geom)%100) geompyD.addToStudy( self.geom, geo_name ) self.mesh = self.smeshpyD.CreateMesh(self.geom) @@ -1187,7 +984,7 @@ class Mesh: self.mesh = self.smeshpyD.CreateEmptyMesh() if name != 0: self.smeshpyD.SetName(self.mesh, name) - elif obj != 0: + elif obj != 0 and objHasName: self.smeshpyD.SetName(self.mesh, GetName(obj)) if not self.geom: @@ -1195,6 +992,12 @@ class Mesh: self.editor = self.mesh.GetMeshEditor() + # 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 @@ -1244,8 +1047,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 +1060,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): @@ -1284,204 +1091,6 @@ class Mesh: 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) - 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) - ## 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 # To know predicted number of e.g. edges, inquire it this way @@ -1574,7 +1183,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 @@ -1605,17 +1214,18 @@ class Mesh: " 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) ) @@ -1668,6 +1278,7 @@ class Mesh: self.Triangle().LengthFromEdges() pass if dim > 2 : + from NETGENPluginDC import NETGEN self.Tetrahedron(NETGEN) pass return self.Compute() @@ -1703,6 +1314,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,9 +1324,26 @@ 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): @@ -1728,7 +1357,7 @@ class Mesh: return status ## 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 +1372,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 +1450,18 @@ class Mesh: meshPart = self.mesh self.mesh.ExportCGNS(meshPart, f, overwrite) + ## 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 +1549,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 +1560,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 +1606,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): @@ -2151,7 +1760,7 @@ class Mesh: return self.mesh.GetMeshEditor() ## 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): @@ -2192,6 +1801,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 +1863,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 +1917,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 +1951,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 +2004,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 +2016,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): @@ -2513,6 +2146,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 +2158,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 +2295,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 +2306,14 @@ class Mesh: def Add0DElement(self, IDOfNode): return self.editor.Add0DElement(IDOfNode) + ## 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 +2467,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 +2480,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 +2500,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 +2510,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,6 +2562,41 @@ 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. @@ -2907,12 +2609,10 @@ class Mesh: 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) + if not IDsOfElements: + IDsOfElements = self.GetElementsId() Functor = 0 if ( isinstance( theCriterion, SMESH._objref_NumericalFunctor ) ): Functor = theCriterion @@ -2928,6 +2628,8 @@ class Mesh: # @return TRUE in case of success, FALSE otherwise. # @ingroup l2_modif_unitetri def TriToQuadObject (self, theObject, theCriterion, MaxAngle): + 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) @@ -3148,7 +2850,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 +2884,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) @@ -3309,22 +3011,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 +3041,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 +3071,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 +3101,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) @@ -3444,20 +3122,26 @@ class Mesh: # @param StepVector vector or DirStruct, 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)): StepVector = self.smeshpyD.GetDirStruct(StepVector) - StepVector,StepVectorParameters = ParseDirStruct(StepVector) - NbOfSteps,Parameters = geompyDC.ParseParameters(NbOfSteps) - Parameters = StepVectorParameters + var_separator + Parameters + 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 @@ -3487,20 +3171,26 @@ class Mesh: # @param StepVector vector, 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 + 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 @@ -3516,9 +3206,8 @@ 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 + 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) @@ -3538,9 +3227,8 @@ 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 + 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 +3258,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 +3305,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 +3312,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 +3347,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 +3389,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 +3431,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 +3465,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 +3485,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 +3504,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,10 +3524,9 @@ 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 @@ -3862,8 +3541,7 @@ 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) + self.mesh.SetParameters(Vector.PS.parameters) if Copy and MakeGroups: return self.editor.TranslateMakeGroups(IDsOfElements, Vector) self.editor.Translate(IDsOfElements, Vector, Copy) @@ -3881,9 +3559,8 @@ 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(Vector.PS.parameters) mesh = self.editor.TranslateMakeMesh(IDsOfElements, Vector, MakeGroups, NewMeshName) - mesh.SetParameters(Parameters) return Mesh ( self.smeshpyD, self.geompyD, mesh ) ## Translates the object @@ -3898,8 +3575,7 @@ 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) + self.mesh.SetParameters(Vector.PS.parameters) if Copy and MakeGroups: return self.editor.TranslateObjectMakeGroups(theObject, Vector) self.editor.TranslateObject(theObject, Vector, Copy) @@ -3917,9 +3593,8 @@ 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(Vector.PS.parameters) mesh = self.editor.TranslateObjectMakeMesh(theObject, Vector, MakeGroups, NewMeshName) - mesh.SetParameters(Parameters) return Mesh( self.smeshpyD, self.geompyD, mesh ) @@ -3939,8 +3614,7 @@ class Mesh: if ( isinstance( theObject, list )): theObject = self.GetIDSource(theObject, SMESH.ALL) - thePoint, Parameters = ParsePointStruct(thePoint) - self.mesh.SetParameters(Parameters) + self.mesh.SetParameters(thePoint.parameters) if Copy and MakeGroups: return self.editor.ScaleMakeGroups(theObject, thePoint, theScaleFact) @@ -3960,9 +3634,9 @@ class Mesh: if ( isinstance( theObject, list )): theObject = self.GetIDSource(theObject,SMESH.ALL) + 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 +3650,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 +3671,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 +3691,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 +3712,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 +3910,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 +3944,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 @@ -4409,7 +4075,17 @@ class Mesh: ## The mother class to define algorithm, it is not recommended to use it directly. # -# More details. +# For each meshing algorithm, a python class inheriting from class Mesh_Algorithm +# should be defined. This descendant class sould have two attributes defining the way +# it is created by class Mesh (see e.g. class StdMeshersDC_Segment in StdMeshersDC.py). +# - meshMethod attribute defines name of method of class Mesh by calling which the +# python class of algorithm is created. E.g. if in class MyPlugin_Algorithm +# meshMethod = "MyAlgorithm", then an instance of MyPlugin_Algorithm is created +# by the following code: my_algo = mesh.MyAlgorithm() +# - algoType defines name of algorithm type and is used mostly to discriminate +# algorithms that are created by the same method of class Mesh. E.g. if +# MyPlugin_Algorithm.algoType = "MyPLUGIN" then it's creation code can be: +# my_algo = mesh.MyAlgorithm(algo="MyPLUGIN") # @ingroup l2_algorithms class Mesh_Algorithm: # @class Mesh_Algorithm @@ -4470,6 +4146,7 @@ class Mesh_Algorithm: # @return SMESH.SMESH_Algo def FindAlgorithm (self, algoname, smeshpyD): study = smeshpyD.GetCurrentStudy() + if not study: return None #to do: find component by smeshpyD object, not by its data type scomp = study.FindComponent(smeshpyD.ComponentDataType()) if scomp is not None: @@ -4589,9 +4266,14 @@ class Mesh_Algorithm: if isinstance( arg, geompyDC.GEOM._objref_GEOM_Object ): argStr = arg.GetStudyEntry() if not argStr: argStr = "GEOM_Obj_%s", arg.GetEntry() + if len( argStr ) > 10: + argStr = argStr[:7]+"..." + if argStr[0] == '[': argStr += ']' a = a + s + argStr s = "," pass + if len(a) > 50: + a = a[:47]+"..." self.mesh.smeshpyD.SetName(hypo, hyp + a) pass geomName="" @@ -4603,15 +4285,10 @@ class Mesh_Algorithm: ## 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 + if not self.mesh or not self.mesh.GetMesh(): return "" + if not self.mesh.GetMesh().HasShapeToMesh(): return "" + shape = self.mesh.GetShape() + return shape.GetStudyEntry() ## Defines "ViscousLayers" hypothesis to give parameters of layers of prisms to build # near mesh boundary. This hypothesis can be used by several 3D algorithms: @@ -4636,9 +4313,9 @@ class Mesh_Algorithm: hyp.SetIgnoreFaces(ignoreFaces) return hyp - ## Transform a list of ether edges or tuples (edge 1st_vertex_of_edge) + ## 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 + # @ingroup l3_hypos_1dhyps def ReversedEdgeIndices(self, reverseList): resList = [] geompy = self.mesh.geompyD @@ -4657,2253 +4334,110 @@ class Mesh_Algorithm: 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)" + 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)" + 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)" + 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 +class Pattern(SMESH._objref_SMESH_Pattern): - ## 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 + def ApplyToMeshFaces(self, theMesh, theFacesIDs, theNodeIndexOnKeyPoint1, theReverse): + decrFun = lambda i: i-1 + theNodeIndexOnKeyPoint1,Parameters,hasVars = ParseParameters(theNodeIndexOnKeyPoint1, decrFun) + theMesh.SetParameters(Parameters) + return SMESH._objref_SMESH_Pattern.ApplyToMeshFaces( self, theMesh, theFacesIDs, theNodeIndexOnKeyPoint1, theReverse ) - ## 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 + def ApplyToHexahedrons(self, theMesh, theVolumesIDs, theNode000Index, theNode001Index): + decrFun = lambda i: i-1 + theNode000Index,theNode001Index,Parameters,hasVars = ParseParameters(theNode000Index,theNode001Index, decrFun) + theMesh.SetParameters(Parameters) + return SMESH._objref_SMESH_Pattern.ApplyToHexahedrons( self, theMesh, theVolumesIDs, theNode000Index, theNode001Index ) - ## 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 +#Registering the new proxy for Pattern +omniORB.registerObjref(SMESH._objref_SMESH_Pattern._NP_RepositoryId, Pattern) - ## 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