-# Copyright (C) 2007-2008 CEA/DEN, EDF R&D, OPEN CASCADE
-#
-# Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
-# CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+# -*- coding: iso-8859-1 -*-
+# Copyright (C) 2007-2010 CEA/DEN, EDF R&D, OPEN CASCADE
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+
# File : smesh.py
# Author : Francis KLOSS, OCC
# Module : SMESH
import StdMeshers
import SALOME
+import SALOMEDS
# import NETGENPlugin module if possible
noNETGENPlugin = 0
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
## @{
Hexotic = 9
BLSURF = 10
GHS3DPRL = 11
+QUADRANGLE = 0
+RADIAL_QUAD = 1
# MirrorType enumeration
POINT = SMESH_MeshEditor.POINT
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
PrecisionConfusion = 1e-07
+# TopAbs_State enumeration
+[TopAbs_IN, TopAbs_OUT, TopAbs_ON, TopAbs_UNKNOWN] = range(4)
+
+
## Converts an angle from degrees to radians
def DegreesToRadians(AngleInDegrees):
from math import pi
## Gets object name
def GetName(obj):
- ior = salome.orb.object_to_string(obj)
- sobj = salome.myStudy.FindObjectIOR(ior)
- if sobj is None:
- return NO_NAME
- else:
- attr = sobj.FindAttribute("AttributeName")[1]
- return attr.Value()
+ if obj:
+ # object not null
+ if isinstance(obj, SALOMEDS._objref_SObject):
+ # study object
+ return obj.GetName()
+ ior = salome.orb.object_to_string(obj)
+ if ior:
+ # CORBA object
+ studies = salome.myStudyManager.GetOpenStudies()
+ for sname in studies:
+ s = salome.myStudyManager.GetStudyByName(sname)
+ if not s: continue
+ sobj = s.FindObjectIOR(ior)
+ if not sobj: continue
+ return sobj.GetName()
+ if hasattr(obj, "GetName"):
+ # unknown CORBA object, having GetName() method
+ return obj.GetName()
+ else:
+ # unknown CORBA object, no GetName() method
+ return NO_NAME
+ pass
+ if hasattr(obj, "GetName"):
+ # unknown non-CORBA object, having GetName() method
+ return obj.GetName()
+ pass
+ raise RuntimeError, "Null or invalid object"
## Prints error message if a hypothesis was not assigned.
def TreatHypoStatus(status, hypName, geomName, isAlgo):
return
hypName = '"' + hypName + '"'
geomName= '"' + geomName+ '"'
- if status < HYP_UNKNOWN_FATAL:
+ if status < HYP_UNKNOWN_FATAL and not geomName =='""':
print hypName, "was assigned to", geomName,"but", reason
- else:
+ elif not geomName == '""':
print hypName, "was not assigned to",geomName,":", reason
+ else:
+ print hypName, "was not assigned:", reason
pass
+## Check meshing plugin availability
+def CheckPlugin(plugin):
+ if plugin == NETGEN and noNETGENPlugin:
+ print "Warning: NETGENPlugin module unavailable"
+ return False
+ elif plugin == GHS3D and noGHS3DPlugin:
+ print "Warning: GHS3DPlugin module unavailable"
+ return False
+ elif plugin == GHS3DPRL and noGHS3DPRLPlugin:
+ print "Warning: GHS3DPRLPlugin module unavailable"
+ return False
+ elif plugin == Hexotic and noHexoticPlugin:
+ print "Warning: HexoticPlugin module unavailable"
+ return False
+ elif plugin == BLSURF and noBLSURFPlugin:
+ print "Warning: BLSURFPlugin module unavailable"
+ return False
+ return True
+
# 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)
if (isinstance(algo, geompyDC.GEOM._objref_GEOM_Object)):
geom = algo
algo = MEFISTO
-
return Mesh_Triangle(self, algo, geom)
## Creates a quadrangle 2D algorithm for faces.
# If the optional \a geom parameter is not set, this algorithm is global.
# \n Otherwise, this algorithm defines a submesh based on \a geom subshape.
# @param geom If defined, the subshape to be meshed (GEOM_Object)
+ # @param algo values are: smesh.QUADRANGLE || smesh.RADIAL_QUAD
# @return an instance of Mesh_Quadrangle algorithm
# @ingroup l3_algos_basic
- def Quadrangle(self, geom=0):
- return Mesh_Quadrangle(self, geom)
+ def Quadrangle(self, geom=0, algo=QUADRANGLE):
+ if algo==RADIAL_QUAD:
+ return Mesh_RadialQuadrangle1D2D(self,geom)
+ else:
+ return Mesh_Quadrangle(self, geom)
## Creates a tetrahedron 3D algorithm for solids.
# The parameter \a algo permits to choose the algorithm: NETGEN or GHS3D
print "Mesh computation failed, exception caught:"
traceback.print_exc()
if True:#not ok:
- errors = self.smeshpyD.GetAlgoState( self.mesh, geom )
allReasons = ""
+
+ # Treat compute errors
+ computeErrors = self.smeshpyD.GetComputeErrors( self.mesh, geom )
+ for err in computeErrors:
+ shapeText = ""
+ if self.mesh.HasShapeToMesh():
+ try:
+ mainIOR = salome.orb.object_to_string(geom)
+ for sname in salome.myStudyManager.GetOpenStudies():
+ s = salome.myStudyManager.GetStudyByName(sname)
+ if not s: continue
+ mainSO = s.FindObjectIOR(mainIOR)
+ if not mainSO: continue
+ subIt = s.NewChildIterator(mainSO)
+ while subIt.More():
+ subSO = subIt.Value()
+ subIt.Next()
+ obj = subSO.GetObject()
+ if not obj: continue
+ go = obj._narrow( geompyDC.GEOM._objref_GEOM_Object )
+ if not go: continue
+ ids = go.GetSubShapeIndices()
+ if len(ids) == 1 and ids[0] == err.subShapeID:
+ shapeText = ' on "%s"' % subSO.GetName()
+ break
+ if not shapeText:
+ shape = self.geompyD.GetSubShape( geom, [err.subShapeID])
+ if shape:
+ shapeText = " on %s #%s" % (shape.GetShapeType(), err.subShapeID)
+ else:
+ shapeText = " on subshape #%s" % (err.subShapeID)
+ except:
+ shapeText = " on subshape #%s" % (err.subShapeID)
+ errText = ""
+ stdErrors = ["OK", #COMPERR_OK
+ "Invalid input mesh", #COMPERR_BAD_INPUT_MESH
+ "std::exception", #COMPERR_STD_EXCEPTION
+ "OCC exception", #COMPERR_OCC_EXCEPTION
+ "SALOME exception", #COMPERR_SLM_EXCEPTION
+ "Unknown exception", #COMPERR_EXCEPTION
+ "Memory allocation problem", #COMPERR_MEMORY_PB
+ "Algorithm failed", #COMPERR_ALGO_FAILED
+ "Unexpected geometry"]#COMPERR_BAD_SHAPE
+ if err.code > 0:
+ if err.code < len(stdErrors): errText = stdErrors[err.code]
+ else:
+ errText = "code %s" % -err.code
+ if errText: errText += ". "
+ errText += err.comment
+ if allReasons != "":allReasons += "\n"
+ allReasons += '"%s" failed%s. Error: %s' %(err.algoName, shapeText, errText)
+ pass
+
+ # Treat hyp errors
+ errors = self.smeshpyD.GetAlgoState( self.mesh, geom )
for err in errors:
if err.isGlobalAlgo:
glob = "global"
reason = "For unknown reason."+\
" Revise Mesh.Compute() implementation in smeshDC.py!"
pass
- if allReasons != "":
- allReasons += "\n"
- pass
+ if allReasons != "":allReasons += "\n"
allReasons += reason
pass
if allReasons != "":
pass
return ok
+ ## Return submesh objects list in meshing order
+ # @return list of list of submesh objects
+ # @ingroup l2_construct
+ def GetMeshOrder(self):
+ return self.mesh.GetMeshOrder()
+
+ ## Return submesh objects list in meshing order
+ # @return list of list of submesh objects
+ # @ingroup l2_construct
+ def SetMeshOrder(self, submeshes):
+ return self.mesh.SetMeshOrder(submeshes)
+
## Removes all nodes and elements
# @ingroup l2_construct
def Clear(self):
pass
status = self.mesh.AddHypothesis(geom, hyp)
isAlgo = hyp._narrow( SMESH_Algo )
- TreatHypoStatus( status, GetName( hyp ), GetName( geom ), isAlgo )
+ hyp_name = GetName( hyp )
+ geom_name = ""
+ if geom:
+ geom_name = GetName( geom )
+ TreatHypoStatus( status, hyp_name, geom_name, isAlgo )
return status
## Unassigns a hypothesis
# 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
def NbElements(self):
return self.mesh.NbElements()
+ ## Returns the number of 0d elements in the mesh
+ # @return an integer value
+ # @ingroup l1_meshinfo
+ def Nb0DElements(self):
+ return self.mesh.Nb0DElements()
+
## Returns the number of edges in the mesh
# @return an integer value
# @ingroup l1_meshinfo
def GetElementType(self, id, iselem):
return self.mesh.GetElementType(id, iselem)
+ ## Returns the geometric type of mesh element
+ # @return the value from SMESH::EntityType enumeration
+ # @ingroup l1_meshinfo
+ def GetElementGeomType(self, id):
+ return self.mesh.GetElementGeomType(id)
+
## Returns the list of submesh elements IDs
# @param Shape a geom object(subshape) IOR
# Shape must be the subshape of a ShapeToMesh()
def ElemNbFaces(self, id):
return self.mesh.ElemNbFaces(id)
+ ## Returns nodes of given face (counted from zero) for given volumic element.
+ # @ingroup l1_meshinfo
+ def GetElemFaceNodes(self,elemId, faceIndex):
+ return self.mesh.GetElemFaceNodes(elemId, faceIndex)
+
+ ## Returns an element based on all given nodes.
+ # @ingroup l1_meshinfo
+ def FindElementByNodes(self,nodes):
+ return self.mesh.FindElementByNodes(nodes)
+
## Returns true if the given element is a polygon
# @ingroup l1_meshinfo
def IsPoly(self, id):
self.mesh.SetParameters(Parameters)
return self.editor.AddNode( x, y, z)
+ ## Creates a 0D element on a node with given number.
+ # @param IDOfNode the ID of node for creation of the element.
+ # @return the Id of the new 0D element
+ # @ingroup l2_modif_add
+ def Add0DElement(self, IDOfNode):
+ return self.editor.Add0DElement(IDOfNode)
+
## Creates a linear or quadratic edge (this is determined
# by the number of given nodes).
# @param IDsOfNodes the list of node IDs for creation of the element.
# @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)
+
+ # Return point state in a closed 2D mesh in terms of TopAbs_State enumeration.
+ # TopAbs_UNKNOWN state means that either mesh is wrong or the analysis fails.
+
+ def GetPointState(self, x, y, z):
+ return self.editor.GetPointState(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
def BestSplit (self, IDOfQuad, theCriterion):
return self.editor.BestSplit(IDOfQuad, self.smeshpyD.GetFunctor(theCriterion))
+ ## Splits volumic elements into tetrahedrons
+ # @param elemIDs either list of elements or mesh or group or submesh
+ # @param method flags passing splitting method:
+ # 1 - split the hexahedron into 5 tetrahedrons
+ # 2 - split the hexahedron into 6 tetrahedrons
+ # @ingroup l2_modif_cutquadr
+ def SplitVolumesIntoTetra(self, elemIDs, method=1 ):
+ if isinstance( elemIDs, Mesh ):
+ elemIDs = elemIDs.GetMesh()
+ self.editor.SplitVolumesIntoTetra(elemIDs, method)
+
## Splits quadrangle faces near triangular facets of volumes
#
# @ingroup l1_auxiliary
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:
mesh.SetParameters(Parameters)
return Mesh( self.smeshpyD, self.geompyD, mesh )
+
+
+ ## Scales the object
+ # @param theObject - the object to translate (mesh, submesh, or group)
+ # @param thePoint - base point for scale
+ # @param theScaleFact - scale factors for axises
+ # @param Copy - allows copying the translated elements
+ # @param MakeGroups - forces the generation of new groups from existing
+ # ones (if Copy)
+ # @return list of created groups (SMESH_GroupBase) if MakeGroups=True,
+ # empty list otherwise
+ def Scale(self, theObject, thePoint, theScaleFact, Copy, MakeGroups=False):
+ if ( isinstance( theObject, Mesh )):
+ theObject = theObject.GetMesh()
+ if ( isinstance( theObject, list )):
+ theObject = self.editor.MakeIDSource(theObject)
+
+ thePoint, Parameters = ParsePointStruct(thePoint)
+ self.mesh.SetParameters(Parameters)
+
+ if Copy and MakeGroups:
+ return self.editor.ScaleMakeGroups(theObject, thePoint, theScaleFact)
+ self.editor.Scale(theObject, thePoint, theScaleFact, Copy)
+ return []
+
+ ## Creates a new mesh from the translated object
+ # @param theObject - the object to translate (mesh, submesh, or group)
+ # @param thePoint - base point for scale
+ # @param theScaleFact - scale factors for axises
+ # @param MakeGroups - forces the generation of new groups from existing ones
+ # @param NewMeshName - the name of the newly created mesh
+ # @return instance of Mesh class
+ def ScaleMakeMesh(self, theObject, thePoint, theScaleFact, MakeGroups=False, NewMeshName=""):
+ if (isinstance(theObject, Mesh)):
+ theObject = theObject.GetMesh()
+ if ( isinstance( theObject, list )):
+ theObject = self.editor.MakeIDSource(theObject)
+
+ mesh = self.editor.ScaleMakeMesh(theObject, thePoint, theScaleFact,
+ MakeGroups, NewMeshName)
+ #mesh.SetParameters(Parameters)
+ return Mesh( self.smeshpyD, self.geompyD, mesh )
+
+
+
## Rotates the elements
# @param IDsOfElements list of elements ids
# @param Axis the axis of rotation (AxisStruct or geom line)
# @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
+
+ ## 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
## 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 theNodeId 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
# @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
+ # The nodes for duplication could be found from these elements
+ # @param theNodesNot - list of nodes to NOT replicate
+ # @param theAffectedElems - the list of elements (cells and edges) to which the
+ # replicated nodes should be associated to.
+ # @return TRUE if operation has been completed successfully, FALSE otherwise
+ # @ingroup l2_modif_edit
+ 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 nodes for duplication could be found from these elements
+ # @param theNodesNot - list of nodes to NOT replicate
+ # @param theShape - shape to detect affected elements (element which geometric center
+ # located on or inside shape).
+ # The replicated nodes should be associated to affected elements.
+ # @return TRUE if operation has been completed successfully, FALSE otherwise
+ # @ingroup l2_modif_edit
+ 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 theElems - group of of elements (edges or faces) to be replicated
+ # @param theNodesNot - group of nodes not to replicated
+ # @param theAffectedElems - group of elements to which the replicated nodes
+ # should be associated to.
+ # @ingroup l2_modif_edit
+ 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.
+ # @param theElems - group of of elements (edges or faces) to be replicated
+ # @param theNodesNot - group of nodes not to replicated
+ # @param theShape - shape to detect affected elements (element which geometric center
+ # located on or inside shape).
+ # The replicated nodes should be associated to affected elements.
+ # @ingroup l2_modif_edit
+ def DoubleNodeElemGroupInRegion(self, theElems, theNodesNot, theShape):
+ return self.editor.DoubleNodeElemGroupInRegion(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 theElems - list of groups of elements (edges or faces) to be replicated
+ # @param theNodesNot - list of groups of nodes not to replicated
+ # @param theAffectedElems - group of elements to which the replicated nodes
+ # should be associated to.
+ # @return TRUE if operation has been completed successfully, FALSE otherwise
+ # @ingroup l2_modif_edit
+ 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.
+ # @param theElems - list of groups of elements (edges or faces) to be replicated
+ # @param theNodesNot - list of groups of nodes not to replicated
+ # @param theShape - shape to detect affected elements (element which geometric center
+ # located on or inside shape).
+ # The replicated nodes should be associated to affected elements.
+ # @return TRUE if operation has been completed successfully, FALSE otherwise
+ # @ingroup l2_modif_edit
+ 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.
#
raise RuntimeError, "Attemp to create " + algo + " algoritm on None shape"
self.mesh = mesh
piece = mesh.geom
+ name = ""
if not geom:
self.geom = piece
else:
self.geom = geom
- name = GetName(geom)
- if name==NO_NAME:
+ try:
+ name = GetName(geom)
+ pass
+ except:
name = mesh.geompyD.SubShapeName(geom, piece)
mesh.geompyD.addToStudyInFather(piece, geom, name)
+ pass
self.subm = mesh.mesh.GetSubMesh(geom, algo.GetName())
self.algo = algo
status = mesh.mesh.AddHypothesis(self.geom, self.algo)
- TreatHypoStatus( status, algo.GetName(), GetName(self.geom), True )
+ TreatHypoStatus( status, algo.GetName(), name, True )
def CompareHyp (self, hyp, args):
print "CompareHyp is not implemented for ", self.__class__.__name__, ":", hyp.GetName()
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
+ if reversedEdges and isinstance( reversedEdges[0], geompyDC.GEOM._objref_GEOM_Object ):
+ for i in range( len( reversedEdges )):
+ reversedEdges[i] = self.mesh.geompyD.GetSubShapeID(self.mesh.geom, reversedEdges[i] )
+ entry = self.MainShapeEntry()
+ hyp = self.Hypothesis("FixedPoints1D", [points, nbSegs, reversedEdges, entry],
+ UseExisting=UseExisting,
+ CompareMethod=self.CompareFixedPoints1D)
+ 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
### 0D algorithm
if self.geom is None:
raise RuntimeError, "Attemp to create SegmentAroundVertex_0D algoritm on None shape"
- name = GetName(self.geom)
- if name == NO_NAME:
+ try:
+ name = GetName(self.geom)
+ pass
+ except:
piece = self.mesh.geom
name = self.mesh.geompyD.SubShapeName(self.geom, piece)
self.mesh.geompyD.addToStudyInFather(piece, self.geom, name)
+ pass
algo = self.FindAlgorithm("SegmentAroundVertex_0D", self.mesh.smeshpyD)
if algo is None:
algo = self.mesh.smeshpyD.CreateHypothesis("SegmentAroundVertex_0D", "libStdMeshersEngine.so")
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).
CompareMethod=self.CompareEqualHyp)
return hyp
+ ## Defines "QuadrangleParams" hypothesis
+ # @param vertex: vertex of a trilateral geometrical face, around which triangles
+ # will be created while other elements will be quadrangles.
+ # Vertex can be either a GEOM_Object or a vertex ID within the
+ # shape to mesh
+ # @param UseExisting: if ==true - searches for the existing hypothesis created with
+ # the same parameters, else (default) - creates a new one
+ #
+ # @ingroup l3_hypos_additi
+ def TriangleVertex(self, vertex, UseExisting=0):
+ vertexID = vertex
+ if isinstance( vertexID, geompyDC.GEOM._objref_GEOM_Object ):
+ vertexID = self.mesh.geompyD.GetSubShapeID( self.mesh.geom, vertex )
+ hyp = self.Hypothesis("QuadrangleParams", [vertexID], UseExisting = UseExisting,
+ CompareMethod=lambda hyp,args: hyp.GetTriaVertex()==args[0])
+ hyp.SetTriaVertex( vertexID )
+ return hyp
+
+
# Public class: Mesh_Tetrahedron
# ------------------------------
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:
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
+ self.mesh.smeshpyD.SetCurrentStudy( None )
hyp = self.mesh.smeshpyD.CreateHypothesis(hypType, so)
self.mesh.smeshpyD.SetCurrentStudy( study ) # enables publishing
self.distribHyp.SetLayerDistribution( hyp )
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 = None #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 self.nbLayers:
+ self.mesh.GetMesh().RemoveHypothesis( self.geom, self.nbLayers )
+ if self.distribHyp is None:
+ self.distribHyp = self.Hypothesis("LayerDistribution2D", UseExisting=0)
+ else:
+ self.mesh.GetMesh().AddHypothesis( self.geom, self.distribHyp )
+ study = self.mesh.smeshpyD.GetCurrentStudy() # prevents publishing own 1D hypothesis
+ self.mesh.smeshpyD.SetCurrentStudy( None )
+ hyp = self.mesh.smeshpyD.CreateHypothesis(hypType, so)
+ self.mesh.smeshpyD.SetCurrentStudy( study ) # enables publishing
+ self.distribHyp.SetLayerDistribution( hyp )
+ return hyp
+
+ ## Defines "NumberOfLayers" 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 NumberOfLayers(self, n, UseExisting=0):
+ if self.distribHyp:
+ 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):
