Salome HOME
ASERIS: Return a group from FillHole()
[modules/smesh.git] / src / SMESH_SWIG / smeshBuilder.py
1 # Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
2 #
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.
7 #
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.
12 #
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
16 #
17 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
18 #
19 #  File   : smeshBuilder.py
20 #  Author : Francis KLOSS, OCC
21 #  Module : SMESH
22
23 import salome
24 from salome.geom import geomBuilder
25
26 import SMESH # This is necessary for back compatibility
27 import omniORB                                       # back compatibility
28 SMESH.MED_V2_1    = 11 #omniORB.EnumItem("MED_V2_1", 11) # back compatibility: use number > MED minor version
29 SMESH.MED_V2_2    = 12 #omniORB.EnumItem("MED_V2_2", 12) # back compatibility: latest minor will be used
30 SMESH.MED_MINOR_0 = 20 # back compatibility
31 SMESH.MED_MINOR_1 = 21 # back compatibility
32 SMESH.MED_MINOR_2 = 22 # back compatibility
33 SMESH.MED_MINOR_3 = 23 # back compatibility
34 SMESH.MED_MINOR_4 = 24 # back compatibility
35 SMESH.MED_MINOR_5 = 25 # back compatibility
36 SMESH.MED_MINOR_6 = 26 # back compatibility
37 SMESH.MED_MINOR_7 = 27 # back compatibility
38 SMESH.MED_MINOR_8 = 28 # back compatibility
39 SMESH.MED_MINOR_9 = 29 # back compatibility
40
41 from   SMESH import *
42 from   salome.smesh.smesh_algorithm import Mesh_Algorithm
43
44 import SALOME
45 import SALOMEDS
46 import os
47 import inspect
48
49 # In case the omniORBpy EnumItem class does not fully support Python 3
50 # (for instance in version 4.2.1-2), the comparison ordering methods must be
51 # defined
52 #
53 try:
54     SMESH.Entity_Triangle < SMESH.Entity_Quadrangle
55 except TypeError:
56     def enumitem_eq(self, other):
57         try:
58             if isinstance(other, omniORB.EnumItem):
59                 if other._parent_id == self._parent_id:
60                     return self._v == other._v
61                 else:
62                     return self._parent_id == other._parent_id
63             else:
64                 return id(self) == id(other)
65         except:
66             return id(self) == id(other)
67
68     def enumitem_lt(self, other):
69         try:
70             if isinstance(other, omniORB.EnumItem):
71                 if other._parent_id == self._parent_id:
72                     return self._v < other._v
73                 else:
74                     return self._parent_id < other._parent_id
75             else:
76                 return id(self) < id(other)
77         except:
78             return id(self) < id(other)
79
80     def enumitem_le(self, other):
81         try:
82             if isinstance(other, omniORB.EnumItem):
83                 if other._parent_id == self._parent_id:
84                     return self._v <= other._v
85                 else:
86                     return self._parent_id <= other._parent_id
87             else:
88                 return id(self) <= id(other)
89         except:
90             return id(self) <= id(other)
91
92     def enumitem_gt(self, other):
93         try:
94             if isinstance(other, omniORB.EnumItem):
95                 if other._parent_id == self._parent_id:
96                     return self._v > other._v
97                 else:
98                     return self._parent_id > other._parent_id
99             else:
100                 return id(self) > id(other)
101         except:
102             return id(self) > id(other)
103
104     def enumitem_ge(self, other):
105         try:
106             if isinstance(other, omniORB.EnumItem):
107                 if other._parent_id == self._parent_id:
108                     return self._v >= other._v
109                 else:
110                     return self._parent_id >= other._parent_id
111             else:
112                 return id(self) >= id(other)
113         except:
114             return id(self) >= id(other)
115
116     omniORB.EnumItem.__eq__ = enumitem_eq
117     omniORB.EnumItem.__lt__ = enumitem_lt
118     omniORB.EnumItem.__le__ = enumitem_le
119     omniORB.EnumItem.__gt__ = enumitem_gt
120     omniORB.EnumItem.__ge__ = enumitem_ge
121
122
123 class MeshMeta(type):
124     """Private class used to workaround a problem that sometimes isinstance(m, Mesh) returns False
125     """
126     def __instancecheck__(cls, inst):
127         """Implement isinstance(inst, cls)."""
128         return any(cls.__subclasscheck__(c)
129                    for c in {type(inst), inst.__class__})
130
131     def __subclasscheck__(cls, sub):
132         """Implement issubclass(sub, cls)."""
133         return type.__subclasscheck__(cls, sub) or (cls.__name__ == sub.__name__ and cls.__module__ == sub.__module__)
134
135 def DegreesToRadians(AngleInDegrees):
136     """Convert an angle from degrees to radians
137     """
138     from math import pi
139     return AngleInDegrees * pi / 180.0
140
141 import salome_notebook
142 notebook = salome_notebook.notebook
143 # Salome notebook variable separator
144 var_separator = ":"
145
146 def ParseParameters(*args):
147     """
148     Return list of variable values from salome notebook.
149     The last argument, if is callable, is used to modify values got from notebook
150     """
151     Result = []
152     Parameters = ""
153     hasVariables = False
154     varModifFun=None
155     if args and callable(args[-1]):
156         args, varModifFun = args[:-1], args[-1]
157     for parameter in args:
158
159         Parameters += str(parameter) + var_separator
160
161         if isinstance(parameter,str):
162             # check if there is an inexistent variable name
163             if not notebook.isVariable(parameter):
164                 raise ValueError("Variable with name '" + parameter + "' doesn't exist!!!")
165             parameter = notebook.get(parameter)
166             hasVariables = True
167             if varModifFun:
168                 parameter = varModifFun(parameter)
169                 pass
170             pass
171         Result.append(parameter)
172
173         pass
174     Parameters = Parameters[:-1]
175     Result.append( Parameters )
176     Result.append( hasVariables )
177     return Result
178
179 def ParseAngles(*args):
180     """
181     Parse parameters while converting variables to radians
182     """
183     return ParseParameters( *( args + (DegreesToRadians, )))
184
185 def __initPointStruct(point,*args):
186     """
187     Substitute PointStruct.__init__() to create SMESH.PointStruct using notebook variables.
188     Parameters are stored in PointStruct.parameters attribute
189     """
190     point.x, point.y, point.z, point.parameters,hasVars = ParseParameters(*args)
191     pass
192 SMESH.PointStruct.__init__ = __initPointStruct
193
194 def __initAxisStruct(ax,*args):
195     """
196     Substitute AxisStruct.__init__() to create SMESH.AxisStruct using notebook variables.
197     Parameters are stored in AxisStruct.parameters attribute
198     """
199     if len( args ) != 6:
200         raise RuntimeError("Bad nb args (%s) passed in SMESH.AxisStruct(x,y,z,dx,dy,dz)"%(len( args )))
201     ax.x, ax.y, ax.z, ax.vx, ax.vy, ax.vz, ax.parameters,hasVars = ParseParameters(*args)
202     pass
203 SMESH.AxisStruct.__init__ = __initAxisStruct
204
205 smeshPrecisionConfusion = 1.e-07
206 def IsEqual(val1, val2, tol=smeshPrecisionConfusion):
207     """Compare real values using smeshPrecisionConfusion as tolerance
208     """
209     if abs(val1 - val2) < tol:
210         return True
211     return False
212
213 NO_NAME = "NoName"
214
215 def GetName(obj):
216     """
217     Return a name of an object
218     
219     Returns:
220         object name
221     """
222     if obj:
223         # object not null
224         if isinstance(obj, SALOMEDS._objref_SObject):
225             # study object
226             return obj.GetName()
227         try:
228             ior  = salome.orb.object_to_string(obj)
229         except:
230             ior = None
231         if ior:
232             sobj = salome.myStudy.FindObjectIOR(ior)
233             if sobj:
234                 return sobj.GetName()
235             if hasattr(obj, "GetName"):
236                 # unknown CORBA object, having GetName() method
237                 return obj.GetName()
238             else:
239                 # unknown CORBA object, no GetName() method
240                 return NO_NAME
241             pass
242         if hasattr(obj, "GetName"):
243             # unknown non-CORBA object, having GetName() method
244             return obj.GetName()
245         pass
246     raise RuntimeError("Null or invalid object")
247
248 def TreatHypoStatus(status, hypName, geomName, isAlgo, mesh):
249     """
250     Print error message if a hypothesis was not assigned.
251     """
252     if isAlgo:
253         hypType = "algorithm"
254     else:
255         hypType = "hypothesis"
256         pass
257     reason = ""
258     if hasattr( status, "__getitem__" ):
259         status, reason = status[0], status[1]
260     if status == HYP_UNKNOWN_FATAL:
261         reason = "for unknown reason"
262     elif status == HYP_INCOMPATIBLE:
263         reason = "this hypothesis mismatches the algorithm"
264     elif status == HYP_NOTCONFORM:
265         reason = "a non-conform mesh would be built"
266     elif status == HYP_ALREADY_EXIST:
267         if isAlgo: return # it does not influence anything
268         reason = hypType + " of the same dimension is already assigned to this shape"
269     elif status == HYP_BAD_DIM:
270         reason = hypType + " mismatches the shape"
271     elif status == HYP_CONCURRENT :
272         reason = "there are concurrent hypotheses on sub-shapes"
273     elif status == HYP_BAD_SUBSHAPE:
274         reason = "the shape is neither the main one, nor its sub-shape, nor a valid group"
275     elif status == HYP_BAD_GEOMETRY:
276         reason = "the algorithm is not applicable to this geometry"
277     elif status == HYP_HIDDEN_ALGO:
278         reason = "it is hidden by an algorithm of an upper dimension, which generates elements of all dimensions"
279     elif status == HYP_HIDING_ALGO:
280         reason = "it hides algorithms of lower dimensions by generating elements of all dimensions"
281     elif status == HYP_NEED_SHAPE:
282         reason = "algorithm can't work without shape"
283     elif status == HYP_INCOMPAT_HYPS:
284         pass
285     else:
286         return
287     where = geomName
288     if where:
289         where = '"%s"' % geomName
290         if mesh:
291             meshName = GetName( mesh )
292             if meshName and meshName != NO_NAME:
293                 where = '"%s" shape in "%s" mesh ' % ( geomName, meshName )
294     if status < HYP_UNKNOWN_FATAL and where:
295         print('"%s" was assigned to %s but %s' %( hypName, where, reason ))
296     elif where:
297         print('"%s" was not assigned to %s : %s' %( hypName, where, reason ))
298     else:
299         print('"%s" was not assigned : %s' %( hypName, reason ))
300         pass
301
302 def AssureGeomPublished(mesh, geom, name=''):
303     """
304     Private method. Add geom (sub-shape of the main shape) into the study if not yet there
305     """
306     if not isinstance( geom, geomBuilder.GEOM._objref_GEOM_Object ):
307         return
308     if not geom.GetStudyEntry():
309         ## get a name
310         if not name and geom.GetShapeType() != geomBuilder.GEOM.COMPOUND:
311             # for all groups SubShapeName() return "Compound_-1"
312             name = mesh.geompyD.SubShapeName(geom, mesh.geom)
313         if not name:
314             name = "%s_%s"%(geom.GetShapeType(), id(geom)%10000)
315         ## publish
316         mesh.geompyD.addToStudyInFather( mesh.geom, geom, name )
317     return
318
319 def FirstVertexOnCurve(mesh, edge):
320     """
321     Returns:
322         the first vertex of a geometrical edge by ignoring orientation
323     """
324     vv = mesh.geompyD.SubShapeAll( edge, geomBuilder.geomBuilder.ShapeType["VERTEX"])
325     if not vv:
326         raise TypeError("Given object has no vertices")
327     if len( vv ) == 1: return vv[0]
328     v0   = mesh.geompyD.MakeVertexOnCurve(edge,0.)
329     xyz  = mesh.geompyD.PointCoordinates( v0 ) # coords of the first vertex
330     xyz1 = mesh.geompyD.PointCoordinates( vv[0] )
331     xyz2 = mesh.geompyD.PointCoordinates( vv[1] )
332     dist1, dist2 = 0,0
333     for i in range(3):
334         dist1 += abs( xyz[i] - xyz1[i] )
335         dist2 += abs( xyz[i] - xyz2[i] )
336     if dist1 < dist2:
337         return vv[0]
338     else:
339         return vv[1]
340
341 smeshInst = None
342 """
343 Warning:
344     smeshInst is a singleton
345 """
346 engine = None
347 doLcc = False
348 created = False
349
350 class smeshBuilder( SMESH._objref_SMESH_Gen, object ):
351     """
352     This class allows to create, load or manipulate meshes.
353     It has a set of methods to create, load or copy meshes, to combine several meshes, etc.
354     It also has methods to get infos and measure meshes.
355     """
356
357     # MirrorType enumeration
358     POINT = SMESH_MeshEditor.POINT
359     AXIS =  SMESH_MeshEditor.AXIS
360     PLANE = SMESH_MeshEditor.PLANE
361
362     # Smooth_Method enumeration
363     LAPLACIAN_SMOOTH = SMESH_MeshEditor.LAPLACIAN_SMOOTH
364     CENTROIDAL_SMOOTH = SMESH_MeshEditor.CENTROIDAL_SMOOTH
365
366     PrecisionConfusion = smeshPrecisionConfusion
367
368     # TopAbs_State enumeration
369     [TopAbs_IN, TopAbs_OUT, TopAbs_ON, TopAbs_UNKNOWN] = list(range(4))
370
371     # Methods of splitting a hexahedron into tetrahedra
372     Hex_5Tet, Hex_6Tet, Hex_24Tet, Hex_2Prisms, Hex_4Prisms = 1, 2, 3, 1, 2
373
374     def __new__(cls, *args):
375         global engine
376         global smeshInst
377         global doLcc
378         #print("==== __new__", engine, smeshInst, doLcc)
379
380         if smeshInst is None:
381             # smesh engine is either retrieved from engine, or created
382             smeshInst = engine
383             # Following test avoids a recursive loop
384             if doLcc:
385                 if smeshInst is not None:
386                     # smesh engine not created: existing engine found
387                     doLcc = False
388                 if doLcc:
389                     doLcc = False
390                     # FindOrLoadComponent called:
391                     # 1. CORBA resolution of server
392                     # 2. the __new__ method is called again
393                     #print("==== smeshInst = lcc.FindOrLoadComponent ", engine, smeshInst, doLcc)
394                     smeshInst = salome.lcc.FindOrLoadComponent( "FactoryServer", "SMESH" )
395             else:
396                 # FindOrLoadComponent not called
397                 if smeshInst is None:
398                     # smeshBuilder instance is created from lcc.FindOrLoadComponent
399                     #print("==== smeshInst = super(smeshBuilder,cls).__new__(cls) ", engine, smeshInst, doLcc)
400                     smeshInst = super(smeshBuilder,cls).__new__(cls)
401                 else:
402                     # smesh engine not created: existing engine found
403                     #print("==== existing ", engine, smeshInst, doLcc)
404                     pass
405             #print("====1 ", smeshInst)
406             return smeshInst
407
408         #print("====2 ", smeshInst)
409         return smeshInst
410
411     def __init__(self, *args):
412         global created
413         #print("--------------- smeshbuilder __init__ ---", created)
414         if not created:
415             created = True
416             SMESH._objref_SMESH_Gen.__init__(self, *args)
417
418
419     def DumpPython(self, theStudy, theIsPublished=True, theIsMultiFile=True):
420         """
421         Dump component to the Python script.
422         This method overrides IDL function to allow default values for the parameters.
423         """
424
425         return SMESH._objref_SMESH_Gen.DumpPython(self, theStudy, theIsPublished, theIsMultiFile)
426
427     def SetDumpPythonHistorical(self, isHistorical):
428         """
429         Set mode of DumpPython(), *historical* or *snapshot*.
430         In the *historical* mode, the Python Dump script includes all commands
431         performed by SMESH engine. In the *snapshot* mode, commands
432         relating to objects removed from the Study are excluded from the script
433         as well as commands not influencing the current state of meshes
434         """
435
436         if isHistorical: val = "true"
437         else:            val = "false"
438         SMESH._objref_SMESH_Gen.SetOption(self, "historical_python_dump", val)
439
440     def init_smesh(self,geompyD = None):
441         """
442         Set Geometry component
443         """    
444         #print("init_smesh")
445         self.UpdateStudy(geompyD)
446         notebook.myStudy = salome.myStudy
447
448     def Mesh(self, obj=0, name=0):
449         """
450         Create a mesh. This mesh can be either 
451
452         * an empty mesh not bound to geometry, if *obj* == 0
453         * an empty mesh bound to geometry, if *obj* is GEOM.GEOM_Object
454         * a mesh wrapping a :class:`CORBA mesh <SMESH.SMESH_Mesh>` given as *obj* parameter.
455
456         Parameters:
457             obj: either 
458
459                    1. a :class:`CORBA mesh <SMESH.SMESH_Mesh>` got by calling e.g.
460                       ::
461
462                         salome.myStudy.FindObjectID("0:1:2:3").GetObject() 
463
464                    2. a geometrical object for meshing
465                    3. none.
466             name: the name for the new mesh.
467
468         Returns:
469             an instance of class :class:`Mesh`.
470         """
471
472         if isinstance(obj,str):
473             obj,name = name,obj
474         return Mesh(self, self.geompyD, obj, name)
475
476     def EnumToLong(self,theItem):
477         """
478         Return a long value from enumeration
479         """
480
481         return theItem._v
482
483     def ColorToString(self,c):
484         """
485         Convert SALOMEDS.Color to string.
486         To be used with filters.
487
488         Parameters:
489             c: color value (SALOMEDS.Color)
490
491         Returns:
492             a string representation of the color.
493         """
494
495         val = ""
496         if isinstance(c, SALOMEDS.Color):
497             val = "%s;%s;%s" % (c.R, c.G, c.B)
498         elif isinstance(c, str):
499             val = c
500         else:
501             raise ValueError("Color value should be of string or SALOMEDS.Color type")
502         return val
503
504     def GetPointStruct(self,theVertex):
505         """
506         Get :class:`SMESH.PointStruct` from vertex
507
508         Parameters:
509                 theVertex (GEOM.GEOM_Object): vertex
510
511         Returns:
512                 :class:`SMESH.PointStruct`
513         """
514
515         [x, y, z] = self.geompyD.PointCoordinates(theVertex)
516         return PointStruct(x,y,z)
517
518     def GetDirStruct(self,theVector):
519         """
520         Get :class:`SMESH.DirStruct` from vector
521
522         Parameters:
523                 theVector (GEOM.GEOM_Object): vector
524
525         Returns:
526                 :class:`SMESH.DirStruct`
527         """
528
529         vertices = self.geompyD.SubShapeAll( theVector, geomBuilder.geomBuilder.ShapeType["VERTEX"] )
530         if(len(vertices) != 2):
531             print("Error: vector object is incorrect.")
532             return None
533         p1 = self.geompyD.PointCoordinates(vertices[0])
534         p2 = self.geompyD.PointCoordinates(vertices[1])
535         pnt = PointStruct(p2[0]-p1[0], p2[1]-p1[1], p2[2]-p1[2])
536         dirst = DirStruct(pnt)
537         return dirst
538
539     def MakeDirStruct(self,x,y,z):
540         """
541         Make :class:`SMESH.DirStruct` from a triplet of floats
542
543         Parameters:
544                 x,y,z (float): vector components
545
546         Returns:
547                 :class:`SMESH.DirStruct`
548         """
549
550         pnt = PointStruct(x,y,z)
551         return DirStruct(pnt)
552
553     def GetAxisStruct(self,theObj):
554         """
555         Get :class:`SMESH.AxisStruct` from a geometrical object
556
557         Parameters:
558             theObj (GEOM.GEOM_Object): line or plane
559
560         Returns:
561             :class:`SMESH.AxisStruct`
562         """
563         import GEOM
564         edges = self.geompyD.SubShapeAll( theObj, geomBuilder.geomBuilder.ShapeType["EDGE"] )
565         axis = None
566         if len(edges) > 1:
567             vertex1, vertex2 = self.geompyD.SubShapeAll( edges[0], geomBuilder.geomBuilder.ShapeType["VERTEX"] )
568             vertex3, vertex4 = self.geompyD.SubShapeAll( edges[1], geomBuilder.geomBuilder.ShapeType["VERTEX"] )
569             vertex1 = self.geompyD.PointCoordinates(vertex1)
570             vertex2 = self.geompyD.PointCoordinates(vertex2)
571             vertex3 = self.geompyD.PointCoordinates(vertex3)
572             vertex4 = self.geompyD.PointCoordinates(vertex4)
573             v1 = [vertex2[0]-vertex1[0], vertex2[1]-vertex1[1], vertex2[2]-vertex1[2]]
574             v2 = [vertex4[0]-vertex3[0], vertex4[1]-vertex3[1], vertex4[2]-vertex3[2]]
575             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] ]
576             axis = AxisStruct(vertex1[0], vertex1[1], vertex1[2], normal[0], normal[1], normal[2])
577             axis._mirrorType = SMESH.SMESH_MeshEditor.PLANE
578         elif len(edges) == 1:
579             vertex1, vertex2 = self.geompyD.SubShapeAll( edges[0], geomBuilder.geomBuilder.ShapeType["VERTEX"] )
580             p1 = self.geompyD.PointCoordinates( vertex1 )
581             p2 = self.geompyD.PointCoordinates( vertex2 )
582             axis = AxisStruct(p1[0], p1[1], p1[2], p2[0]-p1[0], p2[1]-p1[1], p2[2]-p1[2])
583             axis._mirrorType = SMESH.SMESH_MeshEditor.AXIS
584         elif theObj.GetShapeType() == GEOM.VERTEX:
585             x,y,z = self.geompyD.PointCoordinates( theObj )
586             axis = AxisStruct( x,y,z, 1,0,0,)
587             axis._mirrorType = SMESH.SMESH_MeshEditor.POINT
588         return axis
589
590     # From SMESH_Gen interface:
591     # ------------------------
592
593     def SetName(self, obj, name):
594         """
595         Set the given name to an object
596
597         Parameters:
598                 obj: the object to rename
599                 name: a new object name
600         """
601
602         if isinstance( obj, Mesh ):
603             obj = obj.GetMesh()
604         elif isinstance( obj, Mesh_Algorithm ):
605             obj = obj.GetAlgorithm()
606         ior  = salome.orb.object_to_string(obj)
607         SMESH._objref_SMESH_Gen.SetName(self, ior, name)
608
609     def SetEmbeddedMode( self,theMode ):
610         """
611         Set the current mode
612         """
613
614         SMESH._objref_SMESH_Gen.SetEmbeddedMode(self,theMode)
615
616     def IsEmbeddedMode(self):
617         """
618         Get the current mode
619         """
620
621         return SMESH._objref_SMESH_Gen.IsEmbeddedMode(self)
622
623     def UpdateStudy( self, geompyD = None  ):
624         """
625         Update the current study. Calling UpdateStudy() allows to
626         update meshes at switching GEOM->SMESH
627         """
628         #self.UpdateStudy()
629         if not geompyD:
630             from salome.geom import geomBuilder
631             geompyD = geomBuilder.geom
632             if not geompyD:
633                 geompyD = geomBuilder.New()
634             pass
635         self.geompyD=geompyD
636         self.SetGeomEngine(geompyD)
637         SMESH._objref_SMESH_Gen.UpdateStudy(self)
638         sb = salome.myStudy.NewBuilder()
639         sc = salome.myStudy.FindComponent("SMESH")
640         if sc:
641             sb.LoadWith(sc, self)
642         pass
643     
644     def SetEnablePublish( self, theIsEnablePublish ):
645         """
646         Set enable publishing in the study. Calling SetEnablePublish( False ) allows to
647         switch **off** publishing in the Study of mesh objects.
648         """
649        #self.SetEnablePublish(theIsEnablePublish)
650         SMESH._objref_SMESH_Gen.SetEnablePublish(self,theIsEnablePublish)
651         global notebook
652         notebook = salome_notebook.NoteBook( theIsEnablePublish )
653
654
655     def CreateMeshesFromUNV( self,theFileName ):
656         """
657         Create a Mesh object importing data from the given UNV file
658
659         Returns:
660                 an instance of class :class:`Mesh`
661         """
662
663         aSmeshMesh = SMESH._objref_SMESH_Gen.CreateMeshesFromUNV(self,theFileName)
664         aMesh = Mesh(self, self.geompyD, aSmeshMesh)
665         return aMesh
666
667     def CreateMeshesFromMED( self,theFileName ):
668         """
669         Create a Mesh object(s) importing data from the given MED file
670
671         Returns:
672                 a tuple ( list of class :class:`Mesh` instances, 
673                 :class:`SMESH.DriverMED_ReadStatus` )
674         """
675
676         aSmeshMeshes, aStatus = SMESH._objref_SMESH_Gen.CreateMeshesFromMED(self,theFileName)
677         aMeshes = [ Mesh(self, self.geompyD, m) for m in aSmeshMeshes ]
678         return aMeshes, aStatus
679
680     def CreateMeshesFromSAUV( self,theFileName ):
681         """
682         Create a Mesh object(s) importing data from the given SAUV file
683
684         Returns:
685                 a tuple ( list of class :class:`Mesh` instances, :class:`SMESH.DriverMED_ReadStatus` )
686         """
687
688         aSmeshMeshes, aStatus = SMESH._objref_SMESH_Gen.CreateMeshesFromSAUV(self,theFileName)
689         aMeshes = [ Mesh(self, self.geompyD, m) for m in aSmeshMeshes ]
690         return aMeshes, aStatus
691
692     def CreateMeshesFromSTL( self, theFileName ):
693         """
694         Create a Mesh object importing data from the given STL file
695
696         Returns:
697                 an instance of class :class:`Mesh`
698         """
699
700         aSmeshMesh = SMESH._objref_SMESH_Gen.CreateMeshesFromSTL(self,theFileName)
701         aMesh = Mesh(self, self.geompyD, aSmeshMesh)
702         return aMesh
703
704     def CreateMeshesFromCGNS( self, theFileName ):
705         """
706         Create Mesh objects importing data from the given CGNS file
707
708         Returns:
709                 a tuple ( list of class :class:`Mesh` instances, :class:`SMESH.DriverMED_ReadStatus` )
710         """
711
712         aSmeshMeshes, aStatus = SMESH._objref_SMESH_Gen.CreateMeshesFromCGNS(self,theFileName)
713         aMeshes = [ Mesh(self, self.geompyD, m) for m in aSmeshMeshes ]
714         return aMeshes, aStatus
715
716     def CreateMeshesFromGMF( self, theFileName ):
717         """
718         Create a Mesh object importing data from the given GMF file.
719         GMF files must have .mesh extension for the ASCII format and .meshb for
720         the binary format.
721
722         Returns:
723                 ( an instance of class :class:`Mesh`, :class:`SMESH.ComputeError` )
724         """
725
726         aSmeshMesh, error = SMESH._objref_SMESH_Gen.CreateMeshesFromGMF(self,
727                                                                         theFileName,
728                                                                         True)
729         if error.comment: print("*** CreateMeshesFromGMF() errors:\n", error.comment)
730         return Mesh(self, self.geompyD, aSmeshMesh), error
731
732     def Concatenate( self, meshes, uniteIdenticalGroups,
733                      mergeNodesAndElements = False, mergeTolerance = 1e-5, allGroups = False,
734                      name = ""):
735         """
736         Concatenate the given meshes into one mesh. All groups of input meshes will be
737         present in the new mesh.
738
739         Parameters:
740                 meshes: :class:`meshes, sub-meshes, groups or filters <SMESH.SMESH_IDSource>` to combine into one mesh
741                 uniteIdenticalGroups: if True, groups with same names are united, else they are renamed
742                 mergeNodesAndElements: if True, equal nodes and elements are merged
743                 mergeTolerance: tolerance for merging nodes
744                 allGroups: forces creation of groups corresponding to every input mesh
745                 name: name of a new mesh
746
747         Returns:
748                 an instance of class :class:`Mesh`
749         """
750
751         if not meshes: return None
752         for i,m in enumerate(meshes):
753             if isinstance(m, Mesh):
754                 meshes[i] = m.GetMesh()
755         mergeTolerance,Parameters,hasVars = ParseParameters(mergeTolerance)
756         meshes[0].SetParameters(Parameters)
757         if allGroups:
758             aSmeshMesh = SMESH._objref_SMESH_Gen.ConcatenateWithGroups(
759                 self,meshes,uniteIdenticalGroups,mergeNodesAndElements,mergeTolerance)
760         else:
761             aSmeshMesh = SMESH._objref_SMESH_Gen.Concatenate(
762                 self,meshes,uniteIdenticalGroups,mergeNodesAndElements,mergeTolerance)
763         aMesh = Mesh(self, self.geompyD, aSmeshMesh, name=name)
764         return aMesh
765
766     def CopyMesh( self, meshPart, meshName, toCopyGroups=False, toKeepIDs=False):
767         """
768         Create a mesh by copying a part of another mesh.
769
770         Parameters:
771                 meshPart: a part of mesh to copy, either 
772                         :class:`mesh, sub-mesh, group or filter <SMESH.SMESH_IDSource>`.
773                         To copy nodes or elements not forming any mesh object,
774                         pass result of :meth:`Mesh.GetIDSource` as *meshPart*
775                 meshName: a name of the new mesh
776                 toCopyGroups: to create in the new mesh groups the copied elements belongs to
777                 toKeepIDs: to preserve order of the copied elements or not
778
779         Returns:
780                 an instance of class :class:`Mesh`
781         """
782
783         if (isinstance( meshPart, Mesh )):
784             meshPart = meshPart.GetMesh()
785         mesh = SMESH._objref_SMESH_Gen.CopyMesh( self,meshPart,meshName,toCopyGroups,toKeepIDs )
786         return Mesh(self, self.geompyD, mesh)
787
788     def GetSubShapesId( self, theMainObject, theListOfSubObjects ):
789         """
790         Return IDs of sub-shapes
791
792         Parameters:
793                 theMainObject (GEOM.GEOM_Object): a shape
794                 theListOfSubObjects: sub-shapes (list of GEOM.GEOM_Object)
795         Returns:
796                 the list of integer values
797         """
798
799         return SMESH._objref_SMESH_Gen.GetSubShapesId(self,theMainObject, theListOfSubObjects)
800
801     def GetPattern(self):
802         """
803         Create a pattern mapper.
804
805         Returns:
806                 an instance of :class:`SMESH.SMESH_Pattern`
807
808         :ref:`Example of Patterns usage <tui_pattern_mapping>`
809         """
810
811         return SMESH._objref_SMESH_Gen.GetPattern(self)
812
813     def SetBoundaryBoxSegmentation(self, nbSegments):
814         """
815         Set number of segments per diagonal of boundary box of geometry, by which
816         default segment length of appropriate 1D hypotheses is defined in GUI.
817         Default value is 10.
818         """
819
820         SMESH._objref_SMESH_Gen.SetBoundaryBoxSegmentation(self,nbSegments)
821
822     # Filtering. Auxiliary functions:
823     # ------------------------------
824
825     def GetEmptyCriterion(self):
826         """
827         Create an empty criterion
828
829         Returns:
830                 :class:`SMESH.Filter.Criterion`
831         """
832
833         Type = self.EnumToLong(FT_Undefined)
834         Compare = self.EnumToLong(FT_Undefined)
835         Threshold = 0
836         ThresholdStr = ""
837         ThresholdID = ""
838         UnaryOp = self.EnumToLong(FT_Undefined)
839         BinaryOp = self.EnumToLong(FT_Undefined)
840         Tolerance = 1e-07
841         TypeOfElement = ALL
842         Precision = -1 ##@1e-07
843         return Filter.Criterion(Type, Compare, Threshold, ThresholdStr, ThresholdID,
844                                 UnaryOp, BinaryOp, Tolerance, TypeOfElement, Precision)
845
846     def GetCriterion(self,elementType,
847                      CritType,
848                      Compare = FT_EqualTo,
849                      Threshold="",
850                      UnaryOp=FT_Undefined,
851                      BinaryOp=FT_Undefined,
852                      Tolerance=1e-07):
853         """
854         Create a criterion by the given parameters
855         Criterion structures allow to define complex filters by combining them with logical operations (AND / OR) (see example below)
856
857         Parameters:
858                 elementType: the :class:`type of elements <SMESH.ElementType>` (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME)
859                 CritType: the type of criterion :class:`SMESH.FunctorType` (SMESH.FT_Taper, SMESH.FT_Area, etc.).
860                         Note that the items starting from FT_LessThan are not suitable for *CritType*.
861                 Compare:  belongs to {SMESH.FT_LessThan, SMESH.FT_MoreThan, SMESH.FT_EqualTo}
862                 Threshold: the threshold value (range of ids as string, shape, numeric)
863                 UnaryOp:  SMESH.FT_LogicalNOT or SMESH.FT_Undefined
864                 BinaryOp: a binary logical operation SMESH.FT_LogicalAND, SMESH.FT_LogicalOR or
865                         SMESH.FT_Undefined
866                 Tolerance: the tolerance used by SMESH.FT_BelongToGeom, SMESH.FT_BelongToSurface,
867                         SMESH.FT_LyingOnGeom, SMESH.FT_CoplanarFaces criteria
868
869         Returns:
870                 :class:`SMESH.Filter.Criterion`
871
872         Example: :ref:`combining_filters`
873         """
874
875         if not CritType in SMESH.FunctorType._items:
876             raise TypeError("CritType should be of SMESH.FunctorType")
877         aCriterion               = self.GetEmptyCriterion()
878         aCriterion.TypeOfElement = elementType
879         aCriterion.Type          = self.EnumToLong(CritType)
880         aCriterion.Tolerance     = Tolerance
881
882         aThreshold = Threshold
883
884         if Compare in [FT_LessThan, FT_MoreThan, FT_EqualTo]:
885             aCriterion.Compare = self.EnumToLong(Compare)
886         elif Compare == "=" or Compare == "==":
887             aCriterion.Compare = self.EnumToLong(FT_EqualTo)
888         elif Compare == "<":
889             aCriterion.Compare = self.EnumToLong(FT_LessThan)
890         elif Compare == ">":
891             aCriterion.Compare = self.EnumToLong(FT_MoreThan)
892         elif Compare != FT_Undefined:
893             aCriterion.Compare = self.EnumToLong(FT_EqualTo)
894             aThreshold = Compare
895
896         if CritType in [FT_BelongToGeom,     FT_BelongToPlane, FT_BelongToGenSurface,
897                         FT_BelongToCylinder, FT_LyingOnGeom]:
898             # Check that Threshold is GEOM object
899             if isinstance(aThreshold, geomBuilder.GEOM._objref_GEOM_Object):
900                 aCriterion.ThresholdStr = GetName(aThreshold)
901                 aCriterion.ThresholdID  = aThreshold.GetStudyEntry()
902                 if not aCriterion.ThresholdID:
903                     name = aCriterion.ThresholdStr
904                     if not name:
905                         name = "%s_%s"%(aThreshold.GetShapeType(), id(aThreshold)%10000)
906                     aCriterion.ThresholdID = self.geompyD.addToStudy( aThreshold, name )
907             # or a name of GEOM object
908             elif isinstance( aThreshold, str ):
909                 aCriterion.ThresholdStr = aThreshold
910             else:
911                 raise TypeError("The Threshold should be a shape.")
912             if isinstance(UnaryOp,float):
913                 aCriterion.Tolerance = UnaryOp
914                 UnaryOp = FT_Undefined
915                 pass
916         elif CritType == FT_BelongToMeshGroup:
917             # Check that Threshold is a group
918             if isinstance(aThreshold, SMESH._objref_SMESH_GroupBase):
919                 if aThreshold.GetType() != elementType:
920                     raise ValueError("Group type mismatches Element type")
921                 aCriterion.ThresholdStr = aThreshold.GetName()
922                 aCriterion.ThresholdID  = salome.orb.object_to_string( aThreshold )
923                 study = salome.myStudy
924                 if study:
925                     so = study.FindObjectIOR( aCriterion.ThresholdID )
926                     if so:
927                         entry = so.GetID()
928                         if entry:
929                             aCriterion.ThresholdID = entry
930             else:
931                 raise TypeError("The Threshold should be a Mesh Group")
932         elif CritType == FT_RangeOfIds:
933             # Check that Threshold is string
934             if isinstance(aThreshold, str):
935                 aCriterion.ThresholdStr = aThreshold
936             else:
937                 raise TypeError("The Threshold should be a string.")
938         elif CritType == FT_CoplanarFaces:
939             # Check the Threshold
940             if isinstance(aThreshold, int):
941                 aCriterion.ThresholdID = str(aThreshold)
942             elif isinstance(aThreshold, str):
943                 ID = int(aThreshold)
944                 if ID < 1:
945                     raise ValueError("Invalid ID of mesh face: '%s'"%aThreshold)
946                 aCriterion.ThresholdID = aThreshold
947             else:
948                 raise TypeError("The Threshold should be an ID of mesh face and not '%s'"%aThreshold)
949         elif CritType == FT_ConnectedElements:
950             # Check the Threshold
951             if isinstance(aThreshold, geomBuilder.GEOM._objref_GEOM_Object): # shape
952                 aCriterion.ThresholdID = aThreshold.GetStudyEntry()
953                 if not aCriterion.ThresholdID:
954                     name = aThreshold.GetName()
955                     if not name:
956                         name = "%s_%s"%(aThreshold.GetShapeType(), id(aThreshold)%10000)
957                     aCriterion.ThresholdID = self.geompyD.addToStudy( aThreshold, name )
958             elif isinstance(aThreshold, int): # node id
959                 aCriterion.Threshold = aThreshold
960             elif isinstance(aThreshold, list): # 3 point coordinates
961                 if len( aThreshold ) < 3:
962                     raise ValueError("too few point coordinates, must be 3")
963                 aCriterion.ThresholdStr = " ".join( [str(c) for c in aThreshold[:3]] )
964             elif isinstance(aThreshold, str):
965                 if aThreshold.isdigit():
966                     aCriterion.Threshold = aThreshold # node id
967                 else:
968                     aCriterion.ThresholdStr = aThreshold # hope that it's point coordinates
969             else:
970                 raise TypeError("The Threshold should either a VERTEX, or a node ID, "\
971                       "or a list of point coordinates and not '%s'"%aThreshold)
972         elif CritType == FT_ElemGeomType:
973             # Check the Threshold
974             try:
975                 aCriterion.Threshold = self.EnumToLong(aThreshold)
976                 assert( aThreshold in SMESH.GeometryType._items )
977             except:
978                 if isinstance(aThreshold, int):
979                     aCriterion.Threshold = aThreshold
980                 else:
981                     raise TypeError("The Threshold should be an integer or SMESH.GeometryType.")
982                 pass
983             pass
984         elif CritType == FT_EntityType:
985             # Check the Threshold
986             try:
987                 aCriterion.Threshold = self.EnumToLong(aThreshold)
988                 assert( aThreshold in SMESH.EntityType._items )
989             except:
990                 if isinstance(aThreshold, int):
991                     aCriterion.Threshold = aThreshold
992                 else:
993                     raise TypeError("The Threshold should be an integer or SMESH.EntityType.")
994                 pass
995             pass
996
997         elif CritType == FT_GroupColor:
998             # Check the Threshold
999             try:
1000                 aCriterion.ThresholdStr = self.ColorToString(aThreshold)
1001             except:
1002                 raise TypeError("The threshold value should be of SALOMEDS.Color type")
1003             pass
1004         elif CritType in [FT_FreeBorders, FT_FreeEdges, FT_FreeNodes, FT_FreeFaces,
1005                           FT_LinearOrQuadratic, FT_BadOrientedVolume,
1006                           FT_BareBorderFace, FT_BareBorderVolume,
1007                           FT_OverConstrainedFace, FT_OverConstrainedVolume,
1008                           FT_EqualNodes,FT_EqualEdges,FT_EqualFaces,FT_EqualVolumes ]:
1009             # At this point the Threshold is unnecessary
1010             if aThreshold ==  FT_LogicalNOT:
1011                 aCriterion.UnaryOp = self.EnumToLong(FT_LogicalNOT)
1012             elif aThreshold in [FT_LogicalAND, FT_LogicalOR]:
1013                 aCriterion.BinaryOp = aThreshold
1014         else:
1015             # Check Threshold
1016             try:
1017                 aThreshold = float(aThreshold)
1018                 aCriterion.Threshold = aThreshold
1019             except:
1020                 raise TypeError("The Threshold should be a number.")
1021                 return None
1022
1023         if Threshold ==  FT_LogicalNOT or UnaryOp ==  FT_LogicalNOT:
1024             aCriterion.UnaryOp = self.EnumToLong(FT_LogicalNOT)
1025
1026         if Threshold in [FT_LogicalAND, FT_LogicalOR]:
1027             aCriterion.BinaryOp = self.EnumToLong(Threshold)
1028
1029         if UnaryOp in [FT_LogicalAND, FT_LogicalOR]:
1030             aCriterion.BinaryOp = self.EnumToLong(UnaryOp)
1031
1032         if BinaryOp in [FT_LogicalAND, FT_LogicalOR]:
1033             aCriterion.BinaryOp = self.EnumToLong(BinaryOp)
1034
1035         return aCriterion
1036
1037     def GetFilter(self,elementType,
1038                   CritType=FT_Undefined,
1039                   Compare=FT_EqualTo,
1040                   Threshold="",
1041                   UnaryOp=FT_Undefined,
1042                   Tolerance=1e-07,
1043                   mesh=None):
1044         """
1045         Create a filter with the given parameters
1046
1047         Parameters:
1048                 elementType: the :class:`type of elements <SMESH.ElementType>` (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME)
1049                 CritType: the :class:`type of criterion <SMESH.FunctorType>` (SMESH.FT_Taper, SMESH.FT_Area, etc.).
1050                         Note that the items starting from FT_LessThan are not suitable for CritType.
1051                 Compare: belongs to {SMESH.FT_LessThan, SMESH.FT_MoreThan, SMESH.FT_EqualTo}
1052                 Threshold: the threshold value (range of ids as string, shape, numeric)
1053                 UnaryOp:  SMESH.FT_LogicalNOT or SMESH.FT_Undefined
1054                 Tolerance: the tolerance used by SMESH.FT_BelongToGeom, SMESH.FT_BelongToSurface,
1055                         SMESH.FT_LyingOnGeom, SMESH.FT_CoplanarFaces and SMESH.FT_EqualNodes criteria
1056                 mesh: the mesh to initialize the filter with
1057
1058         Returns:
1059                 :class:`SMESH.Filter`
1060
1061         Examples:
1062                See :doc:`Filters usage examples <tui_filters>`
1063         """
1064
1065         aCriterion = self.GetCriterion(elementType, CritType, Compare, Threshold, UnaryOp, FT_Undefined,Tolerance)
1066         aFilterMgr = self.CreateFilterManager()
1067         aFilter = aFilterMgr.CreateFilter()
1068         aCriteria = []
1069         aCriteria.append(aCriterion)
1070         aFilter.SetCriteria(aCriteria)
1071         if mesh:
1072             if isinstance( mesh, Mesh ): aFilter.SetMesh( mesh.GetMesh() )
1073             else                       : aFilter.SetMesh( mesh )
1074         aFilterMgr.UnRegister()
1075         return aFilter
1076
1077     def GetFilterFromCriteria(self,criteria, binOp=SMESH.FT_LogicalAND):
1078         """
1079         Create a filter from criteria
1080
1081         Parameters:
1082                 criteria: a list of :class:`SMESH.Filter.Criterion`
1083                 binOp: binary operator used when binary operator of criteria is undefined
1084
1085         Returns:
1086                 :class:`SMESH.Filter`
1087
1088         Examples:
1089                See :doc:`Filters usage examples <tui_filters>`
1090         """
1091
1092         for i in range( len( criteria ) - 1 ):
1093             if criteria[i].BinaryOp == self.EnumToLong( SMESH.FT_Undefined ):
1094                 criteria[i].BinaryOp = self.EnumToLong( binOp )
1095         aFilterMgr = self.CreateFilterManager()
1096         aFilter = aFilterMgr.CreateFilter()
1097         aFilter.SetCriteria(criteria)
1098         aFilterMgr.UnRegister()
1099         return aFilter
1100
1101     def GetFunctor(self,theCriterion):
1102         """
1103         Create a numerical functor by its type
1104
1105         Parameters:
1106                 theCriterion (SMESH.FunctorType): functor type.
1107                         Note that not all items correspond to numerical functors.
1108
1109         Returns:
1110                 :class:`SMESH.NumericalFunctor`
1111         """
1112
1113         if isinstance( theCriterion, SMESH._objref_NumericalFunctor ):
1114             return theCriterion
1115         aFilterMgr = self.CreateFilterManager()
1116         functor = None
1117         if theCriterion == FT_AspectRatio:
1118             functor = aFilterMgr.CreateAspectRatio()
1119         elif theCriterion == FT_AspectRatio3D:
1120             functor = aFilterMgr.CreateAspectRatio3D()
1121         elif theCriterion == FT_Warping:
1122             functor = aFilterMgr.CreateWarping()
1123         elif theCriterion == FT_MinimumAngle:
1124             functor = aFilterMgr.CreateMinimumAngle()
1125         elif theCriterion == FT_Taper:
1126             functor = aFilterMgr.CreateTaper()
1127         elif theCriterion == FT_Skew:
1128             functor = aFilterMgr.CreateSkew()
1129         elif theCriterion == FT_Area:
1130             functor = aFilterMgr.CreateArea()
1131         elif theCriterion == FT_Volume3D:
1132             functor = aFilterMgr.CreateVolume3D()
1133         elif theCriterion == FT_MaxElementLength2D:
1134             functor = aFilterMgr.CreateMaxElementLength2D()
1135         elif theCriterion == FT_MaxElementLength3D:
1136             functor = aFilterMgr.CreateMaxElementLength3D()
1137         elif theCriterion == FT_MultiConnection:
1138             functor = aFilterMgr.CreateMultiConnection()
1139         elif theCriterion == FT_MultiConnection2D:
1140             functor = aFilterMgr.CreateMultiConnection2D()
1141         elif theCriterion == FT_Length:
1142             functor = aFilterMgr.CreateLength()
1143         elif theCriterion == FT_Length2D:
1144             functor = aFilterMgr.CreateLength2D()
1145         elif theCriterion == FT_Deflection2D:
1146             functor = aFilterMgr.CreateDeflection2D()
1147         elif theCriterion == FT_NodeConnectivityNumber:
1148             functor = aFilterMgr.CreateNodeConnectivityNumber()
1149         elif theCriterion == FT_BallDiameter:
1150             functor = aFilterMgr.CreateBallDiameter()
1151         else:
1152             print("Error: given parameter is not numerical functor type.")
1153         aFilterMgr.UnRegister()
1154         return functor
1155
1156     def CreateHypothesis(self, theHType, theLibName="libStdMeshersEngine.so"):
1157         """
1158         Create hypothesis
1159
1160         Parameters:
1161                 theHType (string): mesh hypothesis type
1162                 theLibName (string): mesh plug-in library name
1163
1164         Returns:
1165                 created hypothesis instance
1166         """
1167         hyp = SMESH._objref_SMESH_Gen.CreateHypothesis(self, theHType, theLibName )
1168
1169         if isinstance( hyp, SMESH._objref_SMESH_Algo ):
1170             return hyp
1171
1172         # wrap hypothesis methods
1173         for meth_name in dir( hyp.__class__ ):
1174             if not meth_name.startswith("Get") and \
1175                not meth_name in dir ( SMESH._objref_SMESH_Hypothesis ):
1176                 method = getattr ( hyp.__class__, meth_name )
1177                 if callable(method):
1178                     setattr( hyp, meth_name, hypMethodWrapper( hyp, method ))
1179
1180         return hyp
1181
1182     def GetMeshInfo(self, obj):
1183         """
1184         Get the mesh statistic.
1185         Use :meth:`smeshBuilder.EnumToLong` to get an integer from 
1186         an item of :class:`SMESH.EntityType`.
1187
1188         Returns:
1189                 dictionary { :class:`SMESH.EntityType` - "count of elements" }
1190         """
1191
1192         if isinstance( obj, Mesh ):
1193             obj = obj.GetMesh()
1194         d = {}
1195         if hasattr(obj, "GetMeshInfo"):
1196             values = obj.GetMeshInfo()
1197             for i in range(SMESH.Entity_Last._v):
1198                 if i < len(values): d[SMESH.EntityType._item(i)]=values[i]
1199             pass
1200         return d
1201
1202     def MinDistance(self, src1, src2=None, id1=0, id2=0, isElem1=False, isElem2=False):
1203         """
1204         Get minimum distance between two objects
1205
1206         * If *src2* is None, and *id2* = 0, distance from *src1* / *id1* to the origin is computed.
1207         * If *src2* is None, and *id2* != 0, it is assumed that both *id1* and *id2* belong to *src1*.
1208
1209         Parameters:
1210                 src1 (SMESH.SMESH_IDSource): first source object
1211                 src2 (SMESH.SMESH_IDSource): second source object
1212                 id1 (int): node/element id from the first source
1213                 id2 (int): node/element id from the second (or first) source
1214                 isElem1 (boolean): *True* if *id1* is element id, *False* if it is node id
1215                 isElem2 (boolean): *True* if *id2* is element id, *False* if it is node id
1216
1217         Returns:
1218                 minimum distance value
1219
1220         See also: 
1221                 :meth:`GetMinDistance`
1222         """
1223
1224         result = self.GetMinDistance(src1, src2, id1, id2, isElem1, isElem2)
1225         if result is None:
1226             result = 0.0
1227         else:
1228             result = result.value
1229         return result
1230
1231     def GetMinDistance(self, src1, src2=None, id1=0, id2=0, isElem1=False, isElem2=False):
1232         """
1233         Get :class:`SMESH.Measure` structure specifying minimum distance data between two objects
1234
1235         * If *src2* is None, and *id2*  = 0, distance from *src1* / *id1* to the origin is computed.
1236         * If *src2* is None, and *id2* != 0, it is assumed that both *id1* and *id2* belong to *src1*.
1237
1238         Parameters:
1239                 src1 (SMESH.SMESH_IDSource): first source object
1240                 src2 (SMESH.SMESH_IDSource): second source object
1241                 id1 (int): node/element id from the first source
1242                 id2 (int): node/element id from the second (or first) source
1243                 isElem1 (boolean): *True* if **id1** is element id, *False* if it is node id
1244                 isElem2 (boolean): *True* if **id2** is element id, *False* if it is node id
1245
1246         Returns:
1247                 :class:`SMESH.Measure` structure or None if input data is invalid
1248         See also: 
1249                 :meth:`MinDistance`
1250         """
1251
1252         if isinstance(src1, Mesh): src1 = src1.mesh
1253         if isinstance(src2, Mesh): src2 = src2.mesh
1254         if src2 is None and id2 != 0: src2 = src1
1255         if not hasattr(src1, "_narrow"): return None
1256         src1 = src1._narrow(SMESH.SMESH_IDSource)
1257         if not src1: return None
1258         unRegister = genObjUnRegister()
1259         if id1 != 0:
1260             m = src1.GetMesh()
1261             e = m.GetMeshEditor()
1262             if isElem1:
1263                 src1 = e.MakeIDSource([id1], SMESH.FACE)
1264             else:
1265                 src1 = e.MakeIDSource([id1], SMESH.NODE)
1266             unRegister.set( src1 )
1267             pass
1268         if hasattr(src2, "_narrow"):
1269             src2 = src2._narrow(SMESH.SMESH_IDSource)
1270             if src2 and id2 != 0:
1271                 m = src2.GetMesh()
1272                 e = m.GetMeshEditor()
1273                 if isElem2:
1274                     src2 = e.MakeIDSource([id2], SMESH.FACE)
1275                 else:
1276                     src2 = e.MakeIDSource([id2], SMESH.NODE)
1277                 unRegister.set( src2 )
1278                 pass
1279             pass
1280         aMeasurements = self.CreateMeasurements()
1281         unRegister.set( aMeasurements )
1282         result = aMeasurements.MinDistance(src1, src2)
1283         return result
1284
1285     def BoundingBox(self, objects):
1286         """
1287         Get bounding box of the specified object(s)
1288
1289         Parameters:
1290                 objects (SMESH.SMESH_IDSource): single source object or list of source objects
1291
1292         Returns:
1293                 tuple of six values (minX, minY, minZ, maxX, maxY, maxZ)
1294
1295         See also: 
1296                :meth:`GetBoundingBox`
1297         """
1298
1299         result = self.GetBoundingBox(objects)
1300         if result is None:
1301             result = (0.0,)*6
1302         else:
1303             result = (result.minX, result.minY, result.minZ, result.maxX, result.maxY, result.maxZ)
1304         return result
1305
1306     def GetBoundingBox(self, objects):
1307         """
1308         Get :class:`SMESH.Measure` structure specifying bounding box data of the specified object(s)
1309
1310         Parameters:
1311                 objects (SMESH.SMESH_IDSource): single source object or list of source objects
1312
1313         Returns:
1314                 :class:`SMESH.Measure` structure
1315
1316         See also: 
1317                 :meth:`BoundingBox`
1318         """
1319
1320         if isinstance(objects, tuple):
1321             objects = list(objects)
1322         if not isinstance(objects, list):
1323             objects = [objects]
1324         srclist = []
1325         for o in objects:
1326             if isinstance(o, Mesh):
1327                 srclist.append(o.mesh)
1328             elif hasattr(o, "_narrow"):
1329                 src = o._narrow(SMESH.SMESH_IDSource)
1330                 if src: srclist.append(src)
1331                 pass
1332             pass
1333         aMeasurements = self.CreateMeasurements()
1334         result = aMeasurements.BoundingBox(srclist)
1335         aMeasurements.UnRegister()
1336         return result
1337
1338     def GetLength(self, obj):
1339         """
1340         Get sum of lengths of all 1D elements in the mesh object.
1341
1342         Parameters:
1343                 obj: :class:`mesh, sub-mesh, group or filter <SMESH.SMESH_IDSource>`
1344
1345         Returns:
1346                 sum of lengths of all 1D elements
1347         """
1348
1349         if isinstance(obj, Mesh): obj = obj.mesh
1350         if isinstance(obj, Mesh_Algorithm): obj = obj.GetSubMesh()
1351         aMeasurements = self.CreateMeasurements()
1352         value = aMeasurements.Length(obj)
1353         aMeasurements.UnRegister()
1354         return value
1355
1356     def GetArea(self, obj):
1357         """
1358         Get sum of areas of all 2D elements in the mesh object.
1359
1360         Parameters:
1361                 obj: :class:`mesh, sub-mesh, group or filter <SMESH.SMESH_IDSource>`
1362
1363         Returns:
1364                 sum of areas of all 2D elements
1365         """
1366
1367         if isinstance(obj, Mesh): obj = obj.mesh
1368         if isinstance(obj, Mesh_Algorithm): obj = obj.GetSubMesh()
1369         aMeasurements = self.CreateMeasurements()
1370         value = aMeasurements.Area(obj)
1371         aMeasurements.UnRegister()
1372         return value
1373
1374     def GetVolume(self, obj):
1375         """
1376         Get sum of volumes of all 3D elements in the mesh object.
1377
1378         Parameters:
1379                 obj: :class:`mesh, sub-mesh, group or filter <SMESH.SMESH_IDSource>`
1380
1381         Returns:
1382                 sum of volumes of all 3D elements
1383         """
1384
1385         if isinstance(obj, Mesh): obj = obj.mesh
1386         if isinstance(obj, Mesh_Algorithm): obj = obj.GetSubMesh()
1387         aMeasurements = self.CreateMeasurements()
1388         value = aMeasurements.Volume(obj)
1389         aMeasurements.UnRegister()
1390         return value
1391
1392     def GetGravityCenter(self, obj):
1393         """
1394         Get gravity center of all nodes of the mesh object.
1395         
1396         Parameters:            
1397                 obj: :class:`mesh, sub-mesh, group or filter <SMESH.SMESH_IDSource>`
1398
1399         Returns:        
1400             Three components of the gravity center (x,y,z)
1401         """
1402         if isinstance(obj, Mesh): obj = obj.mesh
1403         if isinstance(obj, Mesh_Algorithm): obj = obj.GetSubMesh()
1404         aMeasurements = self.CreateMeasurements()
1405         pointStruct = aMeasurements.GravityCenter(obj)
1406         aMeasurements.UnRegister()
1407         return pointStruct.x, pointStruct.y, pointStruct.z
1408
1409     pass # end of class smeshBuilder
1410
1411 import omniORB
1412 omniORB.registerObjref(SMESH._objref_SMESH_Gen._NP_RepositoryId, smeshBuilder)
1413 """Registering the new proxy for SMESH.SMESH_Gen"""
1414
1415
1416 def New( instance=None, instanceGeom=None):
1417     """
1418     Create a new smeshBuilder instance. The smeshBuilder class provides the Python
1419     interface to create or load meshes.
1420
1421     Typical use is::
1422
1423         import salome
1424         salome.salome_init()
1425         from salome.smesh import smeshBuilder
1426         smesh = smeshBuilder.New()
1427
1428     Parameters:
1429         instance:      CORBA proxy of SMESH Engine. If None, the default Engine is used.
1430         instanceGeom:  CORBA proxy of GEOM  Engine. If None, the default Engine is used.
1431     Returns:
1432         :class:`smeshBuilder` instance
1433     """
1434     global engine
1435     global smeshInst
1436     global doLcc
1437     if instance and isinstance( instance, SALOMEDS._objref_Study ):
1438         import sys
1439         sys.stderr.write("Warning: 'study' argument is no more needed in smeshBuilder.New(). Consider updating your script!!!\n\n")
1440         instance = None
1441     engine = instance
1442     if engine is None:
1443         doLcc = True
1444     smeshInst = smeshBuilder()
1445     assert isinstance(smeshInst,smeshBuilder), "Smesh engine class is %s but should be smeshBuilder.smeshBuilder. Import salome.smesh.smeshBuilder before creating the instance."%smeshInst.__class__
1446     smeshInst.init_smesh(instanceGeom)
1447     return smeshInst
1448
1449
1450 # Public class: Mesh
1451 # ==================
1452
1453
1454 class Mesh(metaclass = MeshMeta):
1455     """
1456     This class allows defining and managing a mesh.
1457     It has a set of methods to build a mesh on the given geometry, including the definition of sub-meshes.
1458     It also has methods to define groups of mesh elements, to modify a mesh (by addition of
1459     new nodes and elements and by changing the existing entities), to get information
1460     about a mesh and to export a mesh in different formats.
1461     """    
1462
1463     geom = 0
1464     mesh = 0
1465     editor = 0
1466
1467     def __init__(self, smeshpyD, geompyD, obj=0, name=0):
1468
1469         """
1470         Constructor
1471
1472         Create a mesh on the shape *obj* (or an empty mesh if *obj* is equal to 0) and
1473         sets the GUI name of this mesh to *name*.
1474
1475         Parameters:
1476                 smeshpyD: an instance of smeshBuilder class
1477                 geompyD: an instance of geomBuilder class
1478                 obj: Shape to be meshed or :class:`SMESH.SMESH_Mesh` object
1479                 name: Study name of the mesh
1480         """
1481
1482         self.smeshpyD = smeshpyD
1483         self.geompyD = geompyD
1484         if obj is None:
1485             obj = 0
1486         objHasName = False
1487         if obj != 0:
1488             if isinstance(obj, geomBuilder.GEOM._objref_GEOM_Object):
1489                 self.geom = obj
1490                 objHasName = True
1491                 # publish geom of mesh (issue 0021122)
1492                 if not self.geom.GetStudyEntry():
1493                     objHasName = False
1494                     geompyD.init_geom()
1495                     if name:
1496                         geo_name = name + " shape"
1497                     else:
1498                         geo_name = "%s_%s to mesh"%(self.geom.GetShapeType(), id(self.geom)%100)
1499                     geompyD.addToStudy( self.geom, geo_name )
1500                 self.SetMesh( self.smeshpyD.CreateMesh(self.geom) )
1501
1502             elif isinstance(obj, SMESH._objref_SMESH_Mesh):
1503                 self.SetMesh(obj)
1504         else:
1505             self.SetMesh( self.smeshpyD.CreateEmptyMesh() )
1506         if name:
1507             self.smeshpyD.SetName(self.mesh, name)
1508         elif objHasName:
1509             self.smeshpyD.SetName(self.mesh, GetName(obj)) # + " mesh"
1510
1511         if not self.geom:
1512             self.geom = self.mesh.GetShapeToMesh()
1513
1514         self.editor   = self.mesh.GetMeshEditor()
1515         self.functors = [None] * SMESH.FT_Undefined._v
1516
1517         # set self to algoCreator's
1518         for attrName in dir(self):
1519             attr = getattr( self, attrName )
1520             if isinstance( attr, algoCreator ):
1521                 setattr( self, attrName, attr.copy( self ))
1522                 pass
1523             pass
1524         pass
1525
1526     def __del__(self):
1527         """
1528         Destructor. Clean-up resources
1529         """
1530         if self.mesh:
1531             #self.mesh.UnRegister()
1532             pass
1533         pass
1534
1535     def SetMesh(self, theMesh):
1536         """
1537         Initialize the Mesh object from an instance of :class:`SMESH.SMESH_Mesh` interface
1538
1539         Parameters:
1540                 theMesh: a :class:`SMESH.SMESH_Mesh` object
1541         """
1542
1543
1544         # do not call Register() as this prevents mesh servant deletion at closing study
1545         #if self.mesh: self.mesh.UnRegister()
1546         self.mesh = theMesh
1547         if self.mesh:
1548             #self.mesh.Register()
1549             self.geom = self.mesh.GetShapeToMesh()
1550         pass
1551
1552     def GetMesh(self):
1553         """
1554         Return the mesh, that is an encapsulated instance of :class:`SMESH.SMESH_Mesh` interface
1555
1556         Returns:
1557                 a :class:`SMESH.SMESH_Mesh` object
1558         """
1559
1560         return self.mesh
1561
1562     def GetName(self):
1563         """
1564         Get the name of the mesh
1565
1566         Returns:
1567                 the name of the mesh as a string
1568         """
1569
1570         name = GetName(self.GetMesh())
1571         return name
1572
1573     def SetName(self, name):
1574         """
1575         Set a name to the mesh
1576
1577         Parameters:
1578                 name: a new name of the mesh
1579         """
1580
1581         self.smeshpyD.SetName(self.GetMesh(), name)
1582
1583     def GetSubMesh(self, geom, name):
1584         """
1585         Get a sub-mesh object associated to a *geom* geometrical object.
1586
1587         Parameters:
1588                 geom: a geometrical object (shape)
1589                 name: a name for the sub-mesh in the Object Browser
1590
1591         Returns:
1592                 an object of type :class:`SMESH.SMESH_subMesh`, representing a part of mesh,
1593                 which lies on the given shape
1594
1595         Note:
1596                 A sub-mesh is implicitly created when a sub-shape is specified at
1597                 creating an algorithm, for example::
1598
1599                    algo1D = mesh.Segment(geom=Edge_1)
1600
1601                 create a sub-mesh on *Edge_1* and assign Wire Discretization algorithm to it.
1602                 The created sub-mesh can be retrieved from the algorithm::
1603
1604                    submesh = algo1D.GetSubMesh()
1605         """
1606
1607         AssureGeomPublished( self, geom, name )
1608         submesh = self.mesh.GetSubMesh( geom, name )
1609         return submesh
1610
1611     def GetShape(self):
1612         """
1613         Return the shape associated to the mesh
1614
1615         Returns:
1616                 a GEOM_Object
1617         """
1618
1619         return self.geom
1620
1621     def SetShape(self, geom):
1622         """
1623         Associate the given shape to the mesh (entails the recreation of the mesh)
1624
1625         Parameters:
1626                 geom: the shape to be meshed (GEOM_Object)
1627         """
1628
1629         self.mesh = self.smeshpyD.CreateMesh(geom)
1630
1631     def HasShapeToMesh(self):
1632         """
1633         Return ``True`` if this mesh is based on geometry
1634         """
1635         return self.mesh.HasShapeToMesh()
1636
1637     def Load(self):
1638         """
1639         Load mesh from the study after opening the study
1640         """
1641         self.mesh.Load()
1642
1643     def IsReadyToCompute(self, theSubObject):
1644         """
1645         Return true if the hypotheses are defined well
1646
1647         Parameters:
1648                 theSubObject: a sub-shape of a mesh shape
1649
1650         Returns:
1651                 True or False
1652         """
1653
1654         return self.smeshpyD.IsReadyToCompute(self.mesh, theSubObject)
1655
1656     def GetAlgoState(self, theSubObject):
1657         """
1658         Return errors of hypotheses definition.
1659         The list of errors is empty if everything is OK.
1660
1661         Parameters:
1662                 theSubObject: a sub-shape of a mesh shape
1663
1664         Returns:
1665                 a list of errors
1666         """
1667
1668         return self.smeshpyD.GetAlgoState(self.mesh, theSubObject)
1669
1670     def GetGeometryByMeshElement(self, theElementID, theGeomName):
1671         """
1672         Return a geometrical object on which the given element was built.
1673         The returned geometrical object, if not nil, is either found in the
1674         study or published by this method with the given name
1675
1676         Parameters:
1677             theElementID: the id of the mesh element
1678             theGeomName: the user-defined name of the geometrical object
1679
1680         Returns:
1681             GEOM.GEOM_Object instance
1682         """
1683
1684         return self.smeshpyD.GetGeometryByMeshElement( self.mesh, theElementID, theGeomName )
1685
1686     def MeshDimension(self):
1687         """
1688         Return the mesh dimension depending on the dimension of the underlying shape
1689         or, if the mesh is not based on any shape, basing on deimension of elements
1690
1691         Returns:
1692                 mesh dimension as an integer value [0,3]
1693         """
1694
1695         if self.mesh.HasShapeToMesh():
1696             shells = self.geompyD.SubShapeAllIDs( self.geom, self.geompyD.ShapeType["SOLID"] )
1697             if len( shells ) > 0 :
1698                 return 3
1699             elif self.geompyD.NumberOfFaces( self.geom ) > 0 :
1700                 return 2
1701             elif self.geompyD.NumberOfEdges( self.geom ) > 0 :
1702                 return 1
1703             else:
1704                 return 0;
1705         else:
1706             if self.NbVolumes() > 0: return 3
1707             if self.NbFaces()   > 0: return 2
1708             if self.NbEdges()   > 0: return 1
1709         return 0
1710
1711     def Evaluate(self, geom=0):
1712         """
1713         Evaluate size of prospective mesh on a shape
1714
1715         Returns:
1716                 a list where i-th element is a number of elements of i-th :class:`SMESH.EntityType`.
1717                 To know predicted number of e.g. edges, inquire it this way::
1718
1719                    Evaluate()[ smesh.EnumToLong( SMESH.Entity_Edge )]
1720         """
1721
1722         if geom == 0 or not isinstance(geom, geomBuilder.GEOM._objref_GEOM_Object):
1723             if self.geom == 0:
1724                 geom = self.mesh.GetShapeToMesh()
1725             else:
1726                 geom = self.geom
1727         return self.smeshpyD.Evaluate(self.mesh, geom)
1728
1729
1730     def Compute(self, geom=0, discardModifs=False, refresh=False):
1731         """
1732         Compute the mesh and return the status of the computation
1733
1734         Parameters:
1735                 geom: geomtrical shape on which mesh data should be computed
1736                 discardModifs: if True and the mesh has been edited since
1737                         a last total re-compute and that may prevent successful partial re-compute,
1738                         then the mesh is cleaned before Compute()
1739                 refresh: if *True*, Object Browser is automatically updated (when running in GUI)
1740
1741         Returns:
1742                 True or False
1743         """
1744
1745         if geom == 0 or not isinstance(geom, geomBuilder.GEOM._objref_GEOM_Object):
1746             if self.geom == 0:
1747                 geom = self.mesh.GetShapeToMesh()
1748             else:
1749                 geom = self.geom
1750         ok = False
1751         try:
1752             if discardModifs and self.mesh.HasModificationsToDiscard(): # issue 0020693
1753                 self.mesh.Clear()
1754             ok = self.smeshpyD.Compute(self.mesh, geom)
1755         except SALOME.SALOME_Exception as ex:
1756             print("Mesh computation failed, exception caught:")
1757             print("    ", ex.details.text)
1758         except:
1759             import traceback
1760             print("Mesh computation failed, exception caught:")
1761             traceback.print_exc()
1762         if True:#not ok:
1763             allReasons = ""
1764
1765             # Treat compute errors
1766             computeErrors = self.smeshpyD.GetComputeErrors( self.mesh, geom )
1767             shapeText = ""
1768             for err in computeErrors:
1769                 if self.mesh.HasShapeToMesh():
1770                     shapeText = " on %s" % self.GetSubShapeName( err.subShapeID )
1771                 errText = ""
1772                 stdErrors = ["OK",                   #COMPERR_OK
1773                              "Invalid input mesh",   #COMPERR_BAD_INPUT_MESH
1774                              "std::exception",       #COMPERR_STD_EXCEPTION
1775                              "OCC exception",        #COMPERR_OCC_EXCEPTION
1776                              "..",                   #COMPERR_SLM_EXCEPTION
1777                              "Unknown exception",    #COMPERR_EXCEPTION
1778                              "Memory allocation problem", #COMPERR_MEMORY_PB
1779                              "Algorithm failed",     #COMPERR_ALGO_FAILED
1780                              "Unexpected geometry",  #COMPERR_BAD_SHAPE
1781                              "Warning",              #COMPERR_WARNING
1782                              "Computation cancelled",#COMPERR_CANCELED
1783                              "No mesh on sub-shape"] #COMPERR_NO_MESH_ON_SHAPE
1784                 if err.code > 0:
1785                     if err.code < len(stdErrors): errText = stdErrors[err.code]
1786                 else:
1787                     errText = "code %s" % -err.code
1788                 if errText: errText += ". "
1789                 errText += err.comment
1790                 if allReasons: allReasons += "\n"
1791                 if ok:
1792                     allReasons += '-  "%s"%s - %s' %(err.algoName, shapeText, errText)
1793                 else:
1794                     allReasons += '-  "%s" failed%s. Error: %s' %(err.algoName, shapeText, errText)
1795                 pass
1796
1797             # Treat hyp errors
1798             errors = self.smeshpyD.GetAlgoState( self.mesh, geom )
1799             for err in errors:
1800                 if err.isGlobalAlgo:
1801                     glob = "global"
1802                 else:
1803                     glob = "local"
1804                     pass
1805                 dim = err.algoDim
1806                 name = err.algoName
1807                 if len(name) == 0:
1808                     reason = '%s %sD algorithm is missing' % (glob, dim)
1809                 elif err.state == HYP_MISSING:
1810                     reason = ('%s %sD algorithm "%s" misses %sD hypothesis'
1811                               % (glob, dim, name, dim))
1812                 elif err.state == HYP_NOTCONFORM:
1813                     reason = 'Global "Not Conform mesh allowed" hypothesis is missing'
1814                 elif err.state == HYP_BAD_PARAMETER:
1815                     reason = ('Hypothesis of %s %sD algorithm "%s" has a bad parameter value'
1816                               % ( glob, dim, name ))
1817                 elif err.state == HYP_BAD_GEOMETRY:
1818                     reason = ('%s %sD algorithm "%s" is assigned to mismatching'
1819                               'geometry' % ( glob, dim, name ))
1820                 elif err.state == HYP_HIDDEN_ALGO:
1821                     reason = ('%s %sD algorithm "%s" is ignored due to presence of a %s '
1822                               'algorithm of upper dimension generating %sD mesh'
1823                               % ( glob, dim, name, glob, dim ))
1824                 else:
1825                     reason = ("For unknown reason. "
1826                               "Developer, revise Mesh.Compute() implementation in smeshBuilder.py!")
1827                     pass
1828                 if allReasons: allReasons += "\n"
1829                 allReasons += "-  " + reason
1830                 pass
1831             if not ok or allReasons != "":
1832                 msg = '"' + GetName(self.mesh) + '"'
1833                 if ok: msg += " has been computed with warnings"
1834                 else:  msg += " has not been computed"
1835                 if allReasons != "": msg += ":"
1836                 else:                msg += "."
1837                 print(msg)
1838                 print(allReasons)
1839             pass
1840         if salome.sg.hasDesktop():
1841             if not isinstance( refresh, list): # not a call from subMesh.Compute()
1842                 if refresh: salome.sg.updateObjBrowser()
1843
1844         return ok
1845
1846     def GetComputeErrors(self, shape=0 ):
1847         """
1848         Return a list of error messages (:class:`SMESH.ComputeError`) of the last :meth:`Compute`
1849         """
1850
1851         if shape == 0:
1852             shape = self.mesh.GetShapeToMesh()
1853         return self.smeshpyD.GetComputeErrors( self.mesh, shape )
1854
1855     def GetSubShapeName(self, subShapeID ):
1856         """
1857         Return a name of a sub-shape by its ID.
1858         Possible variants (for *subShapeID* == 3):
1859
1860                 - **"Face_12"** - published sub-shape
1861                 - **FACE #3** - not published sub-shape
1862                 - **sub-shape #3** - invalid sub-shape ID
1863                 - **#3** - error in this function
1864
1865         Parameters:
1866                 subShapeID: a unique ID of a sub-shape
1867
1868         Returns:
1869                 a string describing the sub-shape
1870
1871         """
1872
1873         if not self.mesh.HasShapeToMesh():
1874             return ""
1875         try:
1876             shapeText = ""
1877             mainIOR  = salome.orb.object_to_string( self.GetShape() )
1878             s = salome.myStudy
1879             mainSO = s.FindObjectIOR(mainIOR)
1880             if mainSO:
1881                 if subShapeID == 1:
1882                     shapeText = '"%s"' % mainSO.GetName()
1883                 subIt = s.NewChildIterator(mainSO)
1884                 while subIt.More():
1885                     subSO = subIt.Value()
1886                     subIt.Next()
1887                     obj = subSO.GetObject()
1888                     if not obj: continue
1889                     go = obj._narrow( geomBuilder.GEOM._objref_GEOM_Object )
1890                     if not go: continue
1891                     try:
1892                         ids = self.geompyD.GetSubShapeID( self.GetShape(), go )
1893                     except:
1894                         continue
1895                     if ids == subShapeID:
1896                         shapeText = '"%s"' % subSO.GetName()
1897                         break
1898             if not shapeText:
1899                 shape = self.geompyD.GetSubShape( self.GetShape(), [subShapeID])
1900                 if shape:
1901                     shapeText = '%s #%s' % (shape.GetShapeType(), subShapeID)
1902                 else:
1903                     shapeText = 'sub-shape #%s' % (subShapeID)
1904         except:
1905             shapeText = "#%s" % (subShapeID)
1906         return shapeText
1907
1908     def GetFailedShapes(self, publish=False):
1909         """
1910         Return a list of sub-shapes meshing of which failed, grouped into GEOM groups by
1911         error of an algorithm
1912
1913         Parameters:
1914                 publish: if *True*, the returned groups will be published in the study
1915
1916         Returns:
1917                 a list of GEOM groups each named after a failed algorithm
1918         """
1919
1920
1921         algo2shapes = {}
1922         computeErrors = self.smeshpyD.GetComputeErrors( self.mesh, self.GetShape() )
1923         for err in computeErrors:
1924             shape = self.geompyD.GetSubShape( self.GetShape(), [err.subShapeID])
1925             if not shape: continue
1926             if err.algoName in algo2shapes:
1927                 algo2shapes[ err.algoName ].append( shape )
1928             else:
1929                 algo2shapes[ err.algoName ] = [ shape ]
1930             pass
1931
1932         groups = []
1933         for algoName, shapes in list(algo2shapes.items()):
1934             while shapes:
1935                 groupType = self.smeshpyD.EnumToLong( shapes[0].GetShapeType() )
1936                 otherTypeShapes = []
1937                 sameTypeShapes  = []
1938                 group = self.geompyD.CreateGroup( self.geom, groupType )
1939                 for shape in shapes:
1940                     if shape.GetShapeType() == shapes[0].GetShapeType():
1941                         sameTypeShapes.append( shape )
1942                     else:
1943                         otherTypeShapes.append( shape )
1944                 self.geompyD.UnionList( group, sameTypeShapes )
1945                 if otherTypeShapes:
1946                     group.SetName( "%s %s" % ( algoName, shapes[0].GetShapeType() ))
1947                 else:
1948                     group.SetName( algoName )
1949                 groups.append( group )
1950                 shapes = otherTypeShapes
1951             pass
1952         if publish:
1953             for group in groups:
1954                 self.geompyD.addToStudyInFather( self.geom, group, group.GetName() )
1955         return groups
1956
1957     def GetMeshOrder(self):
1958         """
1959         Return sub-mesh objects list in meshing order
1960
1961         Returns:
1962                 list of lists of :class:`sub-meshes <SMESH.SMESH_subMesh>`
1963         """
1964
1965         return self.mesh.GetMeshOrder()
1966
1967     def SetMeshOrder(self, submeshes):
1968         """
1969         Set order in which concurrent sub-meshes should be meshed
1970
1971         Parameters:
1972                 submeshes: list of lists of :class:`sub-meshes <SMESH.SMESH_subMesh>`
1973         """
1974
1975         return self.mesh.SetMeshOrder(submeshes)
1976
1977     def Clear(self, refresh=False):
1978         """
1979         Remove all nodes and elements generated on geometry. Imported elements remain.
1980
1981         Parameters:
1982                 refresh: if *True*, Object browser is automatically updated (when running in GUI)
1983         """
1984
1985         self.mesh.Clear()
1986         if ( salome.sg.hasDesktop() ):
1987             if refresh: salome.sg.updateObjBrowser()
1988
1989     def ClearSubMesh(self, geomId, refresh=False):
1990         """
1991         Remove all nodes and elements of indicated shape
1992
1993         Parameters:
1994                 geomId: the ID of a sub-shape to remove elements on
1995                 refresh: if *True*, Object browser is automatically updated (when running in GUI)
1996         """
1997
1998         self.mesh.ClearSubMesh(geomId)
1999         if salome.sg.hasDesktop():
2000             if refresh: salome.sg.updateObjBrowser()
2001
2002     def AutomaticTetrahedralization(self, fineness=0):
2003         """
2004         Compute a tetrahedral mesh using AutomaticLength + MEFISTO + Tetrahedron
2005
2006         Parameters:
2007                 fineness: [0.0,1.0] defines mesh fineness
2008
2009         Returns:
2010                 True or False
2011         """
2012
2013         dim = self.MeshDimension()
2014         # assign hypotheses
2015         self.RemoveGlobalHypotheses()
2016         self.Segment().AutomaticLength(fineness)
2017         if dim > 1 :
2018             self.Triangle().LengthFromEdges()
2019             pass
2020         if dim > 2 :
2021             self.Tetrahedron()
2022             pass
2023         return self.Compute()
2024
2025     def AutomaticHexahedralization(self, fineness=0):
2026         """
2027         Compute an hexahedral mesh using AutomaticLength + Quadrangle + Hexahedron
2028
2029         Parameters:
2030                 fineness: [0.0, 1.0] defines mesh fineness
2031
2032         Returns:
2033                 True or False
2034         """
2035
2036         dim = self.MeshDimension()
2037         # assign the hypotheses
2038         self.RemoveGlobalHypotheses()
2039         self.Segment().AutomaticLength(fineness)
2040         if dim > 1 :
2041             self.Quadrangle()
2042             pass
2043         if dim > 2 :
2044             self.Hexahedron()
2045             pass
2046         return self.Compute()
2047
2048     def AddHypothesis(self, hyp, geom=0):
2049         """
2050         Assign a hypothesis
2051
2052         Parameters:
2053                 hyp: a hypothesis to assign
2054                 geom: a subhape of mesh geometry
2055
2056         Returns:
2057                 :class:`SMESH.Hypothesis_Status`
2058         """
2059
2060         if isinstance( hyp, geomBuilder.GEOM._objref_GEOM_Object ):
2061             hyp, geom = geom, hyp
2062         if isinstance( hyp, Mesh_Algorithm ):
2063             hyp = hyp.GetAlgorithm()
2064             pass
2065         if not geom:
2066             geom = self.geom
2067             if not geom:
2068                 geom = self.mesh.GetShapeToMesh()
2069             pass
2070         isApplicable = True
2071         if self.mesh.HasShapeToMesh():
2072             hyp_type     = hyp.GetName()
2073             lib_name     = hyp.GetLibName()
2074             # checkAll    = ( not geom.IsSame( self.mesh.GetShapeToMesh() ))
2075             # if checkAll and geom:
2076             #     checkAll = geom.GetType() == 37
2077             checkAll     = False
2078             isApplicable = self.smeshpyD.IsApplicable(hyp_type, lib_name, geom, checkAll)
2079         if isApplicable:
2080             AssureGeomPublished( self, geom, "shape for %s" % hyp.GetName())
2081             status = self.mesh.AddHypothesis(geom, hyp)
2082         else:
2083             status = HYP_BAD_GEOMETRY, ""
2084         hyp_name = GetName( hyp )
2085         geom_name = ""
2086         if geom:
2087             geom_name = geom.GetName()
2088         isAlgo = hyp._narrow( SMESH_Algo )
2089         TreatHypoStatus( status, hyp_name, geom_name, isAlgo, self )
2090         return status
2091
2092     def IsUsedHypothesis(self, hyp, geom):
2093         """
2094         Return True if an algorithm or hypothesis is assigned to a given shape
2095
2096         Parameters:
2097                 hyp: an algorithm or hypothesis to check
2098                 geom: a subhape of mesh geometry
2099
2100         Returns:
2101                 True of False
2102         """
2103
2104         if not hyp: # or not geom
2105             return False
2106         if isinstance( hyp, Mesh_Algorithm ):
2107             hyp = hyp.GetAlgorithm()
2108             pass
2109         hyps = self.GetHypothesisList(geom)
2110         for h in hyps:
2111             if h.GetId() == hyp.GetId():
2112                 return True
2113         return False
2114
2115     def RemoveHypothesis(self, hyp, geom=0):
2116         """
2117         Unassign a hypothesis
2118
2119         Parameters:
2120                 hyp (SMESH.SMESH_Hypothesis): a hypothesis to unassign
2121                 geom (GEOM.GEOM_Object): a sub-shape of mesh geometry
2122
2123         Returns:
2124                 :class:`SMESH.Hypothesis_Status`
2125         """
2126
2127         if not hyp:
2128             return None
2129         if isinstance( hyp, Mesh_Algorithm ):
2130             hyp = hyp.GetAlgorithm()
2131             pass
2132         shape = geom
2133         if not shape:
2134             shape = self.geom
2135             pass
2136         if self.IsUsedHypothesis( hyp, shape ):
2137             return self.mesh.RemoveHypothesis( shape, hyp )
2138         hypName = GetName( hyp )
2139         geoName = GetName( shape )
2140         print("WARNING: RemoveHypothesis() failed as '%s' is not assigned to '%s' shape" % ( hypName, geoName ))
2141         return None
2142
2143     def GetHypothesisList(self, geom):
2144         """
2145         Get the list of hypotheses added on a geometry
2146
2147         Parameters:
2148                 geom (GEOM.GEOM_Object): a sub-shape of mesh geometry
2149
2150         Returns:
2151                 the sequence of :class:`SMESH.SMESH_Hypothesis`
2152         """
2153
2154         return self.mesh.GetHypothesisList( geom )
2155
2156     def RemoveGlobalHypotheses(self):
2157         """
2158         Remove all global hypotheses
2159         """
2160
2161         current_hyps = self.mesh.GetHypothesisList( self.geom )
2162         for hyp in current_hyps:
2163             self.mesh.RemoveHypothesis( self.geom, hyp )
2164             pass
2165         pass
2166     def ExportMED(self, *args, **kwargs):
2167         """
2168         Export the mesh in a file in MED format
2169         allowing to overwrite the file if it exists or add the exported data to its contents
2170
2171         Parameters:
2172                 fileName: is the file name
2173                 auto_groups (boolean): parameter for creating/not creating
2174                         the groups Group_On_All_Nodes, Group_On_All_Faces, ... ;
2175                         the typical use is auto_groups=False.
2176                 minor (int): define the minor version (y, where version is x.y.z) of MED file format.
2177                         The minor must be between 0 and the current minor version of MED file library.
2178                         If minor is equal to -1, the minor version is not changed (default).
2179                         The major version (x, where version is x.y.z) cannot be changed.
2180                 overwrite (boolean): parameter for overwriting/not overwriting the file
2181                 meshPart: a part of mesh (:class:`sub-mesh, group or filter <SMESH.SMESH_IDSource>`) to export instead of the mesh
2182                 autoDimension: if *True* (default), a space dimension of a MED mesh can be either
2183
2184                         - 1D if all mesh nodes lie on OX coordinate axis, or
2185                         - 2D if all mesh nodes lie on XOY coordinate plane, or
2186                         - 3D in the rest cases.
2187
2188                         If *autoDimension* is *False*, the space dimension is always 3.
2189                 fields: list of GEOM fields defined on the shape to mesh.
2190                 geomAssocFields: each character of this string means a need to export a 
2191                         corresponding field; correspondence between fields and characters is following:
2192                         - 'v' stands for "_vertices _" field;
2193                         - 'e' stands for "_edges _" field;
2194                         - 'f' stands for "_faces _" field;
2195                         - 's' stands for "_solids _" field.
2196         """
2197         # process positional arguments
2198         #args = [i for i in args if i not in [SMESH.MED_V2_1, SMESH.MED_V2_2]] # backward compatibility
2199         fileName        = args[0]
2200         auto_groups     = args[1] if len(args) > 1 else False
2201         minor           = args[2] if len(args) > 2 else -1
2202         overwrite       = args[3] if len(args) > 3 else True
2203         meshPart        = args[4] if len(args) > 4 else None
2204         autoDimension   = args[5] if len(args) > 5 else True
2205         fields          = args[6] if len(args) > 6 else []
2206         geomAssocFields = args[7] if len(args) > 7 else ''
2207         # process keywords arguments
2208         auto_groups     = kwargs.get("auto_groups", auto_groups)
2209         minor           = kwargs.get("minor", minor)
2210         overwrite       = kwargs.get("overwrite", overwrite)
2211         meshPart        = kwargs.get("meshPart", meshPart)
2212         autoDimension   = kwargs.get("autoDimension", autoDimension)
2213         fields          = kwargs.get("fields", fields)
2214         geomAssocFields = kwargs.get("geomAssocFields", geomAssocFields)
2215         # invoke engine's function
2216         if meshPart or fields or geomAssocFields:
2217             unRegister = genObjUnRegister()
2218             if isinstance( meshPart, list ):
2219                 meshPart = self.GetIDSource( meshPart, SMESH.ALL )
2220                 unRegister.set( meshPart )
2221             self.mesh.ExportPartToMED( meshPart, fileName, auto_groups, minor, overwrite, autoDimension,
2222                                        fields, geomAssocFields)
2223         else:
2224             self.mesh.ExportMED(fileName, auto_groups, minor, overwrite, autoDimension)
2225
2226     def ExportSAUV(self, f, auto_groups=0):
2227         """
2228         Export the mesh in a file in SAUV format
2229
2230
2231         Parameters:
2232                 f: is the file name
2233                 auto_groups: boolean parameter for creating/not creating
2234                         the groups Group_On_All_Nodes, Group_On_All_Faces, ... ;
2235                         the typical use is auto_groups=False.
2236         """
2237
2238         self.mesh.ExportSAUV(f, auto_groups)
2239
2240     def ExportDAT(self, f, meshPart=None):
2241         """
2242         Export the mesh in a file in DAT format
2243
2244         Parameters:
2245                 f: the file name
2246                 meshPart: a part of mesh (:class:`sub-mesh, group or filter <SMESH.SMESH_IDSource>`) to export instead of the mesh
2247         """
2248
2249         if meshPart:
2250             unRegister = genObjUnRegister()
2251             if isinstance( meshPart, list ):
2252                 meshPart = self.GetIDSource( meshPart, SMESH.ALL )
2253                 unRegister.set( meshPart )
2254             self.mesh.ExportPartToDAT( meshPart, f )
2255         else:
2256             self.mesh.ExportDAT(f)
2257
2258     def ExportUNV(self, f, meshPart=None):
2259         """
2260         Export the mesh in a file in UNV format
2261
2262         Parameters:
2263                 f: the file name
2264                 meshPart: a part of mesh (:class:`sub-mesh, group or filter <SMESH.SMESH_IDSource>`) to export instead of the mesh
2265         """
2266
2267         if meshPart:
2268             unRegister = genObjUnRegister()
2269             if isinstance( meshPart, list ):
2270                 meshPart = self.GetIDSource( meshPart, SMESH.ALL )
2271                 unRegister.set( meshPart )
2272             self.mesh.ExportPartToUNV( meshPart, f )
2273         else:
2274             self.mesh.ExportUNV(f)
2275
2276     def ExportSTL(self, f, ascii=1, meshPart=None):
2277         """
2278         Export the mesh in a file in STL format
2279
2280         Parameters:
2281                 f: the file name
2282                 ascii: defines the file encoding
2283                 meshPart: a part of mesh (:class:`sub-mesh, group or filter <SMESH.SMESH_IDSource>`) to export instead of the mesh
2284         """
2285
2286         if meshPart:
2287             unRegister = genObjUnRegister()
2288             if isinstance( meshPart, list ):
2289                 meshPart = self.GetIDSource( meshPart, SMESH.ALL )
2290                 unRegister.set( meshPart )
2291             self.mesh.ExportPartToSTL( meshPart, f, ascii )
2292         else:
2293             self.mesh.ExportSTL(f, ascii)
2294
2295     def ExportCGNS(self, f, overwrite=1, meshPart=None, groupElemsByType=False):
2296         """
2297         Export the mesh in a file in CGNS format
2298
2299         Parameters:
2300                 f: is the file name
2301                 overwrite: boolean parameter for overwriting/not overwriting the file
2302                 meshPart: a part of mesh (:class:`sub-mesh, group or filter <SMESH.SMESH_IDSource>`) to export instead of the mesh
2303                 groupElemsByType: if True all elements of same entity type are exported at ones,
2304                         else elements are exported in order of their IDs which can cause creation
2305                         of multiple cgns sections
2306         """
2307
2308         unRegister = genObjUnRegister()
2309         if isinstance( meshPart, list ):
2310             meshPart = self.GetIDSource( meshPart, SMESH.ALL )
2311             unRegister.set( meshPart )
2312         if isinstance( meshPart, Mesh ):
2313             meshPart = meshPart.mesh
2314         elif not meshPart:
2315             meshPart = self.mesh
2316         self.mesh.ExportCGNS(meshPart, f, overwrite, groupElemsByType)
2317
2318     def ExportGMF(self, f, meshPart=None):
2319         """
2320         Export the mesh in a file in GMF format.
2321         GMF files must have .mesh extension for the ASCII format and .meshb for
2322         the bynary format. Other extensions are not allowed.
2323
2324         Parameters:
2325                 f: is the file name
2326                 meshPart: a part of mesh (:class:`sub-mesh, group or filter <SMESH.SMESH_IDSource>`) to export instead of the mesh
2327         """
2328
2329         unRegister = genObjUnRegister()
2330         if isinstance( meshPart, list ):
2331             meshPart = self.GetIDSource( meshPart, SMESH.ALL )
2332             unRegister.set( meshPart )
2333         if isinstance( meshPart, Mesh ):
2334             meshPart = meshPart.mesh
2335         elif not meshPart:
2336             meshPart = self.mesh
2337         self.mesh.ExportGMF(meshPart, f, True)
2338
2339     def ExportToMED(self, *args, **kwargs):
2340         """
2341         Deprecated, used only for compatibility! Please, use :meth:`ExportMED` method instead.
2342         Export the mesh in a file in MED format
2343         allowing to overwrite the file if it exists or add the exported data to its contents
2344
2345         Parameters:
2346                 fileName: the file name
2347                 opt (boolean): parameter for creating/not creating
2348                         the groups Group_On_All_Nodes, Group_On_All_Faces, ...
2349                 overwrite: boolean parameter for overwriting/not overwriting the file
2350                 autoDimension: if *True* (default), a space dimension of a MED mesh can be either
2351
2352                         - 1D if all mesh nodes lie on OX coordinate axis, or
2353                         - 2D if all mesh nodes lie on XOY coordinate plane, or
2354                         - 3D in the rest cases.
2355
2356                         If **autoDimension** is *False*, the space dimension is always 3.
2357         """
2358     
2359         print("WARNING: ExportToMED() is deprecated, use ExportMED() instead")
2360         # process positional arguments
2361         #args = [i for i in args if i not in [SMESH.MED_V2_1, SMESH.MED_V2_2]] # backward compatibility
2362         fileName      = args[0]
2363         auto_groups   = args[1] if len(args) > 1 else False
2364         overwrite     = args[2] if len(args) > 2 else True
2365         autoDimension = args[3] if len(args) > 3 else True
2366         # process keywords arguments
2367         auto_groups   = kwargs.get("opt", auto_groups)         # old keyword name
2368         auto_groups   = kwargs.get("auto_groups", auto_groups) # new keyword name
2369         overwrite     = kwargs.get("overwrite", overwrite)
2370         autoDimension = kwargs.get("autoDimension", autoDimension)
2371         minor = -1
2372         # invoke engine's function
2373         self.mesh.ExportMED(fileName, auto_groups, minor, overwrite, autoDimension)
2374
2375     def ExportToMEDX(self, *args, **kwargs):
2376         """
2377         Deprecated, used only for compatibility! Please, use ExportMED() method instead.
2378         Export the mesh in a file in MED format
2379
2380         Parameters:
2381                 fileName: the file name
2382                 opt (boolean): parameter for creating/not creating
2383                         the groups Group_On_All_Nodes, Group_On_All_Faces, ...
2384                 overwrite: boolean parameter for overwriting/not overwriting the file
2385                 autoDimension: if *True* (default), a space dimension of a MED mesh can be either
2386
2387                         - 1D if all mesh nodes lie on OX coordinate axis, or
2388                         - 2D if all mesh nodes lie on XOY coordinate plane, or
2389                         - 3D in the rest cases.
2390
2391                         If **autoDimension** is *False*, the space dimension is always 3.
2392                 """
2393
2394         print("WARNING: ExportToMEDX() is deprecated, use ExportMED() instead")
2395         # process positional arguments
2396         #args = [i for i in args if i not in [SMESH.MED_V2_1, SMESH.MED_V2_2]] # backward compatibility
2397         fileName      = args[0]
2398         auto_groups   = args[1] if len(args) > 1 else False
2399         overwrite     = args[2] if len(args) > 2 else True
2400         autoDimension = args[3] if len(args) > 3 else True
2401         # process keywords arguments
2402         auto_groups   = kwargs.get("auto_groups", auto_groups)
2403         overwrite     = kwargs.get("overwrite", overwrite)
2404         autoDimension = kwargs.get("autoDimension", autoDimension)
2405         minor = -1
2406         # invoke engine's function
2407         self.mesh.ExportMED(fileName, auto_groups, minor, overwrite, autoDimension)
2408
2409     # Operations with groups:
2410     # ----------------------
2411     def CreateEmptyGroup(self, elementType, name):
2412         """
2413         Create an empty standalone mesh group
2414
2415         Parameters:
2416                 elementType: the :class:`type <SMESH.ElementType>` of elements in the group; 
2417                         either of (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME)
2418                 name: the name of the mesh group
2419
2420         Returns:
2421                 :class:`SMESH.SMESH_Group`
2422         """
2423
2424         return self.mesh.CreateGroup(elementType, name)
2425
2426     def Group(self, grp, name=""):
2427         """
2428         Create a mesh group based on the geometric object *grp*
2429         and give it a *name*.
2430         If *name* is not defined the name of the geometric group is used
2431
2432         Note:
2433                 Works like :meth:`GroupOnGeom`.
2434
2435         Parameters:
2436                 grp:  a geometric group, a vertex, an edge, a face or a solid
2437                 name: the name of the mesh group
2438
2439         Returns:
2440                 :class:`SMESH.SMESH_GroupOnGeom`
2441         """
2442
2443         return self.GroupOnGeom(grp, name)
2444
2445     def GroupOnGeom(self, grp, name="", typ=None):
2446         """
2447         Create a mesh group based on the geometrical object *grp*
2448         and give it a *name*.
2449         if *name* is not defined the name of the geometric group is used
2450
2451         Parameters:
2452                 grp:  a geometrical group, a vertex, an edge, a face or a solid
2453                 name: the name of the mesh group
2454                 typ:  the type of elements in the group; either of
2455                         (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME). If not set, it is
2456                         automatically detected by the type of the geometry
2457
2458         Returns:
2459                 :class:`SMESH.SMESH_GroupOnGeom`
2460         """
2461
2462         AssureGeomPublished( self, grp, name )
2463         if name == "":
2464             name = grp.GetName()
2465         if not typ:
2466             typ = self._groupTypeFromShape( grp )
2467         return self.mesh.CreateGroupFromGEOM(typ, name, grp)
2468
2469     def _groupTypeFromShape( self, shape ):
2470         """
2471         Pivate method to get a type of group on geometry
2472         """
2473         tgeo = str(shape.GetShapeType())
2474         if tgeo == "VERTEX":
2475             typ = NODE
2476         elif tgeo == "EDGE":
2477             typ = EDGE
2478         elif tgeo == "FACE" or tgeo == "SHELL":
2479             typ = FACE
2480         elif tgeo == "SOLID" or tgeo == "COMPSOLID":
2481             typ = VOLUME
2482         elif tgeo == "COMPOUND":
2483             sub = self.geompyD.SubShapeAll( shape, self.geompyD.ShapeType["SHAPE"])
2484             if not sub:
2485                 raise ValueError("_groupTypeFromShape(): empty geometric group or compound '%s'" % GetName(shape))
2486             return self._groupTypeFromShape( sub[0] )
2487         else:
2488             raise ValueError("_groupTypeFromShape(): invalid geometry '%s'" % GetName(shape))
2489         return typ
2490
2491     def GroupOnFilter(self, typ, name, filter):
2492         """
2493         Create a mesh group with given *name* based on the *filter*.
2494         It is a special type of group dynamically updating it's contents during
2495         mesh modification
2496
2497         Parameters:
2498                 typ: the type of elements in the group; either of
2499                         (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME).
2500                 name: the name of the mesh group
2501                 filter (SMESH.Filter): the filter defining group contents
2502
2503         Returns:
2504                 :class:`SMESH.SMESH_GroupOnFilter`
2505         """
2506
2507         return self.mesh.CreateGroupFromFilter(typ, name, filter)
2508
2509     def MakeGroupByIds(self, groupName, elementType, elemIDs):
2510         """
2511         Create a mesh group by the given ids of elements
2512
2513         Parameters:
2514                 groupName: the name of the mesh group
2515                 elementType: the type of elements in the group; either of
2516                         (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME).
2517                 elemIDs: either the list of ids, :class:`mesh, sub-mesh, group or filter <SMESH.SMESH_IDSource>`
2518
2519         Returns:
2520                 :class:`SMESH.SMESH_Group`
2521         """
2522
2523         group = self.mesh.CreateGroup(elementType, groupName)
2524         if isinstance( elemIDs, Mesh ):
2525             elemIDs = elemIDs.GetMesh()
2526         if hasattr( elemIDs, "GetIDs" ):
2527             if hasattr( elemIDs, "SetMesh" ):
2528                 elemIDs.SetMesh( self.GetMesh() )
2529             group.AddFrom( elemIDs )
2530         else:
2531             group.Add(elemIDs)
2532         return group
2533
2534     def MakeGroup(self,
2535                   groupName,
2536                   elementType,
2537                   CritType=FT_Undefined,
2538                   Compare=FT_EqualTo,
2539                   Threshold="",
2540                   UnaryOp=FT_Undefined,
2541                   Tolerance=1e-07):
2542         """
2543         Create a mesh group by the given conditions
2544
2545         Parameters:
2546                 groupName: the name of the mesh group
2547                 elementType (SMESH.ElementType): the type of elements (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME)
2548                 CritType (SMESH.FunctorType): the type of criterion (SMESH.FT_Taper, SMESH.FT_Area, etc.).
2549                         Note that the items starting from FT_LessThan are not suitable for CritType.
2550                 Compare (SMESH.FunctorType): belongs to {SMESH.FT_LessThan, SMESH.FT_MoreThan, SMESH.FT_EqualTo}
2551                 Threshold: the threshold value (range of ids as string, shape, numeric, depending on *CritType*)
2552                 UnaryOp (SMESH.FunctorType):  SMESH.FT_LogicalNOT or SMESH.FT_Undefined
2553                 Tolerance (float): the tolerance used by SMESH.FT_BelongToGeom, SMESH.FT_BelongToSurface,
2554                         SMESH.FT_LyingOnGeom, SMESH.FT_CoplanarFaces criteria
2555
2556         Returns:
2557                 :class:`SMESH.SMESH_GroupOnFilter`
2558         """
2559
2560         aCriterion = self.smeshpyD.GetCriterion(elementType, CritType, Compare, Threshold, UnaryOp, FT_Undefined,Tolerance)
2561         group = self.MakeGroupByCriterion(groupName, aCriterion)
2562         return group
2563
2564     def MakeGroupByCriterion(self, groupName, Criterion):
2565         """
2566         Create a mesh group by the given criterion
2567
2568         Parameters:
2569                 groupName: the name of the mesh group
2570                 Criterion: the instance of :class:`SMESH.Filter.Criterion` class
2571
2572         Returns:
2573                 :class:`SMESH.SMESH_GroupOnFilter`
2574
2575         See Also:
2576                 :meth:`smeshBuilder.GetCriterion`
2577         """
2578
2579         return self.MakeGroupByCriteria( groupName, [Criterion] )
2580
2581     def MakeGroupByCriteria(self, groupName, theCriteria, binOp=SMESH.FT_LogicalAND):
2582         """
2583         Create a mesh group by the given criteria (list of :class:`SMESH.Filter.Criterion`)
2584
2585         Parameters:
2586                 groupName: the name of the mesh group
2587                 theCriteria: the list of :class:`SMESH.Filter.Criterion`
2588                 binOp: binary operator (SMESH.FT_LogicalAND or SMESH.FT_LogicalOR ) used when binary operator of criteria is undefined
2589
2590         Returns:
2591                 :class:`SMESH.SMESH_GroupOnFilter`
2592
2593         See Also:
2594                 :meth:`smeshBuilder.GetCriterion`
2595         """
2596
2597         aFilter = self.smeshpyD.GetFilterFromCriteria( theCriteria, binOp )
2598         group = self.MakeGroupByFilter(groupName, aFilter)
2599         return group
2600
2601     def MakeGroupByFilter(self, groupName, theFilter):
2602         """
2603         Create a mesh group by the given filter
2604
2605         Parameters:
2606                 groupName (string): the name of the mesh group
2607                 theFilter (SMESH.Filter): the filter
2608
2609         Returns:
2610                 :class:`SMESH.SMESH_GroupOnFilter`
2611
2612         See Also:
2613                 :meth:`smeshBuilder.GetFilter`
2614         """
2615
2616         #group = self.CreateEmptyGroup(theFilter.GetElementType(), groupName)
2617         #theFilter.SetMesh( self.mesh )
2618         #group.AddFrom( theFilter )
2619         group = self.GroupOnFilter( theFilter.GetElementType(), groupName, theFilter )
2620         return group
2621
2622     def RemoveGroup(self, group):
2623         """
2624         Remove a group
2625
2626         Parameters:
2627                 group (SMESH.SMESH_GroupBase): group to remove
2628         """
2629
2630         self.mesh.RemoveGroup(group)
2631
2632     def RemoveGroupWithContents(self, group):
2633         """
2634         Remove a group with its contents
2635
2636         Parameters:
2637                 group (SMESH.SMESH_GroupBase): group to remove
2638         """
2639
2640         self.mesh.RemoveGroupWithContents(group)
2641
2642     def GetGroups(self, elemType = SMESH.ALL):
2643         """
2644         Get the list of groups existing in the mesh in the order of creation 
2645         (starting from the oldest one)
2646
2647         Parameters:
2648                 elemType (SMESH.ElementType): type of elements the groups contain;
2649                         by default groups of elements of all types are returned
2650
2651         Returns:
2652                 a list of :class:`SMESH.SMESH_GroupBase`
2653         """
2654
2655         groups = self.mesh.GetGroups()
2656         if elemType == SMESH.ALL:
2657             return groups
2658         typedGroups = []
2659         for g in groups:
2660             if g.GetType() == elemType:
2661                 typedGroups.append( g )
2662                 pass
2663             pass
2664         return typedGroups
2665
2666     def NbGroups(self):
2667         """
2668         Get the number of groups existing in the mesh
2669
2670         Returns:
2671                 the quantity of groups as an integer value
2672         """
2673
2674         return self.mesh.NbGroups()
2675
2676     def GetGroupNames(self):
2677         """
2678         Get the list of names of groups existing in the mesh
2679
2680         Returns:
2681                 list of strings
2682         """
2683
2684         groups = self.GetGroups()
2685         names = []
2686         for group in groups:
2687             names.append(group.GetName())
2688         return names
2689
2690     def GetGroupByName(self, name, elemType = None):
2691         """
2692         Find groups by name and type
2693
2694         Parameters:
2695                 name (string): name of the group of interest
2696                 elemType (SMESH.ElementType): type of elements the groups contain;
2697                         by default one group of any type is returned;
2698                         if elemType == SMESH.ALL then all groups of any type are returned
2699
2700         Returns:
2701                 a list of :class:`SMESH.SMESH_GroupBase`
2702         """
2703
2704         groups = []
2705         for group in self.GetGroups():
2706             if group.GetName() == name:
2707                 if elemType is None:
2708                     return [group]
2709                 if ( elemType == SMESH.ALL or
2710                      group.GetType() == elemType ):
2711                     groups.append( group )
2712         return groups
2713
2714     def UnionGroups(self, group1, group2, name):
2715         """
2716         Produce a union of two groups.
2717         A new group is created. All mesh elements that are
2718         present in the initial groups are added to the new one
2719
2720         Parameters:
2721            group1 (SMESH.SMESH_GroupBase): a group
2722            group2 (SMESH.SMESH_GroupBase): another group
2723
2724         Returns:
2725                 instance of :class:`SMESH.SMESH_Group`
2726         """
2727
2728         return self.mesh.UnionGroups(group1, group2, name)
2729
2730     def UnionListOfGroups(self, groups, name):
2731         """
2732         Produce a union list of groups.
2733         New group is created. All mesh elements that are present in
2734         initial groups are added to the new one
2735
2736         Parameters:
2737            groups: list of :class:`SMESH.SMESH_GroupBase`
2738
2739         Returns:
2740                 instance of :class:`SMESH.SMESH_Group`
2741         """
2742         return self.mesh.UnionListOfGroups(groups, name)
2743
2744     def IntersectGroups(self, group1, group2, name):
2745         """
2746         Prodice an intersection of two groups.
2747         A new group is created. All mesh elements that are common
2748         for the two initial groups are added to the new one.
2749
2750         Parameters:
2751            group1 (SMESH.SMESH_GroupBase): a group
2752            group2 (SMESH.SMESH_GroupBase): another group
2753
2754         Returns:
2755                 instance of :class:`SMESH.SMESH_Group`
2756         """
2757
2758         return self.mesh.IntersectGroups(group1, group2, name)
2759
2760     def IntersectListOfGroups(self, groups, name):
2761         """
2762         Produce an intersection of groups.
2763         New group is created. All mesh elements that are present in all
2764         initial groups simultaneously are added to the new one
2765
2766         Parameters:
2767            groups: a list of :class:`SMESH.SMESH_GroupBase`
2768
2769         Returns:
2770                 instance of :class:`SMESH.SMESH_Group`
2771         """
2772         return self.mesh.IntersectListOfGroups(groups, name)
2773
2774     def CutGroups(self, main_group, tool_group, name):
2775         """
2776         Produce a cut of two groups.
2777         A new group is created. All mesh elements that are present in
2778         the main group but are not present in the tool group are added to the new one
2779
2780         Parameters:
2781            main_group (SMESH.SMESH_GroupBase): a group to cut from
2782            tool_group (SMESH.SMESH_GroupBase): a group to cut by
2783
2784         Returns:
2785                 an instance of :class:`SMESH.SMESH_Group`
2786         """
2787
2788         return self.mesh.CutGroups(main_group, tool_group, name)
2789
2790     def CutListOfGroups(self, main_groups, tool_groups, name):
2791         """
2792         Produce a cut of groups.
2793         A new group is created. All mesh elements that are present in main groups
2794         but do not present in tool groups are added to the new one
2795
2796         Parameters:
2797            main_group: groups to cut from  (list of :class:`SMESH.SMESH_GroupBase`)
2798            tool_group: groups to cut by    (list of :class:`SMESH.SMESH_GroupBase`)
2799
2800         Returns:
2801                 an instance of :class:`SMESH.SMESH_Group`
2802         """
2803
2804         return self.mesh.CutListOfGroups(main_groups, tool_groups, name)
2805
2806     def CreateDimGroup(self, groups, elemType, name,
2807                        nbCommonNodes = SMESH.ALL_NODES, underlyingOnly = True):
2808         """
2809         Create a standalone group of entities basing on nodes of other groups.
2810
2811         Parameters:
2812                 groups: list of reference :class:`sub-meshes, groups or filters <SMESH.SMESH_IDSource>`, of any type.
2813                 elemType: a type of elements to include to the new group; either of
2814                         (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME).
2815                 name: a name of the new group.
2816                 nbCommonNodes: a criterion of inclusion of an element to the new group
2817                         basing on number of element nodes common with reference *groups*.
2818                         Meaning of possible values are:
2819
2820                                 - SMESH.ALL_NODES - include if all nodes are common,
2821                                 - SMESH.MAIN - include if all corner nodes are common (meaningful for a quadratic mesh),
2822                                 - SMESH.AT_LEAST_ONE - include if one or more node is common,
2823                                 - SMEHS.MAJORITY - include if half of nodes or more are common.
2824                 underlyingOnly: if *True* (default), an element is included to the
2825                         new group provided that it is based on nodes of an element of *groups*;
2826                         in this case the reference *groups* are supposed to be of higher dimension
2827                         than *elemType*, which can be useful for example to get all faces lying on
2828                         volumes of the reference *groups*.
2829
2830         Returns:
2831                 an instance of :class:`SMESH.SMESH_Group`
2832         """
2833
2834         if isinstance( groups, SMESH._objref_SMESH_IDSource ):
2835             groups = [groups]
2836         return self.mesh.CreateDimGroup(groups, elemType, name, nbCommonNodes, underlyingOnly)
2837
2838
2839     def ConvertToStandalone(self, group):
2840         """
2841         Convert group on geom into standalone group
2842         """
2843
2844         return self.mesh.ConvertToStandalone(group)
2845
2846     # Get some info about mesh:
2847     # ------------------------
2848
2849     def GetLog(self, clearAfterGet):
2850         """
2851         Return the log of nodes and elements added or removed
2852         since the previous clear of the log.
2853
2854         Parameters:
2855                 clearAfterGet: log is emptied after Get (safe if concurrents access)
2856
2857         Returns:
2858                 list of SMESH.log_block structures { commandType, number, coords, indexes }
2859         """
2860
2861         return self.mesh.GetLog(clearAfterGet)
2862
2863     def ClearLog(self):
2864         """
2865         Clear the log of nodes and elements added or removed since the previous
2866         clear. Must be used immediately after :meth:`GetLog` if clearAfterGet is false.
2867         """
2868
2869         self.mesh.ClearLog()
2870
2871     def SetAutoColor(self, theAutoColor):
2872         """
2873         Toggle auto color mode on the object.
2874         If switched on, a default color of a new group in Create Group dialog is chosen randomly.
2875
2876         Parameters:
2877                 theAutoColor (boolean): the flag which toggles auto color mode.
2878         """
2879
2880         self.mesh.SetAutoColor(theAutoColor)
2881
2882     def GetAutoColor(self):
2883         """
2884         Get flag of object auto color mode.
2885
2886         Returns:
2887                 True or False
2888         """
2889
2890         return self.mesh.GetAutoColor()
2891
2892     def GetId(self):
2893         """
2894         Get the internal ID
2895
2896         Returns:
2897             integer value, which is the internal Id of the mesh
2898         """
2899
2900         return self.mesh.GetId()
2901
2902     def HasDuplicatedGroupNamesMED(self):
2903         """
2904         Check the group names for duplications.
2905         Consider the maximum group name length stored in MED file.
2906
2907         Returns:
2908             True or False
2909         """
2910
2911         return self.