X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMESH_SWIG%2FsmeshDC.py;h=559aa22ea86216551ebff68c2f3b65a6f34b2ca3;hp=4b6d763647618a05828e72fa70a220384441163d;hb=1724cd310e878cad4c2f89cacea8761303d52668;hpb=38fb650b9e64259b6315d09825616da5761c93da diff --git a/src/SMESH_SWIG/smeshDC.py b/src/SMESH_SWIG/smeshDC.py index 4b6d76364..559aa22ea 100644 --- a/src/SMESH_SWIG/smeshDC.py +++ b/src/SMESH_SWIG/smeshDC.py @@ -1,3 +1,4 @@ +# -*- coding: iso-8859-1 -*- # Copyright (C) 2007-2008 CEA/DEN, EDF R&D, OPEN CASCADE # # Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, @@ -107,6 +108,38 @@ 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 ## @{ @@ -148,7 +181,10 @@ 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 = 0,1,2 @@ -163,9 +199,6 @@ def DegreesToRadians(AngleInDegrees): from math import pi return AngleInDegrees * pi / 180.0 -# Salome notebook variable separator -var_separator = ":" - # Parametrized substitute for PointStruct class PointStructStr: @@ -295,55 +328,89 @@ class DirStructStr: def __init__(self, pointStruct): self.pointStruct = pointStruct +# Returns value of the parameter +def ParseValue(Parameter, ConvertToRadians = False): + Result = Parameter + if isinstance(Parameter, str): + p = notebook.get(Parameter) + if p == None: + notebook.getNotebook().AddExpression(Parameter) + p = notebook.get(Parameter) + if ConvertToRadians: + p = DegreesToRadians(p) + Result = p + return Result + +# Returns the input parameter unchanged if it is a string or empty string otherwise +def ParseString(Parameter): + Result = "" + if isinstance(Parameter, str): + Result = Parameter + return Result + # Returns list of variable values from salome notebook def ParsePointStruct(Point): - Parameters = 2*var_separator + Parameters = [] 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) + Parameters.append(ParseString(Point.xStr)) + Parameters.append(ParseString(Point.yStr)) + Parameters.append(ParseString(Point.zStr)) + Point = PointStruct(ParseValue(Point.x), + ParseValue(Point.y), + ParseValue(Point.z)) return Point, Parameters # Returns list of variable values from salome notebook def ParseDirStruct(Dir): - Parameters = 2*var_separator + Parameters = [] 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) + Parameters.append(ParseString(pntStr.x1Str)) + Parameters.append(ParseString(pntStr.x2Str)) + Parameters.append(ParseString(pntStr.y1Str)) + Parameters.append(ParseString(pntStr.y2Str)) + Parameters.append(ParseString(pntStr.z1Str)) + Parameters.append(ParseString(pntStr.z2Str)) + Point = PointStruct(ParseValue(pntStr.x2) - ParseValue(pntStr.x1), + ParseValue(pntStr.y2) - ParseValue(pntStr.y1), + ParseValue(pntStr.z2) - ParseValue(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) + Parameters.append(ParseString(pntStr.xStr)) + Parameters.append(ParseString(pntStr.yStr)) + Parameters.append(ParseString(pntStr.zStr)) + Point = PointStruct(ParseValue(pntStr.x), + ParseValue(pntStr.y), + ParseValue(pntStr.z)) Dir = DirStruct(Point) return Dir, Parameters # Returns list of variable values from salome notebook def ParseAxisStruct(Axis): - Parameters = 5*var_separator + Parameters = [] 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) + Parameters.append(ParseString(Axis.xStr)) + Parameters.append(ParseString(Axis.yStr)) + Parameters.append(ParseString(Axis.zStr)) + Parameters.append(ParseString(Axis.dxStr)) + Parameters.append(ParseString(Axis.dyStr)) + Parameters.append(ParseString(Axis.dzStr)) + Axis = AxisStruct(ParseValue(Axis.x), + ParseValue(Axis.y), + ParseValue(Axis.z), + ParseValue(Axis.dx), + ParseValue(Axis.dy), + ParseValue(Axis.dz)) return Axis, Parameters ## Return list of variable values from salome notebook def ParseAngles(list): Result = [] - Parameters = "" + Parameters = [] for parameter in list: - if isinstance(parameter,str) and notebook.isVariable(parameter): - Result.append(DegreesToRadians(notebook.get(parameter))) - pass - else: - Result.append(parameter) - pass - - Parameters = Parameters + str(parameter) - Parameters = Parameters + var_separator + Result.append(ParseValue(parameter, True)) + Parameters.append(ParseString(parameter)) pass - Parameters = Parameters[:len(Parameters)-1] return Result, Parameters def IsEqual(val1, val2, tol=PrecisionConfusion): @@ -402,6 +469,25 @@ def TreatHypoStatus(status, hypName, geomName, isAlgo): print hypName, "was not assigned to",geomName,":", 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 + # end of l1_auxiliary ## @} @@ -596,7 +682,7 @@ class smeshDC(SMESH._objref_SMESH_Gen): else: aSmeshMesh = SMESH._objref_SMESH_Gen.Concatenate( self,meshes,uniteIdenticalGroups,mergeNodesAndElements,mergeTolerance) - aSmeshMesh.SetParameters(Parameters) + geompyDC.SetParameters(aSmeshMesh, Parameters) aMesh = Mesh(self, self.geompyD, aSmeshMesh) return aMesh @@ -755,12 +841,26 @@ class smeshDC(SMESH._objref_SMESH_Gen): print "Error: given parameter is not numerucal functor type." ## Creates hypothesis - # @param - # @param + # @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 ) + ## Gets the mesh stattistic + # @return dictionary type element - count of elements + # @ingroup l1_meshinfo + def GetMeshInfo(self, obj): + if isinstance( obj, Mesh ): + obj = obj.GetMesh() + d = {} + if hasattr(obj, "_narrow") and obj._narrow(SMESH.SMESH_IDSource): + values = obj.GetMeshInfo() + for i in range(SMESH.Entity_Last._v): + if i < len(values): d[SMESH.EntityType._item(i)]=values[i] + pass + return d + import omniORB #Registering the new proxy for SMESH_Gen omniORB.registerObjref(SMESH._objref_SMESH_Gen._NP_RepositoryId, smeshDC) @@ -1251,6 +1351,8 @@ class Mesh: # Exports the mesh in a file in MED format and chooses the \a version of MED format # @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, ... # @ingroup l2_impexp def ExportToMED(self, f, version, opt=0): self.mesh.ExportToMED(f, opt, version) @@ -1322,19 +1424,37 @@ class Mesh: elif tgeo == "SHELL": typ = VOLUME elif tgeo == "COMPOUND": - if len( self.geompyD.GetObjectIDs( grp )) == 0: - print "Mesh.Group: empty geometric group", GetName( grp ) - return 0 - tgeo = self.geompyD.GetType(grp) - if tgeo == geompyDC.ShapeType["VERTEX"]: - typ = NODE - elif tgeo == geompyDC.ShapeType["EDGE"]: - typ = EDGE - elif tgeo == geompyDC.ShapeType["FACE"]: - typ = FACE - elif tgeo == geompyDC.ShapeType["SOLID"]: - typ = VOLUME - + try: # it raises on a compound of compounds + if len( self.geompyD.GetObjectIDs( grp )) == 0: + print "Mesh.Group: empty geometric group", GetName( grp ) + return 0 + pass + except: + pass + if grp.GetType() == 37: # GEOMImpl_Types.hxx: #define GEOM_GROUP 37 + # group + tgeo = self.geompyD.GetType(grp) + if tgeo == geompyDC.ShapeType["VERTEX"]: + typ = NODE + elif tgeo == geompyDC.ShapeType["EDGE"]: + typ = EDGE + elif tgeo == geompyDC.ShapeType["FACE"]: + typ = FACE + elif tgeo == geompyDC.ShapeType["SOLID"]: + typ = VOLUME + pass + pass + else: + # just a compound + for elemType, shapeType in [[VOLUME,"SOLID"],[FACE,"FACE"], + [EDGE,"EDGE"],[NODE,"VERTEX"]]: + if self.geompyD.SubShapeAll(grp,geompyDC.ShapeType[shapeType]): + typ = elemType + break + pass + pass + pass + pass if typ == None: print "Mesh.Group: bad first argument: expected a group, a vertex, an edge, a face or a solid" return 0 @@ -1595,13 +1715,7 @@ class Mesh: # @ingroup l1_meshinfo def GetMeshInfo(self, obj = None): if not obj: obj = self.mesh - d = {} - if hasattr(obj, "_narrow") and obj._narrow(SMESH.SMESH_IDSource): - values = obj.GetMeshInfo() - for i in range(SMESH.Entity_Last._v): - if i < len(values): d[SMESH.EntityType._item(i)]=values[i] - pass - return d + return self.smeshpyD.GetMeshInfo(obj) ## Returns the number of nodes in the mesh # @return an integer value @@ -1956,7 +2070,7 @@ class Mesh: # @ingroup l2_modif_add def AddNode(self, x, y, z): x,y,z,Parameters = geompyDC.ParseParameters(x,y,z) - self.mesh.SetParameters(Parameters) + geompyDC.SetParameters(self.mesh, Parameters) return self.editor.AddNode( x, y, z) ## Creates a 0D element on a node with given number. @@ -2120,18 +2234,20 @@ class Mesh: # @ingroup l2_modif_movenode def MoveNode(self, NodeID, x, y, z): x,y,z,Parameters = geompyDC.ParseParameters(x,y,z) - self.mesh.SetParameters(Parameters) + geompyDC.SetParameters(self.mesh, Parameters) return self.editor.MoveNode(NodeID, x, y, z) ## Finds the node closest to a point and moves it to a point location # @param x the X coordinate of a point # @param y the Y coordinate of a point # @param z the Z coordinate of a point + # @param NodeID if specified (>0), the node with this ID is moved, + # otherwise, the node closest to point (@a x,@a y,@a z) is moved # @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) + geompyDC.SetParameters(self.mesh, Parameters) return self.editor.MoveClosestNodeToPoint(x, y, z, NodeID) ## Finds the node closest to a point @@ -2219,7 +2335,7 @@ class Mesh: MaxAngle = DegreesToRadians(MaxAngle) if IDsOfElements == []: IDsOfElements = self.GetElementsId() - self.mesh.SetParameters(Parameters) + geompyDC.SetParameters(self.mesh, Parameters) Functor = 0 if ( isinstance( theCriterion, SMESH._objref_NumericalFunctor ) ): Functor = theCriterion @@ -2444,7 +2560,7 @@ class Mesh: if IDsOfElements == []: IDsOfElements = self.GetElementsId() MaxNbOfIterations,MaxAspectRatio,Parameters = geompyDC.ParseParameters(MaxNbOfIterations,MaxAspectRatio) - self.mesh.SetParameters(Parameters) + geompyDC.SetParameters(self.mesh, Parameters) return self.editor.Smooth(IDsOfElements, IDsOfFixedNodes, MaxNbOfIterations, MaxAspectRatio, Method) @@ -2478,7 +2594,7 @@ class Mesh: if IDsOfElements == []: IDsOfElements = self.GetElementsId() MaxNbOfIterations,MaxAspectRatio,Parameters = geompyDC.ParseParameters(MaxNbOfIterations,MaxAspectRatio) - self.mesh.SetParameters(Parameters) + geompyDC.SetParameters(self.mesh, Parameters) return self.editor.SmoothParametric(IDsOfElements, IDsOfFixedNodes, MaxNbOfIterations, MaxAspectRatio, Method) @@ -2512,6 +2628,12 @@ class Mesh: def ConvertFromQuadratic(self): return self.editor.ConvertFromQuadratic() + ## Creates 2D mesh as skin on boundary faces of a 3D mesh + # @return TRUE if operation has been completed successfully, FALSE otherwise + # @ingroup l2_modif_edit + def Make2DMeshFrom3D(self): + return self.editor. Make2DMeshFrom3D() + ## Renumber mesh nodes # @ingroup l2_modif_renumber def RenumberNodes(self): @@ -2549,8 +2671,8 @@ class Mesh: 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) + Parameters = AxisParameters + AngleParameters + Parameters + geompyDC.SetParameters(self.mesh, Parameters) if MakeGroups: return self.editor.RotationSweepMakeGroups(IDsOfElements, Axis, AngleInRadians, NbOfSteps, Tolerance) @@ -2584,8 +2706,8 @@ class Mesh: 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) + Parameters = AxisParameters + AngleParameters + Parameters + geompyDC.SetParameters(self.mesh, Parameters) if MakeGroups: return self.editor.RotationSweepObjectMakeGroups(theObject, Axis, AngleInRadians, NbOfSteps, Tolerance) @@ -2619,8 +2741,8 @@ class Mesh: 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) + Parameters = AxisParameters + AngleParameters + Parameters + geompyDC.SetParameters(self.mesh, Parameters) if MakeGroups: return self.editor.RotationSweepObject1DMakeGroups(theObject, Axis, AngleInRadians, NbOfSteps, Tolerance) @@ -2654,8 +2776,8 @@ class Mesh: 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) + Parameters = AxisParameters + AngleParameters + Parameters + geompyDC.SetParameters(self.mesh, Parameters) if MakeGroups: return self.editor.RotationSweepObject2DMakeGroups(theObject, Axis, AngleInRadians, NbOfSteps, Tolerance) @@ -2676,8 +2798,8 @@ class Mesh: StepVector = self.smeshpyD.GetDirStruct(StepVector) StepVector,StepVectorParameters = ParseDirStruct(StepVector) NbOfSteps,Parameters = geompyDC.ParseParameters(NbOfSteps) - Parameters = StepVectorParameters + var_separator + Parameters - self.mesh.SetParameters(Parameters) + Parameters = StepVectorParameters + Parameters + geompyDC.SetParameters(self.mesh, Parameters) if MakeGroups: return self.editor.ExtrusionSweepMakeGroups(IDsOfElements, StepVector, NbOfSteps) self.editor.ExtrusionSweep(IDsOfElements, StepVector, NbOfSteps) @@ -2718,8 +2840,8 @@ class Mesh: StepVector = self.smeshpyD.GetDirStruct(StepVector) StepVector,StepVectorParameters = ParseDirStruct(StepVector) NbOfSteps,Parameters = geompyDC.ParseParameters(NbOfSteps) - Parameters = StepVectorParameters + var_separator + Parameters - self.mesh.SetParameters(Parameters) + Parameters = StepVectorParameters + Parameters + geompyDC.SetParameters(self.mesh, Parameters) if MakeGroups: return self.editor.ExtrusionSweepObjectMakeGroups(theObject, StepVector, NbOfSteps) self.editor.ExtrusionSweepObject(theObject, StepVector, NbOfSteps) @@ -2739,8 +2861,8 @@ class Mesh: StepVector = self.smeshpyD.GetDirStruct(StepVector) StepVector,StepVectorParameters = ParseDirStruct(StepVector) NbOfSteps,Parameters = geompyDC.ParseParameters(NbOfSteps) - Parameters = StepVectorParameters + var_separator + Parameters - self.mesh.SetParameters(Parameters) + Parameters = StepVectorParameters + Parameters + geompyDC.SetParameters(self.mesh, Parameters) if MakeGroups: return self.editor.ExtrusionSweepObject1DMakeGroups(theObject, StepVector, NbOfSteps) self.editor.ExtrusionSweepObject1D(theObject, StepVector, NbOfSteps) @@ -2760,8 +2882,8 @@ class Mesh: StepVector = self.smeshpyD.GetDirStruct(StepVector) StepVector,StepVectorParameters = ParseDirStruct(StepVector) NbOfSteps,Parameters = geompyDC.ParseParameters(NbOfSteps) - Parameters = StepVectorParameters + var_separator + Parameters - self.mesh.SetParameters(Parameters) + Parameters = StepVectorParameters + Parameters + geompyDC.SetParameters(self.mesh, Parameters) if MakeGroups: return self.editor.ExtrusionSweepObject2DMakeGroups(theObject, StepVector, NbOfSteps) self.editor.ExtrusionSweepObject2D(theObject, StepVector, NbOfSteps) @@ -2795,8 +2917,10 @@ class Mesh: if ( isinstance( RefPoint, geompyDC.GEOM._objref_GEOM_Object)): RefPoint = self.smeshpyD.GetPointStruct(RefPoint) pass - Parameters = AnglesParameters + var_separator + RefPointParameters - self.mesh.SetParameters(Parameters) + if ( isinstance( Path, Mesh )): + Path = Path.GetMesh() + Parameters = AnglesParameters + RefPointParameters + geompyDC.SetParameters(self.mesh, Parameters) if isinstance(Base,list): IDsOfElements = [] @@ -2807,7 +2931,8 @@ class Mesh: HasRefPoint, RefPoint, MakeGroups, ElemType) else: if isinstance(Base,Mesh): - return self.editor.ExtrusionAlongPathObjX(Base.GetMesh(), Path, NodeStart, + Base = Base.GetMesh() + return self.editor.ExtrusionAlongPathObjX(Base, Path, NodeStart, HasAngles, Angles, LinearVariation, HasRefPoint, RefPoint, MakeGroups, ElemType) else: @@ -2847,8 +2972,8 @@ class Mesh: if HasAngles and Angles and LinearVariation: Angles = self.editor.LinearAnglesVariation( PathMesh, PathShape, Angles ) pass - Parameters = AnglesParameters + var_separator + RefPointParameters - self.mesh.SetParameters(Parameters) + Parameters = AnglesParameters + RefPointParameters + geompyDC.SetParameters(self.mesh, Parameters) if MakeGroups: return self.editor.ExtrusionAlongPathMakeGroups(IDsOfElements, PathMesh, PathShape, NodeStart, HasAngles, @@ -2888,8 +3013,8 @@ class Mesh: if HasAngles and Angles and LinearVariation: Angles = self.editor.LinearAnglesVariation( PathMesh, PathShape, Angles ) pass - Parameters = AnglesParameters + var_separator + RefPointParameters - self.mesh.SetParameters(Parameters) + Parameters = AnglesParameters + RefPointParameters + geompyDC.SetParameters(self.mesh, Parameters) if MakeGroups: return self.editor.ExtrusionAlongPathObjectMakeGroups(theObject, PathMesh, PathShape, NodeStart, HasAngles, @@ -2930,8 +3055,8 @@ class Mesh: if HasAngles and Angles and LinearVariation: Angles = self.editor.LinearAnglesVariation( PathMesh, PathShape, Angles ) pass - Parameters = AnglesParameters + var_separator + RefPointParameters - self.mesh.SetParameters(Parameters) + Parameters = AnglesParameters + RefPointParameters + geompyDC.SetParameters(self.mesh, Parameters) if MakeGroups: return self.editor.ExtrusionAlongPathObject1DMakeGroups(theObject, PathMesh, PathShape, NodeStart, HasAngles, @@ -2972,8 +3097,8 @@ class Mesh: if HasAngles and Angles and LinearVariation: Angles = self.editor.LinearAnglesVariation( PathMesh, PathShape, Angles ) pass - Parameters = AnglesParameters + var_separator + RefPointParameters - self.mesh.SetParameters(Parameters) + Parameters = AnglesParameters + RefPointParameters + geompyDC.SetParameters(self.mesh, Parameters) if MakeGroups: return self.editor.ExtrusionAlongPathObject2DMakeGroups(theObject, PathMesh, PathShape, NodeStart, HasAngles, @@ -2997,7 +3122,7 @@ class Mesh: if ( isinstance( Mirror, geompyDC.GEOM._objref_GEOM_Object)): Mirror = self.smeshpyD.GetAxisStruct(Mirror) Mirror,Parameters = ParseAxisStruct(Mirror) - self.mesh.SetParameters(Parameters) + geompyDC.SetParameters(self.mesh, Parameters) if Copy and MakeGroups: return self.editor.MirrorMakeGroups(IDsOfElements, Mirror, theMirrorType) self.editor.Mirror(IDsOfElements, Mirror, theMirrorType, Copy) @@ -3020,7 +3145,7 @@ class Mesh: Mirror,Parameters = ParseAxisStruct(Mirror) mesh = self.editor.MirrorMakeMesh(IDsOfElements, Mirror, theMirrorType, MakeGroups, NewMeshName) - mesh.SetParameters(Parameters) + geompyDC.SetParameters(mesh, Parameters) return Mesh(self.smeshpyD,self.geompyD,mesh) ## Creates a symmetrical copy of the object @@ -3038,7 +3163,7 @@ class Mesh: if ( isinstance( Mirror, geompyDC.GEOM._objref_GEOM_Object)): Mirror = self.smeshpyD.GetAxisStruct(Mirror) Mirror,Parameters = ParseAxisStruct(Mirror) - self.mesh.SetParameters(Parameters) + geompyDC.SetParameters(self.mesh, Parameters) if Copy and MakeGroups: return self.editor.MirrorObjectMakeGroups(theObject, Mirror, theMirrorType) self.editor.MirrorObject(theObject, Mirror, theMirrorType, Copy) @@ -3061,7 +3186,7 @@ class Mesh: Mirror,Parameters = ParseAxisStruct(Mirror) mesh = self.editor.MirrorObjectMakeMesh(theObject, Mirror, theMirrorType, MakeGroups, NewMeshName) - mesh.SetParameters(Parameters) + geompyDC.SetParameters(mesh, Parameters) return Mesh( self.smeshpyD,self.geompyD,mesh ) ## Translates the elements @@ -3077,7 +3202,7 @@ class Mesh: if ( isinstance( Vector, geompyDC.GEOM._objref_GEOM_Object)): Vector = self.smeshpyD.GetDirStruct(Vector) Vector,Parameters = ParseDirStruct(Vector) - self.mesh.SetParameters(Parameters) + geompyDC.SetParameters(self.mesh, Parameters) if Copy and MakeGroups: return self.editor.TranslateMakeGroups(IDsOfElements, Vector) self.editor.Translate(IDsOfElements, Vector, Copy) @@ -3097,7 +3222,7 @@ class Mesh: Vector = self.smeshpyD.GetDirStruct(Vector) Vector,Parameters = ParseDirStruct(Vector) mesh = self.editor.TranslateMakeMesh(IDsOfElements, Vector, MakeGroups, NewMeshName) - mesh.SetParameters(Parameters) + geompyDC.SetParameters(mesh, Parameters) return Mesh ( self.smeshpyD, self.geompyD, mesh ) ## Translates the object @@ -3113,7 +3238,7 @@ class Mesh: if ( isinstance( Vector, geompyDC.GEOM._objref_GEOM_Object)): Vector = self.smeshpyD.GetDirStruct(Vector) Vector,Parameters = ParseDirStruct(Vector) - self.mesh.SetParameters(Parameters) + geompyDC.SetParameters(self.mesh, Parameters) if Copy and MakeGroups: return self.editor.TranslateObjectMakeGroups(theObject, Vector) self.editor.TranslateObject(theObject, Vector, Copy) @@ -3133,7 +3258,7 @@ class Mesh: Vector = self.smeshpyD.GetDirStruct(Vector) Vector,Parameters = ParseDirStruct(Vector) mesh = self.editor.TranslateObjectMakeMesh(theObject, Vector, MakeGroups, NewMeshName) - mesh.SetParameters(Parameters) + geompyDC.SetParameters(mesh, Parameters) return Mesh( self.smeshpyD, self.geompyD, mesh ) ## Rotates the elements @@ -3156,8 +3281,8 @@ class Mesh: if ( isinstance( Axis, geompyDC.GEOM._objref_GEOM_Object)): Axis = self.smeshpyD.GetAxisStruct(Axis) Axis,AxisParameters = ParseAxisStruct(Axis) - Parameters = AxisParameters + var_separator + Parameters - self.mesh.SetParameters(Parameters) + Parameters = AxisParameters + Parameters + geompyDC.SetParameters(self.mesh, Parameters) if Copy and MakeGroups: return self.editor.RotateMakeGroups(IDsOfElements, Axis, AngleInRadians) self.editor.Rotate(IDsOfElements, Axis, AngleInRadians, Copy) @@ -3183,10 +3308,10 @@ class Mesh: if ( isinstance( Axis, geompyDC.GEOM._objref_GEOM_Object)): Axis = self.smeshpyD.GetAxisStruct(Axis) Axis,AxisParameters = ParseAxisStruct(Axis) - Parameters = AxisParameters + var_separator + Parameters + Parameters = AxisParameters + Parameters mesh = self.editor.RotateMakeMesh(IDsOfElements, Axis, AngleInRadians, MakeGroups, NewMeshName) - mesh.SetParameters(Parameters) + geompyDC.SetParameters(mesh, Parameters) return Mesh( self.smeshpyD, self.geompyD, mesh ) ## Rotates the object @@ -3209,8 +3334,8 @@ class Mesh: if (isinstance(Axis, geompyDC.GEOM._objref_GEOM_Object)): Axis = self.smeshpyD.GetAxisStruct(Axis) Axis,AxisParameters = ParseAxisStruct(Axis) - Parameters = AxisParameters + ":" + Parameters - self.mesh.SetParameters(Parameters) + Parameters = AxisParameters + Parameters + geompyDC.SetParameters(self.mesh, Parameters) if Copy and MakeGroups: return self.editor.RotateObjectMakeGroups(theObject, Axis, AngleInRadians) self.editor.RotateObject(theObject, Axis, AngleInRadians, Copy) @@ -3236,10 +3361,10 @@ class Mesh: if (isinstance(Axis, geompyDC.GEOM._objref_GEOM_Object)): Axis = self.smeshpyD.GetAxisStruct(Axis) Axis,AxisParameters = ParseAxisStruct(Axis) - Parameters = AxisParameters + ":" + Parameters + Parameters = AxisParameters + Parameters mesh = self.editor.RotateObjectMakeMesh(theObject, Axis, AngleInRadians, MakeGroups, NewMeshName) - mesh.SetParameters(Parameters) + geompyDC.SetParameters(mesh, Parameters) return Mesh( self.smeshpyD, self.geompyD, mesh ) ## Finds groups of ajacent nodes within Tolerance. @@ -3268,6 +3393,8 @@ class Mesh: # @return a list of groups of equal elements # @ingroup l2_modif_trsf def FindEqualElements (self, MeshOrSubMeshOrGroup): + if ( isinstance( MeshOrSubMeshOrGroup, Mesh )): + MeshOrSubMeshOrGroup = MeshOrSubMeshOrGroup.GetMesh() return self.editor.FindEqualElements(MeshOrSubMeshOrGroup) ## Merges elements in each given group. @@ -3345,6 +3472,43 @@ class Mesh: # @ingroup l1_auxiliary def GetLastCreatedElems(self): return self.editor.GetLastCreatedElems() + + ## Creates a hole in a mesh by doubling the nodes of some particular elements + # @param theNodes identifiers of nodes to be doubled + # @param theModifiedElems identifiers of elements to be updated by the new (doubled) + # nodes. If list of element identifiers is empty then nodes are doubled but + # they not assigned to elements + # @return TRUE if operation has been completed successfully, FALSE otherwise + # @ingroup l2_modif_edit + def DoubleNodes(self, theNodes, theModifiedElems): + return self.editor.DoubleNodes(theNodes, theModifiedElems) + + ## Creates a hole in a mesh by doubling the nodes of some particular elements + # This method provided for convenience works as DoubleNodes() described above. + # @param theNodes identifiers of node to be doubled + # @param theModifiedElems identifiers of elements to be updated + # @return TRUE if operation has been completed successfully, FALSE otherwise + # @ingroup l2_modif_edit + def DoubleNode(self, theNodeId, theModifiedElems): + return self.editor.DoubleNode(theNodeId, theModifiedElems) + + ## Creates a hole in a mesh by doubling the nodes of some particular elements + # This method provided for convenience works as DoubleNodes() described above. + # @param theNodes group of nodes to be doubled + # @param theModifiedElems group of elements to be updated. + # @return TRUE if operation has been completed successfully, FALSE otherwise + # @ingroup l2_modif_edit + def DoubleNodeGroup(self, theNodes, theModifiedElems): + return self.editor.DoubleNodeGroup(theNodes, theModifiedElems) + + ## Creates a hole in a mesh by doubling the nodes of some particular elements + # This method provided for convenience works as DoubleNodes() described above. + # @param theNodes list of groups of nodes to be doubled + # @param theModifiedElems list of groups of elements to be updated. + # @return TRUE if operation has been completed successfully, FALSE otherwise + # @ingroup l2_modif_edit + def DoubleNodeGroups(self, theNodes, theModifiedElems): + return self.editor.DoubleNodeGroups(theNodes, theModifiedElems) ## Creates a hole in a mesh by doubling the nodes of some particular elements # @param theElems - the list of elements (edges or faces) to be replicated @@ -3354,8 +3518,8 @@ class Mesh: # replicated nodes should be associated to. # @return TRUE if operation has been completed successfully, FALSE otherwise # @ingroup l2_modif_edit - def DoubleNodes(self, theElems, theNodesNot, theAffectedElems): - return self.editor.DoubleNodes(theElems, theNodesNot, theAffectedElems) + def DoubleNodeElem(self, theElems, theNodesNot, theAffectedElems): + return self.editor.DoubleNodeElem(theElems, theNodesNot, theAffectedElems) ## Creates a hole in a mesh by doubling the nodes of some particular elements # @param theElems - the list of elements (edges or faces) to be replicated @@ -3366,8 +3530,8 @@ class Mesh: # The replicated nodes should be associated to affected elements. # @return TRUE if operation has been completed successfully, FALSE otherwise # @ingroup l2_modif_edit - def DoubleNodesInRegion(self, theElems, theNodesNot, theShape): - return self.editor.DoubleNodesInRegion(theElems, theNodesNot, theShape) + def DoubleNodeElemInRegion(self, theElems, theNodesNot, theShape): + return self.editor.DoubleNodeElemInRegion(theElems, theNodesNot, theShape) ## Creates a hole in a mesh by doubling the nodes of some particular elements # This method provided for convenience works as DoubleNodes() described above. @@ -3376,8 +3540,8 @@ class Mesh: # @param theAffectedElems - group of elements to which the replicated nodes # should be associated to. # @ingroup l2_modif_edit - def DoubleNodeGroup(self, theElems, theNodesNot, theAffectedElems): - return self.editor.DoubleNodeGroup(theElems, theNodesNot, theAffectedElems) + def DoubleNodeElemGroup(self, theElems, theNodesNot, theAffectedElems): + return self.editor.DoubleNodeElemGroup(theElems, theNodesNot, theAffectedElems) ## Creates a hole in a mesh by doubling the nodes of some particular elements # This method provided for convenience works as DoubleNodes() described above. @@ -3387,8 +3551,8 @@ class Mesh: # located on or inside shape). # The replicated nodes should be associated to affected elements. # @ingroup l2_modif_edit - def DoubleNodeGroupInRegion(self, theElems, theNodesNot, theShape): - return self.editor.DoubleNodeGroup(theElems, theNodesNot, theShape) + def DoubleNodeElemGroupInRegion(self, theElems, theNodesNot, theShape): + return self.editor.DoubleNodeElemGroup(theElems, theNodesNot, theShape) ## Creates a hole in a mesh by doubling the nodes of some particular elements # This method provided for convenience works as DoubleNodes() described above. @@ -3398,8 +3562,8 @@ class Mesh: # should be associated to. # @return TRUE if operation has been completed successfully, FALSE otherwise # @ingroup l2_modif_edit - def DoubleNodeGroups(self, theElems, theNodesNot, theAffectedElems): - return self.editor.DoubleNodeGroups(theElems, theNodesNot, theAffectedElems) + def DoubleNodeElemGroups(self, theElems, theNodesNot, theAffectedElems): + return self.editor.DoubleNodeElemGroups(theElems, theNodesNot, theAffectedElems) ## Creates a hole in a mesh by doubling the nodes of some particular elements # This method provided for convenience works as DoubleNodes() described above. @@ -3410,8 +3574,8 @@ class Mesh: # The replicated nodes should be associated to affected elements. # @return TRUE if operation has been completed successfully, FALSE otherwise # @ingroup l2_modif_edit - def DoubleNodeGroupsInRegion(self, theElems, theNodesNot, theShape): - return self.editor.DoubleNodeGroupsInRegion(theElems, theNodesNot, theShape) + def DoubleNodeElemGroupsInRegion(self, theElems, theNodesNot, theShape): + return self.editor.DoubleNodeElemGroupsInRegion(theElems, theNodesNot, theShape) ## The mother class to define algorithm, it is not recommended to use it directly. # @@ -3989,19 +4153,15 @@ class Mesh_Triangle(Mesh_Algorithm): self.Create(mesh, geom, "MEFISTO_2D") pass elif algoType == BLSURF: - import BLSURFPlugin + CheckPlugin(BLSURF) self.Create(mesh, geom, "BLSURF", "libBLSURFEngine.so") #self.SetPhysicalMesh() - PAL19680 elif algoType == NETGEN: - if noNETGENPlugin: - print "Warning: NETGENPlugin module unavailable" - pass + CheckPlugin(NETGEN) self.Create(mesh, geom, "NETGEN_2D", "libNETGENEngine.so") pass elif algoType == NETGEN_2D: - if noNETGENPlugin: - print "Warning: NETGENPlugin module unavailable" - pass + CheckPlugin(NETGEN) self.Create(mesh, geom, "NETGEN_2D_ONLY", "libNETGENEngine.so") pass @@ -4050,6 +4210,7 @@ class Mesh_Triangle(Mesh_Algorithm): # @ingroup l3_hypos_blsurf def SetPhySize(self, theVal): # Parameter of BLSURF algo + self.SetPhysicalMesh(1) #Custom - else why to set the size? self.Parameters().SetPhySize(theVal) ## Sets lower boundary of mesh element size (PhySize). @@ -4304,22 +4465,22 @@ class Mesh_Tetrahedron(Mesh_Algorithm): Mesh_Algorithm.__init__(self) if algoType == NETGEN: + CheckPlugin(NETGEN) self.Create(mesh, geom, "NETGEN_3D", "libNETGENEngine.so") pass elif algoType == FULL_NETGEN: - if noNETGENPlugin: - print "Warning: NETGENPlugin module has not been imported." + CheckPlugin(NETGEN) self.Create(mesh, geom, "NETGEN_2D3D", "libNETGENEngine.so") pass elif algoType == GHS3D: - import GHS3DPlugin + CheckPlugin(GHS3D) self.Create(mesh, geom, "GHS3D_3D" , "libGHS3DEngine.so") pass elif algoType == GHS3DPRL: - import GHS3DPRLPlugin + CheckPlugin(GHS3DPRL) self.Create(mesh, geom, "GHS3DPRL_3D" , "libGHS3DPRLEngine.so") pass @@ -4457,8 +4618,9 @@ class Mesh_Tetrahedron(Mesh_Algorithm): self.Parameters().SetToMeshHoles(toMesh) ## Set Optimization level: - # None_Optimization, Light_Optimization, Medium_Optimization, Strong_Optimization. - # Default is Medium_Optimization + # None_Optimization, Light_Optimization, Standard_Optimization, StandardPlus_Optimization, + # Strong_Optimization. + # Default is Standard_Optimization # @ingroup l3_hypos_ghs3dh def SetOptimizationLevel(self, level): # Parameter of GHS3D @@ -4555,7 +4717,7 @@ class Mesh_Hexahedron(Mesh_Algorithm): pass elif algoType == Hexotic: - import HexoticPlugin + CheckPlugin(Hexotic) self.Create(mesh, geom, "Hexotic_3D", "libHexoticEngine.so") pass @@ -4588,8 +4750,7 @@ class Mesh_Netgen(Mesh_Algorithm): def __init__(self, mesh, is3D, geom=0): Mesh_Algorithm.__init__(self) - if noNETGENPlugin: - print "Warning: NETGENPlugin module has not been imported." + CheckPlugin(NETGEN) self.is3D = is3D if is3D: @@ -4971,29 +5132,21 @@ import salome_notebook notebook = salome_notebook.notebook ##Return values of the notebook variables -def ParseParameters(last, nbParams,nbParam, value): +def ParseParameters(last, nbParams, nbParam, value): + #print "ParseParameters", last, nbParams, nbParam, value result = None - strResult = "" + strResult = [] counter = 0 listSize = len(last) for n in range(0,nbParams): if n+1 != nbParam: if counter < listSize: - strResult = strResult + last[counter] + strResult.append( last[counter] ) else: - strResult = strResult + "" + strResult = strResult else: - if isinstance(value, str): - if notebook.isVariable(value): - result = notebook.get(value) - strResult=strResult+value - else: - raise RuntimeError, "Variable with name '" + value + "' doesn't exist!!!" - else: - strResult=strResult+str(value) - result = value - if nbParams - 1 != counter: - strResult=strResult+var_separator #":" + strResult.append(ParseString(value)) + result = ParseValue(value) counter = counter+1 return result, strResult @@ -5003,15 +5156,15 @@ class LocalLength(StdMeshers._objref_StdMeshers_LocalLength): ## Set Length parameter value # @param length numerical value or name of variable from notebook def SetLength(self, length): - length,parameters = ParseParameters(StdMeshers._objref_StdMeshers_LocalLength.GetLastParameters(self),2,1,length) - StdMeshers._objref_StdMeshers_LocalLength.SetParameters(self,parameters) + length,parameters = ParseParameters(StdMeshers._objref_StdMeshers_LocalLength.GetParameters(self),2,1,length) + geompyDC.SetParameters(self, parameters) StdMeshers._objref_StdMeshers_LocalLength.SetLength(self,length) ## Set Precision parameter value # @param precision numerical value or name of variable from notebook def SetPrecision(self, precision): - precision,parameters = ParseParameters(StdMeshers._objref_StdMeshers_LocalLength.GetLastParameters(self),2,2,precision) - StdMeshers._objref_StdMeshers_LocalLength.SetParameters(self,parameters) + precision,parameters = ParseParameters(StdMeshers._objref_StdMeshers_LocalLength.GetParameters(self),2,2,precision) + geompyDC.SetParameters(self, parameters) StdMeshers._objref_StdMeshers_LocalLength.SetPrecision(self, precision) #Registering the new proxy for LocalLength @@ -5022,21 +5175,32 @@ omniORB.registerObjref(StdMeshers._objref_StdMeshers_LocalLength._NP_RepositoryI class LayerDistribution(StdMeshers._objref_StdMeshers_LayerDistribution): def SetLayerDistribution(self, hypo): - StdMeshers._objref_StdMeshers_LayerDistribution.SetParameters(self,hypo.GetParameters()) - hypo.ClearParameters(); + geompyDC.SetParameters(self, hypo.GetParameters()) + geompyDC.SetParameters(hypo, []) StdMeshers._objref_StdMeshers_LayerDistribution.SetLayerDistribution(self,hypo) #Registering the new proxy for LayerDistribution omniORB.registerObjref(StdMeshers._objref_StdMeshers_LayerDistribution._NP_RepositoryId, LayerDistribution) +#Wrapper class for StdMeshers_LayerDistribution2D hypothesis +class LayerDistribution2D(StdMeshers._objref_StdMeshers_LayerDistribution2D): + + def SetLayerDistribution(self, hypo): + geompyDC.SetParameters(self, hypo.GetParameters()) + geompyDC.SetParameters(hypo, []) + StdMeshers._objref_StdMeshers_LayerDistribution2D.SetLayerDistribution(self,hypo) + +#Registering the new proxy for LayerDistribution +omniORB.registerObjref(StdMeshers._objref_StdMeshers_LayerDistribution2D._NP_RepositoryId, LayerDistribution2D) + #Wrapper class for StdMeshers_SegmentLengthAroundVertex hypothesis class SegmentLengthAroundVertex(StdMeshers._objref_StdMeshers_SegmentLengthAroundVertex): ## Set Length parameter value # @param length numerical value or name of variable from notebook def SetLength(self, length): - length,parameters = ParseParameters(StdMeshers._objref_StdMeshers_SegmentLengthAroundVertex.GetLastParameters(self),1,1,length) - StdMeshers._objref_StdMeshers_SegmentLengthAroundVertex.SetParameters(self,parameters) + length,parameters = ParseParameters(StdMeshers._objref_StdMeshers_SegmentLengthAroundVertex.GetParameters(self),1,1,length) + geompyDC.SetParameters(self, parameters) StdMeshers._objref_StdMeshers_SegmentLengthAroundVertex.SetLength(self,length) #Registering the new proxy for SegmentLengthAroundVertex @@ -5053,9 +5217,23 @@ class Arithmetic1D(StdMeshers._objref_StdMeshers_Arithmetic1D): nb = 2 if isStart: nb = 1 - length,parameters = ParseParameters(StdMeshers._objref_StdMeshers_Arithmetic1D.GetLastParameters(self),2,nb,length) - StdMeshers._objref_StdMeshers_Arithmetic1D.SetParameters(self,parameters) + length,parameters = ParseParameters(StdMeshers._objref_StdMeshers_Arithmetic1D.GetParameters(self),2,nb,length) + geompyDC.SetParameters(self, parameters) StdMeshers._objref_StdMeshers_Arithmetic1D.SetLength(self,length,isStart) + + ## Set Start Length parameter value + # @param length numerical value or name of variable from notebook + def SetStartLength(self, length): + length,parameters = ParseParameters(StdMeshers._objref_StdMeshers_Arithmetic1D.GetParameters(self),2,1,length) + geompyDC.SetParameters(self, parameters) + StdMeshers._objref_StdMeshers_Arithmetic1D.SetStartLength(self,length) + + ## Set End Length parameter value + # @param length numerical value or name of variable from notebook + def SetEndLength(self, length): + length,parameters = ParseParameters(StdMeshers._objref_StdMeshers_Arithmetic1D.GetParameters(self),2,2,length) + geompyDC.SetParameters(self, parameters) + StdMeshers._objref_StdMeshers_Arithmetic1D.SetEndLength(self,length) #Registering the new proxy for Arithmetic1D omniORB.registerObjref(StdMeshers._objref_StdMeshers_Arithmetic1D._NP_RepositoryId, Arithmetic1D) @@ -5066,8 +5244,8 @@ class Deflection1D(StdMeshers._objref_StdMeshers_Deflection1D): ## Set Deflection parameter value # @param deflection numerical value or name of variable from notebook def SetDeflection(self, deflection): - deflection,parameters = ParseParameters(StdMeshers._objref_StdMeshers_Deflection1D.GetLastParameters(self),1,1,deflection) - StdMeshers._objref_StdMeshers_Deflection1D.SetParameters(self,parameters) + deflection,parameters = ParseParameters(StdMeshers._objref_StdMeshers_Deflection1D.GetParameters(self),1,1,deflection) + geompyDC.SetParameters(self, parameters) StdMeshers._objref_StdMeshers_Deflection1D.SetDeflection(self,deflection) #Registering the new proxy for Deflection1D @@ -5083,8 +5261,8 @@ class StartEndLength(StdMeshers._objref_StdMeshers_StartEndLength): nb = 2 if isStart: nb = 1 - length,parameters = ParseParameters(StdMeshers._objref_StdMeshers_StartEndLength.GetLastParameters(self),2,nb,length) - StdMeshers._objref_StdMeshers_StartEndLength.SetParameters(self,parameters) + length,parameters = ParseParameters(StdMeshers._objref_StdMeshers_StartEndLength.GetParameters(self),2,nb,length) + geompyDC.SetParameters(self, parameters) StdMeshers._objref_StdMeshers_StartEndLength.SetLength(self,length,isStart) #Registering the new proxy for StartEndLength @@ -5096,8 +5274,8 @@ class MaxElementArea(StdMeshers._objref_StdMeshers_MaxElementArea): ## Set Max Element Area parameter value # @param area numerical value or name of variable from notebook def SetMaxElementArea(self, area): - area ,parameters = ParseParameters(StdMeshers._objref_StdMeshers_MaxElementArea.GetLastParameters(self),1,1,area) - StdMeshers._objref_StdMeshers_MaxElementArea.SetParameters(self,parameters) + area ,parameters = ParseParameters(StdMeshers._objref_StdMeshers_MaxElementArea.GetParameters(self),1,1,area) + geompyDC.SetParameters(self, parameters) StdMeshers._objref_StdMeshers_MaxElementArea.SetMaxElementArea(self,area) #Registering the new proxy for MaxElementArea @@ -5108,10 +5286,10 @@ omniORB.registerObjref(StdMeshers._objref_StdMeshers_MaxElementArea._NP_Reposito class MaxElementVolume(StdMeshers._objref_StdMeshers_MaxElementVolume): ## Set Max Element Volume parameter value - # @param area numerical value or name of variable from notebook + # @param volume numerical value or name of variable from notebook def SetMaxElementVolume(self, volume): - volume ,parameters = ParseParameters(StdMeshers._objref_StdMeshers_MaxElementVolume.GetLastParameters(self),1,1,volume) - StdMeshers._objref_StdMeshers_MaxElementVolume.SetParameters(self,parameters) + volume ,parameters = ParseParameters(StdMeshers._objref_StdMeshers_MaxElementVolume.GetParameters(self),1,1,volume) + geompyDC.SetParameters(self, parameters) StdMeshers._objref_StdMeshers_MaxElementVolume.SetMaxElementVolume(self,volume) #Registering the new proxy for MaxElementVolume @@ -5124,138 +5302,153 @@ class NumberOfLayers(StdMeshers._objref_StdMeshers_NumberOfLayers): ## Set Number Of Layers parameter value # @param nbLayers numerical value or name of variable from notebook def SetNumberOfLayers(self, nbLayers): - nbLayers ,parameters = ParseParameters(StdMeshers._objref_StdMeshers_NumberOfLayers.GetLastParameters(self),1,1,nbLayers) - StdMeshers._objref_StdMeshers_NumberOfLayers.SetParameters(self,parameters) + nbLayers ,parameters = ParseParameters(StdMeshers._objref_StdMeshers_NumberOfLayers.GetParameters(self),1,1,nbLayers) + geompyDC.SetParameters(self, parameters) StdMeshers._objref_StdMeshers_NumberOfLayers.SetNumberOfLayers(self,nbLayers) #Registering the new proxy for NumberOfLayers omniORB.registerObjref(StdMeshers._objref_StdMeshers_NumberOfLayers._NP_RepositoryId, NumberOfLayers) +#Wrapper class for StdMeshers_NumberOfLayers2D hypothesis +class NumberOfLayers2D(StdMeshers._objref_StdMeshers_NumberOfLayers2D): + + ## Set Number Of Layers parameter value + # @param nbLayers numerical value or name of variable from notebook + def SetNumberOfLayers(self, nbLayers): + nbLayers ,parameters = ParseParameters(StdMeshers._objref_StdMeshers_NumberOfLayers2D.GetParameters(self),1,1,nbLayers) + geompyDC.SetParameters(self, parameters) + StdMeshers._objref_StdMeshers_NumberOfLayers2D.SetNumberOfLayers(self,nbLayers) + +#Registering the new proxy for NumberOfLayers2D +omniORB.registerObjref(StdMeshers._objref_StdMeshers_NumberOfLayers2D._NP_RepositoryId, NumberOfLayers2D) + #Wrapper class for StdMeshers_NumberOfSegments hypothesis class NumberOfSegments(StdMeshers._objref_StdMeshers_NumberOfSegments): ## Set Number Of Segments parameter value # @param nbSeg numerical value or name of variable from notebook def SetNumberOfSegments(self, nbSeg): - lastParameters = StdMeshers._objref_StdMeshers_NumberOfSegments.GetLastParameters(self) + lastParameters = StdMeshers._objref_StdMeshers_NumberOfSegments.GetParameters(self) nbSeg , parameters = ParseParameters(lastParameters,1,1,nbSeg) - StdMeshers._objref_StdMeshers_NumberOfSegments.SetParameters(self,parameters) + geompyDC.SetParameters(self, parameters) StdMeshers._objref_StdMeshers_NumberOfSegments.SetNumberOfSegments(self,nbSeg) ## Set Scale Factor parameter value # @param factor numerical value or name of variable from notebook def SetScaleFactor(self, factor): - factor, parameters = ParseParameters(StdMeshers._objref_StdMeshers_NumberOfSegments.GetLastParameters(self),2,2,factor) - StdMeshers._objref_StdMeshers_NumberOfSegments.SetParameters(self,parameters) + factor, parameters = ParseParameters(StdMeshers._objref_StdMeshers_NumberOfSegments.GetParameters(self),2,2,factor) + geompyDC.SetParameters(self, parameters) StdMeshers._objref_StdMeshers_NumberOfSegments.SetScaleFactor(self,factor) #Registering the new proxy for NumberOfSegments omniORB.registerObjref(StdMeshers._objref_StdMeshers_NumberOfSegments._NP_RepositoryId, NumberOfSegments) +if not noNETGENPlugin: + #Wrapper class for NETGENPlugin_Hypothesis hypothesis + class NETGENPlugin_Hypothesis(NETGENPlugin._objref_NETGENPlugin_Hypothesis): + + ## Set Max Size parameter value + # @param maxsize numerical value or name of variable from notebook + def SetMaxSize(self, maxsize): + lastParameters = NETGENPlugin._objref_NETGENPlugin_Hypothesis.GetParameters(self) + maxsize, parameters = ParseParameters(lastParameters,4,1,maxsize) + geompyDC.SetParameters(self, parameters) + NETGENPlugin._objref_NETGENPlugin_Hypothesis.SetMaxSize(self,maxsize) + + ## Set Growth Rate parameter value + # @param value numerical value or name of variable from notebook + def SetGrowthRate(self, value): + lastParameters = NETGENPlugin._objref_NETGENPlugin_Hypothesis.GetParameters(self) + value, parameters = ParseParameters(lastParameters,4,2,value) + geompyDC.SetParameters(self, parameters) + NETGENPlugin._objref_NETGENPlugin_Hypothesis.SetGrowthRate(self,value) + + ## Set Number of Segments per Edge parameter value + # @param value numerical value or name of variable from notebook + def SetNbSegPerEdge(self, value): + lastParameters = NETGENPlugin._objref_NETGENPlugin_Hypothesis.GetParameters(self) + value, parameters = ParseParameters(lastParameters,4,3,value) + geompyDC.SetParameters(self, parameters) + NETGENPlugin._objref_NETGENPlugin_Hypothesis.SetNbSegPerEdge(self,value) + + ## Set Number of Segments per Radius parameter value + # @param value numerical value or name of variable from notebook + def SetNbSegPerRadius(self, value): + lastParameters = NETGENPlugin._objref_NETGENPlugin_Hypothesis.GetParameters(self) + value, parameters = ParseParameters(lastParameters,4,4,value) + geompyDC.SetParameters(self, parameters) + NETGENPlugin._objref_NETGENPlugin_Hypothesis.SetNbSegPerRadius(self,value) + + #Registering the new proxy for NETGENPlugin_Hypothesis + omniORB.registerObjref(NETGENPlugin._objref_NETGENPlugin_Hypothesis._NP_RepositoryId, NETGENPlugin_Hypothesis) + + + #Wrapper class for NETGENPlugin_Hypothesis_2D hypothesis + class NETGENPlugin_Hypothesis_2D(NETGENPlugin_Hypothesis,NETGENPlugin._objref_NETGENPlugin_Hypothesis_2D): + pass -#Wrapper class for NETGENPlugin_Hypothesis hypothesis -class NETGENPlugin_Hypothesis(NETGENPlugin._objref_NETGENPlugin_Hypothesis): - - ## Set Max Size parameter value - # @param maxsize numerical value or name of variable from notebook - def SetMaxSize(self, maxsize): - lastParameters = NETGENPlugin._objref_NETGENPlugin_Hypothesis.GetLastParameters(self) - maxsize, parameters = ParseParameters(lastParameters,4,1,maxsize) - NETGENPlugin._objref_NETGENPlugin_Hypothesis.SetParameters(self,parameters) - NETGENPlugin._objref_NETGENPlugin_Hypothesis.SetMaxSize(self,maxsize) - - ## Set Growth Rate parameter value - # @param value numerical value or name of variable from notebook - def SetGrowthRate(self, value): - lastParameters = NETGENPlugin._objref_NETGENPlugin_Hypothesis.GetLastParameters(self) - value, parameters = ParseParameters(lastParameters,4,2,value) - NETGENPlugin._objref_NETGENPlugin_Hypothesis.SetParameters(self,parameters) - NETGENPlugin._objref_NETGENPlugin_Hypothesis.SetGrowthRate(self,value) - - ## Set Number of Segments per Edge parameter value - # @param value numerical value or name of variable from notebook - def SetNbSegPerEdge(self, value): - lastParameters = NETGENPlugin._objref_NETGENPlugin_Hypothesis.GetLastParameters(self) - value, parameters = ParseParameters(lastParameters,4,3,value) - NETGENPlugin._objref_NETGENPlugin_Hypothesis.SetParameters(self,parameters) - NETGENPlugin._objref_NETGENPlugin_Hypothesis.SetNbSegPerEdge(self,value) - - ## Set Number of Segments per Radius parameter value - # @param value numerical value or name of variable from notebook - def SetNbSegPerRadius(self, value): - lastParameters = NETGENPlugin._objref_NETGENPlugin_Hypothesis.GetLastParameters(self) - value, parameters = ParseParameters(lastParameters,4,4,value) - NETGENPlugin._objref_NETGENPlugin_Hypothesis.SetParameters(self,parameters) - NETGENPlugin._objref_NETGENPlugin_Hypothesis.SetNbSegPerRadius(self,value) - -#Registering the new proxy for NETGENPlugin_Hypothesis -omniORB.registerObjref(NETGENPlugin._objref_NETGENPlugin_Hypothesis._NP_RepositoryId, NETGENPlugin_Hypothesis) - - -#Wrapper class for NETGENPlugin_Hypothesis_2D hypothesis -class NETGENPlugin_Hypothesis_2D(NETGENPlugin_Hypothesis,NETGENPlugin._objref_NETGENPlugin_Hypothesis_2D): - pass - -#Registering the new proxy for NETGENPlugin_Hypothesis_2D -omniORB.registerObjref(NETGENPlugin._objref_NETGENPlugin_Hypothesis_2D._NP_RepositoryId, NETGENPlugin_Hypothesis_2D) - -#Wrapper class for NETGENPlugin_SimpleHypothesis_2D hypothesis -class NETGEN_SimpleParameters_2D(NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D): - - ## Set Number of Segments parameter value - # @param nbSeg numerical value or name of variable from notebook - def SetNumberOfSegments(self, nbSeg): - lastParameters = NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.GetLastParameters(self) - nbSeg, parameters = ParseParameters(lastParameters,2,1,nbSeg) - NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.SetParameters(self,parameters) - NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.SetNumberOfSegments(self, nbSeg) - - ## Set Local Length parameter value - # @param length numerical value or name of variable from notebook - def SetLocalLength(self, length): - lastParameters = NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.GetLastParameters(self) - length, parameters = ParseParameters(lastParameters,2,1,length) - NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.SetParameters(self,parameters) - NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.SetLocalLength(self, length) - - ## Set Max Element Area parameter value - # @param area numerical value or name of variable from notebook - def SetMaxElementArea(self, area): - lastParameters = NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.GetLastParameters(self) - area, parameters = ParseParameters(lastParameters,2,2,area) - NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.SetParameters(self,parameters) - NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.SetMaxElementArea(self, area) - - def LengthFromEdges(self): - lastParameters = NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.GetLastParameters(self) - value = 0; - value, parameters = ParseParameters(lastParameters,2,2,value) - NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.SetParameters(self,parameters) - NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.LengthFromEdges(self) - -#Registering the new proxy for NETGEN_SimpleParameters_2D -omniORB.registerObjref(NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D._NP_RepositoryId, NETGEN_SimpleParameters_2D) - - -#Wrapper class for NETGENPlugin_SimpleHypothesis_3D hypothesis -class NETGEN_SimpleParameters_3D(NETGEN_SimpleParameters_2D,NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_3D): - ## Set Max Element Volume parameter value - # @param volume numerical value or name of variable from notebook - def SetMaxElementVolume(self, volume): - lastParameters = NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_3D.GetLastParameters(self) - volume, parameters = ParseParameters(lastParameters,3,3,volume) - NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_3D.SetParameters(self,parameters) - NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_3D.SetMaxElementVolume(self, volume) - - def LengthFromFaces(self): - lastParameters = NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_3D.GetLastParameters(self) - value = 0; - value, parameters = ParseParameters(lastParameters,3,3,value) - NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_3D.SetParameters(self,parameters) - NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_3D.LengthFromFaces(self) - -#Registering the new proxy for NETGEN_SimpleParameters_3D -omniORB.registerObjref(NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_3D._NP_RepositoryId, NETGEN_SimpleParameters_3D) + #Registering the new proxy for NETGENPlugin_Hypothesis_2D + omniORB.registerObjref(NETGENPlugin._objref_NETGENPlugin_Hypothesis_2D._NP_RepositoryId, NETGENPlugin_Hypothesis_2D) + + #Wrapper class for NETGENPlugin_SimpleHypothesis_2D hypothesis + class NETGEN_SimpleParameters_2D(NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D): + + ## Set Number of Segments parameter value + # @param nbSeg numerical value or name of variable from notebook + def SetNumberOfSegments(self, nbSeg): + lastParameters = NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.GetParameters(self) + nbSeg, parameters = ParseParameters(lastParameters,2,1,nbSeg) + geompyDC.SetParameters(self, parameters) + NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.SetNumberOfSegments(self, nbSeg) + + ## Set Local Length parameter value + # @param length numerical value or name of variable from notebook + def SetLocalLength(self, length): + lastParameters = NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.GetParameters(self) + length, parameters = ParseParameters(lastParameters,2,1,length) + geompyDC.SetParameters(self, parameters) + NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.SetLocalLength(self, length) + + ## Set Max Element Area parameter value + # @param area numerical value or name of variable from notebook + def SetMaxElementArea(self, area): + lastParameters = NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.GetParameters(self) + area, parameters = ParseParameters(lastParameters,2,2,area) + geompyDC.SetParameters(self, parameters) + NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.SetMaxElementArea(self, area) + + def LengthFromEdges(self): + lastParameters = NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.GetParameters(self) + value = 0; + value, parameters = ParseParameters(lastParameters,2,2,value) + geompyDC.SetParameters(self, parameters) + NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D.LengthFromEdges(self) + + #Registering the new proxy for NETGEN_SimpleParameters_2D + omniORB.registerObjref(NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_2D._NP_RepositoryId, NETGEN_SimpleParameters_2D) + + + #Wrapper class for NETGENPlugin_SimpleHypothesis_3D hypothesis + class NETGEN_SimpleParameters_3D(NETGEN_SimpleParameters_2D,NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_3D): + ## Set Max Element Volume parameter value + # @param volume numerical value or name of variable from notebook + def SetMaxElementVolume(self, volume): + lastParameters = NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_3D.GetParameters(self) + volume, parameters = ParseParameters(lastParameters,3,3,volume) + geompyDC.SetParameters(self, parameters) + NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_3D.SetMaxElementVolume(self, volume) + + def LengthFromFaces(self): + lastParameters = NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_3D.GetParameters(self) + value = 0; + value, parameters = ParseParameters(lastParameters,3,3,value) + geompyDC.SetParameters(self, parameters) + NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_3D.LengthFromFaces(self) + + #Registering the new proxy for NETGEN_SimpleParameters_3D + omniORB.registerObjref(NETGENPlugin._objref_NETGENPlugin_SimpleHypothesis_3D._NP_RepositoryId, NETGEN_SimpleParameters_3D) + + pass # if not noNETGENPlugin: class Pattern(SMESH._objref_SMESH_Pattern): @@ -5266,7 +5459,7 @@ class Pattern(SMESH._objref_SMESH_Pattern): theNodeIndexOnKeyPoint1,Parameters = geompyDC.ParseParameters(theNodeIndexOnKeyPoint1) if flag: theNodeIndexOnKeyPoint1 -= 1 - theMesh.SetParameters(Parameters) + geompyDC.SetParameters(theMesh, Parameters) return SMESH._objref_SMESH_Pattern.ApplyToMeshFaces( self, theMesh, theFacesIDs, theNodeIndexOnKeyPoint1, theReverse ) def ApplyToHexahedrons(self, theMesh, theVolumesIDs, theNode000Index, theNode001Index): @@ -5281,7 +5474,7 @@ class Pattern(SMESH._objref_SMESH_Pattern): theNode000Index -= 1 if flag1: theNode001Index -= 1 - theMesh.SetParameters(Parameters) + geompyDC.SetParameters(theMesh, Parameters) return SMESH._objref_SMESH_Pattern.ApplyToHexahedrons( self, theMesh, theVolumesIDs, theNode000Index, theNode001Index ) #Registering the new proxy for Pattern