-# Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2007-2019 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
mergeTolerance: tolerance for merging nodes
allGroups: forces creation of groups corresponding to every input mesh
name: name of a new mesh
- meshToAppendTo a mesh to append all given meshes
+ meshToAppendTo: a mesh to append all given meshes
Returns:
an instance of class :class:`Mesh`
+
+ See also:
+ :meth:`Mesh.Append`
"""
if not meshes: return None
- for i,m in enumerate(meshes):
- if isinstance(m, Mesh):
+ if not isinstance( meshes, list ):
+ meshes = [ meshes ]
+ for i,m in enumerate( meshes ):
+ if isinstance( m, Mesh ):
meshes[i] = m.GetMesh()
- mergeTolerance,Parameters,hasVars = ParseParameters(mergeTolerance)
+ mergeTolerance,Parameters,hasVars = ParseParameters( mergeTolerance )
if hasattr(meshes[0], "SetParameters"):
- meshes[0].SetParameters(Parameters)
+ meshes[0].SetParameters( Parameters )
else:
- meshes[0].GetMesh().SetParameters(Parameters)
+ meshes[0].GetMesh().SetParameters( Parameters )
if isinstance( meshToAppendTo, Mesh ):
meshToAppendTo = meshToAppendTo.GetMesh()
if allGroups:
aSmeshMesh = SMESH._objref_SMESH_Gen.ConcatenateWithGroups(
self,meshes,uniteIdenticalGroups,mergeNodesAndElements,
- mergeTolerance,meshToAppendTo)
+ mergeTolerance,meshToAppendTo )
else:
aSmeshMesh = SMESH._objref_SMESH_Gen.Concatenate(
self,meshes,uniteIdenticalGroups,mergeNodesAndElements,
- mergeTolerance,meshToAppendTo)
+ mergeTolerance,meshToAppendTo )
- aMesh = Mesh(self, self.geompyD, aSmeshMesh, name=name)
+ aMesh = Mesh( self, self.geompyD, aSmeshMesh, name=name )
return aMesh
def CopyMesh( self, meshPart, meshName, toCopyGroups=False, toKeepIDs=False):
functor = aFilterMgr.CreateLength()
elif theCriterion == FT_Length2D:
functor = aFilterMgr.CreateLength2D()
+ elif theCriterion == FT_Length3D:
+ functor = aFilterMgr.CreateLength3D()
elif theCriterion == FT_Deflection2D:
functor = aFilterMgr.CreateDeflection2D()
elif theCriterion == FT_NodeConnectivityNumber:
def GetMeshInfo(self, obj):
"""
Get the mesh statistic.
- Use :meth:`smeshBuilder.EnumToLong` to get an integer from
- an item of :class:`SMESH.EntityType`.
Returns:
dictionary { :class:`SMESH.EntityType` - "count of elements" }
minor = -1
# invoke engine's function
self.mesh.ExportMED(fileName, auto_groups, minor, overwrite, autoDimension)
+ return
+
+
+ def Append(self, meshes, uniteIdenticalGroups = True,
+ mergeNodesAndElements = False, mergeTolerance = 1e-5, allGroups = False):
+ """
+ Append given meshes into this mesh.
+ All groups of input meshes will be created in this mesh.
+
+ Parameters:
+ meshes: :class:`meshes, sub-meshes, groups or filters <SMESH.SMESH_IDSource>` to append
+ uniteIdenticalGroups: if True, groups with same names are united, else they are renamed
+ mergeNodesAndElements: if True, equal nodes and elements are merged
+ mergeTolerance: tolerance for merging nodes
+ allGroups: forces creation of groups corresponding to every input mesh
+ """
+ self.smeshpyD.Concatenate( meshes, uniteIdenticalGroups,
+ mergeNodesAndElements, mergeTolerance, allGroups,
+ meshToAppendTo = self.GetMesh() )
# Operations with groups:
# ----------------------
def GetMeshInfo(self, obj = None):
"""
Get the mesh statistic.
- Use :meth:`smeshBuilder.EnumToLong` to get an integer from
- an item of :class:`SMESH.EntityType`.
Returns:
dictionary { :class:`SMESH.EntityType` - "count of elements" }
Returns:
A list of edge groups and a list of corresponding node groups,
- where the group is a list of IDs of edges or elements.
+ where the group is a list of IDs of edges or elements, like follows
+ [[[branch_edges_1],[branch_edges_2]], [[branch_nodes_1],[branch_nodes_2]]].
If a group is closed, the first and last nodes of the group are same.
"""
if isinstance( edges, Mesh ):
NbOfSteps, Tolerance, MakeGroups, TotalAngle)
def ExtrusionSweepObjects(self, nodes, edges, faces, StepVector, NbOfSteps, MakeGroups=False,
- scaleFactors=[], linearVariation=False, basePoint=[] ):
+ scaleFactors=[], linearVariation=False, basePoint=[],
+ angles=[], anglesVariation=False):
"""
Generate new elements by extrusion of the given elements and nodes
NbOfSteps: the number of steps
MakeGroups: forces the generation of new groups from existing ones
scaleFactors: optional scale factors to apply during extrusion
- linearVariation: if *True*, scaleFactors are spread over all *scaleFactors*,
- else scaleFactors[i] is applied to nodes at the i-th extrusion step
- basePoint: optional scaling center; if not provided, a gravity center of
+ linearVariation: if *True*, *scaleFactors* are spread over all *NbOfSteps*,
+ else *scaleFactors* [i] is applied to nodes at the i-th extrusion step
+ basePoint: optional scaling and rotation center; if not provided, a gravity center of
nodes and elements being extruded is used as the scaling center.
It can be either
- a list of tree components of the point or
- a node ID or
- a GEOM point
+ angles: list of angles in radians. Nodes at each extrusion step are rotated
+ around *basePoint*, additionally to previous steps.
+ anglesVariation: forces the computation of rotation angles as linear
+ variation of the given *angles* along path steps
Returns:
the list of created :class:`groups <SMESH.SMESH_GroupBase>` if *MakeGroups* == True, empty list otherwise
basePoint = self.geompyD.PointCoordinates( basePoint )
NbOfSteps,Parameters,hasVars = ParseParameters(NbOfSteps)
- Parameters = StepVector.PS.parameters + var_separator + Parameters
+ scaleFactors,scaleParameters,hasVars = ParseParameters(scaleFactors)
+ angles,angleParameters,hasVars = ParseAngles(angles)
+ Parameters = StepVector.PS.parameters + var_separator + \
+ Parameters + var_separator + \
+ scaleParameters + var_separator + angleParameters
self.mesh.SetParameters(Parameters)
return self.editor.ExtrusionSweepObjects( nodes, edges, faces,
- StepVector, NbOfSteps,
+ StepVector, NbOfSteps, MakeGroups,
scaleFactors, linearVariation, basePoint,
- MakeGroups)
+ angles, anglesVariation )
def ExtrusionSweep(self, IDsOfElements, StepVector, NbOfSteps, MakeGroups=False, IsNodes = False):
return self.editor.AdvancedExtrusion(IDsOfElements, StepVector, NbOfSteps,
ExtrFlags, SewTolerance, MakeGroups)
- def ExtrusionAlongPathObjects(self, Nodes, Edges, Faces, PathMesh, PathShape=None,
+ def ExtrusionAlongPathObjects(self, Nodes, Edges, Faces, PathObject, PathShape=None,
NodeStart=1, HasAngles=False, Angles=[], LinearVariation=False,
- HasRefPoint=False, RefPoint=[0,0,0], MakeGroups=False):
+ HasRefPoint=False, RefPoint=[0,0,0], MakeGroups=False,
+ ScaleFactors=[], ScalesVariation=False):
"""
Generate new elements by extrusion of the given elements and nodes along the path.
The path of extrusion must be a meshed edge.
Nodes: nodes to extrude: a list including ids, :class:`a mesh, sub-meshes, groups or filters <SMESH.SMESH_IDSource>`
Edges: edges to extrude: a list including ids, :class:`a mesh, sub-meshes, groups or filters <SMESH.SMESH_IDSource>`
Faces: faces to extrude: a list including ids, :class:`a mesh, sub-meshes, groups or filters <SMESH.SMESH_IDSource>`
- PathMesh: 1D mesh or 1D sub-mesh, along which proceeds the extrusion
- PathShape: shape (edge) defines the sub-mesh of PathMesh if PathMesh
- contains not only path segments, else it can be None
+ PathObject: :class:`mesh, sub-mesh, group or filter <SMESH.SMESH_IDSource>` containing edges along which proceeds the extrusion
+ PathShape: optional shape (edge or wire) which defines the sub-mesh of the mesh defined by *PathObject* if the mesh contains not only path segments, else it can be None
NodeStart: the first or the last node on the path. Defines the direction of extrusion
- HasAngles: allows the shape to be rotated around the path
- to get the resulting mesh in a helical fashion
- Angles: list of angles
+ HasAngles: not used obsolete
+ Angles: list of angles in radians. Nodes at each extrusion step are rotated
+ around *basePoint*, additionally to previous steps.
LinearVariation: forces the computation of rotation angles as linear
variation of the given Angles along path steps
HasRefPoint: allows using the reference point
- RefPoint: the reference point around which the shape is rotated (the mass center of the
- shape by default). The User can specify any point as the Reference Point.
+ RefPoint: optional scaling and rotation center (mass center of the extruded
+ elements by default). The User can specify any point as the Reference Point.
*RefPoint* can be either GEOM Vertex, [x,y,z] or :class:`SMESH.PointStruct`
MakeGroups: forces the generation of new groups from existing ones
+ ScaleFactors: optional scale factors to apply during extrusion
+ ScalesVariation: if *True*, *scaleFactors* are spread over all *NbOfSteps*,
+ else *scaleFactors* [i] is applied to nodes at the i-th extrusion step
Returns:
list of created :class:`groups <SMESH.SMESH_GroupBase>` and
if isinstance( RefPoint, list ):
if not RefPoint: RefPoint = [0,0,0]
RefPoint = SMESH.PointStruct( *RefPoint )
- if isinstance( PathMesh, Mesh ):
- PathMesh = PathMesh.GetMesh()
+ if isinstance( PathObject, Mesh ):
+ PathObject = PathObject.GetMesh()
Angles,AnglesParameters,hasVars = ParseAngles(Angles)
- Parameters = AnglesParameters + var_separator + RefPoint.parameters
+ ScaleFactors,ScalesParameters,hasVars = ParseParameters(ScaleFactors)
+ Parameters = AnglesParameters + var_separator + \
+ RefPoint.parameters + var_separator + ScalesParameters
self.mesh.SetParameters(Parameters)
return self.editor.ExtrusionAlongPathObjects(Nodes, Edges, Faces,
- PathMesh, PathShape, NodeStart,
+ PathObject, PathShape, NodeStart,
HasAngles, Angles, LinearVariation,
- HasRefPoint, RefPoint, MakeGroups)
+ HasRefPoint, RefPoint, MakeGroups,
+ ScaleFactors, ScalesVariation)
def ExtrusionAlongPathX(self, Base, Path, NodeStart,
HasAngles=False, Angles=[], LinearVariation=False,
Base: :class:`mesh, sub-mesh, group, filter <SMESH.SMESH_IDSource>`, or list of ids of elements for extrusion
Path: 1D mesh or 1D sub-mesh, along which proceeds the extrusion
NodeStart: the start node from Path. Defines the direction of extrusion
- HasAngles: allows the shape to be rotated around the path
- to get the resulting mesh in a helical fashion
- Angles: list of angles in radians
+ HasAngles: not used obsolete
+ Angles: list of angles in radians. Nodes at each extrusion step are rotated
+ around *basePoint*, additionally to previous steps.
LinearVariation: forces the computation of rotation angles as linear
variation of the given Angles along path steps
HasRefPoint: allows using the reference point
PathMesh: mesh containing a 1D sub-mesh on the edge, along which proceeds the extrusion
PathShape: shape (edge) defines the sub-mesh for the path
NodeStart: the first or the last node on the edge. Defines the direction of extrusion
- HasAngles: allows the shape to be rotated around the path
- to get the resulting mesh in a helical fashion
- Angles: list of angles in radians
+ HasAngles: not used obsolete
+ Angles: list of angles in radians. Nodes at each extrusion step are rotated
+ around *basePoint*, additionally to previous steps.
HasRefPoint: allows using the reference point
RefPoint: the reference point around which the shape is rotated (the mass center of the shape by default).
The User can specify any point as the Reference Point.
Example: :ref:`tui_extrusion_along_path`
"""
+ if not IDsOfElements:
+ IDsOfElements = [ self.GetMesh() ]
n,e,f = [],IDsOfElements,IDsOfElements
gr,er = self.ExtrusionAlongPathObjects(n,e,f, PathMesh, PathShape,
NodeStart, HasAngles, Angles,
PathMesh: mesh containing a 1D sub-mesh on the edge, along which the extrusion proceeds
PathShape: shape (edge) defines the sub-mesh for the path
NodeStart: the first or the last node on the edge. Defines the direction of extrusion
- HasAngles: allows the shape to be rotated around the path
- to get the resulting mesh in a helical fashion
- Angles: list of angles
+ HasAngles: not used obsolete
+ Angles: list of angles in radians. Nodes at each extrusion step are rotated
+ around *basePoint*, additionally to previous steps.
HasRefPoint: allows using the reference point
RefPoint: the reference point around which the shape is rotated (the mass center of the shape by default).
The User can specify any point as the Reference Point.
PathMesh: mesh containing a 1D sub-mesh on the edge, along which the extrusion proceeds
PathShape: shape (edge) defines the sub-mesh for the path
NodeStart: the first or the last node on the edge. Defines the direction of extrusion
- HasAngles: allows the shape to be rotated around the path
- to get the resulting mesh in a helical fashion
- Angles: list of angles
+ HasAngles: not used obsolete
+ Angles: list of angles in radians. Nodes at each extrusion step are rotated
+ around *basePoint*, additionally to previous steps.
HasRefPoint: allows using the reference point
RefPoint: the reference point around which the shape is rotated (the mass center of the shape by default).
The User can specify any point as the Reference Point.
PathMesh: mesh containing a 1D sub-mesh on the edge, along which the extrusion proceeds
PathShape: shape (edge) defines the sub-mesh for the path
NodeStart: the first or the last node on the edge. Defines the direction of extrusion
- HasAngles: allows the shape to be rotated around the path
- to get the resulting mesh in a helical fashion
- Angles: list of angles
+ HasAngles: not used obsolete
+ Angles: list of angles in radians. Nodes at each extrusion step are rotated
+ around *basePoint*, additionally to previous steps.
HasRefPoint: allows using the reference point
RefPoint: the reference point around which the shape is rotated (the mass center of the shape by default).
The User can specify any point as the Reference Point.
Parameters:
Tolerance: the value of tolerance
- SubMeshOrGroup: :class:`sub-mesh, group or filter <SMESH.SMESH_IDSource>` or node IDs
+ SubMeshOrGroup: list of :class:`sub-meshes, groups or filters <SMESH.SMESH_IDSource>` or of node IDs
exceptNodes: list of either SubMeshes, Groups or node IDs to exclude from search
SeparateCornerAndMediumNodes: if *True*, in quadratic mesh puts
corner and medium nodes in separate groups thus preventing
"""
unRegister = genObjUnRegister()
- if (isinstance( SubMeshOrGroup, Mesh )):
- SubMeshOrGroup = SubMeshOrGroup.GetMesh()
- if isinstance( SubMeshOrGroup, list ):
- SubMeshOrGroup = self.GetIDSource( SubMeshOrGroup, SMESH.NODE )
- unRegister.set( SubMeshOrGroup )
+ if not isinstance( SubMeshOrGroup, list ):
+ SubMeshOrGroup = [ SubMeshOrGroup ]
+ for i,obj in enumerate( SubMeshOrGroup ):
+ if isinstance( obj, Mesh ):
+ SubMeshOrGroup = [ obj.GetMesh() ]
+ break
+ if isinstance( obj, int ):
+ SubMeshOrGroup = [ self.GetIDSource( SubMeshOrGroup, SMESH.NODE )]
+ unRegister.set( SubMeshOrGroup )
+ break
if not isinstance( exceptNodes, list ):
exceptNodes = [ exceptNodes ]
Parameters:
GroupsOfNodes: a list of groups of nodes IDs for merging.
E.g. [[1,12,13],[25,4]] means that nodes 12, 13 and 4 will be removed and replaced
- in all elements and groups by nodes 1 and 25 correspondingly
+ in all elements and mesh groups by nodes 1 and 25 correspondingly
NodesToKeep: nodes to keep in the mesh: a list of groups, sub-meshes or node IDs.
If *NodesToKeep* does not include a node to keep for some group to merge,
then the first node in the group is kept.
AvoidMakingHoles: prevent merging nodes which cause removal of elements becoming
invalid
"""
- # NodesToKeep are converted to SMESH.SMESH_IDSource in meshEditor.MergeNodes()
self.editor.MergeNodes( GroupsOfNodes, NodesToKeep, AvoidMakingHoles )
- def FindEqualElements (self, MeshOrSubMeshOrGroup=None):
+ def FindEqualElements (self, MeshOrSubMeshOrGroup=None, exceptElements=[]):
"""
Find the elements built on the same nodes.
Parameters:
- MeshOrSubMeshOrGroup: :class:`mesh, sub-mesh, group or filter <SMESH.SMESH_IDSource>`
+ MeshOrSubMeshOrGroup: :class:`mesh, sub-meshes, groups or filters <SMESH.SMESH_IDSource>` or element IDs to check for equal elements
+ exceptElements: list of either SubMeshes, Groups or elements IDs to exclude from search
+
Returns:
the list of groups of equal elements IDs (e.g. [[1,12,13],[4,25]])
"""
- if not MeshOrSubMeshOrGroup:
- MeshOrSubMeshOrGroup=self.mesh
+ unRegister = genObjUnRegister()
+ if MeshOrSubMeshOrGroup is None:
+ MeshOrSubMeshOrGroup = [ self.mesh ]
elif isinstance( MeshOrSubMeshOrGroup, Mesh ):
- MeshOrSubMeshOrGroup = MeshOrSubMeshOrGroup.GetMesh()
- return self.editor.FindEqualElements( MeshOrSubMeshOrGroup )
-
- def MergeElements(self, GroupsOfElementsID):
+ MeshOrSubMeshOrGroup = [ MeshOrSubMeshOrGroup.GetMesh() ]
+ elif not isinstance( MeshOrSubMeshOrGroup, list ):
+ MeshOrSubMeshOrGroup = [ MeshOrSubMeshOrGroup ]
+ if isinstance( MeshOrSubMeshOrGroup[0], int ):
+ MeshOrSubMeshOrGroup = [ self.GetIDSource( MeshOrSubMeshOrGroup, SMESH.ALL )]
+ unRegister.set( MeshOrSubMeshOrGroup )
+ for item in MeshOrSubMeshOrGroup:
+ if isinstance( item, Mesh ):
+ MeshOrSubMeshOrGroup = [ item.GetMesh() ]
+
+ if not isinstance( exceptElements, list ):
+ exceptElements = [ exceptElements ]
+ if exceptElements and isinstance( exceptElements[0], int ):
+ exceptElements = [ self.GetIDSource( exceptElements, SMESH.ALL )]
+ unRegister.set( exceptElements )
+
+ return self.editor.FindEqualElements( MeshOrSubMeshOrGroup, exceptElements )
+
+ def MergeElements(self, GroupsOfElementsID, ElementsToKeep=[]):
"""
Merge elements in each given group.
Parameters:
GroupsOfElementsID: a list of groups (lists) of elements IDs for merging
(e.g. [[1,12,13],[25,4]] means that elements 12, 13 and 4 will be removed and
- replaced in all groups by elements 1 and 25)
+ replaced in all mesh groups by elements 1 and 25)
+ ElementsToKeep: elements to keep in the mesh: a list of groups, sub-meshes or node IDs.
+ If *ElementsToKeep* does not include an element to keep for some group to merge,
+ then the first element in the group is kept.
"""
- self.editor.MergeElements(GroupsOfElementsID)
+ unRegister = genObjUnRegister()
+ if ElementsToKeep:
+ if not isinstance( ElementsToKeep, list ):
+ ElementsToKeep = [ ElementsToKeep ]
+ if isinstance( ElementsToKeep[0], int ):
+ ElementsToKeep = [ self.GetIDSource( ElementsToKeep, SMESH.ALL )]
+ unRegister.set( ElementsToKeep )
+
+ self.editor.MergeElements( GroupsOfElementsID, ElementsToKeep )
def MergeEqualElements(self):
"""
def GetLength(self, elemId=None):
"""
- Get length of 1D element or sum of lengths of all 1D mesh elements
+ Get length of given 1D elements or of all 1D mesh elements
Parameters:
- elemId: mesh element ID (if not defined - sum of length of all 1D elements will be calculated)
+ elemId: either a mesh element ID or a list of IDs or :class:`sub-mesh, group or filter <SMESH.SMESH_IDSource>`. By default sum length of all 1D elements will be calculated.
Returns:
- element's length value if *elemId* is specified or sum of all 1D mesh elements' lengths otherwise
+ Sum of lengths of given elements
"""
length = 0
if elemId == None:
length = self.smeshpyD.GetLength(self)
+ elif isinstance(elemId, SMESH._objref_SMESH_IDSource):
+ length = self.smeshpyD.GetLength(elemId)
+ elif elemId == []:
+ length = 0
+ elif isinstance(elemId, list) and isinstance(elemId[0], SMESH._objref_SMESH_IDSource):
+ for obj in elemId:
+ length += self.smeshpyD.GetLength(obj)
+ elif isinstance(elemId, list) and isinstance(elemId[0], int):
+ unRegister = genObjUnRegister()
+ obj = self.GetIDSource( elemId )
+ unRegister.set( obj )
+ length = self.smeshpyD.GetLength( obj )
else:
length = self.FunctorValue(SMESH.FT_Length, elemId)
return length
def GetArea(self, elemId=None):
"""
- Get area of 2D element or sum of areas of all 2D mesh elements
- elemId mesh element ID (if not defined - sum of areas of all 2D elements will be calculated)
+ Get area of given 2D elements or of all 2D mesh elements
+
+ Parameters:
+ elemId: either a mesh element ID or a list of IDs or :class:`sub-mesh, group or filter <SMESH.SMESH_IDSource>`. By default sum area of all 2D elements will be calculated.
Returns:
- element's area value if *elemId* is specified or sum of all 2D mesh elements' areas otherwise
+ Area of given element's if *elemId* is specified or sum of all 2D mesh elements' areas otherwise
"""
area = 0
if elemId == None:
area = self.smeshpyD.GetArea(self)
+ elif isinstance(elemId, SMESH._objref_SMESH_IDSource):
+ area = self.smeshpyD.GetArea(elemId)
+ elif elemId == []:
+ area = 0
+ elif isinstance(elemId, list) and isinstance(elemId[0], SMESH._objref_SMESH_IDSource):
+ for obj in elemId:
+ area += self.smeshpyD.GetArea(obj)
+ elif isinstance(elemId, list) and isinstance(elemId[0], int):
+ unRegister = genObjUnRegister()
+ obj = self.GetIDSource( elemId )
+ unRegister.set( obj )
+ area = self.smeshpyD.GetArea( obj )
else:
area = self.FunctorValue(SMESH.FT_Area, elemId)
return area
def GetVolume(self, elemId=None):
"""
- Get volume of 3D element or sum of volumes of all 3D mesh elements
+ Get volume of given 3D elements or of all 3D mesh elements
Parameters:
- elemId: mesh element ID (if not defined - sum of volumes of all 3D elements will be calculated)
+ elemId: either a mesh element ID or a list of IDs or :class:`sub-mesh, group or filter <SMESH.SMESH_IDSource>`. By default sum volume of all 3D elements will be calculated.
Returns:
- element's volume value if *elemId* is specified or sum of all 3D mesh elements' volumes otherwise
+ Sum element's volume value if *elemId* is specified or sum of all 3D mesh elements' volumes otherwise
"""
volume = 0
if elemId == None:
- volume = self.smeshpyD.GetVolume(self)
+ volume= self.smeshpyD.GetVolume(self)
+ elif isinstance(elemId, SMESH._objref_SMESH_IDSource):
+ volume= self.smeshpyD.GetVolume(elemId)
+ elif elemId == []:
+ volume = 0
+ elif isinstance(elemId, list) and isinstance(elemId[0], SMESH._objref_SMESH_IDSource):
+ for obj in elemId:
+ volume+= self.smeshpyD.GetVolume(obj)
+ elif isinstance(elemId, list) and isinstance(elemId[0], int):
+ unRegister = genObjUnRegister()
+ obj = self.GetIDSource( elemId )
+ unRegister.set( obj )
+ volume= self.smeshpyD.GetVolume( obj )
else:
volume = self.FunctorValue(SMESH.FT_Volume3D, elemId)
return volume
