1 # Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
3 # This library is free software; you can redistribute it and/or
4 # modify it under the terms of the GNU Lesser General Public
5 # License as published by the Free Software Foundation; either
6 # version 2.1 of the License, or (at your option) any later version.
8 # This library is distributed in the hope that it will be useful,
9 # but WITHOUT ANY WARRANTY; without even the implied warranty of
10 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 # Lesser General Public License for more details.
13 # You should have received a copy of the GNU Lesser General Public
14 # License along with this library; if not, write to the Free Software
15 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
19 # File : smeshBuilder.py
20 # Author : Francis KLOSS, OCC
23 ## @package smeshBuilder
24 # Python API for SALOME %Mesh module
26 ## @defgroup l1_auxiliary Auxiliary methods and structures
27 ## @defgroup l1_creating Creating meshes
29 ## @defgroup l2_impexp Importing and exporting meshes
32 ## These are methods of class \ref smeshBuilder.smeshBuilder "smeshBuilder"
34 ## @defgroup l2_construct Constructing meshes
35 ## @defgroup l2_algorithms Defining Algorithms
37 ## @defgroup l3_algos_basic Basic meshing algorithms
38 ## @defgroup l3_algos_proj Projection Algorithms
39 ## @defgroup l3_algos_segmarv Segments around Vertex
40 ## @defgroup l3_algos_3dextr 3D extrusion meshing algorithm
43 ## @defgroup l2_hypotheses Defining hypotheses
45 ## @defgroup l3_hypos_1dhyps 1D Meshing Hypotheses
46 ## @defgroup l3_hypos_2dhyps 2D Meshing Hypotheses
47 ## @defgroup l3_hypos_maxvol Max Element Volume hypothesis
48 ## @defgroup l3_hypos_quad Quadrangle Parameters hypothesis
49 ## @defgroup l3_hypos_additi Additional Hypotheses
52 ## @defgroup l2_submeshes Constructing sub-meshes
53 ## @defgroup l2_editing Editing Meshes
56 ## @defgroup l1_meshinfo Mesh Information
57 ## @defgroup l1_controls Quality controls and Filtering
58 ## @defgroup l1_grouping Grouping elements
60 ## @defgroup l2_grps_create Creating groups
61 ## @defgroup l2_grps_operon Using operations on groups
62 ## @defgroup l2_grps_delete Deleting Groups
65 ## @defgroup l1_modifying Modifying meshes
67 ## @defgroup l2_modif_add Adding nodes and elements
68 ## @defgroup l2_modif_del Removing nodes and elements
69 ## @defgroup l2_modif_edit Modifying nodes and elements
70 ## @defgroup l2_modif_renumber Renumbering nodes and elements
71 ## @defgroup l2_modif_trsf Transforming meshes (Translation, Rotation, Symmetry, Sewing, Merging)
72 ## @defgroup l2_modif_unitetri Uniting triangles
73 ## @defgroup l2_modif_cutquadr Cutting elements
74 ## @defgroup l2_modif_changori Changing orientation of elements
75 ## @defgroup l2_modif_smooth Smoothing
76 ## @defgroup l2_modif_extrurev Extrusion and Revolution
77 ## @defgroup l2_modif_tofromqu Convert to/from Quadratic Mesh
78 ## @defgroup l2_modif_duplicat Duplication of nodes and elements (to emulate cracks)
81 ## @defgroup l1_measurements Measurements
84 from salome.geom import geomBuilder
86 import SMESH # This is necessary for back compatibility
88 from salome.smesh.smesh_algorithm import Mesh_Algorithm
94 ## Private class used to workaround a problem that sometimes isinstance(m, Mesh) returns False
97 def __instancecheck__(cls, inst):
98 """Implement isinstance(inst, cls)."""
99 return any(cls.__subclasscheck__(c)
100 for c in {type(inst), inst.__class__})
102 def __subclasscheck__(cls, sub):
103 """Implement issubclass(sub, cls)."""
104 return type.__subclasscheck__(cls, sub) or (cls.__name__ == sub.__name__ and cls.__module__ == sub.__module__)
106 ## @addtogroup l1_auxiliary
109 ## Convert an angle from degrees to radians
110 def DegreesToRadians(AngleInDegrees):
112 return AngleInDegrees * pi / 180.0
114 import salome_notebook
115 notebook = salome_notebook.notebook
116 # Salome notebook variable separator
119 ## Return list of variable values from salome notebook.
120 # The last argument, if is callable, is used to modify values got from notebook
121 def ParseParameters(*args):
126 if args and callable( args[-1] ):
127 args, varModifFun = args[:-1], args[-1]
128 for parameter in args:
130 Parameters += str(parameter) + var_separator
132 if isinstance(parameter,str):
133 # check if there is an inexistent variable name
134 if not notebook.isVariable(parameter):
135 raise ValueError, "Variable with name '" + parameter + "' doesn't exist!!!"
136 parameter = notebook.get(parameter)
139 parameter = varModifFun(parameter)
142 Result.append(parameter)
145 Parameters = Parameters[:-1]
146 Result.append( Parameters )
147 Result.append( hasVariables )
150 ## Parse parameters while converting variables to radians
151 def ParseAngles(*args):
152 return ParseParameters( *( args + (DegreesToRadians, )))
154 ## Substitute PointStruct.__init__() to create SMESH.PointStruct using notebook variables.
155 # Parameters are stored in PointStruct.parameters attribute
156 def __initPointStruct(point,*args):
157 point.x, point.y, point.z, point.parameters,hasVars = ParseParameters(*args)
159 SMESH.PointStruct.__init__ = __initPointStruct
161 ## Substitute AxisStruct.__init__() to create SMESH.AxisStruct using notebook variables.
162 # Parameters are stored in AxisStruct.parameters attribute
163 def __initAxisStruct(ax,*args):
166 "Bad nb args (%s) passed in SMESH.AxisStruct(x,y,z,dx,dy,dz)"%(len( args ))
167 ax.x, ax.y, ax.z, ax.vx, ax.vy, ax.vz, ax.parameters,hasVars = ParseParameters(*args)
169 SMESH.AxisStruct.__init__ = __initAxisStruct
171 smeshPrecisionConfusion = 1.e-07
172 ## Compare real values using smeshPrecisionConfusion as tolerance
173 def IsEqual(val1, val2, tol=smeshPrecisionConfusion):
174 if abs(val1 - val2) < tol:
180 ## Return object name
184 if isinstance(obj, SALOMEDS._objref_SObject):
188 ior = salome.orb.object_to_string(obj)
193 studies = salome.myStudyManager.GetOpenStudies()
194 for sname in studies:
195 s = salome.myStudyManager.GetStudyByName(sname)
197 sobj = s.FindObjectIOR(ior)
198 if not sobj: continue
199 return sobj.GetName()
200 if hasattr(obj, "GetName"):
201 # unknown CORBA object, having GetName() method
204 # unknown CORBA object, no GetName() method
207 if hasattr(obj, "GetName"):
208 # unknown non-CORBA object, having GetName() method
211 raise RuntimeError, "Null or invalid object"
213 ## Print error message if a hypothesis was not assigned.
214 def TreatHypoStatus(status, hypName, geomName, isAlgo, mesh):
216 hypType = "algorithm"
218 hypType = "hypothesis"
221 if hasattr( status, "__getitem__" ):
222 status,reason = status[0],status[1]
223 if status == HYP_UNKNOWN_FATAL :
224 reason = "for unknown reason"
225 elif status == HYP_INCOMPATIBLE :
226 reason = "this hypothesis mismatches the algorithm"
227 elif status == HYP_NOTCONFORM :
228 reason = "a non-conform mesh would be built"
229 elif status == HYP_ALREADY_EXIST :
230 if isAlgo: return # it does not influence anything
231 reason = hypType + " of the same dimension is already assigned to this shape"
232 elif status == HYP_BAD_DIM :
233 reason = hypType + " mismatches the shape"
234 elif status == HYP_CONCURENT :
235 reason = "there are concurrent hypotheses on sub-shapes"
236 elif status == HYP_BAD_SUBSHAPE :
237 reason = "the shape is neither the main one, nor its sub-shape, nor a valid group"
238 elif status == HYP_BAD_GEOMETRY:
239 reason = "the algorithm is not applicable to this geometry"
240 elif status == HYP_HIDDEN_ALGO:
241 reason = "it is hidden by an algorithm of an upper dimension, which generates elements of all dimensions"
242 elif status == HYP_HIDING_ALGO:
243 reason = "it hides algorithms of lower dimensions by generating elements of all dimensions"
244 elif status == HYP_NEED_SHAPE:
245 reason = "algorithm can't work without shape"
246 elif status == HYP_INCOMPAT_HYPS:
252 where = '"%s"' % geomName
254 meshName = GetName( mesh )
255 if meshName and meshName != NO_NAME:
256 where = '"%s" shape in "%s" mesh ' % ( geomName, meshName )
257 if status < HYP_UNKNOWN_FATAL and where:
258 print '"%s" was assigned to %s but %s' %( hypName, where, reason )
260 print '"%s" was not assigned to %s : %s' %( hypName, where, reason )
262 print '"%s" was not assigned : %s' %( hypName, reason )
265 ## Private method. Add geom (sub-shape of the main shape) into the study if not yet there
266 def AssureGeomPublished(mesh, geom, name=''):
267 if not isinstance( geom, geomBuilder.GEOM._objref_GEOM_Object ):
269 if not geom.GetStudyEntry() and \
270 mesh.smeshpyD.GetCurrentStudy():
272 studyID = mesh.smeshpyD.GetCurrentStudy()._get_StudyId()
273 if studyID != mesh.geompyD.myStudyId:
274 mesh.geompyD.init_geom( mesh.smeshpyD.GetCurrentStudy())
276 if not name and geom.GetShapeType() != geomBuilder.GEOM.COMPOUND:
277 # for all groups SubShapeName() return "Compound_-1"
278 name = mesh.geompyD.SubShapeName(geom, mesh.geom)
280 name = "%s_%s"%(geom.GetShapeType(), id(geom)%10000)
282 mesh.geompyD.addToStudyInFather( mesh.geom, geom, name )
285 ## Return the first vertex of a geometrical edge by ignoring orientation
286 def FirstVertexOnCurve(mesh, edge):
287 vv = mesh.geompyD.SubShapeAll( edge, geomBuilder.geomBuilder.ShapeType["VERTEX"])
289 raise TypeError, "Given object has no vertices"
290 if len( vv ) == 1: return vv[0]
291 v0 = mesh.geompyD.MakeVertexOnCurve(edge,0.)
292 xyz = mesh.geompyD.PointCoordinates( v0 ) # coords of the first vertex
293 xyz1 = mesh.geompyD.PointCoordinates( vv[0] )
294 xyz2 = mesh.geompyD.PointCoordinates( vv[1] )
297 dist1 += abs( xyz[i] - xyz1[i] )
298 dist2 += abs( xyz[i] - xyz2[i] )
304 # end of l1_auxiliary
308 # Warning: smeshInst is a singleton
314 ## This class allows to create, load or manipulate meshes.
315 # It has a set of methods to create, load or copy meshes, to combine several meshes, etc.
316 # It also has methods to get infos and measure meshes.
317 class smeshBuilder(object, SMESH._objref_SMESH_Gen):
319 # MirrorType enumeration
320 POINT = SMESH_MeshEditor.POINT
321 AXIS = SMESH_MeshEditor.AXIS
322 PLANE = SMESH_MeshEditor.PLANE
324 # Smooth_Method enumeration
325 LAPLACIAN_SMOOTH = SMESH_MeshEditor.LAPLACIAN_SMOOTH
326 CENTROIDAL_SMOOTH = SMESH_MeshEditor.CENTROIDAL_SMOOTH
328 PrecisionConfusion = smeshPrecisionConfusion
330 # TopAbs_State enumeration
331 [TopAbs_IN, TopAbs_OUT, TopAbs_ON, TopAbs_UNKNOWN] = range(4)
333 # Methods of splitting a hexahedron into tetrahedra
334 Hex_5Tet, Hex_6Tet, Hex_24Tet, Hex_2Prisms, Hex_4Prisms = 1, 2, 3, 1, 2
340 #print "==== __new__", engine, smeshInst, doLcc
342 if smeshInst is None:
343 # smesh engine is either retrieved from engine, or created
345 # Following test avoids a recursive loop
347 if smeshInst is not None:
348 # smesh engine not created: existing engine found
352 # FindOrLoadComponent called:
353 # 1. CORBA resolution of server
354 # 2. the __new__ method is called again
355 #print "==== smeshInst = lcc.FindOrLoadComponent ", engine, smeshInst, doLcc
356 smeshInst = salome.lcc.FindOrLoadComponent( "FactoryServer", "SMESH" )
358 # FindOrLoadComponent not called
359 if smeshInst is None:
360 # smeshBuilder instance is created from lcc.FindOrLoadComponent
361 #print "==== smeshInst = super(smeshBuilder,cls).__new__(cls) ", engine, smeshInst, doLcc
362 smeshInst = super(smeshBuilder,cls).__new__(cls)
364 # smesh engine not created: existing engine found
365 #print "==== existing ", engine, smeshInst, doLcc
367 #print "====1 ", smeshInst
370 #print "====2 ", smeshInst
375 #print "--------------- smeshbuilder __init__ ---", created
378 SMESH._objref_SMESH_Gen.__init__(self)
380 ## Dump component to the Python script
381 # This method overrides IDL function to allow default values for the parameters.
382 # @ingroup l1_auxiliary
383 def DumpPython(self, theStudy, theIsPublished=True, theIsMultiFile=True):
384 return SMESH._objref_SMESH_Gen.DumpPython(self, theStudy, theIsPublished, theIsMultiFile)
386 ## Set mode of DumpPython(), \a historical or \a snapshot.
387 # In the \a historical mode, the Python Dump script includes all commands
388 # performed by SMESH engine. In the \a snapshot mode, commands
389 # relating to objects removed from the Study are excluded from the script
390 # as well as commands not influencing the current state of meshes
391 # @ingroup l1_auxiliary
392 def SetDumpPythonHistorical(self, isHistorical):
393 if isHistorical: val = "true"
395 SMESH._objref_SMESH_Gen.SetOption(self, "historical_python_dump", val)
397 ## Set the current study and Geometry component
398 # @ingroup l1_auxiliary
399 def init_smesh(self,theStudy,geompyD = None):
401 self.SetCurrentStudy(theStudy,geompyD)
404 notebook.myStudy = theStudy
406 ## Create a mesh. This can be either an empty mesh, possibly having an underlying geometry,
407 # or a mesh wrapping a CORBA mesh given as a parameter.
408 # @param obj either (1) a CORBA mesh (SMESH._objref_SMESH_Mesh) got e.g. by calling
409 # salome.myStudy.FindObjectID("0:1:2:3").GetObject() or
410 # (2) a Geometrical object for meshing or
412 # @param name the name for the new mesh.
413 # @return an instance of Mesh class.
414 # @ingroup l2_construct
415 def Mesh(self, obj=0, name=0):
416 if isinstance(obj,str):
418 return Mesh(self,self.geompyD,obj,name)
420 ## Return a long value from enumeration
421 # @ingroup l1_auxiliary
422 def EnumToLong(self,theItem):
425 ## Return a string representation of the color.
426 # To be used with filters.
427 # @param c color value (SALOMEDS.Color)
428 # @ingroup l1_auxiliary
429 def ColorToString(self,c):
431 if isinstance(c, SALOMEDS.Color):
432 val = "%s;%s;%s" % (c.R, c.G, c.B)
433 elif isinstance(c, str):
436 raise ValueError, "Color value should be of string or SALOMEDS.Color type"
439 ## Get PointStruct from vertex
440 # @param theVertex a GEOM object(vertex)
441 # @return SMESH.PointStruct
442 # @ingroup l1_auxiliary
443 def GetPointStruct(self,theVertex):
444 [x, y, z] = self.geompyD.PointCoordinates(theVertex)
445 return PointStruct(x,y,z)
447 ## Get DirStruct from vector
448 # @param theVector a GEOM object(vector)
449 # @return SMESH.DirStruct
450 # @ingroup l1_auxiliary
451 def GetDirStruct(self,theVector):
452 vertices = self.geompyD.SubShapeAll( theVector, geomBuilder.geomBuilder.ShapeType["VERTEX"] )
453 if(len(vertices) != 2):
454 print "Error: vector object is incorrect."
456 p1 = self.geompyD.PointCoordinates(vertices[0])
457 p2 = self.geompyD.PointCoordinates(vertices[1])
458 pnt = PointStruct(p2[0]-p1[0], p2[1]-p1[1], p2[2]-p1[2])
459 dirst = DirStruct(pnt)
462 ## Make DirStruct from a triplet
463 # @param x,y,z vector components
464 # @return SMESH.DirStruct
465 # @ingroup l1_auxiliary
466 def MakeDirStruct(self,x,y,z):
467 pnt = PointStruct(x,y,z)
468 return DirStruct(pnt)
470 ## Get AxisStruct from object
471 # @param theObj a GEOM object (line or plane)
472 # @return SMESH.AxisStruct
473 # @ingroup l1_auxiliary
474 def GetAxisStruct(self,theObj):
476 edges = self.geompyD.SubShapeAll( theObj, geomBuilder.geomBuilder.ShapeType["EDGE"] )
479 vertex1, vertex2 = self.geompyD.SubShapeAll( edges[0], geomBuilder.geomBuilder.ShapeType["VERTEX"] )
480 vertex3, vertex4 = self.geompyD.SubShapeAll( edges[1], geomBuilder.geomBuilder.ShapeType["VERTEX"] )
481 vertex1 = self.geompyD.PointCoordinates(vertex1)
482 vertex2 = self.geompyD.PointCoordinates(vertex2)
483 vertex3 = self.geompyD.PointCoordinates(vertex3)
484 vertex4 = self.geompyD.PointCoordinates(vertex4)
485 v1 = [vertex2[0]-vertex1[0], vertex2[1]-vertex1[1], vertex2[2]-vertex1[2]]
486 v2 = [vertex4[0]-vertex3[0], vertex4[1]-vertex3[1], vertex4[2]-vertex3[2]]
487 normal = [ v1[1]*v2[2]-v2[1]*v1[2], v1[2]*v2[0]-v2[2]*v1[0], v1[0]*v2[1]-v2[0]*v1[1] ]
488 axis = AxisStruct(vertex1[0], vertex1[1], vertex1[2], normal[0], normal[1], normal[2])
489 axis._mirrorType = SMESH.SMESH_MeshEditor.PLANE
490 elif len(edges) == 1:
491 vertex1, vertex2 = self.geompyD.SubShapeAll( edges[0], geomBuilder.geomBuilder.ShapeType["VERTEX"] )
492 p1 = self.geompyD.PointCoordinates( vertex1 )
493 p2 = self.geompyD.PointCoordinates( vertex2 )
494 axis = AxisStruct(p1[0], p1[1], p1[2], p2[0]-p1[0], p2[1]-p1[1], p2[2]-p1[2])
495 axis._mirrorType = SMESH.SMESH_MeshEditor.AXIS
496 elif theObj.GetShapeType() == GEOM.VERTEX:
497 x,y,z = self.geompyD.PointCoordinates( theObj )
498 axis = AxisStruct( x,y,z, 1,0,0,)
499 axis._mirrorType = SMESH.SMESH_MeshEditor.POINT
502 # From SMESH_Gen interface:
503 # ------------------------
505 ## Set the given name to the object
506 # @param obj the object to rename
507 # @param name a new object name
508 # @ingroup l1_auxiliary
509 def SetName(self, obj, name):
510 if isinstance( obj, Mesh ):
512 elif isinstance( obj, Mesh_Algorithm ):
513 obj = obj.GetAlgorithm()
514 ior = salome.orb.object_to_string(obj)
515 SMESH._objref_SMESH_Gen.SetName(self, ior, name)
517 ## Set the current mode
518 # @ingroup l1_auxiliary
519 def SetEmbeddedMode( self,theMode ):
520 SMESH._objref_SMESH_Gen.SetEmbeddedMode(self,theMode)
522 ## Get the current mode
523 # @ingroup l1_auxiliary
524 def IsEmbeddedMode(self):
525 return SMESH._objref_SMESH_Gen.IsEmbeddedMode(self)
527 ## Set the current study. Calling SetCurrentStudy( None ) allows to
528 # switch OFF automatic pubilishing in the Study of mesh objects.
529 # @ingroup l1_auxiliary
530 def SetCurrentStudy( self, theStudy, geompyD = None ):
532 from salome.geom import geomBuilder
533 geompyD = geomBuilder.geom
536 self.SetGeomEngine(geompyD)
537 SMESH._objref_SMESH_Gen.SetCurrentStudy(self,theStudy)
540 notebook = salome_notebook.NoteBook( theStudy )
542 notebook = salome_notebook.NoteBook( salome_notebook.PseudoStudyForNoteBook() )
544 sb = theStudy.NewBuilder()
545 sc = theStudy.FindComponent("SMESH")
546 if sc: sb.LoadWith(sc, self)
550 ## Get the current study
551 # @ingroup l1_auxiliary
552 def GetCurrentStudy(self):
553 return SMESH._objref_SMESH_Gen.GetCurrentStudy(self)
555 ## Create a Mesh object importing data from the given UNV file
556 # @return an instance of Mesh class
558 def CreateMeshesFromUNV( self,theFileName ):
559 aSmeshMesh = SMESH._objref_SMESH_Gen.CreateMeshesFromUNV(self,theFileName)
560 aMesh = Mesh(self, self.geompyD, aSmeshMesh)
563 ## Create a Mesh object(s) importing data from the given MED file
564 # @return a tuple ( list of Mesh class instances, SMESH.DriverMED_ReadStatus )
566 def CreateMeshesFromMED( self,theFileName ):
567 aSmeshMeshes, aStatus = SMESH._objref_SMESH_Gen.CreateMeshesFromMED(self,theFileName)
568 aMeshes = [ Mesh(self, self.geompyD, m) for m in aSmeshMeshes ]
569 return aMeshes, aStatus
571 ## Create a Mesh object(s) importing data from the given SAUV file
572 # @return a tuple ( list of Mesh class instances, SMESH.DriverMED_ReadStatus )
574 def CreateMeshesFromSAUV( self,theFileName ):
575 aSmeshMeshes, aStatus = SMESH._objref_SMESH_Gen.CreateMeshesFromSAUV(self,theFileName)
576 aMeshes = [ Mesh(self, self.geompyD, m) for m in aSmeshMeshes ]
577 return aMeshes, aStatus
579 ## Create a Mesh object importing data from the given STL file
580 # @return an instance of Mesh class
582 def CreateMeshesFromSTL( self, theFileName ):
583 aSmeshMesh = SMESH._objref_SMESH_Gen.CreateMeshesFromSTL(self,theFileName)
584 aMesh = Mesh(self, self.geompyD, aSmeshMesh)
587 ## Create Mesh objects importing data from the given CGNS file
588 # @return a tuple ( list of Mesh class instances, SMESH.DriverMED_ReadStatus )
590 def CreateMeshesFromCGNS( self, theFileName ):
591 aSmeshMeshes, aStatus = SMESH._objref_SMESH_Gen.CreateMeshesFromCGNS(self,theFileName)
592 aMeshes = [ Mesh(self, self.geompyD, m) for m in aSmeshMeshes ]
593 return aMeshes, aStatus
595 ## Create a Mesh object importing data from the given GMF file.
596 # GMF files must have .mesh extension for the ASCII format and .meshb for
598 # @return [ an instance of Mesh class, SMESH.ComputeError ]
600 def CreateMeshesFromGMF( self, theFileName ):
601 aSmeshMesh, error = SMESH._objref_SMESH_Gen.CreateMeshesFromGMF(self,
604 if error.comment: print "*** CreateMeshesFromGMF() errors:\n", error.comment
605 return Mesh(self, self.geompyD, aSmeshMesh), error
607 ## Concatenate the given meshes into one mesh. All groups of input meshes will be
608 # present in the new mesh.
609 # @param meshes the meshes, sub-meshes and groups to combine into one mesh
610 # @param uniteIdenticalGroups if true, groups with same names are united, else they are renamed
611 # @param mergeNodesAndElements if true, equal nodes and elements are merged
612 # @param mergeTolerance tolerance for merging nodes
613 # @param allGroups forces creation of groups corresponding to every input mesh
614 # @param name name of a new mesh
615 # @return an instance of Mesh class
616 # @ingroup l1_creating
617 def Concatenate( self, meshes, uniteIdenticalGroups,
618 mergeNodesAndElements = False, mergeTolerance = 1e-5, allGroups = False,
620 if not meshes: return None
621 for i,m in enumerate(meshes):
622 if isinstance(m, Mesh):
623 meshes[i] = m.GetMesh()
624 mergeTolerance,Parameters,hasVars = ParseParameters(mergeTolerance)
625 meshes[0].SetParameters(Parameters)
627 aSmeshMesh = SMESH._objref_SMESH_Gen.ConcatenateWithGroups(
628 self,meshes,uniteIdenticalGroups,mergeNodesAndElements,mergeTolerance)
630 aSmeshMesh = SMESH._objref_SMESH_Gen.Concatenate(
631 self,meshes,uniteIdenticalGroups,mergeNodesAndElements,mergeTolerance)
632 aMesh = Mesh(self, self.geompyD, aSmeshMesh, name=name)
635 ## Create a mesh by copying a part of another mesh.
636 # @param meshPart a part of mesh to copy, either a Mesh, a sub-mesh or a group;
637 # to copy nodes or elements not contained in any mesh object,
638 # pass result of Mesh.GetIDSource( list_of_ids, type ) as meshPart
639 # @param meshName a name of the new mesh
640 # @param toCopyGroups to create in the new mesh groups the copied elements belongs to
641 # @param toKeepIDs to preserve order of the copied elements or not
642 # @return an instance of Mesh class
643 # @ingroup l1_creating
644 def CopyMesh( self, meshPart, meshName, toCopyGroups=False, toKeepIDs=False):
645 if (isinstance( meshPart, Mesh )):
646 meshPart = meshPart.GetMesh()
647 mesh = SMESH._objref_SMESH_Gen.CopyMesh( self,meshPart,meshName,toCopyGroups,toKeepIDs )
648 return Mesh(self, self.geompyD, mesh)
650 ## Return IDs of sub-shapes
651 # @return the list of integer values
652 # @ingroup l1_auxiliary
653 def GetSubShapesId( self, theMainObject, theListOfSubObjects ):
654 return SMESH._objref_SMESH_Gen.GetSubShapesId(self,theMainObject, theListOfSubObjects)
656 ## Create a pattern mapper.
657 # @return an instance of SMESH_Pattern
659 # <a href="../tui_modifying_meshes_page.html#tui_pattern_mapping">Example of Patterns usage</a>
660 # @ingroup l1_modifying
661 def GetPattern(self):
662 return SMESH._objref_SMESH_Gen.GetPattern(self)
664 ## Set number of segments per diagonal of boundary box of geometry, by which
665 # default segment length of appropriate 1D hypotheses is defined in GUI.
666 # Default value is 10.
667 # @ingroup l1_auxiliary
668 def SetBoundaryBoxSegmentation(self, nbSegments):
669 SMESH._objref_SMESH_Gen.SetBoundaryBoxSegmentation(self,nbSegments)
671 # Filtering. Auxiliary functions:
672 # ------------------------------
674 ## Create an empty criterion
675 # @return SMESH.Filter.Criterion
676 # @ingroup l1_controls
677 def GetEmptyCriterion(self):
678 Type = self.EnumToLong(FT_Undefined)
679 Compare = self.EnumToLong(FT_Undefined)
683 UnaryOp = self.EnumToLong(FT_Undefined)
684 BinaryOp = self.EnumToLong(FT_Undefined)
687 Precision = -1 ##@1e-07
688 return Filter.Criterion(Type, Compare, Threshold, ThresholdStr, ThresholdID,
689 UnaryOp, BinaryOp, Tolerance, TypeOfElement, Precision)
691 ## Create a criterion by the given parameters
692 # \n Criterion structures allow to define complex filters by combining them with logical operations (AND / OR) (see example below)
693 # @param elementType the type of elements(SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME)
694 # @param CritType the type of criterion (SMESH.FT_Taper, SMESH.FT_Area, etc.)
695 # Type SMESH.FunctorType._items in the Python Console to see all values.
696 # Note that the items starting from FT_LessThan are not suitable for CritType.
697 # @param Compare belongs to {SMESH.FT_LessThan, SMESH.FT_MoreThan, SMESH.FT_EqualTo}
698 # @param Threshold the threshold value (range of ids as string, shape, numeric)
699 # @param UnaryOp SMESH.FT_LogicalNOT or SMESH.FT_Undefined
700 # @param BinaryOp a binary logical operation SMESH.FT_LogicalAND, SMESH.FT_LogicalOR or
702 # @param Tolerance the tolerance used by SMESH.FT_BelongToGeom, SMESH.FT_BelongToSurface,
703 # SMESH.FT_LyingOnGeom, SMESH.FT_CoplanarFaces criteria
704 # @return SMESH.Filter.Criterion
706 # <a href="../tui_filters_page.html#combining_filters">Example of Criteria usage</a>
707 # @ingroup l1_controls
708 def GetCriterion(self,elementType,
710 Compare = FT_EqualTo,
712 UnaryOp=FT_Undefined,
713 BinaryOp=FT_Undefined,
715 if not CritType in SMESH.FunctorType._items:
716 raise TypeError, "CritType should be of SMESH.FunctorType"
717 aCriterion = self.GetEmptyCriterion()
718 aCriterion.TypeOfElement = elementType
719 aCriterion.Type = self.EnumToLong(CritType)
720 aCriterion.Tolerance = Tolerance
722 aThreshold = Threshold
724 if Compare in [FT_LessThan, FT_MoreThan, FT_EqualTo]:
725 aCriterion.Compare = self.EnumToLong(Compare)
726 elif Compare == "=" or Compare == "==":
727 aCriterion.Compare = self.EnumToLong(FT_EqualTo)
729 aCriterion.Compare = self.EnumToLong(FT_LessThan)
731 aCriterion.Compare = self.EnumToLong(FT_MoreThan)
732 elif Compare != FT_Undefined:
733 aCriterion.Compare = self.EnumToLong(FT_EqualTo)
736 if CritType in [FT_BelongToGeom, FT_BelongToPlane, FT_BelongToGenSurface,
737 FT_BelongToCylinder, FT_LyingOnGeom]:
738 # Check that Threshold is GEOM object
739 if isinstance(aThreshold, geomBuilder.GEOM._objref_GEOM_Object):
740 aCriterion.ThresholdStr = GetName(aThreshold)
741 aCriterion.ThresholdID = aThreshold.GetStudyEntry()
742 if not aCriterion.ThresholdID:
743 name = aCriterion.ThresholdStr
745 name = "%s_%s"%(aThreshold.GetShapeType(), id(aThreshold)%10000)
746 aCriterion.ThresholdID = self.geompyD.addToStudy( aThreshold, name )
747 # or a name of GEOM object
748 elif isinstance( aThreshold, str ):
749 aCriterion.ThresholdStr = aThreshold
751 raise TypeError, "The Threshold should be a shape."
752 if isinstance(UnaryOp,float):
753 aCriterion.Tolerance = UnaryOp
754 UnaryOp = FT_Undefined
756 elif CritType == FT_BelongToMeshGroup:
757 # Check that Threshold is a group
758 if isinstance(aThreshold, SMESH._objref_SMESH_GroupBase):
759 if aThreshold.GetType() != elementType:
760 raise ValueError, "Group type mismatches Element type"
761 aCriterion.ThresholdStr = aThreshold.GetName()
762 aCriterion.ThresholdID = salome.orb.object_to_string( aThreshold )
763 study = self.GetCurrentStudy()
765 so = study.FindObjectIOR( aCriterion.ThresholdID )
769 aCriterion.ThresholdID = entry
771 raise TypeError, "The Threshold should be a Mesh Group"
772 elif CritType == FT_RangeOfIds:
773 # Check that Threshold is string
774 if isinstance(aThreshold, str):
775 aCriterion.ThresholdStr = aThreshold
777 raise TypeError, "The Threshold should be a string."
778 elif CritType == FT_CoplanarFaces:
779 # Check the Threshold
780 if isinstance(aThreshold, int):
781 aCriterion.ThresholdID = str(aThreshold)
782 elif isinstance(aThreshold, str):
785 raise ValueError, "Invalid ID of mesh face: '%s'"%aThreshold
786 aCriterion.ThresholdID = aThreshold
789 "The Threshold should be an ID of mesh face and not '%s'"%aThreshold
790 elif CritType == FT_ConnectedElements:
791 # Check the Threshold
792 if isinstance(aThreshold, geomBuilder.GEOM._objref_GEOM_Object): # shape
793 aCriterion.ThresholdID = aThreshold.GetStudyEntry()
794 if not aCriterion.ThresholdID:
795 name = aThreshold.GetName()
797 name = "%s_%s"%(aThreshold.GetShapeType(), id(aThreshold)%10000)
798 aCriterion.ThresholdID = self.geompyD.addToStudy( aThreshold, name )
799 elif isinstance(aThreshold, int): # node id
800 aCriterion.Threshold = aThreshold
801 elif isinstance(aThreshold, list): # 3 point coordinates
802 if len( aThreshold ) < 3:
803 raise ValueError, "too few point coordinates, must be 3"
804 aCriterion.ThresholdStr = " ".join( [str(c) for c in aThreshold[:3]] )
805 elif isinstance(aThreshold, str):
806 if aThreshold.isdigit():
807 aCriterion.Threshold = aThreshold # node id
809 aCriterion.ThresholdStr = aThreshold # hope that it's point coordinates
812 "The Threshold should either a VERTEX, or a node ID, "\
813 "or a list of point coordinates and not '%s'"%aThreshold
814 elif CritType == FT_ElemGeomType:
815 # Check the Threshold
817 aCriterion.Threshold = self.EnumToLong(aThreshold)
818 assert( aThreshold in SMESH.GeometryType._items )
820 if isinstance(aThreshold, int):
821 aCriterion.Threshold = aThreshold
823 raise TypeError, "The Threshold should be an integer or SMESH.GeometryType."
826 elif CritType == FT_EntityType:
827 # Check the Threshold
829 aCriterion.Threshold = self.EnumToLong(aThreshold)
830 assert( aThreshold in SMESH.EntityType._items )
832 if isinstance(aThreshold, int):
833 aCriterion.Threshold = aThreshold
835 raise TypeError, "The Threshold should be an integer or SMESH.EntityType."
839 elif CritType == FT_GroupColor:
840 # Check the Threshold
842 aCriterion.ThresholdStr = self.ColorToString(aThreshold)
844 raise TypeError, "The threshold value should be of SALOMEDS.Color type"
846 elif CritType in [FT_FreeBorders, FT_FreeEdges, FT_FreeNodes, FT_FreeFaces,
847 FT_LinearOrQuadratic, FT_BadOrientedVolume,
848 FT_BareBorderFace, FT_BareBorderVolume,
849 FT_OverConstrainedFace, FT_OverConstrainedVolume,
850 FT_EqualNodes,FT_EqualEdges,FT_EqualFaces,FT_EqualVolumes ]:
851 # At this point the Threshold is unnecessary
852 if aThreshold == FT_LogicalNOT:
853 aCriterion.UnaryOp = self.EnumToLong(FT_LogicalNOT)
854 elif aThreshold in [FT_LogicalAND, FT_LogicalOR]:
855 aCriterion.BinaryOp = aThreshold
859 aThreshold = float(aThreshold)
860 aCriterion.Threshold = aThreshold
862 raise TypeError, "The Threshold should be a number."
865 if Threshold == FT_LogicalNOT or UnaryOp == FT_LogicalNOT:
866 aCriterion.UnaryOp = self.EnumToLong(FT_LogicalNOT)
868 if Threshold in [FT_LogicalAND, FT_LogicalOR]:
869 aCriterion.BinaryOp = self.EnumToLong(Threshold)
871 if UnaryOp in [FT_LogicalAND, FT_LogicalOR]:
872 aCriterion.BinaryOp = self.EnumToLong(UnaryOp)
874 if BinaryOp in [FT_LogicalAND, FT_LogicalOR]:
875 aCriterion.BinaryOp = self.EnumToLong(BinaryOp)
879 ## Create a filter with the given parameters
880 # @param elementType the type of elements (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME)
881 # @param CritType the type of criterion (SMESH.FT_Taper, SMESH.FT_Area, etc.)
882 # Type SMESH.FunctorType._items in the Python Console to see all values.
883 # Note that the items starting from FT_LessThan are not suitable for CritType.
884 # @param Compare belongs to {SMESH.FT_LessThan, SMESH.FT_MoreThan, SMESH.FT_EqualTo}
885 # @param Threshold the threshold value (range of ids as string, shape, numeric)
886 # @param UnaryOp SMESH.FT_LogicalNOT or SMESH.FT_Undefined
887 # @param Tolerance the tolerance used by SMESH.FT_BelongToGeom, SMESH.FT_BelongToSurface,
888 # SMESH.FT_LyingOnGeom, SMESH.FT_CoplanarFaces and SMESH.FT_EqualNodes criteria
889 # @param mesh the mesh to initialize the filter with
890 # @return SMESH_Filter
892 # <a href="../tui_filters_page.html#tui_filters">Example of Filters usage</a>
893 # @ingroup l1_controls
894 def GetFilter(self,elementType,
895 CritType=FT_Undefined,
898 UnaryOp=FT_Undefined,
901 aCriterion = self.GetCriterion(elementType, CritType, Compare, Threshold, UnaryOp, FT_Undefined,Tolerance)
902 aFilterMgr = self.CreateFilterManager()
903 aFilter = aFilterMgr.CreateFilter()
905 aCriteria.append(aCriterion)
906 aFilter.SetCriteria(aCriteria)
908 if isinstance( mesh, Mesh ): aFilter.SetMesh( mesh.GetMesh() )
909 else : aFilter.SetMesh( mesh )
910 aFilterMgr.UnRegister()
913 ## Create a filter from criteria
914 # @param criteria a list of criteria
915 # @param binOp binary operator used when binary operator of criteria is undefined
916 # @return SMESH_Filter
918 # <a href="../tui_filters_page.html#tui_filters">Example of Filters usage</a>
919 # @ingroup l1_controls
920 def GetFilterFromCriteria(self,criteria, binOp=SMESH.FT_LogicalAND):
921 for i in range( len( criteria ) - 1 ):
922 if criteria[i].BinaryOp == self.EnumToLong( SMESH.FT_Undefined ):
923 criteria[i].BinaryOp = self.EnumToLong( binOp )
924 aFilterMgr = self.CreateFilterManager()
925 aFilter = aFilterMgr.CreateFilter()
926 aFilter.SetCriteria(criteria)
927 aFilterMgr.UnRegister()
930 ## Create a numerical functor by its type
931 # @param theCriterion functor type - an item of SMESH.FunctorType enumeration.
932 # Type SMESH.FunctorType._items in the Python Console to see all items.
933 # Note that not all items correspond to numerical functors.
934 # @return SMESH_NumericalFunctor
935 # @ingroup l1_controls
936 def GetFunctor(self,theCriterion):
937 if isinstance( theCriterion, SMESH._objref_NumericalFunctor ):
939 aFilterMgr = self.CreateFilterManager()
941 if theCriterion == FT_AspectRatio:
942 functor = aFilterMgr.CreateAspectRatio()
943 elif theCriterion == FT_AspectRatio3D:
944 functor = aFilterMgr.CreateAspectRatio3D()
945 elif theCriterion == FT_Warping:
946 functor = aFilterMgr.CreateWarping()
947 elif theCriterion == FT_MinimumAngle:
948 functor = aFilterMgr.CreateMinimumAngle()
949 elif theCriterion == FT_Taper:
950 functor = aFilterMgr.CreateTaper()
951 elif theCriterion == FT_Skew:
952 functor = aFilterMgr.CreateSkew()
953 elif theCriterion == FT_Area:
954 functor = aFilterMgr.CreateArea()
955 elif theCriterion == FT_Volume3D:
956 functor = aFilterMgr.CreateVolume3D()
957 elif theCriterion == FT_MaxElementLength2D:
958 functor = aFilterMgr.CreateMaxElementLength2D()
959 elif theCriterion == FT_MaxElementLength3D:
960 functor = aFilterMgr.CreateMaxElementLength3D()
961 elif theCriterion == FT_MultiConnection:
962 functor = aFilterMgr.CreateMultiConnection()
963 elif theCriterion == FT_MultiConnection2D:
964 functor = aFilterMgr.CreateMultiConnection2D()
965 elif theCriterion == FT_Length:
966 functor = aFilterMgr.CreateLength()
967 elif theCriterion == FT_Length2D:
968 functor = aFilterMgr.CreateLength2D()
969 elif theCriterion == FT_Deflection2D:
970 functor = aFilterMgr.CreateDeflection2D()
971 elif theCriterion == FT_NodeConnectivityNumber:
972 functor = aFilterMgr.CreateNodeConnectivityNumber()
973 elif theCriterion == FT_BallDiameter:
974 functor = aFilterMgr.CreateBallDiameter()
976 print "Error: given parameter is not numerical functor type."
977 aFilterMgr.UnRegister()
981 # @param theHType mesh hypothesis type (string)
982 # @param theLibName mesh plug-in library name
983 # @return created hypothesis instance
984 def CreateHypothesis(self, theHType, theLibName="libStdMeshersEngine.so"):
985 hyp = SMESH._objref_SMESH_Gen.CreateHypothesis(self, theHType, theLibName )
987 if isinstance( hyp, SMESH._objref_SMESH_Algo ):
990 # wrap hypothesis methods
991 #print "HYPOTHESIS", theHType
992 for meth_name in dir( hyp.__class__ ):
993 if not meth_name.startswith("Get") and \
994 not meth_name in dir ( SMESH._objref_SMESH_Hypothesis ):
995 method = getattr ( hyp.__class__, meth_name )
997 setattr( hyp, meth_name, hypMethodWrapper( hyp, method ))
1001 ## Get the mesh statistic
1002 # @return dictionary "element type" - "count of elements"
1003 # @ingroup l1_meshinfo
1004 def GetMeshInfo(self, obj):
1005 if isinstance( obj, Mesh ):
1008 if hasattr(obj, "GetMeshInfo"):
1009 values = obj.GetMeshInfo()
1010 for i in range(SMESH.Entity_Last._v):
1011 if i < len(values): d[SMESH.EntityType._item(i)]=values[i]
1015 ## Get minimum distance between two objects
1017 # If @a src2 is None, and @a id2 = 0, distance from @a src1 / @a id1 to the origin is computed.
1018 # If @a src2 is None, and @a id2 != 0, it is assumed that both @a id1 and @a id2 belong to @a src1.
1020 # @param src1 first source object
1021 # @param src2 second source object
1022 # @param id1 node/element id from the first source
1023 # @param id2 node/element id from the second (or first) source
1024 # @param isElem1 @c True if @a id1 is element id, @c False if it is node id
1025 # @param isElem2 @c True if @a id2 is element id, @c False if it is node id
1026 # @return minimum distance value
1027 # @sa GetMinDistance()
1028 # @ingroup l1_measurements
1029 def MinDistance(self, src1, src2=None, id1=0, id2=0, isElem1=False, isElem2=False):
1030 result = self.GetMinDistance(src1, src2, id1, id2, isElem1, isElem2)
1034 result = result.value
1037 ## Get measure structure specifying minimum distance data between two objects
1039 # If @a src2 is None, and @a id2 = 0, distance from @a src1 / @a id1 to the origin is computed.
1040 # If @a src2 is None, and @a id2 != 0, it is assumed that both @a id1 and @a id2 belong to @a src1.
1042 # @param src1 first source object
1043 # @param src2 second source object
1044 # @param id1 node/element id from the first source
1045 # @param id2 node/element id from the second (or first) source
1046 # @param isElem1 @c True if @a id1 is element id, @c False if it is node id
1047 # @param isElem2 @c True if @a id2 is element id, @c False if it is node id
1048 # @return Measure structure or None if input data is invalid
1050 # @ingroup l1_measurements
1051 def GetMinDistance(self, src1, src2=None, id1=0, id2=0, isElem1=False, isElem2=False):
1052 if isinstance(src1, Mesh): src1 = src1.mesh
1053 if isinstance(src2, Mesh): src2 = src2.mesh
1054 if src2 is None and id2 != 0: src2 = src1
1055 if not hasattr(src1, "_narrow"): return None
1056 src1 = src1._narrow(SMESH.SMESH_IDSource)
1057 if not src1: return None
1058 unRegister = genObjUnRegister()
1061 e = m.GetMeshEditor()
1063 src1 = e.MakeIDSource([id1], SMESH.FACE)
1065 src1 = e.MakeIDSource([id1], SMESH.NODE)
1066 unRegister.set( src1 )
1068 if hasattr(src2, "_narrow"):
1069 src2 = src2._narrow(SMESH.SMESH_IDSource)
1070 if src2 and id2 != 0:
1072 e = m.GetMeshEditor()
1074 src2 = e.MakeIDSource([id2], SMESH.FACE)
1076 src2 = e.MakeIDSource([id2], SMESH.NODE)
1077 unRegister.set( src2 )
1080 aMeasurements = self.CreateMeasurements()
1081 unRegister.set( aMeasurements )
1082 result = aMeasurements.MinDistance(src1, src2)
1085 ## Get bounding box of the specified object(s)
1086 # @param objects single source object or list of source objects
1087 # @return tuple of six values (minX, minY, minZ, maxX, maxY, maxZ)
1088 # @sa GetBoundingBox()
1089 # @ingroup l1_measurements
1090 def BoundingBox(self, objects):
1091 result = self.GetBoundingBox(objects)
1095 result = (result.minX, result.minY, result.minZ, result.maxX, result.maxY, result.maxZ)
1098 ## Get measure structure specifying bounding box data of the specified object(s)
1099 # @param objects single source object or list of source objects
1100 # @return Measure structure
1102 # @ingroup l1_measurements
1103 def GetBoundingBox(self, objects):
1104 if isinstance(objects, tuple):
1105 objects = list(objects)
1106 if not isinstance(objects, list):
1110 if isinstance(o, Mesh):
1111 srclist.append(o.mesh)
1112 elif hasattr(o, "_narrow"):
1113 src = o._narrow(SMESH.SMESH_IDSource)
1114 if src: srclist.append(src)
1117 aMeasurements = self.CreateMeasurements()
1118 result = aMeasurements.BoundingBox(srclist)
1119 aMeasurements.UnRegister()
1122 ## Get sum of lengths of all 1D elements in the mesh object.
1123 # @param obj mesh, submesh or group
1124 # @return sum of lengths of all 1D elements
1125 # @ingroup l1_measurements
1126 def GetLength(self, obj):
1127 if isinstance(obj, Mesh): obj = obj.mesh
1128 if isinstance(obj, Mesh_Algorithm): obj = obj.GetSubMesh()
1129 aMeasurements = self.CreateMeasurements()
1130 value = aMeasurements.Length(obj)
1131 aMeasurements.UnRegister()
1134 ## Get sum of areas of all 2D elements in the mesh object.
1135 # @param obj mesh, submesh or group
1136 # @return sum of areas of all 2D elements
1137 # @ingroup l1_measurements
1138 def GetArea(self, obj):
1139 if isinstance(obj, Mesh): obj = obj.mesh
1140 if isinstance(obj, Mesh_Algorithm): obj = obj.GetSubMesh()
1141 aMeasurements = self.CreateMeasurements()
1142 value = aMeasurements.Area(obj)
1143 aMeasurements.UnRegister()
1146 ## Get sum of volumes of all 3D elements in the mesh object.
1147 # @param obj mesh, submesh or group
1148 # @return sum of volumes of all 3D elements
1149 # @ingroup l1_measurements
1150 def GetVolume(self, obj):
1151 if isinstance(obj, Mesh): obj = obj.mesh
1152 if isinstance(obj, Mesh_Algorithm): obj = obj.GetSubMesh()
1153 aMeasurements = self.CreateMeasurements()
1154 value = aMeasurements.Volume(obj)
1155 aMeasurements.UnRegister()
1158 ## Get gravity center of all nodes of the mesh object.
1159 # @param obj mesh, submesh or group
1160 # @return three components of the gravity center: x,y,z
1161 # @ingroup l1_measurements
1162 def GetGravityCenter(self, obj):
1163 if isinstance(obj, Mesh): obj = obj.mesh
1164 if isinstance(obj, Mesh_Algorithm): obj = obj.GetSubMesh()
1165 aMeasurements = self.CreateMeasurements()
1166 pointStruct = aMeasurements.GravityCenter(obj)
1167 aMeasurements.UnRegister()
1168 return pointStruct.x, pointStruct.y, pointStruct.z
1170 pass # end of class smeshBuilder
1173 #Registering the new proxy for SMESH_Gen
1174 omniORB.registerObjref(SMESH._objref_SMESH_Gen._NP_RepositoryId, smeshBuilder)
1176 ## Create a new smeshBuilder instance.The smeshBuilder class provides the Python
1177 # interface to create or load meshes.
1182 # salome.salome_init()
1183 # from salome.smesh import smeshBuilder
1184 # smesh = smeshBuilder.New(salome.myStudy)
1186 # @param study SALOME study, generally obtained by salome.myStudy.
1187 # @param instance CORBA proxy of SMESH Engine. If None, the default Engine is used.
1188 # @param instanceGeom CORBA proxy of GEOM Engine. If None, the default Engine is used.
1189 # @return smeshBuilder instance
1191 def New( study, instance=None, instanceGeom=None):
1193 Create a new smeshBuilder instance.The smeshBuilder class provides the Python
1194 interface to create or load meshes.
1198 salome.salome_init()
1199 from salome.smesh import smeshBuilder
1200 smesh = smeshBuilder.New(salome.myStudy)
1203 study SALOME study, generally obtained by salome.myStudy.
1204 instance CORBA proxy of SMESH Engine. If None, the default Engine is used.
1205 instanceGeom CORBA proxy of GEOM Engine. If None, the default Engine is used.
1207 smeshBuilder instance
1215 smeshInst = smeshBuilder()
1216 assert isinstance(smeshInst,smeshBuilder), "Smesh engine class is %s but should be smeshBuilder.smeshBuilder. Import salome.smesh.smeshBuilder before creating the instance."%smeshInst.__class__
1217 smeshInst.init_smesh(study, instanceGeom)
1221 # Public class: Mesh
1222 # ==================
1224 ## This class allows defining and managing a mesh.
1225 # It has a set of methods to build a mesh on the given geometry, including the definition of sub-meshes.
1226 # It also has methods to define groups of mesh elements, to modify a mesh (by addition of
1227 # new nodes and elements and by changing the existing entities), to get information
1228 # about a mesh and to export a mesh in different formats.
1230 __metaclass__ = MeshMeta
1238 # Create a mesh on the shape \a obj (or an empty mesh if \a obj is equal to 0) and
1239 # sets the GUI name of this mesh to \a name.
1240 # @param smeshpyD an instance of smeshBuilder class
1241 # @param geompyD an instance of geomBuilder class
1242 # @param obj Shape to be meshed or SMESH_Mesh object
1243 # @param name Study name of the mesh
1244 # @ingroup l2_construct
1245 def __init__(self, smeshpyD, geompyD, obj=0, name=0):
1246 self.smeshpyD=smeshpyD
1247 self.geompyD=geompyD
1252 if isinstance(obj, geomBuilder.GEOM._objref_GEOM_Object):
1255 # publish geom of mesh (issue 0021122)
1256 if not self.geom.GetStudyEntry() and smeshpyD.GetCurrentStudy():
1258 studyID = smeshpyD.GetCurrentStudy()._get_StudyId()
1259 if studyID != geompyD.myStudyId:
1260 geompyD.init_geom( smeshpyD.GetCurrentStudy())
1263 geo_name = name + " shape"
1265 geo_name = "%s_%s to mesh"%(self.geom.GetShapeType(), id(self.geom)%100)
1266 geompyD.addToStudy( self.geom, geo_name )
1267 self.SetMesh( self.smeshpyD.CreateMesh(self.geom) )
1269 elif isinstance(obj, SMESH._objref_SMESH_Mesh):
1272 self.SetMesh( self.smeshpyD.CreateEmptyMesh() )
1274 self.smeshpyD.SetName(self.mesh, name)
1276 self.smeshpyD.SetName(self.mesh, GetName(obj)) # + " mesh"
1279 self.geom = self.mesh.GetShapeToMesh()
1281 self.editor = self.mesh.GetMeshEditor()
1282 self.functors = [None] * SMESH.FT_Undefined._v
1284 # set self to algoCreator's
1285 for attrName in dir(self):
1286 attr = getattr( self, attrName )
1287 if isinstance( attr, algoCreator ):
1288 setattr( self, attrName, attr.copy( self ))
1293 ## Destructor. Clean-up resources
1296 #self.mesh.UnRegister()
1300 ## Initialize the Mesh object from an instance of SMESH_Mesh interface
1301 # @param theMesh a SMESH_Mesh object
1302 # @ingroup l2_construct
1303 def SetMesh(self, theMesh):
1304 # do not call Register() as this prevents mesh servant deletion at closing study
1305 #if self.mesh: self.mesh.UnRegister()
1308 #self.mesh.Register()
1309 self.geom = self.mesh.GetShapeToMesh()
1312 ## Return the mesh, that is an instance of SMESH_Mesh interface
1313 # @return a SMESH_Mesh object
1314 # @ingroup l2_construct
1318 ## Get the name of the mesh
1319 # @return the name of the mesh as a string
1320 # @ingroup l2_construct
1322 name = GetName(self.GetMesh())
1325 ## Set a name to the mesh
1326 # @param name a new name of the mesh
1327 # @ingroup l2_construct
1328 def SetName(self, name):
1329 self.smeshpyD.SetName(self.GetMesh(), name)
1331 ## Get a sub-mesh object associated to a \a geom geometrical object.
1332 # @param geom a geometrical object (shape)
1333 # @param name a name for the sub-mesh in the Object Browser
1334 # @return an object of type SMESH.SMESH_subMesh, representing a part of mesh,
1335 # which lies on the given shape
1337 # The sub-mesh object gives access to the IDs of nodes and elements.
1338 # The sub-mesh object has the following methods:
1339 # - SMESH.SMESH_subMesh.GetNumberOfElements()
1340 # - SMESH.SMESH_subMesh.GetNumberOfNodes( all )
1341 # - SMESH.SMESH_subMesh.GetElementsId()
1342 # - SMESH.SMESH_subMesh.GetElementsByType( ElementType )
1343 # - SMESH.SMESH_subMesh.GetNodesId()
1344 # - SMESH.SMESH_subMesh.GetSubShape()
1345 # - SMESH.SMESH_subMesh.GetFather()
1346 # - SMESH.SMESH_subMesh.GetId()
1347 # @note A sub-mesh is implicitly created when a sub-shape is specified at
1348 # creating an algorithm, for example: <code>algo1D = mesh.Segment(geom=Edge_1) </code>
1349 # creates a sub-mesh on @c Edge_1 and assign Wire Discretization algorithm to it.
1350 # The created sub-mesh can be retrieved from the algorithm:
1351 # <code>submesh = algo1D.GetSubMesh()</code>
1352 # @ingroup l2_submeshes
1353 def GetSubMesh(self, geom, name):
1354 AssureGeomPublished( self, geom, name )
1355 submesh = self.mesh.GetSubMesh( geom, name )
1358 ## Return the shape associated to the mesh
1359 # @return a GEOM_Object
1360 # @ingroup l2_construct
1364 ## Associate the given shape to the mesh (entails the recreation of the mesh)
1365 # @param geom the shape to be meshed (GEOM_Object)
1366 # @ingroup l2_construct
1367 def SetShape(self, geom):
1368 self.mesh = self.smeshpyD.CreateMesh(geom)
1370 ## Load mesh from the study after opening the study
1374 ## Return true if the hypotheses are defined well
1375 # @param theSubObject a sub-shape of a mesh shape
1376 # @return True or False
1377 # @ingroup l2_construct
1378 def IsReadyToCompute(self, theSubObject):
1379 return self.smeshpyD.IsReadyToCompute(self.mesh, theSubObject)
1381 ## Return errors of hypotheses definition.
1382 # The list of errors is empty if everything is OK.
1383 # @param theSubObject a sub-shape of a mesh shape
1384 # @return a list of errors
1385 # @ingroup l2_construct
1386 def GetAlgoState(self, theSubObject):
1387 return self.smeshpyD.GetAlgoState(self.mesh, theSubObject)
1389 ## Return a geometrical object on which the given element was built.
1390 # The returned geometrical object, if not nil, is either found in the
1391 # study or published by this method with the given name
1392 # @param theElementID the id of the mesh element
1393 # @param theGeomName the user-defined name of the geometrical object
1394 # @return GEOM::GEOM_Object instance
1395 # @ingroup l1_meshinfo
1396 def GetGeometryByMeshElement(self, theElementID, theGeomName):
1397 return self.smeshpyD.GetGeometryByMeshElement( self.mesh, theElementID, theGeomName )
1399 ## Return the mesh dimension depending on the dimension of the underlying shape
1400 # or, if the mesh is not based on any shape, basing on deimension of elements
1401 # @return mesh dimension as an integer value [0,3]
1402 # @ingroup l1_meshinfo
1403 def MeshDimension(self):
1404 if self.mesh.HasShapeToMesh():
1405 shells = self.geompyD.SubShapeAllIDs( self.geom, self.geompyD.ShapeType["SOLID"] )
1406 if len( shells ) > 0 :
1408 elif self.geompyD.NumberOfFaces( self.geom ) > 0 :
1410 elif self.geompyD.NumberOfEdges( self.geom ) > 0 :
1415 if self.NbVolumes() > 0: return 3
1416 if self.NbFaces() > 0: return 2
1417 if self.NbEdges() > 0: return 1
1420 ## Evaluate size of prospective mesh on a shape
1421 # @return a list where i-th element is a number of elements of i-th SMESH.EntityType
1422 # To know predicted number of e.g. edges, inquire it this way
1423 # Evaluate()[ EnumToLong( Entity_Edge )]
1424 # @ingroup l2_construct
1425 def Evaluate(self, geom=0):
1426 if geom == 0 or not isinstance(geom, geomBuilder.GEOM._objref_GEOM_Object):
1428 geom = self.mesh.GetShapeToMesh()
1431 return self.smeshpyD.Evaluate(self.mesh, geom)
1434 ## Compute the mesh and return the status of the computation
1435 # @param geom geomtrical shape on which mesh data should be computed
1436 # @param discardModifs if True and the mesh has been edited since
1437 # a last total re-compute and that may prevent successful partial re-compute,
1438 # then the mesh is cleaned before Compute()
1439 # @param refresh if @c True, Object browser is automatically updated (when running in GUI)
1440 # @return True or False
1441 # @ingroup l2_construct
1442 def Compute(self, geom=0, discardModifs=False, refresh=False):
1443 if geom == 0 or not isinstance(geom, geomBuilder.GEOM._objref_GEOM_Object):
1445 geom = self.mesh.GetShapeToMesh()
1450 if discardModifs and self.mesh.HasModificationsToDiscard(): # issue 0020693
1452 ok = self.smeshpyD.Compute(self.mesh, geom)
1453 except SALOME.SALOME_Exception, ex:
1454 print "Mesh computation failed, exception caught:"
1455 print " ", ex.details.text
1458 print "Mesh computation failed, exception caught:"
1459 traceback.print_exc()
1463 # Treat compute errors
1464 computeErrors = self.smeshpyD.GetComputeErrors( self.mesh, geom )
1466 for err in computeErrors:
1467 if self.mesh.HasShapeToMesh():
1468 shapeText = " on %s" % self.GetSubShapeName( err.subShapeID )
1470 stdErrors = ["OK", #COMPERR_OK
1471 "Invalid input mesh", #COMPERR_BAD_INPUT_MESH
1472 "std::exception", #COMPERR_STD_EXCEPTION
1473 "OCC exception", #COMPERR_OCC_EXCEPTION
1474 "..", #COMPERR_SLM_EXCEPTION
1475 "Unknown exception", #COMPERR_EXCEPTION
1476 "Memory allocation problem", #COMPERR_MEMORY_PB
1477 "Algorithm failed", #COMPERR_ALGO_FAILED
1478 "Unexpected geometry", #COMPERR_BAD_SHAPE
1479 "Warning", #COMPERR_WARNING
1480 "Computation cancelled",#COMPERR_CANCELED
1481 "No mesh on sub-shape"] #COMPERR_NO_MESH_ON_SHAPE
1483 if err.code < len(stdErrors): errText = stdErrors[err.code]
1485 errText = "code %s" % -err.code
1486 if errText: errText += ". "
1487 errText += err.comment
1488 if allReasons: allReasons += "\n"
1490 allReasons += '- "%s"%s - %s' %(err.algoName, shapeText, errText)
1492 allReasons += '- "%s" failed%s. Error: %s' %(err.algoName, shapeText, errText)
1496 errors = self.smeshpyD.GetAlgoState( self.mesh, geom )
1498 if err.isGlobalAlgo:
1506 reason = '%s %sD algorithm is missing' % (glob, dim)
1507 elif err.state == HYP_MISSING:
1508 reason = ('%s %sD algorithm "%s" misses %sD hypothesis'
1509 % (glob, dim, name, dim))
1510 elif err.state == HYP_NOTCONFORM:
1511 reason = 'Global "Not Conform mesh allowed" hypothesis is missing'
1512 elif err.state == HYP_BAD_PARAMETER:
1513 reason = ('Hypothesis of %s %sD algorithm "%s" has a bad parameter value'
1514 % ( glob, dim, name ))
1515 elif err.state == HYP_BAD_GEOMETRY:
1516 reason = ('%s %sD algorithm "%s" is assigned to mismatching'
1517 'geometry' % ( glob, dim, name ))
1518 elif err.state == HYP_HIDDEN_ALGO:
1519 reason = ('%s %sD algorithm "%s" is ignored due to presence of a %s '
1520 'algorithm of upper dimension generating %sD mesh'
1521 % ( glob, dim, name, glob, dim ))
1523 reason = ("For unknown reason. "
1524 "Developer, revise Mesh.Compute() implementation in smeshBuilder.py!")
1526 if allReasons: allReasons += "\n"
1527 allReasons += "- " + reason
1529 if not ok or allReasons != "":
1530 msg = '"' + GetName(self.mesh) + '"'
1531 if ok: msg += " has been computed with warnings"
1532 else: msg += " has not been computed"
1533 if allReasons != "": msg += ":"
1538 if salome.sg.hasDesktop() and self.mesh.GetStudyId() >= 0:
1539 if not isinstance( refresh, list): # not a call from subMesh.Compute()
1540 smeshgui = salome.ImportComponentGUI("SMESH")
1541 smeshgui.Init(self.mesh.GetStudyId())
1542 smeshgui.SetMeshIcon( salome.ObjectToID( self.mesh ), ok, (self.NbNodes()==0) )
1543 if refresh: salome.sg.updateObjBrowser(True)
1547 ## Return a list of error messages (SMESH.ComputeError) of the last Compute()
1548 # @ingroup l2_construct
1549 def GetComputeErrors(self, shape=0 ):
1551 shape = self.mesh.GetShapeToMesh()
1552 return self.smeshpyD.GetComputeErrors( self.mesh, shape )
1554 ## Return a name of a sub-shape by its ID
1555 # @param subShapeID a unique ID of a sub-shape
1556 # @return a string describing the sub-shape; possible variants:
1557 # - "Face_12" (published sub-shape)
1558 # - FACE #3 (not published sub-shape)
1559 # - sub-shape #3 (invalid sub-shape ID)
1560 # - #3 (error in this function)
1561 # @ingroup l1_auxiliary
1562 def GetSubShapeName(self, subShapeID ):
1563 if not self.mesh.HasShapeToMesh():
1567 mainIOR = salome.orb.object_to_string( self.GetShape() )
1568 for sname in salome.myStudyManager.GetOpenStudies():
1569 s = salome.myStudyManager.GetStudyByName(sname)
1571 mainSO = s.FindObjectIOR(mainIOR)
1572 if not mainSO: continue
1574 shapeText = '"%s"' % mainSO.GetName()
1575 subIt = s.NewChildIterator(mainSO)
1577 subSO = subIt.Value()
1579 obj = subSO.GetObject()
1580 if not obj: continue
1581 go = obj._narrow( geomBuilder.GEOM._objref_GEOM_Object )
1584 ids = self.geompyD.GetSubShapeID( self.GetShape(), go )
1587 if ids == subShapeID:
1588 shapeText = '"%s"' % subSO.GetName()
1591 shape = self.geompyD.GetSubShape( self.GetShape(), [subShapeID])
1593 shapeText = '%s #%s' % (shape.GetShapeType(), subShapeID)
1595 shapeText = 'sub-shape #%s' % (subShapeID)
1597 shapeText = "#%s" % (subShapeID)
1600 ## Return a list of sub-shapes meshing of which failed, grouped into GEOM groups by
1601 # error of an algorithm
1602 # @param publish if @c True, the returned groups will be published in the study
1603 # @return a list of GEOM groups each named after a failed algorithm
1604 # @ingroup l2_construct
1605 def GetFailedShapes(self, publish=False):
1608 computeErrors = self.smeshpyD.GetComputeErrors( self.mesh, self.GetShape() )
1609 for err in computeErrors:
1610 shape = self.geompyD.GetSubShape( self.GetShape(), [err.subShapeID])
1611 if not shape: continue
1612 if err.algoName in algo2shapes:
1613 algo2shapes[ err.algoName ].append( shape )
1615 algo2shapes[ err.algoName ] = [ shape ]
1619 for algoName, shapes in algo2shapes.items():
1621 groupType = self.smeshpyD.EnumToLong( shapes[0].GetShapeType() )
1622 otherTypeShapes = []
1624 group = self.geompyD.CreateGroup( self.geom, groupType )
1625 for shape in shapes:
1626 if shape.GetShapeType() == shapes[0].GetShapeType():
1627 sameTypeShapes.append( shape )
1629 otherTypeShapes.append( shape )
1630 self.geompyD.UnionList( group, sameTypeShapes )
1632 group.SetName( "%s %s" % ( algoName, shapes[0].GetShapeType() ))
1634 group.SetName( algoName )
1635 groups.append( group )
1636 shapes = otherTypeShapes
1639 for group in groups:
1640 self.geompyD.addToStudyInFather( self.geom, group, group.GetName() )
1643 ## Return sub-mesh objects list in meshing order
1644 # @return list of lists of sub-meshes
1645 # @ingroup l2_construct
1646 def GetMeshOrder(self):
1647 return self.mesh.GetMeshOrder()
1649 ## Set order in which concurrent sub-meshes should be meshed
1650 # @param submeshes list of lists of sub-meshes
1651 # @ingroup l2_construct
1652 def SetMeshOrder(self, submeshes):
1653 return self.mesh.SetMeshOrder(submeshes)
1655 ## Remove all nodes and elements generated on geometry. Imported elements remain.
1656 # @param refresh if @c True, Object browser is automatically updated (when running in GUI)
1657 # @ingroup l2_construct
1658 def Clear(self, refresh=False):
1660 if ( salome.sg.hasDesktop() and
1661 salome.myStudyManager.GetStudyByID( self.mesh.GetStudyId() ) ):
1662 smeshgui = salome.ImportComponentGUI("SMESH")
1663 smeshgui.Init(self.mesh.GetStudyId())
1664 smeshgui.SetMeshIcon( salome.ObjectToID( self.mesh ), False, True )
1665 if refresh: salome.sg.updateObjBrowser(True)
1667 ## Remove all nodes and elements of indicated shape
1668 # @param refresh if @c True, Object browser is automatically updated (when running in GUI)
1669 # @param geomId the ID of a sub-shape to remove elements on
1670 # @ingroup l2_submeshes
1671 def ClearSubMesh(self, geomId, refresh=False):
1672 self.mesh.ClearSubMesh(geomId)
1673 if salome.sg.hasDesktop():
1674 smeshgui = salome.ImportComponentGUI("SMESH")
1675 smeshgui.Init(self.mesh.GetStudyId())
1676 smeshgui.SetMeshIcon( salome.ObjectToID( self.mesh ), False, True )
1677 if refresh: salome.sg.updateObjBrowser(True)
1679 ## Compute a tetrahedral mesh using AutomaticLength + MEFISTO + Tetrahedron
1680 # @param fineness [0.0,1.0] defines mesh fineness
1681 # @return True or False
1682 # @ingroup l3_algos_basic
1683 def AutomaticTetrahedralization(self, fineness=0):
1684 dim = self.MeshDimension()
1686 self.RemoveGlobalHypotheses()
1687 self.Segment().AutomaticLength(fineness)
1689 self.Triangle().LengthFromEdges()
1694 return self.Compute()
1696 ## Compute an hexahedral mesh using AutomaticLength + Quadrangle + Hexahedron
1697 # @param fineness [0.0, 1.0] defines mesh fineness
1698 # @return True or False
1699 # @ingroup l3_algos_basic
1700 def AutomaticHexahedralization(self, fineness=0):
1701 dim = self.MeshDimension()
1702 # assign the hypotheses
1703 self.RemoveGlobalHypotheses()
1704 self.Segment().AutomaticLength(fineness)
1711 return self.Compute()
1713 ## Assign a hypothesis
1714 # @param hyp a hypothesis to assign
1715 # @param geom a subhape of mesh geometry
1716 # @return SMESH.Hypothesis_Status
1717 # @ingroup l2_editing
1718 def AddHypothesis(self, hyp, geom=0):
1719 if isinstance( hyp, geomBuilder.GEOM._objref_GEOM_Object ):
1720 hyp, geom = geom, hyp
1721 if isinstance( hyp, Mesh_Algorithm ):
1722 hyp = hyp.GetAlgorithm()
1727 geom = self.mesh.GetShapeToMesh()
1730 if self.mesh.HasShapeToMesh():
1731 hyp_type = hyp.GetName()
1732 lib_name = hyp.GetLibName()
1733 # checkAll = ( not geom.IsSame( self.mesh.GetShapeToMesh() ))
1734 # if checkAll and geom:
1735 # checkAll = geom.GetType() == 37
1737 isApplicable = self.smeshpyD.IsApplicable(hyp_type, lib_name, geom, checkAll)
1739 AssureGeomPublished( self, geom, "shape for %s" % hyp.GetName())
1740 status = self.mesh.AddHypothesis(geom, hyp)
1742 status = HYP_BAD_GEOMETRY,""
1743 hyp_name = GetName( hyp )
1746 geom_name = geom.GetName()
1747 isAlgo = hyp._narrow( SMESH_Algo )
1748 TreatHypoStatus( status, hyp_name, geom_name, isAlgo, self )
1751 ## Return True if an algorithm of hypothesis is assigned to a given shape
1752 # @param hyp a hypothesis to check
1753 # @param geom a subhape of mesh geometry
1754 # @return True of False
1755 # @ingroup l2_editing
1756 def IsUsedHypothesis(self, hyp, geom):
1757 if not hyp: # or not geom
1759 if isinstance( hyp, Mesh_Algorithm ):
1760 hyp = hyp.GetAlgorithm()
1762 hyps = self.GetHypothesisList(geom)
1764 if h.GetId() == hyp.GetId():
1768 ## Unassign a hypothesis
1769 # @param hyp a hypothesis to unassign
1770 # @param geom a sub-shape of mesh geometry
1771 # @return SMESH.Hypothesis_Status
1772 # @ingroup l2_editing
1773 def RemoveHypothesis(self, hyp, geom=0):
1776 if isinstance( hyp, Mesh_Algorithm ):
1777 hyp = hyp.GetAlgorithm()
1783 if self.IsUsedHypothesis( hyp, shape ):
1784 return self.mesh.RemoveHypothesis( shape, hyp )
1785 hypName = GetName( hyp )
1786 geoName = GetName( shape )
1787 print "WARNING: RemoveHypothesis() failed as '%s' is not assigned to '%s' shape" % ( hypName, geoName )
1790 ## Get the list of hypotheses added on a geometry
1791 # @param geom a sub-shape of mesh geometry
1792 # @return the sequence of SMESH_Hypothesis
1793 # @ingroup l2_editing
1794 def GetHypothesisList(self, geom):
1795 return self.mesh.GetHypothesisList( geom )
1797 ## Remove all global hypotheses
1798 # @ingroup l2_editing
1799 def RemoveGlobalHypotheses(self):
1800 current_hyps = self.mesh.GetHypothesisList( self.geom )
1801 for hyp in current_hyps:
1802 self.mesh.RemoveHypothesis( self.geom, hyp )
1806 ## Export the mesh in a file in MED format
1807 ## allowing to overwrite the file if it exists or add the exported data to its contents
1808 # @param f is the file name
1809 # @param auto_groups boolean parameter for creating/not creating
1810 # the groups Group_On_All_Nodes, Group_On_All_Faces, ... ;
1811 # the typical use is auto_groups=False.
1812 # @param version MED format version
1813 # - MED_V2_1 is obsolete.
1814 # - MED_V2_2 means current version (kept for compatibility reasons)
1815 # - MED_LATEST means current version.
1816 # - MED_MINOR_x where x from 0 to 9 indicates the minor version of MED
1817 # to use for writing MED files, for backward compatibility :
1818 # for instance, with SALOME 8.4 use MED 3.2 (minor=2) instead of 3.3,
1819 # to allow the file to be read with SALOME 8.3.
1820 # @param overwrite boolean parameter for overwriting/not overwriting the file
1821 # @param meshPart a part of mesh (group, sub-mesh) to export instead of the mesh
1822 # @param autoDimension if @c True (default), a space dimension of a MED mesh can be either
1823 # - 1D if all mesh nodes lie on OX coordinate axis, or
1824 # - 2D if all mesh nodes lie on XOY coordinate plane, or
1825 # - 3D in the rest cases.<br>
1826 # If @a autoDimension is @c False, the space dimension is always 3.
1827 # @param fields list of GEOM fields defined on the shape to mesh.
1828 # @param geomAssocFields each character of this string means a need to export a
1829 # corresponding field; correspondence between fields and characters is following:
1830 # - 'v' stands for "_vertices _" field;
1831 # - 'e' stands for "_edges _" field;
1832 # - 'f' stands for "_faces _" field;
1833 # - 's' stands for "_solids _" field.
1834 # @ingroup l2_impexp
1835 def ExportMED(self, f, auto_groups=0, version=MED_LATEST,
1836 overwrite=1, meshPart=None, autoDimension=True, fields=[], geomAssocFields=''):
1837 if meshPart or fields or geomAssocFields:
1838 unRegister = genObjUnRegister()
1839 if isinstance( meshPart, list ):
1840 meshPart = self.GetIDSource( meshPart, SMESH.ALL )
1841 unRegister.set( meshPart )
1842 self.mesh.ExportPartToMED( meshPart, f, auto_groups, version, overwrite, autoDimension,
1843 fields, geomAssocFields)
1845 self.mesh.ExportToMEDX(f, auto_groups, version, overwrite, autoDimension)
1847 ## Export the mesh in a file in SAUV format
1848 # @param f is the file name
1849 # @param auto_groups boolean parameter for creating/not creating
1850 # the groups Group_On_All_Nodes, Group_On_All_Faces, ... ;
1851 # the typical use is auto_groups=false.
1852 # @ingroup l2_impexp
1853 def ExportSAUV(self, f, auto_groups=0):
1854 self.mesh.ExportSAUV(f, auto_groups)
1856 ## Export the mesh in a file in DAT format
1857 # @param f the file name
1858 # @param meshPart a part of mesh (group, sub-mesh) to export instead of the mesh
1859 # @ingroup l2_impexp
1860 def ExportDAT(self, f, meshPart=None):
1862 unRegister = genObjUnRegister()
1863 if isinstance( meshPart, list ):
1864 meshPart = self.GetIDSource( meshPart, SMESH.ALL )
1865 unRegister.set( meshPart )
1866 self.mesh.ExportPartToDAT( meshPart, f )
1868 self.mesh.ExportDAT(f)
1870 ## Export the mesh in a file in UNV format
1871 # @param f the file name
1872 # @param meshPart a part of mesh (group, sub-mesh) to export instead of the mesh
1873 # @ingroup l2_impexp
1874 def ExportUNV(self, f, meshPart=None):
1876 unRegister = genObjUnRegister()
1877 if isinstance( meshPart, list ):
1878 meshPart = self.GetIDSource( meshPart, SMESH.ALL )
1879 unRegister.set( meshPart )
1880 self.mesh.ExportPartToUNV( meshPart, f )
1882 self.mesh.ExportUNV(f)
1884 ## Export the mesh in a file in STL format
1885 # @param f the file name
1886 # @param ascii defines the file encoding
1887 # @param meshPart a part of mesh (group, sub-mesh) to export instead of the mesh
1888 # @ingroup l2_impexp
1889 def ExportSTL(self, f, ascii=1, meshPart=None):
1891 unRegister = genObjUnRegister()
1892 if isinstance( meshPart, list ):
1893 meshPart = self.GetIDSource( meshPart, SMESH.ALL )
1894 unRegister.set( meshPart )
1895 self.mesh.ExportPartToSTL( meshPart, f, ascii )
1897 self.mesh.ExportSTL(f, ascii)
1899 ## Export the mesh in a file in CGNS format
1900 # @param f is the file name
1901 # @param overwrite boolean parameter for overwriting/not overwriting the file
1902 # @param meshPart a part of mesh (group, sub-mesh) to export instead of the mesh
1903 # @param groupElemsByType if true all elements of same entity type are exported at ones,
1904 # else elements are exported in order of their IDs which can cause creation
1905 # of multiple cgns sections
1906 # @ingroup l2_impexp
1907 def ExportCGNS(self, f, overwrite=1, meshPart=None, groupElemsByType=False):
1908 unRegister = genObjUnRegister()
1909 if isinstance( meshPart, list ):
1910 meshPart = self.GetIDSource( meshPart, SMESH.ALL )
1911 unRegister.set( meshPart )
1912 if isinstance( meshPart, Mesh ):
1913 meshPart = meshPart.mesh
1915 meshPart = self.mesh
1916 self.mesh.ExportCGNS(meshPart, f, overwrite, groupElemsByType)
1918 ## Export the mesh in a file in GMF format.
1919 # GMF files must have .mesh extension for the ASCII format and .meshb for
1920 # the bynary format. Other extensions are not allowed.
1921 # @param f is the file name
1922 # @param meshPart a part of mesh (group, sub-mesh) to export instead of the mesh
1923 # @ingroup l2_impexp
1924 def ExportGMF(self, f, meshPart=None):
1925 unRegister = genObjUnRegister()
1926 if isinstance( meshPart, list ):
1927 meshPart = self.GetIDSource( meshPart, SMESH.ALL )
1928 unRegister.set( meshPart )
1929 if isinstance( meshPart, Mesh ):
1930 meshPart = meshPart.mesh
1932 meshPart = self.mesh
1933 self.mesh.ExportGMF(meshPart, f, True)
1935 ## Deprecated, used only for compatibility! Please, use ExportMED() method instead.
1936 # Export the mesh in a file in MED format
1937 # allowing to overwrite the file if it exists or add the exported data to its contents
1938 # @param f the file name
1939 # @param version MED format version:
1940 # - MED_V2_1 is obsolete.
1941 # - MED_V2_2 means current version (kept for compatibility reasons)
1942 # - MED_LATEST means current version.
1943 # - MED_MINOR_x where x from 0 to 9 indicates the minor version of MED
1944 # to use for writing MED files, for backward compatibility :
1945 # for instance, with SALOME 8.4 use MED 3.2 (minor=2) instead of 3.3,
1946 # to allow the file to be read with SALOME 8.3.
1947 # @param opt boolean parameter for creating/not creating
1948 # the groups Group_On_All_Nodes, Group_On_All_Faces, ...
1949 # @param overwrite boolean parameter for overwriting/not overwriting the file
1950 # @param autoDimension if @c True (default), a space dimension of a MED mesh can be either
1951 # - 1D if all mesh nodes lie on OX coordinate axis, or
1952 # - 2D if all mesh nodes lie on XOY coordinate plane, or
1953 # - 3D in the rest cases.<br>
1954 # If @a autoDimension is @c False, the space dimension is always 3.
1955 # @ingroup l2_impexp
1956 def ExportToMED(self, f, version=MED_LATEST, opt=0, overwrite=1, autoDimension=True):
1957 self.mesh.ExportToMEDX(f, opt, version, overwrite, autoDimension)
1959 # Operations with groups:
1960 # ----------------------
1962 ## Create an empty mesh group
1963 # @param elementType the type of elements in the group; either of
1964 # (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME)
1965 # @param name the name of the mesh group
1966 # @return SMESH_Group
1967 # @ingroup l2_grps_create
1968 def CreateEmptyGroup(self, elementType, name):
1969 return self.mesh.CreateGroup(elementType, name)
1971 ## Create a mesh group based on the geometric object \a grp
1972 # and gives a \a name, \n if this parameter is not defined
1973 # the name is the same as the geometric group name \n
1974 # Note: Works like GroupOnGeom().
1975 # @param grp a geometric group, a vertex, an edge, a face or a solid
1976 # @param name the name of the mesh group
1977 # @return SMESH_GroupOnGeom
1978 # @ingroup l2_grps_create
1979 def Group(self, grp, name=""):
1980 return self.GroupOnGeom(grp, name)
1982 ## Create a mesh group based on the geometrical object \a grp
1983 # and gives a \a name, \n if this parameter is not defined
1984 # the name is the same as the geometrical group name
1985 # @param grp a geometrical group, a vertex, an edge, a face or a solid
1986 # @param name the name of the mesh group
1987 # @param typ the type of elements in the group; either of
1988 # (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME). If not set, it is
1989 # automatically detected by the type of the geometry
1990 # @return SMESH_GroupOnGeom
1991 # @ingroup l2_grps_create
1992 def GroupOnGeom(self, grp, name="", typ=None):
1993 AssureGeomPublished( self, grp, name )
1995 name = grp.GetName()
1997 typ = self._groupTypeFromShape( grp )
1998 return self.mesh.CreateGroupFromGEOM(typ, name, grp)
2000 ## Pivate method to get a type of group on geometry
2001 def _groupTypeFromShape( self, shape ):
2002 tgeo = str(shape.GetShapeType())
2003 if tgeo == "VERTEX":
2005 elif tgeo == "EDGE":
2007 elif tgeo == "FACE" or tgeo == "SHELL":
2009 elif tgeo == "SOLID" or tgeo == "COMPSOLID":
2011 elif tgeo == "COMPOUND":
2012 sub = self.geompyD.SubShapeAll( shape, self.geompyD.ShapeType["SHAPE"])
2014 raise ValueError,"_groupTypeFromShape(): empty geometric group or compound '%s'" % GetName(shape)
2015 return self._groupTypeFromShape( sub[0] )
2018 "_groupTypeFromShape(): invalid geometry '%s'" % GetName(shape)
2021 ## Create a mesh group with given \a name based on the \a filter which
2022 ## is a special type of group dynamically updating it's contents during
2023 ## mesh modification
2024 # @param typ the type of elements in the group; either of
2025 # (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME).
2026 # @param name the name of the mesh group
2027 # @param filter the filter defining group contents
2028 # @return SMESH_GroupOnFilter
2029 # @ingroup l2_grps_create
2030 def GroupOnFilter(self, typ, name, filter):
2031 return self.mesh.CreateGroupFromFilter(typ, name, filter)
2033 ## Create a mesh group by the given ids of elements
2034 # @param groupName the name of the mesh group
2035 # @param elementType the type of elements in the group; either of
2036 # (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME).
2037 # @param elemIDs either the list of ids, group, sub-mesh, or filter
2038 # @return SMESH_Group
2039 # @ingroup l2_grps_create
2040 def MakeGroupByIds(self, groupName, elementType, elemIDs):
2041 group = self.mesh.CreateGroup(elementType, groupName)
2042 if isinstance( elemIDs, Mesh ):
2043 elemIDs = elemIDs.GetMesh()
2044 if hasattr( elemIDs, "GetIDs" ):
2045 if hasattr( elemIDs, "SetMesh" ):
2046 elemIDs.SetMesh( self.GetMesh() )
2047 group.AddFrom( elemIDs )
2052 ## Create a mesh group by the given conditions
2053 # @param groupName the name of the mesh group
2054 # @param elementType the type of elements(SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME)
2055 # @param CritType the type of criterion (SMESH.FT_Taper, SMESH.FT_Area, etc.)
2056 # Type SMESH.FunctorType._items in the Python Console to see all values.
2057 # Note that the items starting from FT_LessThan are not suitable for CritType.
2058 # @param Compare belongs to {SMESH.FT_LessThan, SMESH.FT_MoreThan, SMESH.FT_EqualTo}
2059 # @param Threshold the threshold value (range of ids as string, shape, numeric)
2060 # @param UnaryOp SMESH.FT_LogicalNOT or SMESH.FT_Undefined
2061 # @param Tolerance the tolerance used by SMESH.FT_BelongToGeom, SMESH.FT_BelongToSurface,
2062 # SMESH.FT_LyingOnGeom, SMESH.FT_CoplanarFaces criteria
2063 # @return SMESH_GroupOnFilter
2064 # @ingroup l2_grps_create
2068 CritType=FT_Undefined,
2071 UnaryOp=FT_Undefined,
2073 aCriterion = self.smeshpyD.GetCriterion(elementType, CritType, Compare, Threshold, UnaryOp, FT_Undefined,Tolerance)
2074 group = self.MakeGroupByCriterion(groupName, aCriterion)
2077 ## Create a mesh group by the given criterion
2078 # @param groupName the name of the mesh group
2079 # @param Criterion the instance of Criterion class
2080 # @return SMESH_GroupOnFilter
2081 # @ingroup l2_grps_create
2082 def MakeGroupByCriterion(self, groupName, Criterion):
2083 return self.MakeGroupByCriteria( groupName, [Criterion] )
2085 ## Create a mesh group by the given criteria (list of criteria)
2086 # @param groupName the name of the mesh group
2087 # @param theCriteria the list of criteria
2088 # @param binOp binary operator used when binary operator of criteria is undefined
2089 # @return SMESH_GroupOnFilter
2090 # @ingroup l2_grps_create
2091 def MakeGroupByCriteria(self, groupName, theCriteria, binOp=SMESH.FT_LogicalAND):
2092 aFilter = self.smeshpyD.GetFilterFromCriteria( theCriteria, binOp )
2093 group = self.MakeGroupByFilter(groupName, aFilter)
2096 ## Create a mesh group by the given filter
2097 # @param groupName the name of the mesh group
2098 # @param theFilter the instance of Filter class
2099 # @return SMESH_GroupOnFilter
2100 # @ingroup l2_grps_create
2101 def MakeGroupByFilter(self, groupName, theFilter):
2102 #group = self.CreateEmptyGroup(theFilter.GetElementType(), groupName)
2103 #theFilter.SetMesh( self.mesh )
2104 #group.AddFrom( theFilter )
2105 group = self.GroupOnFilter( theFilter.GetElementType(), groupName, theFilter )
2109 # @ingroup l2_grps_delete
2110 def RemoveGroup(self, group):
2111 self.mesh.RemoveGroup(group)
2113 ## Remove a group with its contents
2114 # @ingroup l2_grps_delete
2115 def RemoveGroupWithContents(self, group):
2116 self.mesh.RemoveGroupWithContents(group)
2118 ## Get the list of groups existing in the mesh in the order
2119 # of creation (starting from the oldest one)
2120 # @param elemType type of elements the groups contain; either of
2121 # (SMESH.ALL, SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME);
2122 # by default groups of elements of all types are returned
2123 # @return a sequence of SMESH_GroupBase
2124 # @ingroup l2_grps_create
2125 def GetGroups(self, elemType = SMESH.ALL):
2126 groups = self.mesh.GetGroups()
2127 if elemType == SMESH.ALL:
2131 if g.GetType() == elemType:
2132 typedGroups.append( g )
2137 ## Get the number of groups existing in the mesh
2138 # @return the quantity of groups as an integer value
2139 # @ingroup l2_grps_create
2141 return self.mesh.NbGroups()
2143 ## Get the list of names of groups existing in the mesh
2144 # @return list of strings
2145 # @ingroup l2_grps_create
2146 def GetGroupNames(self):
2147 groups = self.GetGroups()
2149 for group in groups:
2150 names.append(group.GetName())
2153 ## Find groups by name and type
2154 # @param name name of the group of interest
2155 # @param elemType type of elements the groups contain; either of
2156 # (SMESH.ALL, SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME);
2157 # by default one group of any type of elements is returned
2158 # if elemType == SMESH.ALL then all groups of any type are returned
2159 # @return a list of SMESH_GroupBase's
2160 # @ingroup l2_grps_create
2161 def GetGroupByName(self, name, elemType = None):
2163 for group in self.GetGroups():
2164 if group.GetName() == name:
2165 if elemType is None:
2167 if ( elemType == SMESH.ALL or
2168 group.GetType() == elemType ):
2169 groups.append( group )
2172 ## Produce a union of two groups.
2173 # A new group is created. All mesh elements that are
2174 # present in the initial groups are added to the new one
2175 # @return an instance of SMESH_Group
2176 # @ingroup l2_grps_operon
2177 def UnionGroups(self, group1, group2, name):
2178 return self.mesh.UnionGroups(group1, group2, name)
2180 ## Produce a union list of groups.
2181 # New group is created. All mesh elements that are present in
2182 # initial groups are added to the new one
2183 # @return an instance of SMESH_Group
2184 # @ingroup l2_grps_operon
2185 def UnionListOfGroups(self, groups, name):
2186 return self.mesh.UnionListOfGroups(groups, name)
2188 ## Prodice an intersection of two groups.
2189 # A new group is created. All mesh elements that are common
2190 # for the two initial groups are added to the new one.
2191 # @return an instance of SMESH_Group
2192 # @ingroup l2_grps_operon
2193 def IntersectGroups(self, group1, group2, name):
2194 return self.mesh.IntersectGroups(group1, group2, name)
2196 ## Produce an intersection of groups.
2197 # New group is created. All mesh elements that are present in all
2198 # initial groups simultaneously are added to the new one
2199 # @return an instance of SMESH_Group
2200 # @ingroup l2_grps_operon
2201 def IntersectListOfGroups(self, groups, name):
2202 return self.mesh.IntersectListOfGroups(groups, name)
2204 ## Produce a cut of two groups.
2205 # A new group is created. All mesh elements that are present in
2206 # the main group but are not present in the tool group are added to the new one
2207 # @return an instance of SMESH_Group
2208 # @ingroup l2_grps_operon
2209 def CutGroups(self, main_group, tool_group, name):
2210 return self.mesh.CutGroups(main_group, tool_group, name)
2212 ## Produce a cut of groups.
2213 # A new group is created. All mesh elements that are present in main groups
2214 # but do not present in tool groups are added to the new one
2215 # @return an instance of SMESH_Group
2216 # @ingroup l2_grps_operon
2217 def CutListOfGroups(self, main_groups, tool_groups, name):
2218 return self.mesh.CutListOfGroups(main_groups, tool_groups, name)
2221 # Create a standalone group of entities basing on nodes of other groups.
2222 # \param groups - list of reference groups, sub-meshes or filters, of any type.
2223 # \param elemType - a type of elements to include to the new group; either of
2224 # (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME).
2225 # \param name - a name of the new group.
2226 # \param nbCommonNodes - a criterion of inclusion of an element to the new group
2227 # basing on number of element nodes common with reference \a groups.
2228 # Meaning of possible values are:
2229 # - SMESH.ALL_NODES - include if all nodes are common,
2230 # - SMESH.MAIN - include if all corner nodes are common (meaningful for a quadratic mesh),
2231 # - SMESH.AT_LEAST_ONE - include if one or more node is common,
2232 # - SMEHS.MAJORITY - include if half of nodes or more are common.
2233 # \param underlyingOnly - if \c True (default), an element is included to the
2234 # new group provided that it is based on nodes of an element of \a groups;
2235 # in this case the reference \a groups are supposed to be of higher dimension
2236 # than \a elemType, which can be useful for example to get all faces lying on
2237 # volumes of the reference \a groups.
2238 # @return an instance of SMESH_Group
2239 # @ingroup l2_grps_operon
2240 def CreateDimGroup(self, groups, elemType, name,
2241 nbCommonNodes = SMESH.ALL_NODES, underlyingOnly = True):
2242 if isinstance( groups, SMESH._objref_SMESH_IDSource ):
2244 return self.mesh.CreateDimGroup(groups, elemType, name, nbCommonNodes, underlyingOnly)
2247 ## Convert group on geom into standalone group
2248 # @ingroup l2_grps_operon
2249 def ConvertToStandalone(self, group):
2250 return self.mesh.ConvertToStandalone(group)
2252 # Get some info about mesh:
2253 # ------------------------
2255 ## Return the log of nodes and elements added or removed
2256 # since the previous clear of the log.
2257 # @param clearAfterGet log is emptied after Get (safe if concurrents access)
2258 # @return list of log_block structures:
2263 # @ingroup l1_auxiliary
2264 def GetLog(self, clearAfterGet):
2265 return self.mesh.GetLog(clearAfterGet)
2267 ## Clear the log of nodes and elements added or removed since the previous
2268 # clear. Must be used immediately after GetLog if clearAfterGet is false.
2269 # @ingroup l1_auxiliary
2271 self.mesh.ClearLog()
2273 ## Toggle auto color mode on the object.
2274 # @param theAutoColor the flag which toggles auto color mode.
2276 # If switched on, a default color of a new group in Create Group dialog is chosen randomly.
2277 # @ingroup l1_grouping
2278 def SetAutoColor(self, theAutoColor):
2279 self.mesh.SetAutoColor(theAutoColor)
2281 ## Get flag of object auto color mode.
2282 # @return True or False
2283 # @ingroup l1_grouping
2284 def GetAutoColor(self):
2285 return self.mesh.GetAutoColor()
2287 ## Get the internal ID
2288 # @return integer value, which is the internal Id of the mesh
2289 # @ingroup l1_auxiliary
2291 return self.mesh.GetId()
2294 # @return integer value, which is the study Id of the mesh
2295 # @ingroup l1_auxiliary
2296 def GetStudyId(self):
2297 return self.mesh.GetStudyId()
2299 ## Check the group names for duplications.
2300 # Consider the maximum group name length stored in MED file.
2301 # @return True or False
2302 # @ingroup l1_grouping
2303 def HasDuplicatedGroupNamesMED(self):
2304 return self.mesh.HasDuplicatedGroupNamesMED()
2306 ## Obtain the mesh editor tool
2307 # @return an instance of SMESH_MeshEditor
2308 # @ingroup l1_modifying
2309 def GetMeshEditor(self):
2312 ## Wrap a list of IDs of elements or nodes into SMESH_IDSource which
2313 # can be passed as argument to a method accepting mesh, group or sub-mesh
2314 # @param ids list of IDs
2315 # @param elemType type of elements; this parameter is used to distinguish
2316 # IDs of nodes from IDs of elements; by default ids are treated as
2317 # IDs of elements; use SMESH.NODE if ids are IDs of nodes.
2318 # @return an instance of SMESH_IDSource
2319 # @warning call UnRegister() for the returned object as soon as it is no more useful:
2320 # idSrc = mesh.GetIDSource( [1,3,5], SMESH.NODE )
2321 # mesh.DoSomething( idSrc )
2322 # idSrc.UnRegister()
2323 # @ingroup l1_auxiliary
2324 def GetIDSource(self, ids, elemType = SMESH.ALL):
2325 if isinstance( ids, int ):
2327 return self.editor.MakeIDSource(ids, elemType)
2330 # Get information about mesh contents:
2331 # ------------------------------------
2333 ## Get the mesh statistic
2334 # @return dictionary type element - count of elements
2335 # @ingroup l1_meshinfo
2336 def GetMeshInfo(self, obj = None):
2337 if not obj: obj = self.mesh
2338 return self.smeshpyD.GetMeshInfo(obj)
2340 ## Return the number of nodes in the mesh
2341 # @return an integer value
2342 # @ingroup l1_meshinfo
2344 return self.mesh.NbNodes()
2346 ## Return the number of elements in the mesh
2347 # @return an integer value
2348 # @ingroup l1_meshinfo
2349 def NbElements(self):
2350 return self.mesh.NbElements()
2352 ## Return the number of 0d elements in the mesh
2353 # @return an integer value
2354 # @ingroup l1_meshinfo
2355 def Nb0DElements(self):
2356 return self.mesh.Nb0DElements()
2358 ## Return the number of ball discrete elements in the mesh
2359 # @return an integer value
2360 # @ingroup l1_meshinfo
2362 return self.mesh.NbBalls()
2364 ## Return the number of edges in the mesh
2365 # @return an integer value
2366 # @ingroup l1_meshinfo
2368 return self.mesh.NbEdges()
2370 ## Return the number of edges with the given order in the mesh
2371 # @param elementOrder the order of elements:
2372 # SMESH.ORDER_ANY, SMESH.ORDER_LINEAR or SMESH.ORDER_QUADRATIC
2373 # @return an integer value
2374 # @ingroup l1_meshinfo
2375 def NbEdgesOfOrder(self, elementOrder):
2376 return self.mesh.NbEdgesOfOrder(elementOrder)
2378 ## Return the number of faces in the mesh
2379 # @return an integer value
2380 # @ingroup l1_meshinfo
2382 return self.mesh.NbFaces()
2384 ## Return the number of faces with the given order in the mesh
2385 # @param elementOrder the order of elements:
2386 # SMESH.ORDER_ANY, SMESH.ORDER_LINEAR or SMESH.ORDER_QUADRATIC
2387 # @return an integer value
2388 # @ingroup l1_meshinfo
2389 def NbFacesOfOrder(self, elementOrder):
2390 return self.mesh.NbFacesOfOrder(elementOrder)
2392 ## Return the number of triangles in the mesh
2393 # @return an integer value
2394 # @ingroup l1_meshinfo
2395 def NbTriangles(self):
2396 return self.mesh.NbTriangles()
2398 ## Return the number of triangles with the given order in the mesh
2399 # @param elementOrder is the order of elements:
2400 # SMESH.ORDER_ANY, SMESH.ORDER_LINEAR or SMESH.ORDER_QUADRATIC
2401 # @return an integer value
2402 # @ingroup l1_meshinfo
2403 def NbTrianglesOfOrder(self, elementOrder):
2404 return self.mesh.NbTrianglesOfOrder(elementOrder)
2406 ## Return the number of biquadratic triangles in the mesh
2407 # @return an integer value
2408 # @ingroup l1_meshinfo
2409 def NbBiQuadTriangles(self):
2410 return self.mesh.NbBiQuadTriangles()
2412 ## Return the number of quadrangles in the mesh
2413 # @return an integer value
2414 # @ingroup l1_meshinfo
2415 def NbQuadrangles(self):
2416 return self.mesh.NbQuadrangles()
2418 ## Return the number of quadrangles with the given order in the mesh
2419 # @param elementOrder the order of elements:
2420 # SMESH.ORDER_ANY, SMESH.ORDER_LINEAR or SMESH.ORDER_QUADRATIC
2421 # @return an integer value
2422 # @ingroup l1_meshinfo
2423 def NbQuadranglesOfOrder(self, elementOrder):
2424 return self.mesh.NbQuadranglesOfOrder(elementOrder)
2426 ## Return the number of biquadratic quadrangles in the mesh
2427 # @return an integer value
2428 # @ingroup l1_meshinfo
2429 def NbBiQuadQuadrangles(self):
2430 return self.mesh.NbBiQuadQuadrangles()
2432 ## Return the number of polygons of given order in the mesh
2433 # @param elementOrder the order of elements:
2434 # SMESH.ORDER_ANY, SMESH.ORDER_LINEAR or SMESH.ORDER_QUADRATIC
2435 # @return an integer value
2436 # @ingroup l1_meshinfo
2437 def NbPolygons(self, elementOrder = SMESH.ORDER_ANY):
2438 return self.mesh.NbPolygonsOfOrder(elementOrder)
2440 ## Return the number of volumes in the mesh
2441 # @return an integer value
2442 # @ingroup l1_meshinfo
2443 def NbVolumes(self):
2444 return self.mesh.NbVolumes()
2446 ## Return the number of volumes with the given order in the mesh
2447 # @param elementOrder the order of elements:
2448 # SMESH.ORDER_ANY, SMESH.ORDER_LINEAR or SMESH.ORDER_QUADRATIC
2449 # @return an integer value
2450 # @ingroup l1_meshinfo
2451 def NbVolumesOfOrder(self, elementOrder):
2452 return self.mesh.NbVolumesOfOrder(elementOrder)
2454 ## Return the number of tetrahedrons in the mesh
2455 # @return an integer value
2456 # @ingroup l1_meshinfo
2458 return self.mesh.NbTetras()
2460 ## Return the number of tetrahedrons with the given order in the mesh
2461 # @param elementOrder the order of elements:
2462 # SMESH.ORDER_ANY, SMESH.ORDER_LINEAR or SMESH.ORDER_QUADRATIC
2463 # @return an integer value
2464 # @ingroup l1_meshinfo
2465 def NbTetrasOfOrder(self, elementOrder):
2466 return self.mesh.NbTetrasOfOrder(elementOrder)
2468 ## Return the number of hexahedrons in the mesh
2469 # @return an integer value
2470 # @ingroup l1_meshinfo
2472 return self.mesh.NbHexas()
2474 ## Return the number of hexahedrons with the given order in the mesh
2475 # @param elementOrder the order of elements:
2476 # SMESH.ORDER_ANY, SMESH.ORDER_LINEAR or SMESH.ORDER_QUADRATIC
2477 # @return an integer value
2478 # @ingroup l1_meshinfo
2479 def NbHexasOfOrder(self, elementOrder):
2480 return self.mesh.NbHexasOfOrder(elementOrder)
2482 ## Return the number of triquadratic hexahedrons in the mesh
2483 # @return an integer value
2484 # @ingroup l1_meshinfo
2485 def NbTriQuadraticHexas(self):
2486 return self.mesh.NbTriQuadraticHexas()
2488 ## Return the number of pyramids in the mesh
2489 # @return an integer value
2490 # @ingroup l1_meshinfo
2491 def NbPyramids(self):
2492 return self.mesh.NbPyramids()
2494 ## Return the number of pyramids with the given order in the mesh
2495 # @param elementOrder the order of elements:
2496 # SMESH.ORDER_ANY, SMESH.ORDER_LINEAR or SMESH.ORDER_QUADRATIC
2497 # @return an integer value
2498 # @ingroup l1_meshinfo
2499 def NbPyramidsOfOrder(self, elementOrder):
2500 return self.mesh.NbPyramidsOfOrder(elementOrder)
2502 ## Return the number of prisms in the mesh
2503 # @return an integer value
2504 # @ingroup l1_meshinfo
2506 return self.mesh.NbPrisms()
2508 ## Return the number of prisms with the given order in the mesh
2509 # @param elementOrder the order of elements:
2510 # SMESH.ORDER_ANY, SMESH.ORDER_LINEAR or SMESH.ORDER_QUADRATIC
2511 # @return an integer value
2512 # @ingroup l1_meshinfo
2513 def NbPrismsOfOrder(self, elementOrder):
2514 return self.mesh.NbPrismsOfOrder(elementOrder)
2516 ## Return the number of hexagonal prisms in the mesh
2517 # @return an integer value
2518 # @ingroup l1_meshinfo
2519 def NbHexagonalPrisms(self):
2520 return self.mesh.NbHexagonalPrisms()
2522 ## Return the number of polyhedrons in the mesh
2523 # @return an integer value
2524 # @ingroup l1_meshinfo
2525 def NbPolyhedrons(self):
2526 return self.mesh.NbPolyhedrons()
2528 ## Return the number of submeshes in the mesh
2529 # @return an integer value
2530 # @ingroup l1_meshinfo
2531 def NbSubMesh(self):
2532 return self.mesh.NbSubMesh()
2534 ## Return the list of mesh elements IDs
2535 # @return the list of integer values
2536 # @ingroup l1_meshinfo
2537 def GetElementsId(self):
2538 return self.mesh.GetElementsId()
2540 ## Return the list of IDs of mesh elements with the given type
2541 # @param elementType the required type of elements, either of
2542 # (SMESH.NODE, SMESH.EDGE, SMESH.FACE or SMESH.VOLUME)
2543 # @return list of integer values
2544 # @ingroup l1_meshinfo
2545 def GetElementsByType(self, elementType):
2546 return self.mesh.GetElementsByType(elementType)
2548 ## Return the list of mesh nodes IDs
2549 # @return the list of integer values
2550 # @ingroup l1_meshinfo
2551 def GetNodesId(self):
2552 return self.mesh.GetNodesId()
2554 # Get the information about mesh elements:
2555 # ------------------------------------
2557 ## Return the type of mesh element
2558 # @return the value from SMESH::ElementType enumeration
2559 # Type SMESH.ElementType._items in the Python Console to see all possible values.
2560 # @ingroup l1_meshinfo
2561 def GetElementType(self, id, iselem=True):
2562 return self.mesh.GetElementType(id, iselem)
2564 ## Return the geometric type of mesh element
2565 # @return the value from SMESH::EntityType enumeration
2566 # Type SMESH.EntityType._items in the Python Console to see all possible values.
2567 # @ingroup l1_meshinfo
2568 def GetElementGeomType(self, id):
2569 return self.mesh.GetElementGeomType(id)
2571 ## Return the shape type of mesh element
2572 # @return the value from SMESH::GeometryType enumeration.
2573 # Type SMESH.GeometryType._items in the Python Console to see all possible values.
2574 # @ingroup l1_meshinfo
2575 def GetElementShape(self, id):
2576 return self.mesh.GetElementShape(id)
2578 ## Return the list of submesh elements IDs
2579 # @param Shape a geom object(sub-shape)
2580 # Shape must be the sub-shape of a ShapeToMesh()
2581 # @return the list of integer values
2582 # @ingroup l1_meshinfo
2583 def GetSubMeshElementsId(self, Shape):
2584 if isinstance( Shape, geomBuilder.GEOM._objref_GEOM_Object):
2585 ShapeID = self.geompyD.GetSubShapeID( self.geom, Shape )
2588 return self.mesh.GetSubMeshElementsId(ShapeID)
2590 ## Return the list of submesh nodes IDs
2591 # @param Shape a geom object(sub-shape)
2592 # Shape must be the sub-shape of a ShapeToMesh()
2593 # @param all If true, gives all nodes of submesh elements, otherwise gives only submesh nodes
2594 # @return the list of integer values
2595 # @ingroup l1_meshinfo
2596 def GetSubMeshNodesId(self, Shape, all):
2597 if isinstance( Shape, geomBuilder.GEOM._objref_GEOM_Object):
2598 ShapeID = self.geompyD.GetSubShapeID( self.geom, Shape )
2601 return self.mesh.GetSubMeshNodesId(ShapeID, all)
2603 ## Return type of elements on given shape
2604 # @param Shape a geom object(sub-shape)
2605 # Shape must be a sub-shape of a ShapeToMesh()
2606 # @return element type
2607 # @ingroup l1_meshinfo
2608 def GetSubMeshElementType(self, Shape):
2609 if isinstance( Shape, geomBuilder.GEOM._objref_GEOM_Object):
2610 ShapeID = self.geompyD.GetSubShapeID( self.geom, Shape )
2613 return self.mesh.GetSubMeshElementType(ShapeID)
2615 ## Get the mesh description
2616 # @return string value
2617 # @ingroup l1_meshinfo
2619 return self.mesh.Dump()
2622 # Get the information about nodes and elements of a mesh by its IDs:
2623 # -----------------------------------------------------------
2625 ## Get XYZ coordinates of a node
2626 # \n If there is no nodes for the given ID - return an empty list
2627 # @return a list of double precision values
2628 # @ingroup l1_meshinfo
2629 def GetNodeXYZ(self, id):
2630 return self.mesh.GetNodeXYZ(id)
2632 ## Return list of IDs of inverse elements for the given node
2633 # \n If there is no node for the given ID - return an empty list
2634 # @return a list of integer values
2635 # @ingroup l1_meshinfo
2636 def GetNodeInverseElements(self, id):
2637 return self.mesh.GetNodeInverseElements(id)
2639 ## Return the position of a node on the shape
2640 # @return SMESH::NodePosition
2641 # @ingroup l1_meshinfo
2642 def GetNodePosition(self,NodeID):
2643 return self.mesh.GetNodePosition(NodeID)
2645 ## Return the position of an element on the shape
2646 # @return SMESH::ElementPosition
2647 # @ingroup l1_meshinfo
2648 def GetElementPosition(self,ElemID):
2649 return self.mesh.GetElementPosition(ElemID)
2651 ## Return the ID of the shape, on which the given node was generated.
2652 # @return an integer value > 0 or -1 if there is no node for the given
2653 # ID or the node is not assigned to any geometry
2654 # @ingroup l1_meshinfo
2655 def GetShapeID(self, id):
2656 return self.mesh.GetShapeID(id)
2658 ## Return the ID of the shape, on which the given element was generated.
2659 # @return an integer value > 0 or -1 if there is no element for the given
2660 # ID or the element is not assigned to any geometry
2661 # @ingroup l1_meshinfo
2662 def GetShapeIDForElem(self,id):
2663 return self.mesh.GetShapeIDForElem(id)
2665 ## Return the number of nodes of the given element
2666 # @return an integer value > 0 or -1 if there is no element for the given ID
2667 # @ingroup l1_meshinfo
2668 def GetElemNbNodes(self, id):
2669 return self.mesh.GetElemNbNodes(id)
2671 ## Return the node ID the given (zero based) index for the given element
2672 # \n If there is no element for the given ID - return -1
2673 # \n If there is no node for the given index - return -2
2674 # @return an integer value
2675 # @ingroup l1_meshinfo
2676 def GetElemNode(self, id, index):
2677 return self.mesh.GetElemNode(id, index)
2679 ## Return the IDs of nodes of the given element
2680 # @return a list of integer values
2681 # @ingroup l1_meshinfo
2682 def GetElemNodes(self, id):
2683 return self.mesh.GetElemNodes(id)
2685 ## Return true if the given node is the medium node in the given quadratic element
2686 # @ingroup l1_meshinfo
2687 def IsMediumNode(self, elementID, nodeID):
2688 return self.mesh.IsMediumNode(elementID, nodeID)
2690 ## Return true if the given node is the medium node in one of quadratic elements
2691 # @param nodeID ID of the node
2692 # @param elementType the type of elements to check a state of the node, either of
2693 # (SMESH.ALL, SMESH.NODE, SMESH.EDGE, SMESH.FACE or SMESH.VOLUME)
2694 # @ingroup l1_meshinfo
2695 def IsMediumNodeOfAnyElem(self, nodeID, elementType = SMESH.ALL ):
2696 return self.mesh.IsMediumNodeOfAnyElem(nodeID, elementType)
2698 ## Return the number of edges for the given element
2699 # @ingroup l1_meshinfo
2700 def ElemNbEdges(self, id):
2701 return self.mesh.ElemNbEdges(id)
2703 ## Return the number of faces for the given element
2704 # @ingroup l1_meshinfo
2705 def ElemNbFaces(self, id):
2706 return self.mesh.ElemNbFaces(id)
2708 ## Return nodes of given face (counted from zero) for given volumic element.
2709 # @ingroup l1_meshinfo
2710 def GetElemFaceNodes(self,elemId, faceIndex):
2711 return self.mesh.GetElemFaceNodes(elemId, faceIndex)
2713 ## Return three components of normal of given mesh face
2714 # (or an empty array in KO case)
2715 # @ingroup l1_meshinfo
2716 def GetFaceNormal(self, faceId, normalized=False):
2717 return self.mesh.GetFaceNormal(faceId,normalized)
2719 ## Return an element based on all given nodes.
2720 # @ingroup l1_meshinfo
2721 def FindElementByNodes(self, nodes):
2722 return self.mesh.FindElementByNodes(nodes)
2724 ## Return elements including all given nodes.
2725 # @ingroup l1_meshinfo
2726 def GetElementsByNodes(self, nodes, elemType=SMESH.ALL):
2727 return self.mesh.GetElementsByNodes( nodes, elemType )
2729 ## Return true if the given element is a polygon
2730 # @ingroup l1_meshinfo
2731 def IsPoly(self, id):
2732 return self.mesh.IsPoly(id)
2734 ## Return true if the given element is quadratic
2735 # @ingroup l1_meshinfo
2736 def IsQuadratic(self, id):
2737 return self.mesh.IsQuadratic(id)
2739 ## Return diameter of a ball discrete element or zero in case of an invalid \a id
2740 # @ingroup l1_meshinfo
2741 def GetBallDiameter(self, id):
2742 return self.mesh.GetBallDiameter(id)
2744 ## Return XYZ coordinates of the barycenter of the given element
2745 # \n If there is no element for the given ID - return an empty list
2746 # @return a list of three double values
2747 # @ingroup l1_meshinfo
2748 def BaryCenter(self, id):
2749 return self.mesh.BaryCenter(id)
2751 ## Pass mesh elements through the given filter and return IDs of fitting elements
2752 # @param theFilter SMESH_Filter
2753 # @return a list of ids
2754 # @ingroup l1_controls
2755 def GetIdsFromFilter(self, theFilter):
2756 theFilter.SetMesh( self.mesh )
2757 return theFilter.GetIDs()
2759 # Get mesh measurements information:
2760 # ------------------------------------
2762 ## Verify whether a 2D mesh element has free edges (edges connected to one face only)\n
2763 # Return a list of special structures (borders).
2764 # @return a list of SMESH.FreeEdges.Border structure: edge id and ids of two its nodes.
2765 # @ingroup l1_measurements
2766 def GetFreeBorders(self):
2767 aFilterMgr = self.smeshpyD.CreateFilterManager()
2768 aPredicate = aFilterMgr.CreateFreeEdges()
2769 aPredicate.SetMesh(self.mesh)
2770 aBorders = aPredicate.GetBorders()
2771 aFilterMgr.UnRegister()
2774 ## Get minimum distance between two nodes, elements or distance to the origin
2775 # @param id1 first node/element id
2776 # @param id2 second node/element id (if 0, distance from @a id1 to the origin is computed)
2777 # @param isElem1 @c True if @a id1 is element id, @c False if it is node id
2778 # @param isElem2 @c True if @a id2 is element id, @c False if it is node id
2779 # @return minimum distance value
2780 # @sa GetMinDistance()
2781 # @ingroup l1_measurements
2782 def MinDistance(self, id1, id2=0, isElem1=False, isElem2=False):
2783 aMeasure = self.GetMinDistance(id1, id2, isElem1, isElem2)
2784 return aMeasure.value
2786 ## Get measure structure specifying minimum distance data between two objects
2787 # @param id1 first node/element id
2788 # @param id2 second node/element id (if 0, distance from @a id1 to the origin is computed)
2789 # @param isElem1 @c True if @a id1 is element id, @c False if it is node id
2790 # @param isElem2 @c True if @a id2 is element id, @c False if it is node id
2791 # @return Measure structure
2793 # @ingroup l1_measurements
2794 def GetMinDistance(self, id1, id2=0, isElem1=False, isElem2=False):
2796 id1 = self.editor.MakeIDSource([id1], SMESH.FACE)
2798 id1 = self.editor.MakeIDSource([id1], SMESH.NODE)
2801 id2 = self.editor.MakeIDSource([id2], SMESH.FACE)
2803 id2 = self.editor.MakeIDSource([id2], SMESH.NODE)
2808 aMeasurements = self.smeshpyD.CreateMeasurements()
2809 aMeasure = aMeasurements.MinDistance(id1, id2)
2810 genObjUnRegister([aMeasurements,id1, id2])
2813 ## Get bounding box of the specified object(s)
2814 # @param objects single source object or list of source objects or list of nodes/elements IDs
2815 # @param isElem if @a objects is a list of IDs, @c True value in this parameters specifies that @a objects are elements,
2816 # @c False specifies that @a objects are nodes
2817 # @return tuple of six values (minX, minY, minZ, maxX, maxY, maxZ)
2818 # @sa GetBoundingBox()
2819 # @ingroup l1_measurements
2820 def BoundingBox(self, objects=None, isElem=False):
2821 result = self.GetBoundingBox(objects, isElem)
2825 result = (result.minX, result.minY, result.minZ, result.maxX, result.maxY, result.maxZ)
2828 ## Get measure structure specifying bounding box data of the specified object(s)
2829 # @param IDs single source object or list of source objects or list of nodes/elements IDs
2830 # @param isElem if @a IDs is a list of IDs, @c True value in this parameters specifies that @a objects are elements,
2831 # @c False specifies that @a objects are nodes
2832 # @return Measure structure
2834 # @ingroup l1_measurements
2835 def GetBoundingBox(self, IDs=None, isElem=False):
2838 elif isinstance(IDs, tuple):
2840 if not isinstance(IDs, list):
2842 if len(IDs) > 0 and isinstance(IDs[0], int):
2845 unRegister = genObjUnRegister()
2847 if isinstance(o, Mesh):
2848 srclist.append(o.mesh)
2849 elif hasattr(o, "_narrow"):
2850 src = o._narrow(SMESH.SMESH_IDSource)
2851 if src: srclist.append(src)
2853 elif isinstance(o, list):
2855 srclist.append(self.editor.MakeIDSource(o, SMESH.FACE))
2857 srclist.append(self.editor.MakeIDSource(o, SMESH.NODE))
2858 unRegister.set( srclist[-1] )
2861 aMeasurements = self.smeshpyD.CreateMeasurements()
2862 unRegister.set( aMeasurements )
2863 aMeasure = aMeasurements.BoundingBox(srclist)
2866 # Mesh edition (SMESH_MeshEditor functionality):
2867 # ---------------------------------------------
2869 ## Remove the elements from the mesh by ids
2870 # @param IDsOfElements is a list of ids of elements to remove
2871 # @return True or False
2872 # @ingroup l2_modif_del
2873 def RemoveElements(self, IDsOfElements):
2874 return self.editor.RemoveElements(IDsOfElements)
2876 ## Remove nodes from mesh by ids
2877 # @param IDsOfNodes is a list of ids of nodes to remove
2878 # @return True or False
2879 # @ingroup l2_modif_del
2880 def RemoveNodes(self, IDsOfNodes):
2881 return self.editor.RemoveNodes(IDsOfNodes)
2883 ## Remove all orphan (free) nodes from mesh
2884 # @return number of the removed nodes
2885 # @ingroup l2_modif_del
2886 def RemoveOrphanNodes(self):
2887 return self.editor.RemoveOrphanNodes()
2889 ## Add a node to the mesh by coordinates
2890 # @return Id of the new node
2891 # @ingroup l2_modif_add
2892 def AddNode(self, x, y, z):
2893 x,y,z,Parameters,hasVars = ParseParameters(x,y,z)
2894 if hasVars: self.mesh.SetParameters(Parameters)
2895 return self.editor.AddNode( x, y, z)
2897 ## Create a 0D element on a node with given number.
2898 # @param IDOfNode the ID of node for creation of the element.
2899 # @param DuplicateElements to add one more 0D element to a node or not
2900 # @return the Id of the new 0D element
2901 # @ingroup l2_modif_add
2902 def Add0DElement( self, IDOfNode, DuplicateElements=True ):
2903 return self.editor.Add0DElement( IDOfNode, DuplicateElements )
2905 ## Create 0D elements on all nodes of the given elements except those
2906 # nodes on which a 0D element already exists.
2907 # @param theObject an object on whose nodes 0D elements will be created.
2908 # It can be mesh, sub-mesh, group, list of element IDs or a holder
2909 # of nodes IDs created by calling mesh.GetIDSource( nodes, SMESH.NODE )
2910 # @param theGroupName optional name of a group to add 0D elements created
2911 # and/or found on nodes of \a theObject.
2912 # @param DuplicateElements to add one more 0D element to a node or not
2913 # @return an object (a new group or a temporary SMESH_IDSource) holding
2914 # IDs of new and/or found 0D elements. IDs of 0D elements
2915 # can be retrieved from the returned object by calling GetIDs()
2916 # @ingroup l2_modif_add
2917 def Add0DElementsToAllNodes(self, theObject, theGroupName="", DuplicateElements=False):
2918 unRegister = genObjUnRegister()
2919 if isinstance( theObject, Mesh ):
2920 theObject = theObject.GetMesh()
2921 elif isinstance( theObject, list ):
2922 theObject = self.GetIDSource( theObject, SMESH.ALL )
2923 unRegister.set( theObject )
2924 return self.editor.Create0DElementsOnAllNodes( theObject, theGroupName, DuplicateElements )
2926 ## Create a ball element on a node with given ID.
2927 # @param IDOfNode the ID of node for creation of the element.
2928 # @param diameter the bal diameter.
2929 # @return the Id of the new ball element
2930 # @ingroup l2_modif_add
2931 def AddBall(self, IDOfNode, diameter):
2932 return self.editor.AddBall( IDOfNode, diameter )
2934 ## Create a linear or quadratic edge (this is determined
2935 # by the number of given nodes).
2936 # @param IDsOfNodes the list of node IDs for creation of the element.
2937 # The order of nodes in this list should correspond to the description
2938 # of MED. \n This description is located by the following link:
2939 # http://www.code-aster.org/outils/med/html/modele_de_donnees.html#3.
2940 # @return the Id of the new edge
2941 # @ingroup l2_modif_add
2942 def AddEdge(self, IDsOfNodes):
2943 return self.editor.AddEdge(IDsOfNodes)
2945 ## Create a linear or quadratic face (this is determined
2946 # by the number of given nodes).
2947 # @param IDsOfNodes the list of node IDs for creation of the element.
2948 # The order of nodes in this list should correspond to the description
2949 # of MED. \n This description is located by the following link:
2950 # http://www.code-aster.org/outils/med/html/modele_de_donnees.html#3.
2951 # @return the Id of the new face
2952 # @ingroup l2_modif_add
2953 def AddFace(self, IDsOfNodes):
2954 return self.editor.AddFace(IDsOfNodes)
2956 ## Add a polygonal face to the mesh by the list of node IDs
2957 # @param IdsOfNodes the list of node IDs for creation of the element.
2958 # @return the Id of the new face
2959 # @ingroup l2_modif_add
2960 def AddPolygonalFace(self, IdsOfNodes):
2961 return self.editor.AddPolygonalFace(IdsOfNodes)
2963 ## Add a quadratic polygonal face to the mesh by the list of node IDs
2964 # @param IdsOfNodes the list of node IDs for creation of the element;
2965 # corner nodes follow first.
2966 # @return the Id of the new face
2967 # @ingroup l2_modif_add
2968 def AddQuadPolygonalFace(self, IdsOfNodes):
2969 return self.editor.AddQuadPolygonalFace(IdsOfNodes)
2971 ## Create both simple and quadratic volume (this is determined
2972 # by the number of given nodes).
2973 # @param IDsOfNodes the list of node IDs for creation of the element.
2974 # The order of nodes in this list should correspond to the description
2975 # of MED. \n This description is located by the following link:
2976 # http://www.code-aster.org/outils/med/html/modele_de_donnees.html#3.
2977 # @return the Id of the new volumic element
2978 # @ingroup l2_modif_add
2979 def AddVolume(self, IDsOfNodes):
2980 return self.editor.AddVolume(IDsOfNodes)
2982 ## Create a volume of many faces, giving nodes for each face.
2983 # @param IdsOfNodes the list of node IDs for volume creation face by face.
2984 # @param Quantities the list of integer values, Quantities[i]
2985 # gives the quantity of nodes in face number i.
2986 # @return the Id of the new volumic element
2987 # @ingroup l2_modif_add
2988 def AddPolyhedralVolume (self, IdsOfNodes, Quantities):
2989 return self.editor.AddPolyhedralVolume(IdsOfNodes, Quantities)
2991 ## Create a volume of many faces, giving the IDs of the existing faces.
2992 # @param IdsOfFaces the list of face IDs for volume creation.
2994 # Note: The created volume will refer only to the nodes
2995 # of the given faces, not to the faces themselves.
2996 # @return the Id of the new volumic element
2997 # @ingroup l2_modif_add
2998 def AddPolyhedralVolumeByFaces (self, IdsOfFaces):
2999 return self.editor.AddPolyhedralVolumeByFaces(IdsOfFaces)
3002 ## @brief Binds a node to a vertex
3003 # @param NodeID a node ID
3004 # @param Vertex a vertex or vertex ID
3005 # @return True if succeed else raises an exception
3006 # @ingroup l2_modif_add
3007 def SetNodeOnVertex(self, NodeID, Vertex):
3008 if ( isinstance( Vertex, geomBuilder.GEOM._objref_GEOM_Object)):
3009 VertexID = self.geompyD.GetSubShapeID( self.geom, Vertex )
3013 self.editor.SetNodeOnVertex(NodeID, VertexID)
3014 except SALOME.SALOME_Exception, inst:
3015 raise ValueError, inst.details.text
3019 ## @brief Stores the node position on an edge
3020 # @param NodeID a node ID
3021 # @param Edge an edge or edge ID
3022 # @param paramOnEdge a parameter on the edge where the node is located
3023 # @return True if succeed else raises an exception
3024 # @ingroup l2_modif_add
3025 def SetNodeOnEdge(self, NodeID, Edge, paramOnEdge):
3026 if ( isinstance( Edge, geomBuilder.GEOM._objref_GEOM_Object)):
3027 EdgeID = self.geompyD.GetSubShapeID( self.geom, Edge )
3031 self.editor.SetNodeOnEdge(NodeID, EdgeID, paramOnEdge)
3032 except SALOME.SALOME_Exception, inst:
3033 raise ValueError, inst.details.text
3036 ## @brief Stores node position on a face
3037 # @param NodeID a node ID
3038 # @param Face a face or face ID
3039 # @param u U parameter on the face where the node is located
3040 # @param v V parameter on the face where the node is located
3041 # @return True if succeed else raises an exception
3042 # @ingroup l2_modif_add
3043 def SetNodeOnFace(self, NodeID, Face, u, v):
3044 if ( isinstance( Face, geomBuilder.GEOM._objref_GEOM_Object)):
3045 FaceID = self.geompyD.GetSubShapeID( self.geom, Face )
3049 self.editor.SetNodeOnFace(NodeID, FaceID, u, v)
3050 except SALOME.SALOME_Exception, inst:
3051 raise ValueError, inst.details.text
3054 ## @brief Binds a node to a solid
3055 # @param NodeID a node ID
3056 # @param Solid a solid or solid ID
3057 # @return True if succeed else raises an exception
3058 # @ingroup l2_modif_add
3059 def SetNodeInVolume(self, NodeID, Solid):
3060 if ( isinstance( Solid, geomBuilder.GEOM._objref_GEOM_Object)):
3061 SolidID = self.geompyD.GetSubShapeID( self.geom, Solid )
3065 self.editor.SetNodeInVolume(NodeID, SolidID)
3066 except SALOME.SALOME_Exception, inst:
3067 raise ValueError, inst.details.text
3070 ## @brief Bind an element to a shape
3071 # @param ElementID an element ID
3072 # @param Shape a shape or shape ID
3073 # @return True if succeed else raises an exception
3074 # @ingroup l2_modif_add
3075 def SetMeshElementOnShape(self, ElementID, Shape):
3076 if ( isinstance( Shape, geomBuilder.GEOM._objref_GEOM_Object)):
3077 ShapeID = self.geompyD.GetSubShapeID( self.geom, Shape )
3081 self.editor.SetMeshElementOnShape(ElementID, ShapeID)
3082 except SALOME.SALOME_Exception, inst:
3083 raise ValueError, inst.details.text
3087 ## Move the node with the given id
3088 # @param NodeID the id of the node
3089 # @param x a new X coordinate
3090 # @param y a new Y coordinate
3091 # @param z a new Z coordinate
3092 # @return True if succeed else False
3093 # @ingroup l2_modif_edit
3094 def MoveNode(self, NodeID, x, y, z):
3095 x,y,z,Parameters,hasVars = ParseParameters(x,y,z)
3096 if hasVars: self.mesh.SetParameters(Parameters)
3097 return self.editor.MoveNode(NodeID, x, y, z)
3099 ## Find the node closest to a point and moves it to a point location
3100 # @param x the X coordinate of a point
3101 # @param y the Y coordinate of a point
3102 # @param z the Z coordinate of a point
3103 # @param NodeID if specified (>0), the node with this ID is moved,
3104 # otherwise, the node closest to point (@a x,@a y,@a z) is moved
3105 # @return the ID of a node
3106 # @ingroup l2_modif_edit
3107 def MoveClosestNodeToPoint(self, x, y, z, NodeID):
3108 x,y,z,Parameters,hasVars = ParseParameters(x,y,z)
3109 if hasVars: self.mesh.SetParameters(Parameters)
3110 return self.editor.MoveClosestNodeToPoint(x, y, z, NodeID)
3112 ## Find the node closest to a point
3113 # @param x the X coordinate of a point
3114 # @param y the Y coordinate of a point
3115 # @param z the Z coordinate of a point
3116 # @return the ID of a node
3117 # @ingroup l1_meshinfo
3118 def FindNodeClosestTo(self, x, y, z):
3119 #preview = self.mesh.GetMeshEditPreviewer()
3120 #return preview.MoveClosestNodeToPoint(x, y, z, -1)
3121 return self.editor.FindNodeClosestTo(x, y, z)
3123 ## Find the elements where a point lays IN or ON
3124 # @param x the X coordinate of a point
3125 # @param y the Y coordinate of a point
3126 # @param z the Z coordinate of a point
3127 # @param elementType type of elements to find; either of
3128 # (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME); SMESH.ALL type
3129 # means elements of any type excluding nodes, discrete and 0D elements.
3130 # @param meshPart a part of mesh (group, sub-mesh) to search within
3131 # @return list of IDs of found elements
3132 # @ingroup l1_meshinfo
3133 def FindElementsByPoint(self, x, y, z, elementType = SMESH.ALL, meshPart=None):
3135 return self.editor.FindAmongElementsByPoint( meshPart, x, y, z, elementType );
3137 return self.editor.FindElementsByPoint(x, y, z, elementType)
3139 ## Return point state in a closed 2D mesh in terms of TopAbs_State enumeration:
3140 # 0-IN, 1-OUT, 2-ON, 3-UNKNOWN
3141 # UNKNOWN state means that either mesh is wrong or the analysis fails.
3142 # @ingroup l1_meshinfo
3143 def GetPointState(self, x, y, z):
3144 return self.editor.GetPointState(x, y, z)
3146 ## Check if a 2D mesh is manifold
3147 # @ingroup l1_controls
3148 def IsManifold(self):
3149 return self.editor.IsManifold()
3151 ## Check if orientation of 2D elements is coherent
3152 # @ingroup l1_controls
3153 def IsCoherentOrientation2D(self):
3154 return self.editor.IsCoherentOrientation2D()
3156 ## Find the node closest to a point and moves it to a point location
3157 # @param x the X coordinate of a point
3158 # @param y the Y coordinate of a point
3159 # @param z the Z coordinate of a point
3160 # @return the ID of a moved node
3161 # @ingroup l2_modif_edit
3162 def MeshToPassThroughAPoint(self, x, y, z):
3163 return self.editor.MoveClosestNodeToPoint(x, y, z, -1)
3165 ## Replace two neighbour triangles sharing Node1-Node2 link
3166 # with the triangles built on the same 4 nodes but having other common link.
3167 # @param NodeID1 the ID of the first node
3168 # @param NodeID2 the ID of the second node
3169 # @return false if proper faces were not found
3170 # @ingroup l2_modif_cutquadr
3171 def InverseDiag(self, NodeID1, NodeID2):
3172 return self.editor.InverseDiag(NodeID1, NodeID2)
3174 ## Replace two neighbour triangles sharing Node1-Node2 link
3175 # with a quadrangle built on the same 4 nodes.
3176 # @param NodeID1 the ID of the first node
3177 # @param NodeID2 the ID of the second node
3178 # @return false if proper faces were not found
3179 # @ingroup l2_modif_unitetri
3180 def DeleteDiag(self, NodeID1, NodeID2):
3181 return self.editor.DeleteDiag(NodeID1, NodeID2)
3183 ## Reorient elements by ids
3184 # @param IDsOfElements if undefined reorients all mesh elements
3185 # @return True if succeed else False
3186 # @ingroup l2_modif_changori
3187 def Reorient(self, IDsOfElements=None):
3188 if IDsOfElements == None:
3189 IDsOfElements = self.GetElementsId()
3190 return self.editor.Reorient(IDsOfElements)
3192 ## Reorient all elements of the object
3193 # @param theObject mesh, submesh or group
3194 # @return True if succeed else False
3195 # @ingroup l2_modif_changori
3196 def ReorientObject(self, theObject):
3197 if ( isinstance( theObject, Mesh )):
3198 theObject = theObject.GetMesh()
3199 return self.editor.ReorientObject(theObject)
3201 ## Reorient faces contained in \a the2DObject.
3202 # @param the2DObject is a mesh, sub-mesh, group or list of IDs of 2D elements
3203 # @param theDirection is a desired direction of normal of \a theFace.
3204 # It can be either a GEOM vector or a list of coordinates [x,y,z].
3205 # @param theFaceOrPoint defines a face of \a the2DObject whose normal will be
3206 # compared with theDirection. It can be either ID of face or a point
3207 # by which the face will be found. The point can be given as either
3208 # a GEOM vertex or a list of point coordinates.
3209 # @return number of reoriented faces
3210 # @ingroup l2_modif_changori
3211 def Reorient2D(self, the2DObject, theDirection, theFaceOrPoint ):
3212 unRegister = genObjUnRegister()
3214 if isinstance( the2DObject, Mesh ):
3215 the2DObject = the2DObject.GetMesh()
3216 if isinstance( the2DObject, list ):
3217 the2DObject = self.GetIDSource( the2DObject, SMESH.FACE )
3218 unRegister.set( the2DObject )
3219 # check theDirection
3220 if isinstance( theDirection, geomBuilder.GEOM._objref_GEOM_Object):
3221 theDirection = self.smeshpyD.GetDirStruct( theDirection )
3222 if isinstance( theDirection, list ):
3223 theDirection = self.smeshpyD.MakeDirStruct( *theDirection )
3224 # prepare theFace and thePoint
3225 theFace = theFaceOrPoint
3226 thePoint = PointStruct(0,0,0)
3227 if isinstance( theFaceOrPoint, geomBuilder.GEOM._objref_GEOM_Object):
3228 thePoint = self.smeshpyD.GetPointStruct( theFaceOrPoint )
3230 if isinstance( theFaceOrPoint, list ):
3231 thePoint = PointStruct( *theFaceOrPoint )
3233 if isinstance( theFaceOrPoint, PointStruct ):
3234 thePoint = theFaceOrPoint
3236 return self.editor.Reorient2D( the2DObject, theDirection, theFace, thePoint )
3238 ## Reorient faces according to adjacent volumes.
3239 # @param the2DObject is a mesh, sub-mesh, group or list of
3240 # either IDs of faces or face groups.
3241 # @param the3DObject is a mesh, sub-mesh, group or list of IDs of volumes.
3242 # @param theOutsideNormal to orient faces to have their normals
3243 # pointing either \a outside or \a inside the adjacent volumes.
3244 # @return number of reoriented faces.
3245 # @ingroup l2_modif_changori
3246 def Reorient2DBy3D(self, the2DObject, the3DObject, theOutsideNormal=True ):
3247 unRegister = genObjUnRegister()
3249 if not isinstance( the2DObject, list ):
3250 the2DObject = [ the2DObject ]
3251 elif the2DObject and isinstance( the2DObject[0], int ):
3252 the2DObject = self.GetIDSource( the2DObject, SMESH.FACE )
3253 unRegister.set( the2DObject )
3254 the2DObject = [ the2DObject ]
3255 for i,obj2D in enumerate( the2DObject ):
3256 if isinstance( obj2D, Mesh ):
3257 the2DObject[i] = obj2D.GetMesh()
3258 if isinstance( obj2D, list ):
3259 the2DObject[i] = self.GetIDSource( obj2D, SMESH.FACE )
3260 unRegister.set( the2DObject[i] )
3262 if isinstance( the3DObject, Mesh ):
3263 the3DObject = the3DObject.GetMesh()
3264 if isinstance( the3DObject, list ):
3265 the3DObject = self.GetIDSource( the3DObject, SMESH.VOLUME )
3266 unRegister.set( the3DObject )
3267 return self.editor.Reorient2DBy3D( the2DObject, the3DObject, theOutsideNormal )
3269 ## Fuse the neighbouring triangles into quadrangles.
3270 # @param IDsOfElements The triangles to be fused.
3271 # @param theCriterion a numerical functor, in terms of enum SMESH.FunctorType, used to
3272 # applied to possible quadrangles to choose a neighbour to fuse with.
3273 # Type SMESH.FunctorType._items in the Python Console to see all items.
3274 # Note that not all items correspond to numerical functors.
3275 # @param MaxAngle is the maximum angle between element normals at which the fusion
3276 # is still performed; theMaxAngle is measured in radians.
3277 # Also it could be a name of variable which defines angle in degrees.
3278 # @return TRUE in case of success, FALSE otherwise.
3279 # @ingroup l2_modif_unitetri
3280 def TriToQuad(self, IDsOfElements, theCriterion, MaxAngle):
3281 MaxAngle,Parameters,hasVars = ParseAngles(MaxAngle)
3282 self.mesh.SetParameters(Parameters)
3283 if not IDsOfElements:
3284 IDsOfElements = self.GetElementsId()
3285 Functor = self.smeshpyD.GetFunctor(theCriterion)
3286 return self.editor.TriToQuad(IDsOfElements, Functor, MaxAngle)
3288 ## Fuse the neighbouring triangles of the object into quadrangles
3289 # @param theObject is mesh, submesh or group
3290 # @param theCriterion is a numerical functor, in terms of enum SMESH.FunctorType,
3291 # applied to possible quadrangles to choose a neighbour to fuse with.
3292 # Type SMESH.FunctorType._items in the Python Console to see all items.
3293 # Note that not all items correspond to numerical functors.
3294 # @param MaxAngle a max angle between element normals at which the fusion
3295 # is still performed; theMaxAngle is measured in radians.
3296 # @return TRUE in case of success, FALSE otherwise.
3297 # @ingroup l2_modif_unitetri
3298 def TriToQuadObject (self, theObject, theCriterion, MaxAngle):
3299 MaxAngle,Parameters,hasVars = ParseAngles(MaxAngle)
3300 self.mesh.SetParameters(Parameters)
3301 if isinstance( theObject, Mesh ):
3302 theObject = theObject.GetMesh()
3303 Functor = self.smeshpyD.GetFunctor(theCriterion)
3304 return self.editor.TriToQuadObject(theObject, Functor, MaxAngle)
3306 ## Split quadrangles into triangles.
3307 # @param IDsOfElements the faces to be split.
3308 # @param theCriterion is a numerical functor, in terms of enum SMESH.FunctorType, used to
3309 # choose a diagonal for splitting. If @a theCriterion is None, which is a default
3310 # value, then quadrangles will be split by the smallest diagonal.
3311 # Type SMESH.FunctorType._items in the Python Console to see all items.
3312 # Note that not all items correspond to numerical functors.
3313 # @return TRUE in case of success, FALSE otherwise.
3314 # @ingroup l2_modif_cutquadr
3315 def QuadToTri (self, IDsOfElements, theCriterion = None):
3316 if IDsOfElements == []:
3317 IDsOfElements = self.GetElementsId()
3318 if theCriterion is None:
3319 theCriterion = FT_MaxElementLength2D
3320 Functor = self.smeshpyD.GetFunctor(theCriterion)
3321 return self.editor.QuadToTri(IDsOfElements, Functor)
3323 ## Split quadrangles into triangles.
3324 # @param theObject the object from which the list of elements is taken,
3325 # this is mesh, submesh or group
3326 # @param theCriterion is a numerical functor, in terms of enum SMESH.FunctorType, used to
3327 # choose a diagonal for splitting. If @a theCriterion is None, which is a default
3328 # value, then quadrangles will be split by the smallest diagonal.
3329 # Type SMESH.FunctorType._items in the Python Console to see all items.
3330 # Note that not all items correspond to numerical functors.
3331 # @return TRUE in case of success, FALSE otherwise.
3332 # @ingroup l2_modif_cutquadr
3333 def QuadToTriObject (self, theObject, theCriterion = None):
3334 if ( isinstance( theObject, Mesh )):
3335 theObject = theObject.GetMesh()
3336 if theCriterion is None:
3337 theCriterion = FT_MaxElementLength2D
3338 Functor = self.smeshpyD.GetFunctor(theCriterion)
3339 return self.editor.QuadToTriObject(theObject, Functor)
3341 ## Split each of given quadrangles into 4 triangles. A node is added at the center of
3343 # @param theElements the faces to be split. This can be either mesh, sub-mesh,
3344 # group or a list of face IDs. By default all quadrangles are split
3345 # @ingroup l2_modif_cutquadr
3346 def QuadTo4Tri (self, theElements=[]):
3347 unRegister = genObjUnRegister()
3348 if isinstance( theElements, Mesh ):
3349 theElements = theElements.mesh
3350 elif not theElements:
3351 theElements = self.mesh
3352 elif isinstance( theElements, list ):
3353 theElements = self.GetIDSource( theElements, SMESH.FACE )
3354 unRegister.set( theElements )
3355 return self.editor.QuadTo4Tri( theElements )
3357 ## Split quadrangles into triangles.
3358 # @param IDsOfElements the faces to be split
3359 # @param Diag13 is used to choose a diagonal for splitting.
3360 # @return TRUE in case of success, FALSE otherwise.
3361 # @ingroup l2_modif_cutquadr
3362 def SplitQuad (self, IDsOfElements, Diag13):
3363 if IDsOfElements == []:
3364 IDsOfElements = self.GetElementsId()
3365 return self.editor.SplitQuad(IDsOfElements, Diag13)
3367 ## Split quadrangles into triangles.
3368 # @param theObject the object from which the list of elements is taken,
3369 # this is mesh, submesh or group
3370 # @param Diag13 is used to choose a diagonal for splitting.
3371 # @return TRUE in case of success, FALSE otherwise.
3372 # @ingroup l2_modif_cutquadr
3373 def SplitQuadObject (self, theObject, Diag13):
3374 if ( isinstance( theObject, Mesh )):
3375 theObject = theObject.GetMesh()
3376 return self.editor.SplitQuadObject(theObject, Diag13)
3378 ## Find a better splitting of the given quadrangle.
3379 # @param IDOfQuad the ID of the quadrangle to be split.
3380 # @param theCriterion is a numerical functor, in terms of enum SMESH.FunctorType, used to
3381 # choose a diagonal for splitting.
3382 # Type SMESH.FunctorType._items in the Python Console to see all items.
3383 # Note that not all items correspond to numerical functors.
3384 # @return 1 if 1-3 diagonal is better, 2 if 2-4
3385 # diagonal is better, 0 if error occurs.
3386 # @ingroup l2_modif_cutquadr
3387 def BestSplit (self, IDOfQuad, theCriterion):
3388 return self.editor.BestSplit(IDOfQuad, self.smeshpyD.GetFunctor(theCriterion))
3390 ## Split volumic elements into tetrahedrons
3391 # @param elems either a list of elements or a mesh or a group or a submesh or a filter
3392 # @param method flags passing splitting method:
3393 # smesh.Hex_5Tet, smesh.Hex_6Tet, smesh.Hex_24Tet.
3394 # smesh.Hex_5Tet - to split the hexahedron into 5 tetrahedrons, etc.
3395 # @ingroup l2_modif_cutquadr
3396 def SplitVolumesIntoTetra(self, elems, method=smeshBuilder.Hex_5Tet ):
3397 unRegister = genObjUnRegister()
3398 if isinstance( elems, Mesh ):
3399 elems = elems.GetMesh()
3400 if ( isinstance( elems, list )):
3401 elems = self.editor.MakeIDSource(elems, SMESH.VOLUME)
3402 unRegister.set( elems )
3403 self.editor.SplitVolumesIntoTetra(elems, method)
3406 ## Split bi-quadratic elements into linear ones without creation of additional nodes:
3407 # - bi-quadratic triangle will be split into 3 linear quadrangles;
3408 # - bi-quadratic quadrangle will be split into 4 linear quadrangles;
3409 # - tri-quadratic hexahedron will be split into 8 linear hexahedra.
3410 # Quadratic elements of lower dimension adjacent to the split bi-quadratic element
3411 # will be split in order to keep the mesh conformal.
3412 # @param elems - elements to split: sub-meshes, groups, filters or element IDs;
3413 # if None (default), all bi-quadratic elements will be split
3414 # @ingroup l2_modif_cutquadr
3415 def SplitBiQuadraticIntoLinear(self, elems=None):
3416 unRegister = genObjUnRegister()
3417 if elems and isinstance( elems, list ) and isinstance( elems[0], int ):
3418 elems = self.editor.MakeIDSource(elems, SMESH.ALL)
3419 unRegister.set( elems )
3421 elems = [ self.GetMesh() ]
3422 if isinstance( elems, Mesh ):
3423 elems = [ elems.GetMesh() ]
3424 if not isinstance( elems, list ):
3426 self.editor.SplitBiQuadraticIntoLinear( elems )
3428 ## Split hexahedra into prisms
3429 # @param elems either a list of elements or a mesh or a group or a submesh or a filter
3430 # @param startHexPoint a point used to find a hexahedron for which @a facetNormal
3431 # gives a normal vector defining facets to split into triangles.
3432 # @a startHexPoint can be either a triple of coordinates or a vertex.
3433 # @param facetNormal a normal to a facet to split into triangles of a
3434 # hexahedron found by @a startHexPoint.
3435 # @a facetNormal can be either a triple of coordinates or an edge.
3436 # @param method flags passing splitting method: smesh.Hex_2Prisms, smesh.Hex_4Prisms.
3437 # smesh.Hex_2Prisms - to split the hexahedron into 2 prisms, etc.
3438 # @param allDomains if @c False, only hexahedra adjacent to one closest
3439 # to @a startHexPoint are split, else @a startHexPoint
3440 # is used to find the facet to split in all domains present in @a elems.
3441 # @ingroup l2_modif_cutquadr
3442 def SplitHexahedraIntoPrisms(self, elems, startHexPoint, facetNormal,
3443 method=smeshBuilder.Hex_2Prisms, allDomains=False ):
3445 unRegister = genObjUnRegister()
3446 if isinstance( elems, Mesh ):
3447 elems = elems.GetMesh()
3448 if ( isinstance( elems, list )):
3449 elems = self.editor.MakeIDSource(elems, SMESH.VOLUME)
3450 unRegister.set( elems )
3453 if isinstance( startHexPoint, geomBuilder.GEOM._objref_GEOM_Object):
3454 startHexPoint = self.smeshpyD.GetPointStruct( startHexPoint )
3455 elif isinstance( startHexPoint, list ):
3456 startHexPoint = SMESH.PointStruct( startHexPoint[0],
3459 if isinstance( facetNormal, geomBuilder.GEOM._objref_GEOM_Object):
3460 facetNormal = self.smeshpyD.GetDirStruct( facetNormal )
3461 elif isinstance( facetNormal, list ):
3462 facetNormal = self.smeshpyD.MakeDirStruct( facetNormal[0],
3465 self.mesh.SetParameters( startHexPoint.parameters + facetNormal.PS.parameters )
3467 self.editor.SplitHexahedraIntoPrisms(elems, startHexPoint, facetNormal, method, allDomains)
3469 ## Split quadrangle faces near triangular facets of volumes
3471 # @ingroup l2_modif_cutquadr
3472 def SplitQuadsNearTriangularFacets(self):
3473 faces_array = self.GetElementsByType(SMESH.FACE)
3474 for face_id in faces_array:
3475 if self.GetElemNbNodes(face_id) == 4: # quadrangle
3476 quad_nodes = self.mesh.GetElemNodes(face_id)
3477 node1_elems = self.GetNodeInverseElements(quad_nodes[1 -1])
3478 isVolumeFound = False
3479 for node1_elem in node1_elems:
3480 if not isVolumeFound:
3481 if self.GetElementType(node1_elem, True) == SMESH.VOLUME:
3482 nb_nodes = self.GetElemNbNodes(node1_elem)
3483 if 3 < nb_nodes and nb_nodes < 7: # tetra or penta, or prism
3484 volume_elem = node1_elem
3485 volume_nodes = self.mesh.GetElemNodes(volume_elem)
3486 if volume_nodes.count(quad_nodes[2 -1]) > 0: # 1,2
3487 if volume_nodes.count(quad_nodes[4 -1]) > 0: # 1,2,4
3488 isVolumeFound = True
3489 if volume_nodes.count(quad_nodes[3 -1]) == 0: # 1,2,4 & !3
3490 self.SplitQuad([face_id], False) # diagonal 2-4
3491 elif volume_nodes.count(quad_nodes[3 -1]) > 0: # 1,2,3 & !4
3492 isVolumeFound = True
3493 self.SplitQuad([face_id], True) # diagonal 1-3
3494 elif volume_nodes.count(quad_nodes[4 -1]) > 0: # 1,4 & !2
3495 if volume_nodes.count(quad_nodes[3 -1]) > 0: # 1,4,3 & !2
3496 isVolumeFound = True
3497 self.SplitQuad([face_id], True) # diagonal 1-3
3499 ## @brief Splits hexahedrons into tetrahedrons.
3501 # This operation uses pattern mapping functionality for splitting.
3502 # @param theObject the object from which the list of hexahedrons is taken; this is mesh, submesh or group.
3503 # @param theNode000,theNode001 within the range [0,7]; gives the orientation of the
3504 # pattern relatively each hexahedron: the (0,0,0) key-point of the pattern
3505 # will be mapped into <VAR>theNode000</VAR>-th node of each volume, the (0,0,1)
3506 # key-point will be mapped into <VAR>theNode001</VAR>-th node of each volume.
3507 # The (0,0,0) key-point of the used pattern corresponds to a non-split corner.
3508 # @return TRUE in case of success, FALSE otherwise.
3509 # @ingroup l2_modif_cutquadr
3510 def SplitHexaToTetras (self, theObject, theNode000, theNode001):
3511 # Pattern: 5.---------.6
3516 # (0,0,1) 4.---------.7 * |
3523 # (0,0,0) 0.---------.3
3524 pattern_tetra = "!!! Nb of points: \n 8 \n\
3534 !!! Indices of points of 6 tetras: \n\
3542 pattern = self.smeshpyD.GetPattern()
3543 isDone = pattern.LoadFromFile(pattern_tetra)
3545 print 'Pattern.LoadFromFile :', pattern.GetErrorCode()
3548 pattern.ApplyToHexahedrons(self.mesh, theObject.GetIDs(), theNode000, theNode001)
3549 isDone = pattern.MakeMesh(self.mesh, False, False)
3550 if not isDone: print 'Pattern.MakeMesh :', pattern.GetErrorCode()
3552 # split quafrangle faces near triangular facets of volumes
3553 self.SplitQuadsNearTriangularFacets()
3557 ## @brief Split hexahedrons into prisms.
3559 # Uses the pattern mapping functionality for splitting.
3560 # @param theObject the object (mesh, submesh or group) from where the list of hexahedrons is taken;
3561 # @param theNode000,theNode001 (within the range [0,7]) gives the orientation of the
3562 # pattern relatively each hexahedron: keypoint (0,0,0) of the pattern
3563 # will be mapped into the <VAR>theNode000</VAR>-th node of each volume, keypoint (0,0,1)
3564 # will be mapped into the <VAR>theNode001</VAR>-th node of each volume.
3565 # Edge (0,0,0)-(0,0,1) of used pattern connects two not split corners.
3566 # @return TRUE in case of success, FALSE otherwise.
3567 # @ingroup l2_modif_cutquadr
3568 def SplitHexaToPrisms (self, theObject, theNode000, theNode001):
3569 # Pattern: 5.---------.6
3574 # (0,0,1) 4.---------.7 |
3581 # (0,0,0) 0.---------.3
3582 pattern_prism = "!!! Nb of points: \n 8 \n\
3592 !!! Indices of points of 2 prisms: \n\
3596 pattern = self.smeshpyD.GetPattern()
3597 isDone = pattern.LoadFromFile(pattern_prism)
3599 print 'Pattern.LoadFromFile :', pattern.GetErrorCode()
3602 pattern.ApplyToHexahedrons(self.mesh, theObject.GetIDs(), theNode000, theNode001)
3603 isDone = pattern.MakeMesh(self.mesh, False, False)
3604 if not isDone: print 'Pattern.MakeMesh :', pattern.GetErrorCode()
3606 # Split quafrangle faces near triangular facets of volumes
3607 self.SplitQuadsNearTriangularFacets()
3612 # @param IDsOfElements the list if ids of elements to smooth
3613 # @param IDsOfFixedNodes the list of ids of fixed nodes.
3614 # Note that nodes built on edges and boundary nodes are always fixed.
3615 # @param MaxNbOfIterations the maximum number of iterations
3616 # @param MaxAspectRatio varies in range [1.0, inf]
3617 # @param Method is either Laplacian (smesh.LAPLACIAN_SMOOTH)
3618 # or Centroidal (smesh.CENTROIDAL_SMOOTH)
3619 # @return TRUE in case of success, FALSE otherwise.
3620 # @ingroup l2_modif_smooth
3621 def Smooth(self, IDsOfElements, IDsOfFixedNodes,
3622 MaxNbOfIterations, MaxAspectRatio, Method):
3623 if IDsOfElements == []:
3624 IDsOfElements = self.GetElementsId()
3625 MaxNbOfIterations,MaxAspectRatio,Parameters,hasVars = ParseParameters(MaxNbOfIterations,MaxAspectRatio)
3626 self.mesh.SetParameters(Parameters)
3627 return self.editor.Smooth(IDsOfElements, IDsOfFixedNodes,
3628 MaxNbOfIterations, MaxAspectRatio, Method)
3630 ## Smooth elements which belong to the given object
3631 # @param theObject the object to smooth
3632 # @param IDsOfFixedNodes the list of ids of fixed nodes.
3633 # Note that nodes built on edges and boundary nodes are always fixed.
3634 # @param MaxNbOfIterations the maximum number of iterations
3635 # @param MaxAspectRatio varies in range [1.0, inf]
3636 # @param Method is either Laplacian (smesh.LAPLACIAN_SMOOTH)
3637 # or Centroidal (smesh.CENTROIDAL_SMOOTH)
3638 # @return TRUE in case of success, FALSE otherwise.
3639 # @ingroup l2_modif_smooth
3640 def SmoothObject(self, theObject, IDsOfFixedNodes,
3641 MaxNbOfIterations, MaxAspectRatio, Method):
3642 if ( isinstance( theObject, Mesh )):
3643 theObject = theObject.GetMesh()
3644 return self.editor.SmoothObject(theObject, IDsOfFixedNodes,
3645 MaxNbOfIterations, MaxAspectRatio, Method)
3647 ## Parametrically smooth the given elements
3648 # @param IDsOfElements the list if ids of elements to smooth
3649 # @param IDsOfFixedNodes the list of ids of fixed nodes.
3650 # Note that nodes built on edges and boundary nodes are always fixed.
3651 # @param MaxNbOfIterations the maximum number of iterations
3652 # @param MaxAspectRatio varies in range [1.0, inf]
3653 # @param Method is either Laplacian (smesh.LAPLACIAN_SMOOTH)
3654 # or Centroidal (smesh.CENTROIDAL_SMOOTH)
3655 # @return TRUE in case of success, FALSE otherwise.
3656 # @ingroup l2_modif_smooth
3657 def SmoothParametric(self, IDsOfElements, IDsOfFixedNodes,
3658 MaxNbOfIterations, MaxAspectRatio, Method):
3659 if IDsOfElements == []:
3660 IDsOfElements = self.GetElementsId()
3661 MaxNbOfIterations,MaxAspectRatio,Parameters,hasVars = ParseParameters(MaxNbOfIterations,MaxAspectRatio)
3662 self.mesh.SetParameters(Parameters)
3663 return self.editor.SmoothParametric(IDsOfElements, IDsOfFixedNodes,
3664 MaxNbOfIterations, MaxAspectRatio, Method)
3666 ## Parametrically smooth the elements which belong to the given object
3667 # @param theObject the object to smooth
3668 # @param IDsOfFixedNodes the list of ids of fixed nodes.
3669 # Note that nodes built on edges and boundary nodes are always fixed.
3670 # @param MaxNbOfIterations the maximum number of iterations
3671 # @param MaxAspectRatio varies in range [1.0, inf]
3672 # @param Method is either Laplacian (smesh.LAPLACIAN_SMOOTH)
3673 # or Centroidal (smesh.CENTROIDAL_SMOOTH)
3674 # @return TRUE in case of success, FALSE otherwise.
3675 # @ingroup l2_modif_smooth
3676 def SmoothParametricObject(self, theObject, IDsOfFixedNodes,
3677 MaxNbOfIterations, MaxAspectRatio, Method):
3678 if ( isinstance( theObject, Mesh )):
3679 theObject = theObject.GetMesh()
3680 return self.editor.SmoothParametricObject(theObject, IDsOfFixedNodes,
3681 MaxNbOfIterations, MaxAspectRatio, Method)
3683 ## Convert the mesh to quadratic or bi-quadratic, deletes old elements, replacing
3684 # them with quadratic with the same id.
3685 # @param theForce3d new node creation method:
3686 # 0 - the medium node lies at the geometrical entity from which the mesh element is built
3687 # 1 - the medium node lies at the middle of the line segments connecting two nodes of a mesh element
3688 # @param theSubMesh a group or a sub-mesh to convert; WARNING: in this case the mesh can become not conformal
3689 # @param theToBiQuad If True, converts the mesh to bi-quadratic
3690 # @return SMESH.ComputeError which can hold a warning
3691 # @ingroup l2_modif_tofromqu
3692 def ConvertToQuadratic(self, theForce3d=False, theSubMesh=None, theToBiQuad=False):
3693 if isinstance( theSubMesh, Mesh ):
3694 theSubMesh = theSubMesh.mesh
3696 self.editor.ConvertToBiQuadratic(theForce3d,theSubMesh)
3699 self.editor.ConvertToQuadraticObject(theForce3d,theSubMesh)
3701 self.editor.ConvertToQuadratic(theForce3d)
3702 error = self.editor.GetLastError()
3703 if error and error.comment:
3707 ## Convert the mesh from quadratic to ordinary,
3708 # deletes old quadratic elements, \n replacing
3709 # them with ordinary mesh elements with the same id.
3710 # @param theSubMesh a group or a sub-mesh to convert; WARNING: in this case the mesh can become not conformal
3711 # @ingroup l2_modif_tofromqu
3712 def ConvertFromQuadratic(self, theSubMesh=None):
3714 self.editor.ConvertFromQuadraticObject(theSubMesh)
3716 return self.editor.ConvertFromQuadratic()
3718 ## Create 2D mesh as skin on boundary faces of a 3D mesh
3719 # @return TRUE if operation has been completed successfully, FALSE otherwise
3720 # @ingroup l2_modif_add
3721 def Make2DMeshFrom3D(self):
3722 return self.editor.Make2DMeshFrom3D()
3724 ## Create missing boundary elements
3725 # @param elements - elements whose boundary is to be checked:
3726 # mesh, group, sub-mesh or list of elements
3727 # if elements is mesh, it must be the mesh whose MakeBoundaryMesh() is called
3728 # @param dimension - defines type of boundary elements to create, either of
3729 # { SMESH.BND_2DFROM3D, SMESH.BND_1DFROM3D, SMESH.BND_1DFROM2D }
3730 # SMESH.BND_1DFROM3D create mesh edges on all borders of free facets of 3D cells
3731 # @param groupName - a name of group to store created boundary elements in,
3732 # "" means not to create the group
3733 # @param meshName - a name of new mesh to store created boundary elements in,
3734 # "" means not to create the new mesh
3735 # @param toCopyElements - if true, the checked elements will be copied into
3736 # the new mesh else only boundary elements will be copied into the new mesh
3737 # @param toCopyExistingBondary - if true, not only new but also pre-existing
3738 # boundary elements will be copied into the new mesh
3739 # @return tuple (mesh, group) where boundary elements were added to
3740 # @ingroup l2_modif_add
3741 def MakeBoundaryMesh(self, elements, dimension=SMESH.BND_2DFROM3D, groupName="", meshName="",
3742 toCopyElements=False, toCopyExistingBondary=False):
3743 unRegister = genObjUnRegister()
3744 if isinstance( elements, Mesh ):
3745 elements = elements.GetMesh()
3746 if ( isinstance( elements, list )):
3747 elemType = SMESH.ALL
3748 if elements: elemType = self.GetElementType( elements[0], iselem=True)
3749 elements = self.editor.MakeIDSource(elements, elemType)
3750 unRegister.set( elements )
3751 mesh, group = self.editor.MakeBoundaryMesh(elements,dimension,groupName,meshName,
3752 toCopyElements,toCopyExistingBondary)
3753 if mesh: mesh = self.smeshpyD.Mesh(mesh)
3757 # @brief Create missing boundary elements around either the whole mesh or
3758 # groups of elements
3759 # @param dimension - defines type of boundary elements to create, either of
3760 # { SMESH.BND_2DFROM3D, SMESH.BND_1DFROM3D, SMESH.BND_1DFROM2D }
3761 # @param groupName - a name of group to store all boundary elements in,
3762 # "" means not to create the group
3763 # @param meshName - a name of a new mesh, which is a copy of the initial
3764 # mesh + created boundary elements; "" means not to create the new mesh
3765 # @param toCopyAll - if true, the whole initial mesh will be copied into
3766 # the new mesh else only boundary elements will be copied into the new mesh
3767 # @param groups - groups of elements to make boundary around
3768 # @retval tuple( long, mesh, groups )
3769 # long - number of added boundary elements
3770 # mesh - the mesh where elements were added to
3771 # group - the group of boundary elements or None
3773 # @ingroup l2_modif_add
3774 def MakeBoundaryElements(self, dimension=SMESH.BND_2DFROM3D, groupName="", meshName="",
3775 toCopyAll=False, groups=[]):
3776 nb, mesh, group = self.editor.MakeBoundaryElements(dimension,groupName,meshName,
3778 if mesh: mesh = self.smeshpyD.Mesh(mesh)
3779 return nb, mesh, group
3781 ## Renumber mesh nodes (Obsolete, does nothing)
3782 # @ingroup l2_modif_renumber
3783 def RenumberNodes(self):
3784 self.editor.RenumberNodes()
3786 ## Renumber mesh elements (Obsole, does nothing)
3787 # @ingroup l2_modif_renumber
3788 def RenumberElements(self):
3789 self.editor.RenumberElements()
3791 ## Private method converting \a arg into a list of SMESH_IdSource's
3792 def _getIdSourceList(self, arg, idType, unRegister):
3793 if arg and isinstance( arg, list ):
3794 if isinstance( arg[0], int ):
3795 arg = self.GetIDSource( arg, idType )
3796 unRegister.set( arg )
3797 elif isinstance( arg[0], Mesh ):
3798 arg[0] = arg[0].GetMesh()
3799 elif isinstance( arg, Mesh ):
3801 if arg and isinstance( arg, SMESH._objref_SMESH_IDSource ):
3805 ## Generate new elements by rotation of the given elements and nodes around the axis
3806 # @param nodes - nodes to revolve: a list including ids, groups, sub-meshes or a mesh
3807 # @param edges - edges to revolve: a list including ids, groups, sub-meshes or a mesh
3808 # @param faces - faces to revolve: a list including ids, groups, sub-meshes or a mesh
3809 # @param Axis the axis of rotation: AxisStruct, line (geom object) or [x,y,z,dx,dy,dz]
3810 # @param AngleInRadians the angle of Rotation (in radians) or a name of variable
3811 # which defines angle in degrees
3812 # @param NbOfSteps the number of steps
3813 # @param Tolerance tolerance
3814 # @param MakeGroups forces the generation of new groups from existing ones
3815 # @param TotalAngle gives meaning of AngleInRadians: if True then it is an angular size
3816 # of all steps, else - size of each step
3817 # @return the list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
3818 # @ingroup l2_modif_extrurev
3819 def RotationSweepObjects(self, nodes, edges, faces, Axis, AngleInRadians, NbOfSteps, Tolerance,
3820 MakeGroups=False, TotalAngle=False):
3821 unRegister = genObjUnRegister()
3822 nodes = self._getIdSourceList( nodes, SMESH.NODE, unRegister )
3823 edges = self._getIdSourceList( edges, SMESH.EDGE, unRegister )
3824 faces = self._getIdSourceList( faces, SMESH.FACE, unRegister )
3826 if isinstance( Axis, geomBuilder.GEOM._objref_GEOM_Object):
3827 Axis = self.smeshpyD.GetAxisStruct( Axis )
3828 if isinstance( Axis, list ):
3829 Axis = SMESH.AxisStruct( *Axis )
3831 AngleInRadians,AngleParameters,hasVars = ParseAngles(AngleInRadians)
3832 NbOfSteps,Tolerance,Parameters,hasVars = ParseParameters(NbOfSteps,Tolerance)
3833 Parameters = Axis.parameters + var_separator + AngleParameters + var_separator + Parameters
3834 self.mesh.SetParameters(Parameters)
3835 if TotalAngle and NbOfSteps:
3836 AngleInRadians /= NbOfSteps
3837 return self.editor.RotationSweepObjects( nodes, edges, faces,
3838 Axis, AngleInRadians,
3839 NbOfSteps, Tolerance, MakeGroups)
3841 ## Generate new elements by rotation of the elements around the axis
3842 # @param IDsOfElements the list of ids of elements to sweep
3843 # @param Axis the axis of rotation, AxisStruct or line(geom object)
3844 # @param AngleInRadians the angle of Rotation (in radians) or a name of variable which defines angle in degrees
3845 # @param NbOfSteps the number of steps
3846 # @param Tolerance tolerance
3847 # @param MakeGroups forces the generation of new groups from existing ones
3848 # @param TotalAngle gives meaning of AngleInRadians: if True then it is an angular size
3849 # of all steps, else - size of each step
3850 # @return the list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
3851 # @ingroup l2_modif_extrurev
3852 def RotationSweep(self, IDsOfElements, Axis, AngleInRadians, NbOfSteps, Tolerance,
3853 MakeGroups=False, TotalAngle=False):
3854 return self.RotationSweepObjects([], IDsOfElements, IDsOfElements, Axis,
3855 AngleInRadians, NbOfSteps, Tolerance,
3856 MakeGroups, TotalAngle)
3858 ## Generate new elements by rotation of the elements of object around the axis
3859 # @param theObject object which elements should be sweeped.
3860 # It can be a mesh, a sub mesh or a group.
3861 # @param Axis the axis of rotation, AxisStruct or line(geom object)
3862 # @param AngleInRadians the angle of Rotation
3863 # @param NbOfSteps number of steps
3864 # @param Tolerance tolerance
3865 # @param MakeGroups forces the generation of new groups from existing ones
3866 # @param TotalAngle gives meaning of AngleInRadians: if True then it is an angular size
3867 # of all steps, else - size of each step
3868 # @return the list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
3869 # @ingroup l2_modif_extrurev
3870 def RotationSweepObject(self, theObject, Axis, AngleInRadians, NbOfSteps, Tolerance,
3871 MakeGroups=False, TotalAngle=False):
3872 return self.RotationSweepObjects( [], theObject, theObject, Axis,
3873 AngleInRadians, NbOfSteps, Tolerance,
3874 MakeGroups, TotalAngle )
3876 ## Generate new elements by rotation of the elements of object around the axis
3877 # @param theObject object which elements should be sweeped.
3878 # It can be a mesh, a sub mesh or a group.
3879 # @param Axis the axis of rotation, AxisStruct or line(geom object)
3880 # @param AngleInRadians the angle of Rotation
3881 # @param NbOfSteps number of steps
3882 # @param Tolerance tolerance
3883 # @param MakeGroups forces the generation of new groups from existing ones
3884 # @param TotalAngle gives meaning of AngleInRadians: if True then it is an angular size
3885 # of all steps, else - size of each step
3886 # @return the list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
3887 # @ingroup l2_modif_extrurev
3888 def RotationSweepObject1D(self, theObject, Axis, AngleInRadians, NbOfSteps, Tolerance,
3889 MakeGroups=False, TotalAngle=False):
3890 return self.RotationSweepObjects([],theObject,[], Axis,
3891 AngleInRadians, NbOfSteps, Tolerance,
3892 MakeGroups, TotalAngle)
3894 ## Generate new elements by rotation of the elements of object around the axis
3895 # @param theObject object which elements should be sweeped.
3896 # It can be a mesh, a sub mesh or a group.
3897 # @param Axis the axis of rotation, AxisStruct or line(geom object)
3898 # @param AngleInRadians the angle of Rotation
3899 # @param NbOfSteps number of steps
3900 # @param Tolerance tolerance
3901 # @param MakeGroups forces the generation of new groups from existing ones
3902 # @param TotalAngle gives meaning of AngleInRadians: if True then it is an angular size
3903 # of all steps, else - size of each step
3904 # @return the list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
3905 # @ingroup l2_modif_extrurev
3906 def RotationSweepObject2D(self, theObject, Axis, AngleInRadians, NbOfSteps, Tolerance,
3907 MakeGroups=False, TotalAngle=False):
3908 return self.RotationSweepObjects([],[],theObject, Axis, AngleInRadians,
3909 NbOfSteps, Tolerance, MakeGroups, TotalAngle)
3911 ## Generate new elements by extrusion of the given elements and nodes
3912 # @param nodes nodes to extrude: a list including ids, groups, sub-meshes or a mesh
3913 # @param edges edges to extrude: a list including ids, groups, sub-meshes or a mesh
3914 # @param faces faces to extrude: a list including ids, groups, sub-meshes or a mesh
3915 # @param StepVector vector or DirStruct or 3 vector components, defining
3916 # the direction and value of extrusion for one step (the total extrusion
3917 # length will be NbOfSteps * ||StepVector||)
3918 # @param NbOfSteps the number of steps
3919 # @param MakeGroups forces the generation of new groups from existing ones
3920 # @param scaleFactors optional scale factors to apply during extrusion
3921 # @param linearVariation if @c True, scaleFactors are spread over all @a scaleFactors,
3922 # else scaleFactors[i] is applied to nodes at the i-th extrusion step
3923 # @param basePoint optional scaling center; if not provided, a gravity center of
3924 # nodes and elements being extruded is used as the scaling center.
3926 # - a list of tree components of the point or
3929 # @return the list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
3930 # @ingroup l2_modif_extrurev
3931 # @ref tui_extrusion example
3932 def ExtrusionSweepObjects(self, nodes, edges, faces, StepVector, NbOfSteps, MakeGroups=False,
3933 scaleFactors=[], linearVariation=False, basePoint=[] ):
3934 unRegister = genObjUnRegister()
3935 nodes = self._getIdSourceList( nodes, SMESH.NODE, unRegister )
3936 edges = self._getIdSourceList( edges, SMESH.EDGE, unRegister )
3937 faces = self._getIdSourceList( faces, SMESH.FACE, unRegister )
3939 if isinstance( StepVector, geomBuilder.GEOM._objref_GEOM_Object):
3940 StepVector = self.smeshpyD.GetDirStruct(StepVector)
3941 if isinstance( StepVector, list ):
3942 StepVector = self.smeshpyD.MakeDirStruct(*StepVector)
3944 if isinstance( basePoint, int):
3945 xyz = self.GetNodeXYZ( basePoint )
3947 raise RuntimeError, "Invalid node ID: %s" % basePoint
3949 if isinstance( basePoint, geomBuilder.GEOM._objref_GEOM_Object ):
3950 basePoint = self.geompyD.PointCoordinates( basePoint )
3952 NbOfSteps,Parameters,hasVars = ParseParameters(NbOfSteps)
3953 Parameters = StepVector.PS.parameters + var_separator + Parameters
3954 self.mesh.SetParameters(Parameters)
3956 return self.editor.ExtrusionSweepObjects( nodes, edges, faces,
3957 StepVector, NbOfSteps,
3958 scaleFactors, linearVariation, basePoint,
3962 ## Generate new elements by extrusion of the elements with given ids
3963 # @param IDsOfElements the list of ids of elements or nodes for extrusion
3964 # @param StepVector vector or DirStruct or 3 vector components, defining
3965 # the direction and value of extrusion for one step (the total extrusion
3966 # length will be NbOfSteps * ||StepVector||)
3967 # @param NbOfSteps the number of steps
3968 # @param MakeGroups forces the generation of new groups from existing ones
3969 # @param IsNodes is True if elements with given ids are nodes
3970 # @return the list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
3971 # @ingroup l2_modif_extrurev
3972 # @ref tui_extrusion example
3973 def ExtrusionSweep(self, IDsOfElements, StepVector, NbOfSteps, MakeGroups=False, IsNodes = False):
3975 if IsNodes: n = IDsOfElements
3976 else : e,f, = IDsOfElements,IDsOfElements
3977 return self.ExtrusionSweepObjects(n,e,f, StepVector, NbOfSteps, MakeGroups)
3979 ## Generate new elements by extrusion along the normal to a discretized surface or wire
3980 # @param Elements elements to extrude - a list including ids, groups, sub-meshes or a mesh.
3981 # Only faces can be extruded so far. A sub-mesh should be a sub-mesh on geom faces.
3982 # @param StepSize length of one extrusion step (the total extrusion
3983 # length will be \a NbOfSteps * \a StepSize ).
3984 # @param NbOfSteps number of extrusion steps.
3985 # @param ByAverageNormal if True each node is translated by \a StepSize
3986 # along the average of the normal vectors to the faces sharing the node;
3987 # else each node is translated along the same average normal till
3988 # intersection with the plane got by translation of the face sharing
3989 # the node along its own normal by \a StepSize.
3990 # @param UseInputElemsOnly to use only \a Elements when computing extrusion direction
3991 # for every node of \a Elements.
3992 # @param MakeGroups forces generation of new groups from existing ones.
3993 # @param Dim dimension of elements to extrude: 2 - faces or 1 - edges. Extrusion of edges
3994 # is not yet implemented. This parameter is used if \a Elements contains
3995 # both faces and edges, i.e. \a Elements is a Mesh.
3996 # @return the list of created groups (SMESH_GroupBase) if \a MakeGroups=True,
3997 # empty list otherwise.
3998 # @ingroup l2_modif_extrurev
3999 # @ref tui_extrusion example
4000 def ExtrusionByNormal(self, Elements, StepSize, NbOfSteps,
4001 ByAverageNormal=False, UseInputElemsOnly=True, MakeGroups=False, Dim = 2):
4002 unRegister = genObjUnRegister()
4003 if isinstance( Elements, Mesh ):
4004 Elements = [ Elements.GetMesh() ]
4005 if isinstance( Elements, list ):
4007 raise RuntimeError, "Elements empty!"
4008 if isinstance( Elements[0], int ):
4009 Elements = self.GetIDSource( Elements, SMESH.ALL )
4010 unRegister.set( Elements )
4011 if not isinstance( Elements, list ):
4012 Elements = [ Elements ]
4013 StepSize,NbOfSteps,Parameters,hasVars = ParseParameters(StepSize,NbOfSteps)
4014 self.mesh.SetParameters(Parameters)
4015 return self.editor.ExtrusionByNormal(Elements, StepSize, NbOfSteps,
4016 ByAverageNormal, UseInputElemsOnly, MakeGroups, Dim)
4018 ## Generate new elements by extrusion of the elements or nodes which belong to the object
4019 # @param theObject the object whose elements or nodes should be processed.
4020 # It can be a mesh, a sub-mesh or a group.
4021 # @param StepVector vector or DirStruct or 3 vector components, defining
4022 # the direction and value of extrusion for one step (the total extrusion
4023 # length will be NbOfSteps * ||StepVector||)
4024 # @param NbOfSteps the number of steps
4025 # @param MakeGroups forces the generation of new groups from existing ones
4026 # @param IsNodes is True if elements to extrude are nodes
4027 # @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
4028 # @ingroup l2_modif_extrurev
4029 # @ref tui_extrusion example
4030 def ExtrusionSweepObject(self, theObject, StepVector, NbOfSteps, MakeGroups=False, IsNodes=False):
4032 if IsNodes: n = theObject
4033 else : e,f, = theObject,theObject
4034 return self.ExtrusionSweepObjects(n,e,f, StepVector, NbOfSteps, MakeGroups)
4036 ## Generate new elements by extrusion of edges which belong to the object
4037 # @param theObject object whose 1D elements should be processed.
4038 # It can be a mesh, a sub-mesh or a group.
4039 # @param StepVector vector or DirStruct or 3 vector components, defining
4040 # the direction and value of extrusion for one step (the total extrusion
4041 # length will be NbOfSteps * ||StepVector||)
4042 # @param NbOfSteps the number of steps
4043 # @param MakeGroups to generate new groups from existing ones
4044 # @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
4045 # @ingroup l2_modif_extrurev
4046 # @ref tui_extrusion example
4047 def ExtrusionSweepObject1D(self, theObject, StepVector, NbOfSteps, MakeGroups=False):
4048 return self.ExtrusionSweepObjects([],theObject,[], StepVector, NbOfSteps, MakeGroups)
4050 ## Generate new elements by extrusion of faces which belong to the object
4051 # @param theObject object whose 2D elements should be processed.
4052 # It can be a mesh, a sub-mesh or a group.
4053 # @param StepVector vector or DirStruct or 3 vector components, defining
4054 # the direction and value of extrusion for one step (the total extrusion
4055 # length will be NbOfSteps * ||StepVector||)
4056 # @param NbOfSteps the number of steps
4057 # @param MakeGroups forces the generation of new groups from existing ones
4058 # @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
4059 # @ingroup l2_modif_extrurev
4060 # @ref tui_extrusion example
4061 def ExtrusionSweepObject2D(self, theObject, StepVector, NbOfSteps, MakeGroups=False):
4062 return self.ExtrusionSweepObjects([],[],theObject, StepVector, NbOfSteps, MakeGroups)
4064 ## Generate new elements by extrusion of the elements with given ids
4065 # @param IDsOfElements is ids of elements
4066 # @param StepVector vector or DirStruct or 3 vector components, defining
4067 # the direction and value of extrusion for one step (the total extrusion
4068 # length will be NbOfSteps * ||StepVector||)
4069 # @param NbOfSteps the number of steps
4070 # @param ExtrFlags sets flags for extrusion
4071 # @param SewTolerance uses for comparing locations of nodes if flag
4072 # EXTRUSION_FLAG_SEW is set
4073 # @param MakeGroups forces the generation of new groups from existing ones
4074 # @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
4075 # @ingroup l2_modif_extrurev
4076 def AdvancedExtrusion(self, IDsOfElements, StepVector, NbOfSteps,
4077 ExtrFlags, SewTolerance, MakeGroups=False):
4078 if isinstance( StepVector, geomBuilder.GEOM._objref_GEOM_Object):
4079 StepVector = self.smeshpyD.GetDirStruct(StepVector)
4080 if isinstance( StepVector, list ):
4081 StepVector = self.smeshpyD.MakeDirStruct(*StepVector)
4082 return self.editor.AdvancedExtrusion(IDsOfElements, StepVector, NbOfSteps,
4083 ExtrFlags, SewTolerance, MakeGroups)
4085 ## Generate new elements by extrusion of the given elements and nodes along the path.
4086 # The path of extrusion must be a meshed edge.
4087 # @param Nodes nodes to extrude: a list including ids, groups, sub-meshes or a mesh
4088 # @param Edges edges to extrude: a list including ids, groups, sub-meshes or a mesh
4089 # @param Faces faces to extrude: a list including ids, groups, sub-meshes or a mesh
4090 # @param PathMesh 1D mesh or 1D sub-mesh, along which proceeds the extrusion
4091 # @param PathShape shape (edge) defines the sub-mesh of PathMesh if PathMesh
4092 # contains not only path segments, else it can be None
4093 # @param NodeStart the first or the last node on the path. Defines the direction of extrusion
4094 # @param HasAngles allows the shape to be rotated around the path
4095 # to get the resulting mesh in a helical fashion
4096 # @param Angles list of angles
4097 # @param LinearVariation forces the computation of rotation angles as linear
4098 # variation of the given Angles along path steps
4099 # @param HasRefPoint allows using the reference point
4100 # @param RefPoint the point around which the shape is rotated (the mass center of the
4101 # shape by default). The User can specify any point as the Reference Point.
4102 # @param MakeGroups forces the generation of new groups from existing ones
4103 # @return list of created groups (SMESH_GroupBase) and SMESH::Extrusion_Error
4104 # @ingroup l2_modif_extrurev
4105 # @ref tui_extrusion_along_path example
4106 def ExtrusionAlongPathObjects(self, Nodes, Edges, Faces, PathMesh, PathShape=None,
4107 NodeStart=1, HasAngles=False, Angles=[], LinearVariation=False,
4108 HasRefPoint=False, RefPoint=[0,0,0], MakeGroups=False):
4109 unRegister = genObjUnRegister()
4110 Nodes = self._getIdSourceList( Nodes, SMESH.NODE, unRegister )
4111 Edges = self._getIdSourceList( Edges, SMESH.EDGE, unRegister )
4112 Faces = self._getIdSourceList( Faces, SMESH.FACE, unRegister )
4114 if isinstance( RefPoint, geomBuilder.GEOM._objref_GEOM_Object):
4115 RefPoint = self.smeshpyD.GetPointStruct(RefPoint)
4116 if isinstance( RefPoint, list ):
4117 if not RefPoint: RefPoint = [0,0,0]
4118 RefPoint = SMESH.PointStruct( *RefPoint )
4119 if isinstance( PathMesh, Mesh ):
4120 PathMesh = PathMesh.GetMesh()
4121 Angles,AnglesParameters,hasVars = ParseAngles(Angles)
4122 Parameters = AnglesParameters + var_separator + RefPoint.parameters
4123 self.mesh.SetParameters(Parameters)
4124 return self.editor.ExtrusionAlongPathObjects(Nodes, Edges, Faces,
4125 PathMesh, PathShape, NodeStart,
4126 HasAngles, Angles, LinearVariation,
4127 HasRefPoint, RefPoint, MakeGroups)
4129 ## Generate new elements by extrusion of the given elements
4130 # The path of extrusion must be a meshed edge.
4131 # @param Base mesh or group, or sub-mesh, or list of ids of elements for extrusion
4132 # @param Path - 1D mesh or 1D sub-mesh, along which proceeds the extrusion
4133 # @param NodeStart the start node from Path. Defines the direction of extrusion
4134 # @param HasAngles allows the shape to be rotated around the path
4135 # to get the resulting mesh in a helical fashion
4136 # @param Angles list of angles in radians
4137 # @param LinearVariation forces the computation of rotation angles as linear
4138 # variation of the given Angles along path steps
4139 # @param HasRefPoint allows using the reference point
4140 # @param RefPoint the point around which the elements are rotated (the mass
4141 # center of the elements by default).
4142 # The User can specify any point as the Reference Point.
4143 # RefPoint can be either GEOM Vertex, [x,y,z] or SMESH.PointStruct
4144 # @param MakeGroups forces the generation of new groups from existing ones
4145 # @param ElemType type of elements for extrusion (if param Base is a mesh)
4146 # @return list of created groups (SMESH_GroupBase) and SMESH::Extrusion_Error if MakeGroups=True,
4147 # only SMESH::Extrusion_Error otherwise
4148 # @ingroup l2_modif_extrurev
4149 # @ref tui_extrusion_along_path example
4150 def ExtrusionAlongPathX(self, Base, Path, NodeStart,
4151 HasAngles=False, Angles=[], LinearVariation=False,
4152 HasRefPoint=False, RefPoint=[0,0,0], MakeGroups=False,
4153 ElemType=SMESH.FACE):
4155 if ElemType == SMESH.NODE: n = Base
4156 if ElemType == SMESH.EDGE: e = Base
4157 if ElemType == SMESH.FACE: f = Base
4158 gr,er = self.ExtrusionAlongPathObjects(n,e,f, Path, None, NodeStart,
4159 HasAngles, Angles, LinearVariation,
4160 HasRefPoint, RefPoint, MakeGroups)
4161 if MakeGroups: return gr,er
4164 ## Generate new elements by extrusion of the given elements
4165 # The path of extrusion must be a meshed edge.
4166 # @param IDsOfElements ids of elements
4167 # @param PathMesh mesh containing a 1D sub-mesh on the edge, along which proceeds the extrusion
4168 # @param PathShape shape(edge) defines the sub-mesh for the path
4169 # @param NodeStart the first or the last node on the edge. Defines the direction of extrusion
4170 # @param HasAngles allows the shape to be rotated around the path
4171 # to get the resulting mesh in a helical fashion
4172 # @param Angles list of angles in radians
4173 # @param HasRefPoint allows using the reference point
4174 # @param RefPoint the point around which the shape is rotated (the mass center of the shape by default).
4175 # The User can specify any point as the Reference Point.
4176 # @param MakeGroups forces the generation of new groups from existing ones
4177 # @param LinearVariation forces the computation of rotation angles as linear
4178 # variation of the given Angles along path steps
4179 # @return list of created groups (SMESH_GroupBase) and SMESH::Extrusion_Error if MakeGroups=True,
4180 # only SMESH::Extrusion_Error otherwise
4181 # @ingroup l2_modif_extrurev
4182 # @ref tui_extrusion_along_path example
4183 def ExtrusionAlongPath(self, IDsOfElements, PathMesh, PathShape, NodeStart,
4184 HasAngles=False, Angles=[], HasRefPoint=False, RefPoint=[],
4185 MakeGroups=False, LinearVariation=False):
4186 n,e,f = [],IDsOfElements,IDsOfElements
4187 gr,er = self.ExtrusionAlongPathObjects(n,e,f, PathMesh, PathShape,
4188 NodeStart, HasAngles, Angles,
4190 HasRefPoint, RefPoint, MakeGroups)
4191 if MakeGroups: return gr,er
4194 ## Generate new elements by extrusion of the elements which belong to the object
4195 # The path of extrusion must be a meshed edge.
4196 # @param theObject the object whose elements should be processed.
4197 # It can be a mesh, a sub-mesh or a group.
4198 # @param PathMesh mesh containing a 1D sub-mesh on the edge, along which the extrusion proceeds
4199 # @param PathShape shape(edge) defines the sub-mesh for the path
4200 # @param NodeStart the first or the last node on the edge. Defines the direction of extrusion
4201 # @param HasAngles allows the shape to be rotated around the path
4202 # to get the resulting mesh in a helical fashion
4203 # @param Angles list of angles
4204 # @param HasRefPoint allows using the reference point
4205 # @param RefPoint the point around which the shape is rotated (the mass center of the shape by default).
4206 # The User can specify any point as the Reference Point.
4207 # @param MakeGroups forces the generation of new groups from existing ones
4208 # @param LinearVariation forces the computation of rotation angles as linear
4209 # variation of the given Angles along path steps
4210 # @return list of created groups (SMESH_GroupBase) and SMESH::Extrusion_Error if MakeGroups=True,
4211 # only SMESH::Extrusion_Error otherwise
4212 # @ingroup l2_modif_extrurev
4213 # @ref tui_extrusion_along_path example
4214 def ExtrusionAlongPathObject(self, theObject, PathMesh, PathShape, NodeStart,
4215 HasAngles=False, Angles=[], HasRefPoint=False, RefPoint=[],
4216 MakeGroups=False, LinearVariation=False):
4217 n,e,f = [],theObject,theObject
4218 gr,er = self.ExtrusionAlongPathObjects(n,e,f, PathMesh, PathShape, NodeStart,
4219 HasAngles, Angles, LinearVariation,
4220 HasRefPoint, RefPoint, MakeGroups)
4221 if MakeGroups: return gr,er
4224 ## Generate new elements by extrusion of mesh segments which belong to the object
4225 # The path of extrusion must be a meshed edge.
4226 # @param theObject the object whose 1D elements should be processed.
4227 # It can be a mesh, a sub-mesh or a group.
4228 # @param PathMesh mesh containing a 1D sub-mesh on the edge, along which the extrusion proceeds
4229 # @param PathShape shape(edge) defines the sub-mesh for the path
4230 # @param NodeStart the first or the last node on the edge. Defines the direction of extrusion
4231 # @param HasAngles allows the shape to be rotated around the path
4232 # to get the resulting mesh in a helical fashion
4233 # @param Angles list of angles
4234 # @param HasRefPoint allows using the reference point
4235 # @param RefPoint the point around which the shape is rotated (the mass center of the shape by default).
4236 # The User can specify any point as the Reference Point.
4237 # @param MakeGroups forces the generation of new groups from existing ones
4238 # @param LinearVariation forces the computation of rotation angles as linear
4239 # variation of the given Angles along path steps
4240 # @return list of created groups (SMESH_GroupBase) and SMESH::Extrusion_Error if MakeGroups=True,
4241 # only SMESH::Extrusion_Error otherwise
4242 # @ingroup l2_modif_extrurev
4243 # @ref tui_extrusion_along_path example
4244 def ExtrusionAlongPathObject1D(self, theObject, PathMesh, PathShape, NodeStart,
4245 HasAngles=False, Angles=[], HasRefPoint=False, RefPoint=[],
4246 MakeGroups=False, LinearVariation=False):
4247 n,e,f = [],theObject,[]
4248 gr,er = self.ExtrusionAlongPathObjects(n,e,f, PathMesh, PathShape, NodeStart,
4249 HasAngles, Angles, LinearVariation,
4250 HasRefPoint, RefPoint, MakeGroups)
4251 if MakeGroups: return gr,er
4254 ## Generate new elements by extrusion of faces which belong to the object
4255 # The path of extrusion must be a meshed edge.
4256 # @param theObject the object whose 2D elements should be processed.
4257 # It can be a mesh, a sub-mesh or a group.
4258 # @param PathMesh mesh containing a 1D sub-mesh on the edge, along which the extrusion proceeds
4259 # @param PathShape shape(edge) defines the sub-mesh for the path
4260 # @param NodeStart the first or the last node on the edge. Defines the direction of extrusion
4261 # @param HasAngles allows the shape to be rotated around the path
4262 # to get the resulting mesh in a helical fashion
4263 # @param Angles list of angles
4264 # @param HasRefPoint allows using the reference point
4265 # @param RefPoint the point around which the shape is rotated (the mass center of the shape by default).
4266 # The User can specify any point as the Reference Point.
4267 # @param MakeGroups forces the generation of new groups from existing ones
4268 # @param LinearVariation forces the computation of rotation angles as linear
4269 # variation of the given Angles along path steps
4270 # @return list of created groups (SMESH_GroupBase) and SMESH::Extrusion_Error if MakeGroups=True,
4271 # only SMESH::Extrusion_Error otherwise
4272 # @ingroup l2_modif_extrurev
4273 # @ref tui_extrusion_along_path example
4274 def ExtrusionAlongPathObject2D(self, theObject, PathMesh, PathShape, NodeStart,
4275 HasAngles=False, Angles=[], HasRefPoint=False, RefPoint=[],
4276 MakeGroups=False, LinearVariation=False):
4277 n,e,f = [],[],theObject
4278 gr,er = self.ExtrusionAlongPathObjects(n,e,f, PathMesh, PathShape, NodeStart,
4279 HasAngles, Angles, LinearVariation,
4280 HasRefPoint, RefPoint, MakeGroups)
4281 if MakeGroups: return gr,er
4284 ## Create a symmetrical copy of mesh elements
4285 # @param IDsOfElements list of elements ids
4286 # @param Mirror is AxisStruct or geom object(point, line, plane)
4287 # @param theMirrorType smeshBuilder.POINT, smeshBuilder.AXIS or smeshBuilder.PLANE
4288 # If the Mirror is a geom object this parameter is unnecessary
4289 # @param Copy allows to copy element (Copy is 1) or to replace with its mirroring (Copy is 0)
4290 # @param MakeGroups forces the generation of new groups from existing ones (if Copy)
4291 # @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
4292 # @ingroup l2_modif_trsf
4293 def Mirror(self, IDsOfElements, Mirror, theMirrorType=None, Copy=0, MakeGroups=False):
4294 if IDsOfElements == []:
4295 IDsOfElements = self.GetElementsId()
4296 if ( isinstance( Mirror, geomBuilder.GEOM._objref_GEOM_Object)):
4297 Mirror = self.smeshpyD.GetAxisStruct(Mirror)
4298 theMirrorType = Mirror._mirrorType
4300 self.mesh.SetParameters(Mirror.parameters)
4301 if Copy and MakeGroups:
4302 return self.editor.MirrorMakeGroups(IDsOfElements, Mirror, theMirrorType)
4303 self.editor.Mirror(IDsOfElements, Mirror, theMirrorType, Copy)
4306 ## Create a new mesh by a symmetrical copy of mesh elements
4307 # @param IDsOfElements the list of elements ids
4308 # @param Mirror is AxisStruct or geom object (point, line, plane)
4309 # @param theMirrorType smeshBuilder.POINT, smeshBuilder.AXIS or smeshBuilder.PLANE
4310 # If the Mirror is a geom object this parameter is unnecessary
4311 # @param MakeGroups to generate new groups from existing ones
4312 # @param NewMeshName a name of the new mesh to create
4313 # @return instance of Mesh class
4314 # @ingroup l2_modif_trsf
4315 def MirrorMakeMesh(self, IDsOfElements, Mirror, theMirrorType=0, MakeGroups=0, NewMeshName=""):
4316 if IDsOfElements == []:
4317 IDsOfElements = self.GetElementsId()
4318 if ( isinstance( Mirror, geomBuilder.GEOM._objref_GEOM_Object)):
4319 Mirror = self.smeshpyD.GetAxisStruct(Mirror)
4320 theMirrorType = Mirror._mirrorType
4322 self.mesh.SetParameters(Mirror.parameters)
4323 mesh = self.editor.MirrorMakeMesh(IDsOfElements, Mirror, theMirrorType,
4324 MakeGroups, NewMeshName)
4325 return Mesh(self.smeshpyD,self.geompyD,mesh)
4327 ## Create a symmetrical copy of the object
4328 # @param theObject mesh, submesh or group
4329 # @param Mirror AxisStruct or geom object (point, line, plane)
4330 # @param theMirrorType smeshBuilder.POINT, smeshBuilder.AXIS or smeshBuilder.PLANE
4331 # If the Mirror is a geom object this parameter is unnecessary
4332 # @param Copy allows copying the element (Copy is 1) or replacing it with its mirror (Copy is 0)
4333 # @param MakeGroups forces the generation of new groups from existing ones (if Copy)
4334 # @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
4335 # @ingroup l2_modif_trsf
4336 def MirrorObject (self, theObject, Mirror, theMirrorType=None, Copy=0, MakeGroups=False):
4337 if ( isinstance( theObject, Mesh )):
4338 theObject = theObject.GetMesh()
4339 if ( isinstance( Mirror, geomBuilder.GEOM._objref_GEOM_Object)):
4340 Mirror = self.smeshpyD.GetAxisStruct(Mirror)
4341 theMirrorType = Mirror._mirrorType
4343 self.mesh.SetParameters(Mirror.parameters)
4344 if Copy and MakeGroups:
4345 return self.editor.MirrorObjectMakeGroups(theObject, Mirror, theMirrorType)
4346 self.editor.MirrorObject(theObject, Mirror, theMirrorType, Copy)
4349 ## Create a new mesh by a symmetrical copy of the object
4350 # @param theObject mesh, submesh or group
4351 # @param Mirror AxisStruct or geom object (point, line, plane)
4352 # @param theMirrorType smeshBuilder.POINT, smeshBuilder.AXIS or smeshBuilder.PLANE
4353 # If the Mirror is a geom object this parameter is unnecessary
4354 # @param MakeGroups forces the generation of new groups from existing ones
4355 # @param NewMeshName the name of the new mesh to create
4356 # @return instance of Mesh class
4357 # @ingroup l2_modif_trsf
4358 def MirrorObjectMakeMesh (self, theObject, Mirror, theMirrorType=0,MakeGroups=0,NewMeshName=""):
4359 if ( isinstance( theObject, Mesh )):
4360 theObject = theObject.GetMesh()
4361 if ( isinstance( Mirror, geomBuilder.GEOM._objref_GEOM_Object)):
4362 Mirror = self.smeshpyD.GetAxisStruct(Mirror)
4363 theMirrorType = Mirror._mirrorType
4365 self.mesh.SetParameters(Mirror.parameters)
4366 mesh = self.editor.MirrorObjectMakeMesh(theObject, Mirror, theMirrorType,
4367 MakeGroups, NewMeshName)
4368 return Mesh( self.smeshpyD,self.geompyD,mesh )
4370 ## Translate the elements
4371 # @param IDsOfElements list of elements ids
4372 # @param Vector the direction of translation (DirStruct or vector or 3 vector components)
4373 # @param Copy allows copying the translated elements
4374 # @param MakeGroups forces the generation of new groups from existing ones (if Copy)
4375 # @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
4376 # @ingroup l2_modif_trsf
4377 def Translate(self, IDsOfElements, Vector, Copy, MakeGroups=False):
4378 if IDsOfElements == []:
4379 IDsOfElements = self.GetElementsId()
4380 if ( isinstance( Vector, geomBuilder.GEOM._objref_GEOM_Object)):
4381 Vector = self.smeshpyD.GetDirStruct(Vector)
4382 if isinstance( Vector, list ):
4383 Vector = self.smeshpyD.MakeDirStruct(*Vector)
4384 self.mesh.SetParameters(Vector.PS.parameters)
4385 if Copy and MakeGroups:
4386 return self.editor.TranslateMakeGroups(IDsOfElements, Vector)
4387 self.editor.Translate(IDsOfElements, Vector, Copy)
4390 ## Create a new mesh of translated elements
4391 # @param IDsOfElements list of elements ids
4392 # @param Vector the direction of translation (DirStruct or vector or 3 vector components)
4393 # @param MakeGroups forces the generation of new groups from existing ones
4394 # @param NewMeshName the name of the newly created mesh
4395 # @return instance of Mesh class
4396 # @ingroup l2_modif_trsf
4397 def TranslateMakeMesh(self, IDsOfElements, Vector, MakeGroups=False, NewMeshName=""):
4398 if IDsOfElements == []:
4399 IDsOfElements = self.GetElementsId()
4400 if ( isinstance( Vector, geomBuilder.GEOM._objref_GEOM_Object)):
4401 Vector = self.smeshpyD.GetDirStruct(Vector)
4402 if isinstance( Vector, list ):
4403 Vector = self.smeshpyD.MakeDirStruct(*Vector)
4404 self.mesh.SetParameters(Vector.PS.parameters)
4405 mesh = self.editor.TranslateMakeMesh(IDsOfElements, Vector, MakeGroups, NewMeshName)
4406 return Mesh ( self.smeshpyD, self.geompyD, mesh )
4408 ## Translate the object
4409 # @param theObject the object to translate (mesh, submesh, or group)
4410 # @param Vector direction of translation (DirStruct or geom vector or 3 vector components)
4411 # @param Copy allows copying the translated elements
4412 # @param MakeGroups forces the generation of new groups from existing ones (if Copy)
4413 # @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
4414 # @ingroup l2_modif_trsf
4415 def TranslateObject(self, theObject, Vector, Copy, MakeGroups=False):
4416 if ( isinstance( theObject, Mesh )):
4417 theObject = theObject.GetMesh()
4418 if ( isinstance( Vector, geomBuilder.GEOM._objref_GEOM_Object)):
4419 Vector = self.smeshpyD.GetDirStruct(Vector)
4420 if isinstance( Vector, list ):
4421 Vector = self.smeshpyD.MakeDirStruct(*Vector)
4422 self.mesh.SetParameters(Vector.PS.parameters)
4423 if Copy and MakeGroups:
4424 return self.editor.TranslateObjectMakeGroups(theObject, Vector)
4425 self.editor.TranslateObject(theObject, Vector, Copy)
4428 ## Create a new mesh from the translated object
4429 # @param theObject the object to translate (mesh, submesh, or group)
4430 # @param Vector the direction of translation (DirStruct or geom vector or 3 vector components)
4431 # @param MakeGroups forces the generation of new groups from existing ones
4432 # @param NewMeshName the name of the newly created mesh
4433 # @return instance of Mesh class
4434 # @ingroup l2_modif_trsf
4435 def TranslateObjectMakeMesh(self, theObject, Vector, MakeGroups=False, NewMeshName=""):
4436 if isinstance( theObject, Mesh ):
4437 theObject = theObject.GetMesh()
4438 if isinstance( Vector, geomBuilder.GEOM._objref_GEOM_Object ):
4439 Vector = self.smeshpyD.GetDirStruct(Vector)
4440 if isinstance( Vector, list ):
4441 Vector = self.smeshpyD.MakeDirStruct(*Vector)
4442 self.mesh.SetParameters(Vector.PS.parameters)
4443 mesh = self.editor.TranslateObjectMakeMesh(theObject, Vector, MakeGroups, NewMeshName)
4444 return Mesh( self.smeshpyD, self.geompyD, mesh )
4449 # @param theObject - the object to translate (mesh, submesh, or group)
4450 # @param thePoint - base point for scale (SMESH.PointStruct or list of 3 coordinates)
4451 # @param theScaleFact - list of 1-3 scale factors for axises
4452 # @param Copy - allows copying the translated elements
4453 # @param MakeGroups - forces the generation of new groups from existing
4455 # @return list of created groups (SMESH_GroupBase) if MakeGroups=True,
4456 # empty list otherwise
4457 def Scale(self, theObject, thePoint, theScaleFact, Copy, MakeGroups=False):
4458 unRegister = genObjUnRegister()
4459 if ( isinstance( theObject, Mesh )):
4460 theObject = theObject.GetMesh()
4461 if ( isinstance( theObject, list )):
4462 theObject = self.GetIDSource(theObject, SMESH.ALL)
4463 unRegister.set( theObject )
4464 if ( isinstance( thePoint, list )):
4465 thePoint = PointStruct( thePoint[0], thePoint[1], thePoint[2] )
4466 if ( isinstance( theScaleFact, float )):
4467 theScaleFact = [theScaleFact]
4468 if ( isinstance( theScaleFact, int )):
4469 theScaleFact = [ float(theScaleFact)]
4471 self.mesh.SetParameters(thePoint.parameters)
4473 if Copy and MakeGroups:
4474 return self.editor.ScaleMakeGroups(theObject, thePoint, theScaleFact)
4475 self.editor.Scale(theObject, thePoint, theScaleFact, Copy)
4478 ## Create a new mesh from the translated object
4479 # @param theObject - the object to translate (mesh, submesh, or group)
4480 # @param thePoint - base point for scale (SMESH.PointStruct or list of 3 coordinates)
4481 # @param theScaleFact - list of 1-3 scale factors for axises
4482 # @param MakeGroups - forces the generation of new groups from existing ones
4483 # @param NewMeshName - the name of the newly created mesh
4484 # @return instance of Mesh class
4485 def ScaleMakeMesh(self, theObject, thePoint, theScaleFact, MakeGroups=False, NewMeshName=""):
4486 unRegister = genObjUnRegister()
4487 if (isinstance(theObject, Mesh)):
4488 theObject = theObject.GetMesh()
4489 if ( isinstance( theObject, list )):
4490 theObject = self.GetIDSource(theObject,SMESH.ALL)
4491 unRegister.set( theObject )
4492 if ( isinstance( thePoint, list )):
4493 thePoint = PointStruct( thePoint[0], thePoint[1], thePoint[2] )
4494 if ( isinstance( theScaleFact, float )):
4495 theScaleFact = [theScaleFact]
4496 if ( isinstance( theScaleFact, int )):
4497 theScaleFact = [ float(theScaleFact)]
4499 self.mesh.SetParameters(thePoint.parameters)
4500 mesh = self.editor.ScaleMakeMesh(theObject, thePoint, theScaleFact,
4501 MakeGroups, NewMeshName)
4502 return Mesh( self.smeshpyD, self.geompyD, mesh )
4506 ## Rotate the elements
4507 # @param IDsOfElements list of elements ids
4508 # @param Axis the axis of rotation (AxisStruct or geom line)
4509 # @param AngleInRadians the angle of rotation (in radians) or a name of variable which defines angle in degrees
4510 # @param Copy allows copying the rotated elements
4511 # @param MakeGroups forces the generation of new groups from existing ones (if Copy)
4512 # @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
4513 # @ingroup l2_modif_trsf
4514 def Rotate (self, IDsOfElements, Axis, AngleInRadians, Copy, MakeGroups=False):
4515 if IDsOfElements == []:
4516 IDsOfElements = self.GetElementsId()
4517 if ( isinstance( Axis, geomBuilder.GEOM._objref_GEOM_Object)):
4518 Axis = self.smeshpyD.GetAxisStruct(Axis)
4519 AngleInRadians,Parameters,hasVars = ParseAngles(AngleInRadians)
4520 Parameters = Axis.parameters + var_separator + Parameters
4521 self.mesh.SetParameters(Parameters)
4522 if Copy and MakeGroups:
4523 return self.editor.RotateMakeGroups(IDsOfElements, Axis, AngleInRadians)
4524 self.editor.Rotate(IDsOfElements, Axis, AngleInRadians, Copy)
4527 ## Create a new mesh of rotated elements
4528 # @param IDsOfElements list of element ids
4529 # @param Axis the axis of rotation (AxisStruct or geom line)
4530 # @param AngleInRadians the angle of rotation (in radians) or a name of variable which defines angle in degrees
4531 # @param MakeGroups forces the generation of new groups from existing ones
4532 # @param NewMeshName the name of the newly created mesh
4533 # @return instance of Mesh class
4534 # @ingroup l2_modif_trsf
4535 def RotateMakeMesh (self, IDsOfElements, Axis, AngleInRadians, MakeGroups=0, NewMeshName=""):
4536 if IDsOfElements == []:
4537 IDsOfElements = self.GetElementsId()
4538 if ( isinstance( Axis, geomBuilder.GEOM._objref_GEOM_Object)):
4539 Axis = self.smeshpyD.GetAxisStruct(Axis)
4540 AngleInRadians,Parameters,hasVars = ParseAngles(AngleInRadians)
4541 Parameters = Axis.parameters + var_separator + Parameters
4542 self.mesh.SetParameters(Parameters)
4543 mesh = self.editor.RotateMakeMesh(IDsOfElements, Axis, AngleInRadians,
4544 MakeGroups, NewMeshName)
4545 return Mesh( self.smeshpyD, self.geompyD, mesh )
4547 ## Rotate the object
4548 # @param theObject the object to rotate( mesh, submesh, or group)
4549 # @param Axis the axis of rotation (AxisStruct or geom line)
4550 # @param AngleInRadians the angle of rotation (in radians) or a name of variable which defines angle in degrees
4551 # @param Copy allows copying the rotated elements
4552 # @param MakeGroups forces the generation of new groups from existing ones (if Copy)
4553 # @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
4554 # @ingroup l2_modif_trsf
4555 def RotateObject (self, theObject, Axis, AngleInRadians, Copy, MakeGroups=False):
4556 if (isinstance(theObject, Mesh)):
4557 theObject = theObject.GetMesh()
4558 if (isinstance(Axis, geomBuilder.GEOM._objref_GEOM_Object)):
4559 Axis = self.smeshpyD.GetAxisStruct(Axis)
4560 AngleInRadians,Parameters,hasVars = ParseAngles(AngleInRadians)
4561 Parameters = Axis.parameters + ":" + Parameters
4562 self.mesh.SetParameters(Parameters)
4563 if Copy and MakeGroups:
4564 return self.editor.RotateObjectMakeGroups(theObject, Axis, AngleInRadians)
4565 self.editor.RotateObject(theObject, Axis, AngleInRadians, Copy)
4568 ## Create a new mesh from the rotated object
4569 # @param theObject the object to rotate (mesh, submesh, or group)
4570 # @param Axis the axis of rotation (AxisStruct or geom line)
4571 # @param AngleInRadians the angle of rotation (in radians) or a name of variable which defines angle in degrees
4572 # @param MakeGroups forces the generation of new groups from existing ones
4573 # @param NewMeshName the name of the newly created mesh
4574 # @return instance of Mesh class
4575 # @ingroup l2_modif_trsf
4576 def RotateObjectMakeMesh(self, theObject, Axis, AngleInRadians, MakeGroups=0,NewMeshName=""):
4577 if (isinstance( theObject, Mesh )):
4578 theObject = theObject.GetMesh()
4579 if (isinstance(Axis, geomBuilder.GEOM._objref_GEOM_Object)):
4580 Axis = self.smeshpyD.GetAxisStruct(Axis)
4581 AngleInRadians,Parameters,hasVars = ParseAngles(AngleInRadians)
4582 Parameters = Axis.parameters + ":" + Parameters
4583 mesh = self.editor.RotateObjectMakeMesh(theObject, Axis, AngleInRadians,
4584 MakeGroups, NewMeshName)
4585 self.mesh.SetParameters(Parameters)
4586 return Mesh( self.smeshpyD, self.geompyD, mesh )
4588 ## Create an offset mesh from the given 2D object
4589 # @param theObject the source object (mesh, submesh, group or filter)
4590 # @param theValue signed offset size
4591 # @param MakeGroups forces the generation of new groups from existing ones
4592 # @param NewMeshName the name of a mesh to create. If empty, offset elements are added
4594 # @return a tuple (mesh, list_of_groups)
4595 # @ingroup l2_modif_trsf
4596 def Offset(self, theObject, theValue, MakeGroups=False, NewMeshName=''):
4597 if isinstance( theObject, Mesh ):
4598 theObject = theObject.GetMesh()
4599 theValue,Parameters,hasVars = ParseParameters(theValue)
4600 mesh_groups = self.editor.Offset(theObject, theValue, MakeGroups, NewMeshName )
4601 self.mesh.SetParameters(Parameters)
4602 # if mesh_groups[0]:
4603 # return Mesh( self.smeshpyD, self.geompyD, mesh_groups[0] ), mesh_groups[1]
4606 ## Find groups of adjacent nodes within Tolerance.
4607 # @param Tolerance the value of tolerance
4608 # @param SeparateCornerAndMediumNodes if @c True, in quadratic mesh puts
4609 # corner and medium nodes in separate groups thus preventing
4610 # their further merge.
4611 # @return the list of groups of nodes IDs (e.g. [[1,12,13],[4,25]])
4612 # @ingroup l2_modif_trsf
4613 def FindCoincidentNodes (self, Tolerance, SeparateCornerAndMediumNodes=False):
4614 return self.editor.FindCoincidentNodes( Tolerance, SeparateCornerAndMediumNodes )
4616 ## Find groups of ajacent nodes within Tolerance.
4617 # @param Tolerance the value of tolerance
4618 # @param SubMeshOrGroup SubMesh, Group or Filter
4619 # @param exceptNodes list of either SubMeshes, Groups or node IDs to exclude from search
4620 # @param SeparateCornerAndMediumNodes if @c True, in quadratic mesh puts
4621 # corner and medium nodes in separate groups thus preventing
4622 # their further merge.
4623 # @return the list of groups of nodes IDs (e.g. [[1,12,13],[4,25]])
4624 # @ingroup l2_modif_trsf
4625 def FindCoincidentNodesOnPart (self, SubMeshOrGroup, Tolerance,
4626 exceptNodes=[], SeparateCornerAndMediumNodes=False):
4627 unRegister = genObjUnRegister()
4628 if (isinstance( SubMeshOrGroup, Mesh )):
4629 SubMeshOrGroup = SubMeshOrGroup.GetMesh()
4630 if not isinstance( exceptNodes, list ):
4631 exceptNodes = [ exceptNodes ]
4632 if exceptNodes and isinstance( exceptNodes[0], int ):
4633 exceptNodes = [ self.GetIDSource( exceptNodes, SMESH.NODE )]
4634 unRegister.set( exceptNodes )
4635 return self.editor.FindCoincidentNodesOnPartBut(SubMeshOrGroup, Tolerance,
4636 exceptNodes, SeparateCornerAndMediumNodes)
4639 # @param GroupsOfNodes a list of groups of nodes IDs for merging
4640 # (e.g. [[1,12,13],[25,4]], then nodes 12, 13 and 4 will be removed and replaced
4641 # by nodes 1 and 25 correspondingly in all elements and groups
4642 # @param NodesToKeep nodes to keep in the mesh: a list of groups, sub-meshes or node IDs.
4643 # If @a NodesToKeep does not include a node to keep for some group to merge,
4644 # then the first node in the group is kept.
4645 # @param AvoidMakingHoles prevent merging nodes which cause removal of elements becoming
4647 # @ingroup l2_modif_trsf
4648 def MergeNodes (self, GroupsOfNodes, NodesToKeep=[], AvoidMakingHoles=False):
4649 # NodesToKeep are converted to SMESH_IDSource in meshEditor.MergeNodes()
4650 self.editor.MergeNodes( GroupsOfNodes, NodesToKeep, AvoidMakingHoles )
4652 ## Find the elements built on the same nodes.
4653 # @param MeshOrSubMeshOrGroup Mesh or SubMesh, or Group of elements for searching
4654 # @return the list of groups of equal elements IDs (e.g. [[1,12,13],[4,25]])
4655 # @ingroup l2_modif_trsf
4656 def FindEqualElements (self, MeshOrSubMeshOrGroup=None):
4657 if not MeshOrSubMeshOrGroup:
4658 MeshOrSubMeshOrGroup=self.mesh
4659 elif isinstance( MeshOrSubMeshOrGroup, Mesh ):
4660 MeshOrSubMeshOrGroup = MeshOrSubMeshOrGroup.GetMesh()
4661 return self.editor.FindEqualElements( MeshOrSubMeshOrGroup )
4663 ## Merge elements in each given group.
4664 # @param GroupsOfElementsID a list of groups of elements IDs for merging
4665 # (e.g. [[1,12,13],[25,4]], then elements 12, 13 and 4 will be removed and
4666 # replaced by elements 1 and 25 in all groups)
4667 # @ingroup l2_modif_trsf
4668 def MergeElements(self, GroupsOfElementsID):
4669 self.editor.MergeElements(GroupsOfElementsID)
4671 ## Leave one element and remove all other elements built on the same nodes.
4672 # @ingroup l2_modif_trsf
4673 def MergeEqualElements(self):
4674 self.editor.MergeEqualElements()
4676 ## Returns all or only closed free borders
4677 # @return list of SMESH.FreeBorder's
4678 # @ingroup l2_modif_trsf
4679 def FindFreeBorders(self, ClosedOnly=True):
4680 return self.editor.FindFreeBorders( ClosedOnly )
4682 ## Fill with 2D elements a hole defined by a SMESH.FreeBorder.
4683 # @param FreeBorder either a SMESH.FreeBorder or a list on node IDs. These nodes
4684 # must describe all sequential nodes of the hole border. The first and the last
4685 # nodes must be the same. Use FindFreeBorders() to get nodes of holes.
4686 # @ingroup l2_modif_trsf
4687 def FillHole(self, holeNodes):
4688 if holeNodes and isinstance( holeNodes, list ) and isinstance( holeNodes[0], int ):
4689 holeNodes = SMESH.FreeBorder(nodeIDs=holeNodes)
4690 if not isinstance( holeNodes, SMESH.FreeBorder ):
4691 raise TypeError, "holeNodes must be either SMESH.FreeBorder or list of integer and not %s" % holeNodes
4692 self.editor.FillHole( holeNodes )
4694 ## Return groups of FreeBorder's coincident within the given tolerance.
4695 # @param tolerance the tolerance. If the tolerance <= 0.0 then one tenth of an average
4696 # size of elements adjacent to free borders being compared is used.
4697 # @return SMESH.CoincidentFreeBorders structure
4698 # @ingroup l2_modif_trsf
4699 def FindCoincidentFreeBorders (self, tolerance=0.):
4700 return self.editor.FindCoincidentFreeBorders( tolerance )
4702 ## Sew FreeBorder's of each group
4703 # @param freeBorders either a SMESH.CoincidentFreeBorders structure or a list of lists
4704 # where each enclosed list contains node IDs of a group of coincident free
4705 # borders such that each consequent triple of IDs within a group describes
4706 # a free border in a usual way: n1, n2, nLast - i.e. 1st node, 2nd node and
4707 # last node of a border.
4708 # For example [[1, 2, 10, 20, 21, 40], [11, 12, 15, 55, 54, 41]] describes two
4709 # groups of coincident free borders, each group including two borders.
4710 # @param createPolygons if @c True faces adjacent to free borders are converted to
4711 # polygons if a node of opposite border falls on a face edge, else such
4712 # faces are split into several ones.
4713 # @param createPolyhedra if @c True volumes adjacent to free borders are converted to
4714 # polyhedra if a node of opposite border falls on a volume edge, else such
4715 # volumes, if any, remain intact and the mesh becomes non-conformal.
4716 # @return a number of successfully sewed groups
4717 # @ingroup l2_modif_trsf
4718 def SewCoincidentFreeBorders (self, freeBorders, createPolygons=False, createPolyhedra=False):
4719 if freeBorders and isinstance( freeBorders, list ):
4720 # construct SMESH.CoincidentFreeBorders
4721 if isinstance( freeBorders[0], int ):
4722 freeBorders = [freeBorders]
4724 coincidentGroups = []
4725 for nodeList in freeBorders:
4726 if not nodeList or len( nodeList ) % 3:
4727 raise ValueError, "Wrong number of nodes in this group: %s" % nodeList
4730 group.append ( SMESH.FreeBorderPart( len(borders), 0, 1, 2 ))
4731 borders.append( SMESH.FreeBorder( nodeList[:3] ))
4732 nodeList = nodeList[3:]
4734 coincidentGroups.append( group )
4736 freeBorders = SMESH.CoincidentFreeBorders( borders, coincidentGroups )
4738 return self.editor.SewCoincidentFreeBorders( freeBorders, createPolygons, createPolyhedra )
4741 # @return SMESH::Sew_Error
4742 # @ingroup l2_modif_trsf
4743 def SewFreeBorders (self, FirstNodeID1, SecondNodeID1, LastNodeID1,
4744 FirstNodeID2, SecondNodeID2, LastNodeID2,
4745 CreatePolygons, CreatePolyedrs):
4746 return self.editor.SewFreeBorders(FirstNodeID1, SecondNodeID1, LastNodeID1,
4747 FirstNodeID2, SecondNodeID2, LastNodeID2,
4748 CreatePolygons, CreatePolyedrs)
4750 ## Sew conform free borders
4751 # @return SMESH::Sew_Error
4752 # @ingroup l2_modif_trsf
4753 def SewConformFreeBorders (self, FirstNodeID1, SecondNodeID1, LastNodeID1,
4754 FirstNodeID2, SecondNodeID2):
4755 return self.editor.SewConformFreeBorders(FirstNodeID1, SecondNodeID1, LastNodeID1,
4756 FirstNodeID2, SecondNodeID2)
4758 ## Sew border to side
4759 # @return SMESH::Sew_Error
4760 # @ingroup l2_modif_trsf
4761 def SewBorderToSide (self, FirstNodeIDOnFreeBorder, SecondNodeIDOnFreeBorder, LastNodeIDOnFreeBorder,
4762 FirstNodeIDOnSide, LastNodeIDOnSide, CreatePolygons, CreatePolyedrs):
4763 return self.editor.SewBorderToSide(FirstNodeIDOnFreeBorder, SecondNodeIDOnFreeBorder, LastNodeIDOnFreeBorder,
4764 FirstNodeIDOnSide, LastNodeIDOnSide, CreatePolygons, CreatePolyedrs)
4766 ## Sew two sides of a mesh. The nodes belonging to Side1 are
4767 # merged with the nodes of elements of Side2.
4768 # The number of elements in theSide1 and in theSide2 must be
4769 # equal and they should have similar nodal connectivity.
4770 # The nodes to merge should belong to side borders and
4771 # the first node should be linked to the second.
4772 # @return SMESH::Sew_Error
4773 # @ingroup l2_modif_trsf
4774 def SewSideElements (self, IDsOfSide1Elements, IDsOfSide2Elements,
4775 NodeID1OfSide1ToMerge, NodeID1OfSide2ToMerge,
4776 NodeID2OfSide1ToMerge, NodeID2OfSide2ToMerge):
4777 return self.editor.SewSideElements(IDsOfSide1Elements, IDsOfSide2Elements,
4778 NodeID1OfSide1ToMerge, NodeID1OfSide2ToMerge,
4779 NodeID2OfSide1ToMerge, NodeID2OfSide2ToMerge)
4781 ## Set new nodes for the given element.
4782 # @param ide the element id
4783 # @param newIDs nodes ids
4784 # @return If the number of nodes does not correspond to the type of element - return false
4785 # @ingroup l2_modif_edit
4786 def ChangeElemNodes(self, ide, newIDs):
4787 return self.editor.ChangeElemNodes(ide, newIDs)
4789 ## If during the last operation of MeshEditor some nodes were
4790 # created, this method return the list of their IDs, \n
4791 # if new nodes were not created - return empty list
4792 # @return the list of integer values (can be empty)
4793 # @ingroup l2_modif_add
4794 def GetLastCreatedNodes(self):
4795 return self.editor.GetLastCreatedNodes()
4797 ## If during the last operation of MeshEditor some elements were
4798 # created this method return the list of their IDs, \n
4799 # if new elements were not created - return empty list
4800 # @return the list of integer values (can be empty)
4801 # @ingroup l2_modif_add
4802 def GetLastCreatedElems(self):
4803 return self.editor.GetLastCreatedElems()
4805 ## Forget what nodes and elements were created by the last mesh edition operation
4806 # @ingroup l2_modif_add
4807 def ClearLastCreated(self):
4808 self.editor.ClearLastCreated()
4810 ## Create duplicates of given elements, i.e. create new elements based on the
4811 # same nodes as the given ones.
4812 # @param theElements - container of elements to duplicate. It can be a Mesh,
4813 # sub-mesh, group, filter or a list of element IDs. If \a theElements is
4814 # a Mesh, elements of highest dimension are duplicated
4815 # @param theGroupName - a name of group to contain the generated elements.
4816 # If a group with such a name already exists, the new elements
4817 # are added to the existing group, else a new group is created.
4818 # If \a theGroupName is empty, new elements are not added
4820 # @return a group where the new elements are added. None if theGroupName == "".
4821 # @ingroup l2_modif_duplicat
4822 def DoubleElements(self, theElements, theGroupName=""):
4823 unRegister = genObjUnRegister()
4824 if isinstance( theElements, Mesh ):
4825 theElements = theElements.mesh
4826 elif isinstance( theElements, list ):
4827 theElements = self.GetIDSource( theElements, SMESH.ALL )
4828 unRegister.set( theElements )
4829 return self.editor.DoubleElements(theElements, theGroupName)
4831 ## Create a hole in a mesh by doubling the nodes of some particular elements
4832 # @param theNodes identifiers of nodes to be doubled
4833 # @param theModifiedElems identifiers of elements to be updated by the new (doubled)
4834 # nodes. If list of element identifiers is empty then nodes are doubled but
4835 # they not assigned to elements
4836 # @return TRUE if operation has been completed successfully, FALSE otherwise
4837 # @ingroup l2_modif_duplicat
4838 def DoubleNodes(self, theNodes, theModifiedElems):
4839 return self.editor.DoubleNodes(theNodes, theModifiedElems)
4841 ## Create a hole in a mesh by doubling the nodes of some particular elements
4842 # This method provided for convenience works as DoubleNodes() described above.
4843 # @param theNodeId identifiers of node to be doubled
4844 # @param theModifiedElems identifiers of elements to be updated
4845 # @return TRUE if operation has been completed successfully, FALSE otherwise
4846 # @ingroup l2_modif_duplicat
4847 def DoubleNode(self, theNodeId, theModifiedElems):
4848 return self.editor.DoubleNode(theNodeId, theModifiedElems)
4850 ## Create a hole in a mesh by doubling the nodes of some particular elements
4851 # This method provided for convenience works as DoubleNodes() described above.
4852 # @param theNodes group of nodes to be doubled
4853 # @param theModifiedElems group of elements to be updated.
4854 # @param theMakeGroup forces the generation of a group containing new nodes.
4855 # @return TRUE or a created group if operation has been completed successfully,
4856 # FALSE or None otherwise
4857 # @ingroup l2_modif_duplicat
4858 def DoubleNodeGroup(self, theNodes, theModifiedElems, theMakeGroup=False):
4860 return self.editor.DoubleNodeGroupNew(theNodes, theModifiedElems)
4861 return self.editor.DoubleNodeGroup(theNodes, theModifiedElems)
4863 ## Create a hole in a mesh by doubling the nodes of some particular elements
4864 # This method provided for convenience works as DoubleNodes() described above.
4865 # @param theNodes list of groups of nodes to be doubled
4866 # @param theModifiedElems list of groups of elements to be updated.
4867 # @param theMakeGroup forces the generation of a group containing new nodes.
4868 # @return TRUE if operation has been completed successfully, FALSE otherwise
4869 # @ingroup l2_modif_duplicat
4870 def DoubleNodeGroups(self, theNodes, theModifiedElems, theMakeGroup=False):
4872 return self.editor.DoubleNodeGroupsNew(theNodes, theModifiedElems)
4873 return self.editor.DoubleNodeGroups(theNodes, theModifiedElems)
4875 ## Create a hole in a mesh by doubling the nodes of some particular elements
4876 # @param theElems - the list of elements (edges or faces) to be replicated
4877 # The nodes for duplication could be found from these elements
4878 # @param theNodesNot - list of nodes to NOT replicate
4879 # @param theAffectedElems - the list of elements (cells and edges) to which the
4880 # replicated nodes should be associated to.
4881 # @return TRUE if operation has been completed successfully, FALSE otherwise
4882 # @ingroup l2_modif_duplicat
4883 def DoubleNodeElem(self, theElems, theNodesNot, theAffectedElems):
4884 return self.editor.DoubleNodeElem(theElems, theNodesNot, theAffectedElems)
4886 ## Create a hole in a mesh by doubling the nodes of some particular elements
4887 # @param theElems - the list of elements (edges or faces) to be replicated
4888 # The nodes for duplication could be found from these elements
4889 # @param theNodesNot - list of nodes to NOT replicate
4890 # @param theShape - shape to detect affected elements (element which geometric center
4891 # located on or inside shape).
4892 # The replicated nodes should be associated to affected elements.
4893 # @return TRUE if operation has been completed successfully, FALSE otherwise
4894 # @ingroup l2_modif_duplicat
4895 def DoubleNodeElemInRegion(self, theElems, theNodesNot, theShape):
4896 return self.editor.DoubleNodeElemInRegion(theElems, theNodesNot, theShape)
4898 ## Create a hole in a mesh by doubling the nodes of some particular elements
4899 # This method provided for convenience works as DoubleNodes() described above.
4900 # @param theElems - group of of elements (edges or faces) to be replicated
4901 # @param theNodesNot - group of nodes not to replicated
4902 # @param theAffectedElems - group of elements to which the replicated nodes
4903 # should be associated to.
4904 # @param theMakeGroup forces the generation of a group containing new elements.
4905 # @param theMakeNodeGroup forces the generation of a group containing new nodes.
4906 # @return TRUE or created groups (one or two) if operation has been completed successfully,
4907 # FALSE or None otherwise
4908 # @ingroup l2_modif_duplicat
4909 def DoubleNodeElemGroup(self, theElems, theNodesNot, theAffectedElems,
4910 theMakeGroup=False, theMakeNodeGroup=False):
4911 if theMakeGroup or theMakeNodeGroup:
4912 twoGroups = self.editor.DoubleNodeElemGroup2New(theElems, theNodesNot,
4914 theMakeGroup, theMakeNodeGroup)
4915 if theMakeGroup and theMakeNodeGroup:
4918 return twoGroups[ int(theMakeNodeGroup) ]
4919 return self.editor.DoubleNodeElemGroup(theElems, theNodesNot, theAffectedElems)
4921 ## Create a hole in a mesh by doubling the nodes of some particular elements
4922 # This method provided for convenience works as DoubleNodes() described above.
4923 # @param theElems - group of of elements (edges or faces) to be replicated
4924 # @param theNodesNot - group of nodes not to replicated
4925 # @param theShape - shape to detect affected elements (element which geometric center
4926 # located on or inside shape).
4927 # The replicated nodes should be associated to affected elements.
4928 # @ingroup l2_modif_duplicat
4929 def DoubleNodeElemGroupInRegion(self, theElems, theNodesNot, theShape):
4930 return self.editor.DoubleNodeElemGroupInRegion(theElems, theNodesNot, theShape)
4932 ## Create a hole in a mesh by doubling the nodes of some particular elements
4933 # This method provided for convenience works as DoubleNodes() described above.
4934 # @param theElems - list of groups of elements (edges or faces) to be replicated
4935 # @param theNodesNot - list of groups of nodes not to replicated
4936 # @param theAffectedElems - group of elements to which the replicated nodes
4937 # should be associated to.
4938 # @param theMakeGroup forces the generation of a group containing new elements.
4939 # @param theMakeNodeGroup forces the generation of a group containing new nodes.
4940 # @return TRUE or created groups (one or two) if operation has been completed successfully,
4941 # FALSE or None otherwise
4942 # @ingroup l2_modif_duplicat
4943 def DoubleNodeElemGroups(self, theElems, theNodesNot, theAffectedElems,
4944 theMakeGroup=False, theMakeNodeGroup=False):
4945 if theMakeGroup or theMakeNodeGroup:
4946 twoGroups = self.editor.DoubleNodeElemGroups2New(theElems, theNodesNot,
4948 theMakeGroup, theMakeNodeGroup)
4949 if theMakeGroup and theMakeNodeGroup:
4952 return twoGroups[ int(theMakeNodeGroup) ]
4953 return self.editor.DoubleNodeElemGroups(theElems, theNodesNot, theAffectedElems)
4955 ## Create a hole in a mesh by doubling the nodes of some particular elements
4956 # This method provided for convenience works as DoubleNodes() described above.
4957 # @param theElems - list of groups of elements (edges or faces) to be replicated
4958 # @param theNodesNot - list of groups of nodes not to replicated
4959 # @param theShape - shape to detect affected elements (element which geometric center
4960 # located on or inside shape).
4961 # The replicated nodes should be associated to affected elements.
4962 # @return TRUE if operation has been completed successfully, FALSE otherwise
4963 # @ingroup l2_modif_duplicat
4964 def DoubleNodeElemGroupsInRegion(self, theElems, theNodesNot, theShape):
4965 return self.editor.DoubleNodeElemGroupsInRegion(theElems, theNodesNot, theShape)
4967 ## Identify the elements that will be affected by node duplication (actual duplication is not performed.
4968 # This method is the first step of DoubleNodeElemGroupsInRegion.
4969 # @param theElems - list of groups of nodes or elements (edges or faces) to be replicated
4970 # @param theNodesNot - list of groups of nodes not to replicated
4971 # @param theShape - shape to detect affected elements (element which geometric center
4972 # located on or inside shape).
4973 # The replicated nodes should be associated to affected elements.
4974 # @return groups of affected elements in order: volumes, faces, edges
4975 # @ingroup l2_modif_duplicat
4976 def AffectedElemGroupsInRegion(self, theElems, theNodesNot, theShape):
4977 return self.editor.AffectedElemGroupsInRegion(theElems, theNodesNot, theShape)
4979 ## Double nodes on shared faces between groups of volumes and create flat elements on demand.
4980 # The list of groups must describe a partition of the mesh volumes.
4981 # The nodes of the internal faces at the boundaries of the groups are doubled.
4982 # In option, the internal faces are replaced by flat elements.
4983 # Triangles are transformed in prisms, and quadrangles in hexahedrons.
4984 # @param theDomains - list of groups of volumes
4985 # @param createJointElems - if TRUE, create the elements
4986 # @param onAllBoundaries - if TRUE, the nodes and elements are also created on
4987 # the boundary between \a theDomains and the rest mesh
4988 # @return TRUE if operation has been completed successfully, FALSE otherwise
4989 # @ingroup l2_modif_duplicat
4990 def DoubleNodesOnGroupBoundaries(self, theDomains, createJointElems, onAllBoundaries=False ):
4991 return self.editor.DoubleNodesOnGroupBoundaries( theDomains, createJointElems, onAllBoundaries )
4993 ## Double nodes on some external faces and create flat elements.
4994 # Flat elements are mainly used by some types of mechanic calculations.
4996 # Each group of the list must be constituted of faces.
4997 # Triangles are transformed in prisms, and quadrangles in hexahedrons.
4998 # @param theGroupsOfFaces - list of groups of faces
4999 # @return TRUE if operation has been completed successfully, FALSE otherwise
5000 # @ingroup l2_modif_duplicat
5001 def CreateFlatElementsOnFacesGroups(self, theGroupsOfFaces ):
5002 return self.editor.CreateFlatElementsOnFacesGroups( theGroupsOfFaces )
5004 ## identify all the elements around a geom shape, get the faces delimiting the hole
5006 def CreateHoleSkin(self, radius, theShape, groupName, theNodesCoords):
5007 return self.editor.CreateHoleSkin( radius, theShape, groupName, theNodesCoords )
5009 ## Create a polyline consisting of 1D mesh elements each lying on a 2D element of
5010 # the initial mesh. Positions of new nodes are found by cutting the mesh by the
5011 # plane passing through pairs of points specified by each PolySegment structure.
5012 # If there are several paths connecting a pair of points, the shortest path is
5013 # selected by the module. Position of the cutting plane is defined by the two
5014 # points and an optional vector lying on the plane specified by a PolySegment.
5015 # By default the vector is defined by Mesh module as following. A middle point
5016 # of the two given points is computed. The middle point is projected to the mesh.
5017 # The vector goes from the middle point to the projection point. In case of planar
5018 # mesh, the vector is normal to the mesh.
5019 # @param segments - PolySegment's defining positions of cutting planes.
5020 # Return the used vector which goes from the middle point to its projection.
5021 # @param groupName - optional name of a group where created mesh segments will
5023 # @ingroup l2_modif_duplicat
5024 def MakePolyLine(self, segments, groupName='', isPreview=False ):
5025 editor = self.editor
5027 editor = self.mesh.GetMeshEditPreviewer()
5028 segmentsRes = editor.MakePolyLine( segments, groupName )
5029 for i, seg in enumerate( segmentsRes ):
5030 segments[i].vector = seg.vector
5032 return editor.GetPreviewData()
5035 ## Return a cached numerical functor by its type.
5036 # @param theCriterion functor type - an item of SMESH.FunctorType enumeration.
5037 # Type SMESH.FunctorType._items in the Python Console to see all items.
5038 # Note that not all items correspond to numerical functors.
5039 # @return SMESH_NumericalFunctor. The functor is already initialized
5041 # @ingroup l1_measurements
5042 def GetFunctor(self, funcType ):
5043 fn = self.functors[ funcType._v ]
5045 fn = self.smeshpyD.GetFunctor(funcType)
5046 fn.SetMesh(self.mesh)
5047 self.functors[ funcType._v ] = fn
5050 ## Return value of a functor for a given element
5051 # @param funcType an item of SMESH.FunctorType enum
5052 # Type "SMESH.FunctorType._items" in the Python Console to see all items.
5053 # @param elemId element or node ID
5054 # @param isElem @a elemId is ID of element or node
5055 # @return the functor value or zero in case of invalid arguments
5056 # @ingroup l1_measurements
5057 def FunctorValue(self, funcType, elemId, isElem=True):
5058 fn = self.GetFunctor( funcType )
5059 if fn.GetElementType() == self.GetElementType(elemId, isElem):
5060 val = fn.GetValue(elemId)
5065 ## Get length of 1D element or sum of lengths of all 1D mesh elements
5066 # @param elemId mesh element ID (if not defined - sum of length of all 1D elements will be calculated)
5067 # @return element's length value if \a elemId is specified or sum of all 1D mesh elements' lengths otherwise
5068 # @ingroup l1_measurements
5069 def GetLength(self, elemId=None):
5072 length = self.smeshpyD.GetLength(self)
5074 length = self.FunctorValue(SMESH.FT_Length, elemId)
5077 ## Get area of 2D element or sum of areas of all 2D mesh elements
5078 # @param elemId mesh element ID (if not defined - sum of areas of all 2D elements will be calculated)
5079 # @return element's area value if \a elemId is specified or sum of all 2D mesh elements' areas otherwise
5080 # @ingroup l1_measurements
5081 def GetArea(self, elemId=None):
5084 area = self.smeshpyD.GetArea(self)
5086 area = self.FunctorValue(SMESH.FT_Area, elemId)
5089 ## Get volume of 3D element or sum of volumes of all 3D mesh elements
5090 # @param elemId mesh element ID (if not defined - sum of volumes of all 3D elements will be calculated)
5091 # @return element's volume value if \a elemId is specified or sum of all 3D mesh elements' volumes otherwise
5092 # @ingroup l1_measurements
5093 def GetVolume(self, elemId=None):
5096 volume = self.smeshpyD.GetVolume(self)
5098 volume = self.FunctorValue(SMESH.FT_Volume3D, elemId)
5101 ## Get maximum element length.
5102 # @param elemId mesh element ID
5103 # @return element's maximum length value
5104 # @ingroup l1_measurements
5105 def GetMaxElementLength(self, elemId):
5106 if self.GetElementType(elemId, True) == SMESH.VOLUME:
5107 ftype = SMESH.FT_MaxElementLength3D
5109 ftype = SMESH.FT_MaxElementLength2D
5110 return self.FunctorValue(ftype, elemId)
5112 ## Get aspect ratio of 2D or 3D element.
5113 # @param elemId mesh element ID
5114 # @return element's aspect ratio value
5115 # @ingroup l1_measurements
5116 def GetAspectRatio(self, elemId):
5117 if self.GetElementType(elemId, True) == SMESH.VOLUME:
5118 ftype = SMESH.FT_AspectRatio3D
5120 ftype = SMESH.FT_AspectRatio
5121 return self.FunctorValue(ftype, elemId)
5123 ## Get warping angle of 2D element.
5124 # @param elemId mesh element ID
5125 # @return element's warping angle value
5126 # @ingroup l1_measurements
5127 def GetWarping(self, elemId):
5128 return self.FunctorValue(SMESH.FT_Warping, elemId)
5130 ## Get minimum angle of 2D element.
5131 # @param elemId mesh element ID
5132 # @return element's minimum angle value
5133 # @ingroup l1_measurements
5134 def GetMinimumAngle(self, elemId):
5135 return self.FunctorValue(SMESH.FT_MinimumAngle, elemId)
5137 ## Get taper of 2D element.
5138 # @param elemId mesh element ID
5139 # @return element's taper value
5140 # @ingroup l1_measurements
5141 def GetTaper(self, elemId):
5142 return self.FunctorValue(SMESH.FT_Taper, elemId)
5144 ## Get skew of 2D element.
5145 # @param elemId mesh element ID
5146 # @return element's skew value
5147 # @ingroup l1_measurements
5148 def GetSkew(self, elemId):
5149 return self.FunctorValue(SMESH.FT_Skew, elemId)
5151 ## Return minimal and maximal value of a given functor.
5152 # @param funType a functor type, an item of SMESH.FunctorType enum
5153 # (one of SMESH.FunctorType._items)
5154 # @param meshPart a part of mesh (group, sub-mesh) to treat
5155 # @return tuple (min,max)
5156 # @ingroup l1_measurements
5157 def GetMinMax(self, funType, meshPart=None):
5158 unRegister = genObjUnRegister()
5159 if isinstance( meshPart, list ):
5160 meshPart = self.GetIDSource( meshPart, SMESH.ALL )
5161 unRegister.set( meshPart )
5162 if isinstance( meshPart, Mesh ):
5163 meshPart = meshPart.mesh
5164 fun = self.GetFunctor( funType )
5167 if hasattr( meshPart, "SetMesh" ):
5168 meshPart.SetMesh( self.mesh ) # set mesh to filter
5169 hist = fun.GetLocalHistogram( 1, False, meshPart )
5171 hist = fun.GetHistogram( 1, False )
5173 return hist[0].min, hist[0].max
5176 pass # end of Mesh class
5179 ## Private class used to compensate change of CORBA API of SMESH_Mesh for backward compatibility
5180 # with old dump scripts which call SMESH_Mesh directly and not via smeshBuilder.Mesh
5182 class meshProxy(SMESH._objref_SMESH_Mesh):
5184 SMESH._objref_SMESH_Mesh.__init__(self)
5185 def __deepcopy__(self, memo=None):
5186 new = self.__class__()
5188 def CreateDimGroup(self,*args): # 2 args added: nbCommonNodes, underlyingOnly
5189 if len( args ) == 3:
5190 args += SMESH.ALL_NODES, True
5191 return SMESH._objref_SMESH_Mesh.CreateDimGroup( self, *args )
5193 omniORB.registerObjref(SMESH._objref_SMESH_Mesh._NP_RepositoryId, meshProxy)
5196 ## Private class wrapping SMESH.SMESH_SubMesh in order to add Compute()
5198 class submeshProxy(SMESH._objref_SMESH_subMesh):
5200 SMESH._objref_SMESH_subMesh.__init__(self)
5202 def __deepcopy__(self, memo=None):
5203 new = self.__class__()
5206 ## Compute the sub-mesh and return the status of the computation
5207 # @param refresh if @c True, Object browser is automatically updated (when running in GUI)
5208 # @return True or False
5210 # This is a method of SMESH.SMESH_submesh that can be obtained via Mesh.GetSubMesh() or
5211 # @ref smesh_algorithm.Mesh_Algorithm.GetSubMesh() "Mesh_Algorithm.GetSubMesh()".
5212 # @ingroup l2_submeshes
5213 def Compute(self,refresh=False):
5215 self.mesh = Mesh( smeshBuilder(), None, self.GetMesh())
5217 ok = self.mesh.Compute( self.GetSubShape(),refresh=[] )
5219 if salome.sg.hasDesktop() and self.mesh.GetStudyId() >= 0:
5220 smeshgui = salome.ImportComponentGUI("SMESH")
5221 smeshgui.Init(self.mesh.GetStudyId())
5222 smeshgui.SetMeshIcon( salome.ObjectToID( self ), ok, (self.GetNumberOfElements()==0) )
5223 if refresh: salome.sg.updateObjBrowser(True)
5228 omniORB.registerObjref(SMESH._objref_SMESH_subMesh._NP_RepositoryId, submeshProxy)
5231 ## Private class used to compensate change of CORBA API of SMESH_MeshEditor for backward
5232 # compatibility with old dump scripts which call SMESH_MeshEditor directly and not via
5235 class meshEditor(SMESH._objref_SMESH_MeshEditor):
5237 SMESH._objref_SMESH_MeshEditor.__init__(self)
5239 def __getattr__(self, name ): # method called if an attribute not found
5240 if not self.mesh: # look for name() method in Mesh class
5241 self.mesh = Mesh( None, None, SMESH._objref_SMESH_MeshEditor.GetMesh(self))
5242 if hasattr( self.mesh, name ):
5243 return getattr( self.mesh, name )
5244 if name == "ExtrusionAlongPathObjX":
5245 return getattr( self.mesh, "ExtrusionAlongPathX" ) # other method name
5246 print "meshEditor: attribute '%s' NOT FOUND" % name
5248 def __deepcopy__(self, memo=None):
5249 new = self.__class__()
5251 def FindCoincidentNodes(self,*args): # a 2nd arg added (SeparateCornerAndMediumNodes)
5252 if len( args ) == 1: args += False,
5253 return SMESH._objref_SMESH_MeshEditor.FindCoincidentNodes( self, *args )
5254 def FindCoincidentNodesOnPart(self,*args): # a 3d arg added (SeparateCornerAndMediumNodes)
5255 if len( args ) == 2: args += False,
5256 return SMESH._objref_SMESH_MeshEditor.FindCoincidentNodesOnPart( self, *args )
5257 def MergeNodes(self,*args): # 2 args added (NodesToKeep,AvoidMakingHoles)
5258 if len( args ) == 1:
5259 return SMESH._objref_SMESH_MeshEditor.MergeNodes( self, args[0], [], False )
5260 NodesToKeep = args[1]
5261 AvoidMakingHoles = args[2] if len( args ) == 3 else False
5262 unRegister = genObjUnRegister()
5264 if isinstance( NodesToKeep, list ) and isinstance( NodesToKeep[0], int ):
5265 NodesToKeep = self.MakeIDSource( NodesToKeep, SMESH.NODE )
5266 if not isinstance( NodesToKeep, list ):
5267 NodesToKeep = [ NodesToKeep ]
5268 return SMESH._objref_SMESH_MeshEditor.MergeNodes( self, args[0], NodesToKeep, AvoidMakingHoles )
5270 omniORB.registerObjref(SMESH._objref_SMESH_MeshEditor._NP_RepositoryId, meshEditor)
5272 ## Private class wrapping SMESH.SMESH_Pattern CORBA class in order to treat Notebook
5273 # variables in some methods
5275 class Pattern(SMESH._objref_SMESH_Pattern):
5277 def LoadFromFile(self, patternTextOrFile ):
5278 text = patternTextOrFile
5279 if os.path.exists( text ):
5280 text = open( patternTextOrFile ).read()
5282 return SMESH._objref_SMESH_Pattern.LoadFromFile( self, text )
5284 def ApplyToMeshFaces(self, theMesh, theFacesIDs, theNodeIndexOnKeyPoint1, theReverse):
5285 decrFun = lambda i: i-1
5286 theNodeIndexOnKeyPoint1,Parameters,hasVars = ParseParameters(theNodeIndexOnKeyPoint1, decrFun)
5287 theMesh.SetParameters(Parameters)
5288 return SMESH._objref_SMESH_Pattern.ApplyToMeshFaces( self, theMesh, theFacesIDs, theNodeIndexOnKeyPoint1, theReverse )
5290 def ApplyToHexahedrons(self, theMesh, theVolumesIDs, theNode000Index, theNode001Index):
5291 decrFun = lambda i: i-1
5292 theNode000Index,theNode001Index,Parameters,hasVars = ParseParameters(theNode000Index,theNode001Index, decrFun)
5293 theMesh.SetParameters(Parameters)
5294 return SMESH._objref_SMESH_Pattern.ApplyToHexahedrons( self, theMesh, theVolumesIDs, theNode000Index, theNode001Index )
5296 def MakeMesh(self, mesh, CreatePolygons=False, CreatePolyhedra=False):
5297 if isinstance( mesh, Mesh ):
5298 mesh = mesh.GetMesh()
5299 return SMESH._objref_SMESH_Pattern.MakeMesh( self, mesh, CreatePolygons, CreatePolyhedra )
5301 # Registering the new proxy for Pattern
5302 omniORB.registerObjref(SMESH._objref_SMESH_Pattern._NP_RepositoryId, Pattern)
5304 ## Private class used to bind methods creating algorithms to the class Mesh
5307 def __init__(self, method):
5309 self.defaultAlgoType = ""
5310 self.algoTypeToClass = {}
5311 self.method = method
5313 # Store a python class of algorithm
5314 def add(self, algoClass):
5315 if type( algoClass ).__name__ == 'classobj' and \
5316 hasattr( algoClass, "algoType"):
5317 self.algoTypeToClass[ algoClass.algoType ] = algoClass
5318 if not self.defaultAlgoType and \
5319 hasattr( algoClass, "isDefault") and algoClass.isDefault:
5320 self.defaultAlgoType = algoClass.algoType
5321 #print "Add",algoClass.algoType, "dflt",self.defaultAlgoType
5323 # Create a copy of self and assign mesh to the copy
5324 def copy(self, mesh):
5325 other = algoCreator( self.method )
5326 other.defaultAlgoType = self.defaultAlgoType
5327 other.algoTypeToClass = self.algoTypeToClass
5331 # Create an instance of algorithm
5332 def __call__(self,algo="",geom=0,*args):
5335 if isinstance( algo, str ):
5337 elif ( isinstance( algo, geomBuilder.GEOM._objref_GEOM_Object ) and \
5338 not isinstance( geom, geomBuilder.GEOM._objref_GEOM_Object )):
5343 if isinstance( geom, geomBuilder.GEOM._objref_GEOM_Object ):
5345 elif not algoType and isinstance( geom, str ):
5350 if isinstance( arg, geomBuilder.GEOM._objref_GEOM_Object ) and not shape:
5352 elif isinstance( arg, str ) and not algoType:
5355 import traceback, sys
5356 msg = "Warning. Unexpected argument in mesh.%s() ---> %s" % ( self.method, arg )
5357 sys.stderr.write( msg + '\n' )
5358 tb = traceback.extract_stack(None,2)
5359 traceback.print_list( [tb[0]] )
5361 algoType = self.defaultAlgoType
5362 if not algoType and self.algoTypeToClass:
5363 algoType = sorted( self.algoTypeToClass.keys() )[0]
5364 if self.algoTypeToClass.has_key( algoType ):
5365 #print "Create algo",algoType
5366 return self.algoTypeToClass[ algoType ]( self.mesh, shape )
5367 raise RuntimeError, "No class found for algo type %s" % algoType
5370 ## Private class used to substitute and store variable parameters of hypotheses.
5372 class hypMethodWrapper:
5373 def __init__(self, hyp, method):
5375 self.method = method
5376 #print "REBIND:", method.__name__
5379 # call a method of hypothesis with calling SetVarParameter() before
5380 def __call__(self,*args):
5382 return self.method( self.hyp, *args ) # hypothesis method with no args
5384 #print "MethWrapper.__call__",self.method.__name__, args
5386 parsed = ParseParameters(*args) # replace variables with their values
5387 self.hyp.SetVarParameter( parsed[-2], self.method.__name__ )
5388 result = self.method( self.hyp, *parsed[:-2] ) # call hypothesis method
5389 except omniORB.CORBA.BAD_PARAM: # raised by hypothesis method call
5390 # maybe there is a replaced string arg which is not variable
5391 result = self.method( self.hyp, *args )
5392 except ValueError, detail: # raised by ParseParameters()
5394 result = self.method( self.hyp, *args )
5395 except omniORB.CORBA.BAD_PARAM:
5396 raise ValueError, detail # wrong variable name
5401 ## A helper class that calls UnRegister() of SALOME.GenericObj'es stored in it
5403 class genObjUnRegister:
5405 def __init__(self, genObj=None):
5406 self.genObjList = []
5410 def set(self, genObj):
5411 "Store one or a list of of SALOME.GenericObj'es"
5412 if isinstance( genObj, list ):
5413 self.genObjList.extend( genObj )
5415 self.genObjList.append( genObj )
5419 for genObj in self.genObjList:
5420 if genObj and hasattr( genObj, "UnRegister" ):
5424 ## Bind methods creating mesher plug-ins to the Mesh class
5426 for pluginName in os.environ[ "SMESH_MeshersList" ].split( ":" ):
5428 #print "pluginName: ", pluginName
5429 pluginBuilderName = pluginName + "Builder"
5431 exec( "from salome.%s.%s import *" % (pluginName, pluginBuilderName))
5432 except Exception, e:
5433 from salome_utils import verbose
5434 if verbose(): print "Exception while loading %s: %s" % ( pluginBuilderName, e )
5436 exec( "from salome.%s import %s" % (pluginName, pluginBuilderName))
5437 plugin = eval( pluginBuilderName )
5438 #print " plugin:" , str(plugin)
5440 # add methods creating algorithms to Mesh
5441 for k in dir( plugin ):
5442 if k[0] == '_': continue
5443 algo = getattr( plugin, k )
5444 #print " algo:", str(algo)
5445 if type( algo ).__name__ == 'classobj' and hasattr( algo, "meshMethod" ):
5446 #print " meshMethod:" , str(algo.meshMethod)
5447 if not hasattr( Mesh, algo.meshMethod ):
5448 setattr( Mesh, algo.meshMethod, algoCreator( algo.meshMethod ))
5450 getattr( Mesh, algo.meshMethod ).add( algo )