+# -*- 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
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
## @}
# @return an instance of Mesh class.
# @ingroup l2_construct
def Mesh(self, obj=0, name=0):
- return Mesh(self,self.geompyD,obj,name)
+ if isinstance(obj,str):
+ obj,name = name,obj
+ return Mesh(self,self.geompyD,obj,name)
## Returns a long value from enumeration
# Should be used for SMESH.FunctorType enumeration
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
# Get informations about mesh contents:
# ------------------------------------
+ ## Gets the mesh stattistic
+ # @return dictionary type element - count of elements
+ # @ingroup l1_meshinfo
+ def GetMeshInfo(self, obj = None):
+ if not obj: obj = self.mesh
+ return self.smeshpyD.GetMeshInfo(obj)
+
## Returns the number of nodes in the mesh
# @return an integer value
# @ingroup l1_meshinfo
# @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):
# @return the ID of a node
# @ingroup l2_modif_throughp
def FindNodeClosestTo(self, x, y, z):
- preview = self.mesh.GetMeshEditPreviewer()
- return preview.MoveClosestNodeToPoint(x, y, z, -1)
+ #preview = self.mesh.GetMeshEditPreviewer()
+ #return preview.MoveClosestNodeToPoint(x, y, z, -1)
+ return self.editor.FindNodeClosestTo(x, y, z)
+
+ ## Finds the elements where a point lays IN or ON
+ # @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 elementType type of elements to find (SMESH.ALL type
+ # means elements of any type excluding nodes and 0D elements)
+ # @return list of IDs of found elements
+ # @ingroup l2_modif_throughp
+ def FindElementsByPoint(self, x, y, z, elementType = SMESH.ALL):
+ return self.editor.FindElementsByPoint(x, y, z, elementType)
+
## Finds the node closest to a point and moves it to a point location
# @param x the X coordinate of a point
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):
HasRefPoint, RefPoint, MakeGroups, ElemType)
else:
if isinstance(Base,Mesh):
- return self.editor.ExtrusionAlongPathObjX(Base.GetMesh(), Path, NodeStart,
+ return self.editor.ExtrusionAlongPathObjX(Base, Path, NodeStart,
HasAngles, Angles, LinearVariation,
HasRefPoint, RefPoint, MakeGroups, ElemType)
else:
# @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.
#
return True
return False
+
+ ## Defines "FixedPoints1D" hypothesis to cut an edge using parameter
+ # on curve from 0 to 1 (additionally it is neecessary to check
+ # orientation of edges and create list of reversed edges if it is
+ # needed) and sets numbers of segments between given points (default
+ # values are equals 1
+ # @param points defines the list of parameters on curve
+ # @param nbSegs defines the list of numbers of segments
+ # @param reversedEdges is a list of edges to mesh using reversed orientation
+ # @param UseExisting if ==true - searches for an existing hypothesis created with
+ # the same parameters, else (default) - creates a new one
+ # @return an instance of StdMeshers_Arithmetic1D hypothesis
+ # @ingroup l3_hypos_1dhyps
+ def FixedPoints1D(self, points, nbSegs=[1], reversedEdges=[], UseExisting=0):
+ if not isinstance(reversedEdges,list): #old version script, before adding reversedEdges
+ reversedEdges, UseExisting = [], reversedEdges
+ entry = self.MainShapeEntry()
+ hyp = self.Hypothesis("FixedPoints1D", [points, nbSegs, reversedEdges, entry],
+ UseExisting=UseExisting,
+ CompareMethod=self.CompareArithmetic1D)
+ hyp.SetPoints(points)
+ hyp.SetNbSegments(nbSegs)
+ hyp.SetReversedEdges(reversedEdges)
+ hyp.SetObjectEntry(entry)
+ return hyp
+
+ ## Private method
+ ## Check if the given "FixedPoints1D" hypothesis has the same parameters
+ ## as the given arguments
+ def CompareFixedPoints1D(self, hyp, args):
+ if hyp.GetPoints() == args[0]:
+ if hyp.GetNbSegments() == args[1]:
+ if hyp.GetReversedEdges() == args[2]:
+ if not args[2] or hyp.GetObjectEntry() == args[3]:
+ return True
+ return False
+
+
+
## Defines "StartEndLength" hypothesis to cut an edge in several segments with increasing geometric length
# @param start defines the length of the first segment
# @param end defines the length of the last segment
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:
hyp.SetFineness( fineness )
return hyp
+# Public class: Mesh_RadialQuadrangle1D2D
+# -------------------------------
+
+## Defines a Radial Quadrangle 1D2D algorithm
+# @ingroup l2_algos_radialq
+#
+class Mesh_RadialQuadrangle1D2D(Mesh_Algorithm):
+
+ ## Private constructor.
+ def __init__(self, mesh, geom=0):
+ Mesh_Algorithm.__init__(self)
+ self.Create(mesh, geom, "RadialQuadrangle_1D2D")
+
+ self.distribHyp = self.Hypothesis("LayerDistribution2D", UseExisting=0)
+ self.nbLayers = None
+
+ ## Return 2D hypothesis holding the 1D one
+ def Get2DHypothesis(self):
+ return self.distribHyp
+
+ ## Private method creating a 1D hypothesis and storing it in the LayerDistribution
+ # hypothesis. Returns the created hypothesis
+ def OwnHypothesis(self, hypType, args=[], so="libStdMeshersEngine.so"):
+ #print "OwnHypothesis",hypType
+ if not self.nbLayers is None:
+ self.mesh.GetMesh().RemoveHypothesis( self.geom, self.nbLayers )
+ self.mesh.GetMesh().AddHypothesis( self.geom, self.distribHyp )
+ study = self.mesh.smeshpyD.GetCurrentStudy() # prevents publishing own 1D hypothesis
+ hyp = self.mesh.smeshpyD.CreateHypothesis(hypType, so)
+ self.mesh.smeshpyD.SetCurrentStudy( study ) # enables publishing
+ self.distribHyp.SetLayerDistribution( hyp )
+ return hyp
+
+ ## Defines "NumberOfLayers2D" hypothesis, specifying the number of layers
+ # @param n number of layers
+ # @param UseExisting if ==true - searches for the existing hypothesis created with
+ # the same parameters, else (default) - creates a new one
+ def NumberOfLayers2D(self, n, UseExisting=0):
+ self.mesh.GetMesh().RemoveHypothesis( self.geom, self.distribHyp )
+ self.nbLayers = self.Hypothesis("NumberOfLayers2D", [n], UseExisting=UseExisting,
+ CompareMethod=self.CompareNumberOfLayers)
+ self.nbLayers.SetNumberOfLayers( n )
+ return self.nbLayers
+
+ ## Checks if the given "NumberOfLayers" hypothesis has the same parameters as the given arguments
+ def CompareNumberOfLayers(self, hyp, args):
+ return IsEqual(hyp.GetNumberOfLayers(), args[0])
+
+ ## Defines "LocalLength" hypothesis, specifying the segment length
+ # @param l the length of segments
+ # @param p the precision of rounding
+ def LocalLength(self, l, p=1e-07):
+ hyp = self.OwnHypothesis("LocalLength", [l,p])
+ hyp.SetLength(l)
+ hyp.SetPrecision(p)
+ return hyp
+
+ ## Defines "NumberOfSegments" hypothesis, specifying the number of layers
+ # @param n the number of layers
+ # @param s the scale factor (optional)
+ def NumberOfSegments(self, n, s=[]):
+ if s == []:
+ hyp = self.OwnHypothesis("NumberOfSegments", [n])
+ else:
+ hyp = self.OwnHypothesis("NumberOfSegments", [n,s])
+ hyp.SetDistrType( 1 )
+ hyp.SetScaleFactor(s)
+ hyp.SetNumberOfSegments(n)
+ return hyp
+
+ ## Defines "Arithmetic1D" hypothesis, specifying the distribution of segments
+ # with a length that changes in arithmetic progression
+ # @param start the length of the first segment
+ # @param end the length of the last segment
+ def Arithmetic1D(self, start, end ):
+ hyp = self.OwnHypothesis("Arithmetic1D", [start, end])
+ hyp.SetLength(start, 1)
+ hyp.SetLength(end , 0)
+ return hyp
+
+ ## Defines "StartEndLength" hypothesis, specifying distribution of segments
+ # as geometric length increasing
+ # @param start for the length of the first segment
+ # @param end for the length of the last segment
+ def StartEndLength(self, start, end):
+ hyp = self.OwnHypothesis("StartEndLength", [start, end])
+ hyp.SetLength(start, 1)
+ hyp.SetLength(end , 0)
+ return hyp
+
+ ## Defines "AutomaticLength" hypothesis, specifying the number of segments
+ # @param fineness defines the quality of the mesh within the range [0-1]
+ def AutomaticLength(self, fineness=0):
+ hyp = self.OwnHypothesis("AutomaticLength")
+ hyp.SetFineness( fineness )
+ return hyp
+
+
# Private class: Mesh_UseExisting
# -------------------------------
class Mesh_UseExisting(Mesh_Algorithm):
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)
#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.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
-#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.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)
+
+ pass # if not noNETGENPlugin:
class Pattern(SMESH._objref_SMESH_Pattern):