+# -*- 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,
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
## @{
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
from math import pi
return AngleInDegrees * pi / 180.0
-# Salome notebook variable separator
-var_separator = ":"
-
# Parametrized substitute for PointStruct
class PointStructStr:
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):
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
## @}
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
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)
# 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)
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
# @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
# @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.
# @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
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
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)
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)
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):
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)
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)
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)
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)
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)
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)
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)
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)
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 = []
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:
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,
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,
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,
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,
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)
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
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)
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
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)
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
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)
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
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)
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
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)
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.
# @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.
# @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
# 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
# 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.
# @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.
# 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.
# 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.
# 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.
#
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
# @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).
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
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
pass
elif algoType == Hexotic:
- import HexoticPlugin
+ CheckPlugin(Hexotic)
self.Create(mesh, geom, "Hexotic_3D", "libHexoticEngine.so")
pass
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:
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
## 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
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
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)
## 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
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
## 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
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
## 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):
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):
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
