reason = hypType + " of the same dimension is already assigned to this shape"
elif status == HYP_BAD_DIM :
reason = hypType + " mismatches the shape"
- elif status == HYP_CONCURENT :
+ elif status == HYP_CONCURRENT :
reason = "there are concurrent hypotheses on sub-shapes"
elif status == HYP_BAD_SUBSHAPE :
reason = "the shape is neither the main one, nor its sub-shape, nor a valid group"
aMeasurements.UnRegister()
return value
+ ## Get gravity center of all nodes of the mesh object.
+ # @param obj mesh, submesh or group
+ # @return three components of the gravity center: x,y,z
+ # @ingroup l1_measurements
+ def GetGravityCenter(self, obj):
+ if isinstance(obj, Mesh): obj = obj.mesh
+ if isinstance(obj, Mesh_Algorithm): obj = obj.GetSubMesh()
+ aMeasurements = self.CreateMeasurements()
+ pointStruct = aMeasurements.GravityCenter(obj)
+ aMeasurements.UnRegister()
+ return pointStruct.x, pointStruct.y, pointStruct.z
+
pass # end of class smeshBuilder
import omniORB
# from salome.smesh import smeshBuilder
# smesh = smeshBuilder.New(salome.myStudy)
# \endcode
-# @param study SALOME study, generally obtained by salome.myStudy.
-# @param instance CORBA proxy of SMESH Engine. If None, the default Engine is used.
+# @param study SALOME study, generally obtained by salome.myStudy.
+# @param instance CORBA proxy of SMESH Engine. If None, the default Engine is used.
+# @param instanceGeom CORBA proxy of GEOM Engine. If None, the default Engine is used.
# @return smeshBuilder instance
-def New( study, instance=None):
+def New( study, instance=None, instanceGeom=None):
"""
Create a new smeshBuilder instance.The smeshBuilder class provides the Python
interface to create or load meshes.
smesh = smeshBuilder.New(salome.myStudy)
Parameters:
- study SALOME study, generally obtained by salome.myStudy.
- instance CORBA proxy of SMESH Engine. If None, the default Engine is used.
+ study SALOME study, generally obtained by salome.myStudy.
+ instance CORBA proxy of SMESH Engine. If None, the default Engine is used.
+ instanceGeom CORBA proxy of GEOM Engine. If None, the default Engine is used.
Returns:
smeshBuilder instance
"""
doLcc = True
smeshInst = smeshBuilder()
assert isinstance(smeshInst,smeshBuilder), "Smesh engine class is %s but should be smeshBuilder.smeshBuilder. Import salome.smesh.smeshBuilder before creating the instance."%smeshInst.__class__
- smeshInst.init_smesh(study)
+ smeshInst.init_smesh(study, instanceGeom)
return smeshInst
# @param auto_groups boolean parameter for creating/not creating
# the groups Group_On_All_Nodes, Group_On_All_Faces, ... ;
# the typical use is auto_groups=False.
- # @param version MED format version (MED_V2_1 or MED_V2_2,
- # the latter meaning any current version). The parameter is
- # obsolete since MED_V2_1 is no longer supported.
+ # @param version MED format version
+ # - MED_V2_1 is obsolete.
+ # - MED_V2_2 means current version (kept for compatibility reasons)
+ # - MED_LATEST means current version.
+ # - MED_MINOR_x where x from 0 to 9 indicates the minor version of MED
+ # to use for writing MED files, for backward compatibility :
+ # for instance, with SALOME 8.4 use MED 3.2 (minor=2) instead of 3.3,
+ # to allow the file to be read with SALOME 8.3.
# @param overwrite boolean parameter for overwriting/not overwriting the file
# @param meshPart a part of mesh (group, sub-mesh) to export instead of the mesh
# @param autoDimension if @c True (default), a space dimension of a MED mesh can be either
# - 'f' stands for "_faces _" field;
# - 's' stands for "_solids _" field.
# @ingroup l2_impexp
- def ExportMED(self, f, auto_groups=0, version=MED_V2_2,
+ def ExportMED(self, f, auto_groups=0, version=MED_LATEST,
overwrite=1, meshPart=None, autoDimension=True, fields=[], geomAssocFields=''):
if meshPart or fields or geomAssocFields:
unRegister = genObjUnRegister()
# Export the mesh in a file in MED format
# allowing to overwrite the file if it exists or add the exported data to its contents
# @param f the file name
- # @param version MED format version (MED_V2_1 or MED_V2_2,
- # the latter meaning any current version). The parameter is
- # obsolete since MED_V2_1 is no longer supported.
+ # @param version MED format version:
+ # - MED_V2_1 is obsolete.
+ # - MED_V2_2 means current version (kept for compatibility reasons)
+ # - MED_LATEST means current version.
+ # - MED_MINOR_x where x from 0 to 9 indicates the minor version of MED
+ # to use for writing MED files, for backward compatibility :
+ # for instance, with SALOME 8.4 use MED 3.2 (minor=2) instead of 3.3,
+ # to allow the file to be read with SALOME 8.3.
# @param opt boolean parameter for creating/not creating
# the groups Group_On_All_Nodes, Group_On_All_Faces, ...
# @param overwrite boolean parameter for overwriting/not overwriting the file
# - 3D in the rest cases.<br>
# If @a autoDimension is @c False, the space dimension is always 3.
# @ingroup l2_impexp
- def ExportToMED(self, f, version=MED_V2_2, opt=0, overwrite=1, autoDimension=True):
+ def ExportToMED(self, f, version=MED_LATEST, opt=0, overwrite=1, autoDimension=True):
self.mesh.ExportToMEDX(f, opt, version, overwrite, autoDimension)
# Operations with groups:
return self.editor.MakeIDSource(ids, elemType)
- # Get informations about mesh contents:
+ # Get information about mesh contents:
# ------------------------------------
- ## Get the mesh stattistic
+ ## Get the mesh statistic
# @return dictionary type element - count of elements
# @ingroup l1_meshinfo
def GetMeshInfo(self, obj = None):
# Type SMESH.FunctorType._items in the Python Console to see all items.
# Note that not all items correspond to numerical functors.
# @param MaxAngle is the maximum angle between element normals at which the fusion
- # is still performed; theMaxAngle is mesured in radians.
+ # is still performed; theMaxAngle is measured in radians.
# Also it could be a name of variable which defines angle in degrees.
# @return TRUE in case of success, FALSE otherwise.
# @ingroup l2_modif_unitetri
# Type SMESH.FunctorType._items in the Python Console to see all items.
# Note that not all items correspond to numerical functors.
# @param MaxAngle a max angle between element normals at which the fusion
- # is still performed; theMaxAngle is mesured in radians.
+ # is still performed; theMaxAngle is measured in radians.
# @return TRUE in case of success, FALSE otherwise.
# @ingroup l2_modif_unitetri
def TriToQuadObject (self, theObject, theCriterion, MaxAngle):
return self.editor.TriToQuadObject(theObject, Functor, MaxAngle)
## Split quadrangles into triangles.
- # @param IDsOfElements the faces to be splitted.
+ # @param IDsOfElements the faces to be split.
# @param theCriterion is a numerical functor, in terms of enum SMESH.FunctorType, used to
# choose a diagonal for splitting. If @a theCriterion is None, which is a default
# value, then quadrangles will be split by the smallest diagonal.
## Split each of given quadrangles into 4 triangles. A node is added at the center of
# a quadrangle.
- # @param theElements the faces to be splitted. This can be either mesh, sub-mesh,
+ # @param theElements the faces to be split. This can be either mesh, sub-mesh,
# group or a list of face IDs. By default all quadrangles are split
# @ingroup l2_modif_cutquadr
def QuadTo4Tri (self, theElements=[]):
return self.editor.QuadTo4Tri( theElements )
## Split quadrangles into triangles.
- # @param IDsOfElements the faces to be splitted
+ # @param IDsOfElements the faces to be split
# @param Diag13 is used to choose a diagonal for splitting.
# @return TRUE in case of success, FALSE otherwise.
# @ingroup l2_modif_cutquadr
return self.editor.SplitQuadObject(theObject, Diag13)
## Find a better splitting of the given quadrangle.
- # @param IDOfQuad the ID of the quadrangle to be splitted.
+ # @param IDOfQuad the ID of the quadrangle to be split.
# @param theCriterion is a numerical functor, in terms of enum SMESH.FunctorType, used to
# choose a diagonal for splitting.
# Type SMESH.FunctorType._items in the Python Console to see all items.
self.mesh.SetParameters(Parameters)
return Mesh( self.smeshpyD, self.geompyD, mesh )
+ ## Create an offset mesh from the given 2D object
+ # @param theObject the source object (mesh, submesh, group or filter)
+ # @param theValue signed offset size
+ # @param MakeGroups forces the generation of new groups from existing ones
+ # @param NewMeshName the name of a mesh to create. If empty, offset elements are added
+ # to this mesh
+ # @return a tuple (mesh, list_of_groups)
+ # @ingroup l2_modif_trsf
+ def Offset(self, theObject, theValue, MakeGroups=False, NewMeshName=''):
+ if isinstance( theObject, Mesh ):
+ theObject = theObject.GetMesh()
+ theValue,Parameters,hasVars = ParseParameters(theValue)
+ mesh_groups = self.editor.Offset(theObject, theValue, MakeGroups, NewMeshName )
+ self.mesh.SetParameters(Parameters)
+ # if mesh_groups[0]:
+ # return Mesh( self.smeshpyD, self.geompyD, mesh_groups[0] ), mesh_groups[1]
+ return mesh_groups
+
## Find groups of adjacent nodes within Tolerance.
# @param Tolerance the value of tolerance
# @param SeparateCornerAndMediumNodes if @c True, in quadratic mesh puts
# a Mesh, elements of highest dimension are duplicated
# @param theGroupName - a name of group to contain the generated elements.
# If a group with such a name already exists, the new elements
- # are added to the existng group, else a new group is created.
+ # are added to the existing group, else a new group is created.
# If \a theGroupName is empty, new elements are not added
# in any group.
# @return a group where the new elements are added. None if theGroupName == "".
## Identify the elements that will be affected by node duplication (actual duplication is not performed.
# This method is the first step of DoubleNodeElemGroupsInRegion.
- # @param theElems - list of groups of elements (edges or faces) to be replicated
+ # @param theElems - list of groups of nodes or 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 groups of affected elements
+ # @return groups of affected elements in order: volumes, faces, edges
# @ingroup l2_modif_duplicat
def AffectedElemGroupsInRegion(self, theElems, theNodesNot, theShape):
return self.editor.AffectedElemGroupsInRegion(theElems, theNodesNot, theShape)
def CreateHoleSkin(self, radius, theShape, groupName, theNodesCoords):
return self.editor.CreateHoleSkin( radius, theShape, groupName, theNodesCoords )
+ ## Create a polyline consisting of 1D mesh elements each lying on a 2D element of
+ # the initial mesh. Positions of new nodes are found by cutting the mesh by the
+ # plane passing through pairs of points specified by each PolySegment structure.
+ # If there are several paths connecting a pair of points, the shortest path is
+ # selected by the module. Position of the cutting plane is defined by the two
+ # points and an optional vector lying on the plane specified by a PolySegment.
+ # By default the vector is defined by Mesh module as following. A middle point
+ # of the two given points is computed. The middle point is projected to the mesh.
+ # The vector goes from the middle point to the projection point. In case of planar
+ # mesh, the vector is normal to the mesh.
+ # @param segments - PolySegment's defining positions of cutting planes.
+ # Return the used vector which goes from the middle point to its projection.
+ # @param groupName - optional name of a group where created mesh segments will
+ # be added.
+ # @ingroup l2_modif_duplicat
+ def MakePolyLine(self, segments, groupName='', isPreview=False ):
+ editor = self.editor
+ if isPreview:
+ editor = self.mesh.GetMeshEditPreviewer()
+ segmentsRes = editor.MakePolyLine( segments, groupName )
+ for i, seg in enumerate( segmentsRes ):
+ segments[i].vector = seg.vector
+ if isPreview:
+ return editor.GetPreviewData()
+ return None
+
## Return a cached numerical functor by its type.
# @param theCriterion functor type - an item of SMESH.FunctorType enumeration.
# Type SMESH.FunctorType._items in the Python Console to see all items.