Salome HOME
Bug 0020072: GHS3DPRLPLUGIN update. Integrating the attached patch.
[modules/smesh.git] / src / SMESH_SWIG / smeshDC.py
1 #  Copyright (C) 2007-2008  CEA/DEN, EDF R&D, OPEN CASCADE
2 #
3 #  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 #  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
5 #
6 #  This library is free software; you can redistribute it and/or
7 #  modify it under the terms of the GNU Lesser General Public
8 #  License as published by the Free Software Foundation; either
9 #  version 2.1 of the License.
10 #
11 #  This library is distributed in the hope that it will be useful,
12 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
13 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 #  Lesser General Public License for more details.
15 #
16 #  You should have received a copy of the GNU Lesser General Public
17 #  License along with this library; if not, write to the Free Software
18 #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
19 #
20 #  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21 #
22 #  File   : smesh.py
23 #  Author : Francis KLOSS, OCC
24 #  Module : SMESH
25 #
26 """
27  \namespace smesh
28  \brief Module smesh
29 """
30
31 ## @defgroup l1_auxiliary Auxiliary methods and structures
32 ## @defgroup l1_creating  Creating meshes
33 ## @{
34 ##   @defgroup l2_impexp     Importing and exporting meshes
35 ##   @defgroup l2_construct  Constructing meshes
36 ##   @defgroup l2_algorithms Defining Algorithms
37 ##   @{
38 ##     @defgroup l3_algos_basic   Basic meshing algorithms
39 ##     @defgroup l3_algos_proj    Projection Algorithms
40 ##     @defgroup l3_algos_radialp Radial Prism
41 ##     @defgroup l3_algos_segmarv Segments around Vertex
42 ##     @defgroup l3_algos_3dextr  3D extrusion meshing algorithm
43
44 ##   @}
45 ##   @defgroup l2_hypotheses Defining hypotheses
46 ##   @{
47 ##     @defgroup l3_hypos_1dhyps 1D Meshing Hypotheses
48 ##     @defgroup l3_hypos_2dhyps 2D Meshing Hypotheses
49 ##     @defgroup l3_hypos_maxvol Max Element Volume hypothesis
50 ##     @defgroup l3_hypos_netgen Netgen 2D and 3D hypotheses
51 ##     @defgroup l3_hypos_ghs3dh GHS3D Parameters hypothesis
52 ##     @defgroup l3_hypos_blsurf BLSURF Parameters hypothesis
53 ##     @defgroup l3_hypos_hexotic Hexotic Parameters hypothesis
54 ##     @defgroup l3_hypos_additi Additional Hypotheses
55
56 ##   @}
57 ##   @defgroup l2_submeshes Constructing submeshes
58 ##   @defgroup l2_compounds Building Compounds
59 ##   @defgroup l2_editing   Editing Meshes
60
61 ## @}
62 ## @defgroup l1_meshinfo  Mesh Information
63 ## @defgroup l1_controls  Quality controls and Filtering
64 ## @defgroup l1_grouping  Grouping elements
65 ## @{
66 ##   @defgroup l2_grps_create Creating groups
67 ##   @defgroup l2_grps_edit   Editing groups
68 ##   @defgroup l2_grps_operon Using operations on groups
69 ##   @defgroup l2_grps_delete Deleting Groups
70
71 ## @}
72 ## @defgroup l1_modifying Modifying meshes
73 ## @{
74 ##   @defgroup l2_modif_add      Adding nodes and elements
75 ##   @defgroup l2_modif_del      Removing nodes and elements
76 ##   @defgroup l2_modif_edit     Modifying nodes and elements
77 ##   @defgroup l2_modif_renumber Renumbering nodes and elements
78 ##   @defgroup l2_modif_trsf     Transforming meshes (Translation, Rotation, Symmetry, Sewing, Merging)
79 ##   @defgroup l2_modif_movenode Moving nodes
80 ##   @defgroup l2_modif_throughp Mesh through point
81 ##   @defgroup l2_modif_invdiag  Diagonal inversion of elements
82 ##   @defgroup l2_modif_unitetri Uniting triangles
83 ##   @defgroup l2_modif_changori Changing orientation of elements
84 ##   @defgroup l2_modif_cutquadr Cutting quadrangles
85 ##   @defgroup l2_modif_smooth   Smoothing
86 ##   @defgroup l2_modif_extrurev Extrusion and Revolution
87 ##   @defgroup l2_modif_patterns Pattern mapping
88 ##   @defgroup l2_modif_tofromqu Convert to/from Quadratic Mesh
89
90 ## @}
91
92 import salome
93 import geompyDC
94
95 import SMESH # This is necessary for back compatibility
96 from   SMESH import *
97
98 import StdMeshers
99
100 import SALOME
101
102 # import NETGENPlugin module if possible
103 noNETGENPlugin = 0
104 try:
105     import NETGENPlugin
106 except ImportError:
107     noNETGENPlugin = 1
108     pass
109
110 ## @addtogroup l1_auxiliary
111 ## @{
112
113 # Types of algorithms
114 REGULAR    = 1
115 PYTHON     = 2
116 COMPOSITE  = 3
117 SOLE       = 0
118 SIMPLE     = 1
119
120 MEFISTO       = 3
121 NETGEN        = 4
122 GHS3D         = 5
123 FULL_NETGEN   = 6
124 NETGEN_2D     = 7
125 NETGEN_1D2D   = NETGEN
126 NETGEN_1D2D3D = FULL_NETGEN
127 NETGEN_FULL   = FULL_NETGEN
128 Hexa    = 8
129 Hexotic = 9
130 BLSURF  = 10
131 GHS3DPRL = 11
132
133 # MirrorType enumeration
134 POINT = SMESH_MeshEditor.POINT
135 AXIS =  SMESH_MeshEditor.AXIS
136 PLANE = SMESH_MeshEditor.PLANE
137
138 # Smooth_Method enumeration
139 LAPLACIAN_SMOOTH = SMESH_MeshEditor.LAPLACIAN_SMOOTH
140 CENTROIDAL_SMOOTH = SMESH_MeshEditor.CENTROIDAL_SMOOTH
141
142 # Fineness enumeration (for NETGEN)
143 VeryCoarse = 0
144 Coarse     = 1
145 Moderate   = 2
146 Fine       = 3
147 VeryFine   = 4
148 Custom     = 5
149
150 # Optimization level of GHS3D
151 None_Optimization, Light_Optimization, Medium_Optimization, Strong_Optimization = 0,1,2,3
152
153 # Topology treatment way of BLSURF
154 FromCAD, PreProcess, PreProcessPlus = 0,1,2
155
156 # Element size flag of BLSURF
157 DefaultSize, DefaultGeom, Custom = 0,0,1
158
159 PrecisionConfusion = 1e-07
160
161 def IsEqual(val1, val2, tol=PrecisionConfusion):
162     if abs(val1 - val2) < tol:
163         return True
164     return False
165
166 NO_NAME = "NoName"
167
168 ## Gets object name
169 def GetName(obj):
170     ior  = salome.orb.object_to_string(obj)
171     sobj = salome.myStudy.FindObjectIOR(ior)
172     if sobj is None:
173         return NO_NAME
174     else:
175         attr = sobj.FindAttribute("AttributeName")[1]
176         return attr.Value()
177
178 ## Sets a name to the object
179 def SetName(obj, name):
180     if isinstance( obj, Mesh ):
181         obj = obj.GetMesh()
182     elif isinstance( obj, Mesh_Algorithm ):
183         obj = obj.GetAlgorithm()
184     ior  = salome.orb.object_to_string(obj)
185     sobj = salome.myStudy.FindObjectIOR(ior)
186     if not sobj is None:
187         attr = sobj.FindAttribute("AttributeName")[1]
188         attr.SetValue(name)
189
190 ## Prints error message if a hypothesis was not assigned.
191 def TreatHypoStatus(status, hypName, geomName, isAlgo):
192     if isAlgo:
193         hypType = "algorithm"
194     else:
195         hypType = "hypothesis"
196         pass
197     if status == HYP_UNKNOWN_FATAL :
198         reason = "for unknown reason"
199     elif status == HYP_INCOMPATIBLE :
200         reason = "this hypothesis mismatches the algorithm"
201     elif status == HYP_NOTCONFORM :
202         reason = "a non-conform mesh would be built"
203     elif status == HYP_ALREADY_EXIST :
204         reason = hypType + " of the same dimension is already assigned to this shape"
205     elif status == HYP_BAD_DIM :
206         reason = hypType + " mismatches the shape"
207     elif status == HYP_CONCURENT :
208         reason = "there are concurrent hypotheses on sub-shapes"
209     elif status == HYP_BAD_SUBSHAPE :
210         reason = "the shape is neither the main one, nor its subshape, nor a valid group"
211     elif status == HYP_BAD_GEOMETRY:
212         reason = "geometry mismatches the expectation of the algorithm"
213     elif status == HYP_HIDDEN_ALGO:
214         reason = "it is hidden by an algorithm of an upper dimension, which generates elements of all dimensions"
215     elif status == HYP_HIDING_ALGO:
216         reason = "it hides algorithms of lower dimensions by generating elements of all dimensions"
217     elif status == HYP_NEED_SHAPE:
218         reason = "Algorithm can't work without shape"
219     else:
220         return
221     hypName = '"' + hypName + '"'
222     geomName= '"' + geomName+ '"'
223     if status < HYP_UNKNOWN_FATAL:
224         print hypName, "was assigned to",    geomName,"but", reason
225     else:
226         print hypName, "was not assigned to",geomName,":", reason
227         pass
228
229 ## Converts an angle from degrees to radians
230 def DegreesToRadians(AngleInDegrees):
231     from math import pi
232     return AngleInDegrees * pi / 180.0
233
234 # end of l1_auxiliary
235 ## @}
236
237 # All methods of this class are accessible directly from the smesh.py package.
238 class smeshDC(SMESH._objref_SMESH_Gen):
239
240     ## Sets the current study and Geometry component
241     #  @ingroup l1_auxiliary
242     def init_smesh(self,theStudy,geompyD):
243         self.SetCurrentStudy(theStudy,geompyD)
244
245     ## Creates an empty Mesh. This mesh can have an underlying geometry.
246     #  @param obj the Geometrical object on which the mesh is built. If not defined,
247     #             the mesh will have no underlying geometry.
248     #  @param name the name for the new mesh.
249     #  @return an instance of Mesh class.
250     #  @ingroup l2_construct
251     def Mesh(self, obj=0, name=0):
252       return Mesh(self,self.geompyD,obj,name)
253
254     ## Returns a long value from enumeration
255     #  Should be used for SMESH.FunctorType enumeration
256     #  @ingroup l1_controls
257     def EnumToLong(self,theItem):
258         return theItem._v
259
260     ## Gets PointStruct from vertex
261     #  @param theVertex a GEOM object(vertex)
262     #  @return SMESH.PointStruct
263     #  @ingroup l1_auxiliary
264     def GetPointStruct(self,theVertex):
265         [x, y, z] = self.geompyD.PointCoordinates(theVertex)
266         return PointStruct(x,y,z)
267
268     ## Gets DirStruct from vector
269     #  @param theVector a GEOM object(vector)
270     #  @return SMESH.DirStruct
271     #  @ingroup l1_auxiliary
272     def GetDirStruct(self,theVector):
273         vertices = self.geompyD.SubShapeAll( theVector, geompyDC.ShapeType["VERTEX"] )
274         if(len(vertices) != 2):
275             print "Error: vector object is incorrect."
276             return None
277         p1 = self.geompyD.PointCoordinates(vertices[0])
278         p2 = self.geompyD.PointCoordinates(vertices[1])
279         pnt = PointStruct(p2[0]-p1[0], p2[1]-p1[1], p2[2]-p1[2])
280         dirst = DirStruct(pnt)
281         return dirst
282
283     ## Makes DirStruct from a triplet
284     #  @param x,y,z vector components
285     #  @return SMESH.DirStruct
286     #  @ingroup l1_auxiliary
287     def MakeDirStruct(self,x,y,z):
288         pnt = PointStruct(x,y,z)
289         return DirStruct(pnt)
290
291     ## Get AxisStruct from object
292     #  @param theObj a GEOM object (line or plane)
293     #  @return SMESH.AxisStruct
294     #  @ingroup l1_auxiliary
295     def GetAxisStruct(self,theObj):
296         edges = self.geompyD.SubShapeAll( theObj, geompyDC.ShapeType["EDGE"] )
297         if len(edges) > 1:
298             vertex1, vertex2 = self.geompyD.SubShapeAll( edges[0], geompyDC.ShapeType["VERTEX"] )
299             vertex3, vertex4 = self.geompyD.SubShapeAll( edges[1], geompyDC.ShapeType["VERTEX"] )
300             vertex1 = self.geompyD.PointCoordinates(vertex1)
301             vertex2 = self.geompyD.PointCoordinates(vertex2)
302             vertex3 = self.geompyD.PointCoordinates(vertex3)
303             vertex4 = self.geompyD.PointCoordinates(vertex4)
304             v1 = [vertex2[0]-vertex1[0], vertex2[1]-vertex1[1], vertex2[2]-vertex1[2]]
305             v2 = [vertex4[0]-vertex3[0], vertex4[1]-vertex3[1], vertex4[2]-vertex3[2]]
306             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] ]
307             axis = AxisStruct(vertex1[0], vertex1[1], vertex1[2], normal[0], normal[1], normal[2])
308             return axis
309         elif len(edges) == 1:
310             vertex1, vertex2 = self.geompyD.SubShapeAll( edges[0], geompyDC.ShapeType["VERTEX"] )
311             p1 = self.geompyD.PointCoordinates( vertex1 )
312             p2 = self.geompyD.PointCoordinates( vertex2 )
313             axis = AxisStruct(p1[0], p1[1], p1[2], p2[0]-p1[0], p2[1]-p1[1], p2[2]-p1[2])
314             return axis
315         return None
316
317     # From SMESH_Gen interface:
318     # ------------------------
319
320     ## Sets the current mode
321     #  @ingroup l1_auxiliary
322     def SetEmbeddedMode( self,theMode ):
323         #self.SetEmbeddedMode(theMode)
324         SMESH._objref_SMESH_Gen.SetEmbeddedMode(self,theMode)
325
326     ## Gets the current mode
327     #  @ingroup l1_auxiliary
328     def IsEmbeddedMode(self):
329         #return self.IsEmbeddedMode()
330         return SMESH._objref_SMESH_Gen.IsEmbeddedMode(self)
331
332     ## Sets the current study
333     #  @ingroup l1_auxiliary
334     def SetCurrentStudy( self, theStudy, geompyD = None ):
335         #self.SetCurrentStudy(theStudy)
336         if not geompyD:
337             import geompy
338             geompyD = geompy.geom
339             pass
340         self.geompyD=geompyD
341         self.SetGeomEngine(geompyD)
342         SMESH._objref_SMESH_Gen.SetCurrentStudy(self,theStudy)
343
344     ## Gets the current study
345     #  @ingroup l1_auxiliary
346     def GetCurrentStudy(self):
347         #return self.GetCurrentStudy()
348         return SMESH._objref_SMESH_Gen.GetCurrentStudy(self)
349
350     ## Creates a Mesh object importing data from the given UNV file
351     #  @return an instance of Mesh class
352     #  @ingroup l2_impexp
353     def CreateMeshesFromUNV( self,theFileName ):
354         aSmeshMesh = SMESH._objref_SMESH_Gen.CreateMeshesFromUNV(self,theFileName)
355         aMesh = Mesh(self, self.geompyD, aSmeshMesh)
356         return aMesh
357
358     ## Creates a Mesh object(s) importing data from the given MED file
359     #  @return a list of Mesh class instances
360     #  @ingroup l2_impexp
361     def CreateMeshesFromMED( self,theFileName ):
362         aSmeshMeshes, aStatus = SMESH._objref_SMESH_Gen.CreateMeshesFromMED(self,theFileName)
363         aMeshes = []
364         for iMesh in range(len(aSmeshMeshes)) :
365             aMesh = Mesh(self, self.geompyD, aSmeshMeshes[iMesh])
366             aMeshes.append(aMesh)
367         return aMeshes, aStatus
368
369     ## Creates a Mesh object importing data from the given STL file
370     #  @return an instance of Mesh class
371     #  @ingroup l2_impexp
372     def CreateMeshesFromSTL( self, theFileName ):
373         aSmeshMesh = SMESH._objref_SMESH_Gen.CreateMeshesFromSTL(self,theFileName)
374         aMesh = Mesh(self, self.geompyD, aSmeshMesh)
375         return aMesh
376
377     ## Concatenate the given meshes into one mesh.
378     #  @return an instance of Mesh class
379     #  @param meshes the meshes to combine into one mesh
380     #  @param uniteIdenticalGroups if true, groups with same names are united, else they are renamed
381     #  @param mergeNodesAndElements if true, equal nodes and elements aremerged
382     #  @param mergeTolerance tolerance for merging nodes
383     #  @param allGroups forces creation of groups of all elements
384     def Concatenate( self, meshes, uniteIdenticalGroups,
385                      mergeNodesAndElements = False, mergeTolerance = 1e-5, allGroups = False):
386         if allGroups:
387             aSmeshMesh = SMESH._objref_SMESH_Gen.ConcatenateWithGroups(
388                 self,meshes,uniteIdenticalGroups,mergeNodesAndElements,mergeTolerance)
389         else:
390             aSmeshMesh = SMESH._objref_SMESH_Gen.Concatenate(
391                 self,meshes,uniteIdenticalGroups,mergeNodesAndElements,mergeTolerance)
392         aMesh = Mesh(self, self.geompyD, aSmeshMesh)
393         return aMesh
394
395     ## From SMESH_Gen interface
396     #  @return the list of integer values
397     #  @ingroup l1_auxiliary
398     def GetSubShapesId( self, theMainObject, theListOfSubObjects ):
399         return SMESH._objref_SMESH_Gen.GetSubShapesId(self,theMainObject, theListOfSubObjects)
400
401     ## From SMESH_Gen interface. Creates a pattern
402     #  @return an instance of SMESH_Pattern
403     #
404     #  <a href="../tui_modifying_meshes_page.html#tui_pattern_mapping">Example of Patterns usage</a>
405     #  @ingroup l2_modif_patterns
406     def GetPattern(self):
407         return SMESH._objref_SMESH_Gen.GetPattern(self)
408
409
410     # Filtering. Auxiliary functions:
411     # ------------------------------
412
413     ## Creates an empty criterion
414     #  @return SMESH.Filter.Criterion
415     #  @ingroup l1_controls
416     def GetEmptyCriterion(self):
417         Type = self.EnumToLong(FT_Undefined)
418         Compare = self.EnumToLong(FT_Undefined)
419         Threshold = 0
420         ThresholdStr = ""
421         ThresholdID = ""
422         UnaryOp = self.EnumToLong(FT_Undefined)
423         BinaryOp = self.EnumToLong(FT_Undefined)
424         Tolerance = 1e-07
425         TypeOfElement = ALL
426         Precision = -1 ##@1e-07
427         return Filter.Criterion(Type, Compare, Threshold, ThresholdStr, ThresholdID,
428                                 UnaryOp, BinaryOp, Tolerance, TypeOfElement, Precision)
429
430     ## Creates a criterion by the given parameters
431     #  @param elementType the type of elements(NODE, EDGE, FACE, VOLUME)
432     #  @param CritType the type of criterion (FT_Taper, FT_Area, FT_RangeOfIds, FT_LyingOnGeom etc.)
433     #  @param Compare  belongs to {FT_LessThan, FT_MoreThan, FT_EqualTo}
434     #  @param Treshold the threshold value (range of ids as string, shape, numeric)
435     #  @param UnaryOp  FT_LogicalNOT or FT_Undefined
436     #  @param BinaryOp a binary logical operation FT_LogicalAND, FT_LogicalOR or
437     #                  FT_Undefined (must be for the last criterion of all criteria)
438     #  @return SMESH.Filter.Criterion
439     #  @ingroup l1_controls
440     def GetCriterion(self,elementType,
441                      CritType,
442                      Compare = FT_EqualTo,
443                      Treshold="",
444                      UnaryOp=FT_Undefined,
445                      BinaryOp=FT_Undefined):
446         aCriterion = self.GetEmptyCriterion()
447         aCriterion.TypeOfElement = elementType
448         aCriterion.Type = self.EnumToLong(CritType)
449
450         aTreshold = Treshold
451
452         if Compare in [FT_LessThan, FT_MoreThan, FT_EqualTo]:
453             aCriterion.Compare = self.EnumToLong(Compare)
454         elif Compare == "=" or Compare == "==":
455             aCriterion.Compare = self.EnumToLong(FT_EqualTo)
456         elif Compare == "<":
457             aCriterion.Compare = self.EnumToLong(FT_LessThan)
458         elif Compare == ">":
459             aCriterion.Compare = self.EnumToLong(FT_MoreThan)
460         else:
461             aCriterion.Compare = self.EnumToLong(FT_EqualTo)
462             aTreshold = Compare
463
464         if CritType in [FT_BelongToGeom,     FT_BelongToPlane, FT_BelongToGenSurface,
465                         FT_BelongToCylinder, FT_LyingOnGeom]:
466             # Checks the treshold
467             if isinstance(aTreshold, geompyDC.GEOM._objref_GEOM_Object):
468                 aCriterion.ThresholdStr = GetName(aTreshold)
469                 aCriterion.ThresholdID = salome.ObjectToID(aTreshold)
470             else:
471                 print "Error: The treshold should be a shape."
472                 return None
473         elif CritType == FT_RangeOfIds:
474             # Checks the treshold
475             if isinstance(aTreshold, str):
476                 aCriterion.ThresholdStr = aTreshold
477             else:
478                 print "Error: The treshold should be a string."
479                 return None
480         elif CritType in [FT_FreeBorders, FT_FreeEdges, FT_BadOrientedVolume]:
481             # At this point the treshold is unnecessary
482             if aTreshold ==  FT_LogicalNOT:
483                 aCriterion.UnaryOp = self.EnumToLong(FT_LogicalNOT)
484             elif aTreshold in [FT_LogicalAND, FT_LogicalOR]:
485                 aCriterion.BinaryOp = aTreshold
486         else:
487             # Check treshold
488             try:
489                 aTreshold = float(aTreshold)
490                 aCriterion.Threshold = aTreshold
491             except:
492                 print "Error: The treshold should be a number."
493                 return None
494
495         if Treshold ==  FT_LogicalNOT or UnaryOp ==  FT_LogicalNOT:
496             aCriterion.UnaryOp = self.EnumToLong(FT_LogicalNOT)
497
498         if Treshold in [FT_LogicalAND, FT_LogicalOR]:
499             aCriterion.BinaryOp = self.EnumToLong(Treshold)
500
501         if UnaryOp in [FT_LogicalAND, FT_LogicalOR]:
502             aCriterion.BinaryOp = self.EnumToLong(UnaryOp)
503
504         if BinaryOp in [FT_LogicalAND, FT_LogicalOR]:
505             aCriterion.BinaryOp = self.EnumToLong(BinaryOp)
506
507         return aCriterion
508
509     ## Creates a filter with the given parameters
510     #  @param elementType the type of elements in the group
511     #  @param CritType the type of criterion ( FT_Taper, FT_Area, FT_RangeOfIds, FT_LyingOnGeom etc. )
512     #  @param Compare  belongs to {FT_LessThan, FT_MoreThan, FT_EqualTo}
513     #  @param Treshold the threshold value (range of id ids as string, shape, numeric)
514     #  @param UnaryOp  FT_LogicalNOT or FT_Undefined
515     #  @return SMESH_Filter
516     #  @ingroup l1_controls
517     def GetFilter(self,elementType,
518                   CritType=FT_Undefined,
519                   Compare=FT_EqualTo,
520                   Treshold="",
521                   UnaryOp=FT_Undefined):
522         aCriterion = self.GetCriterion(elementType, CritType, Compare, Treshold, UnaryOp, FT_Undefined)
523         aFilterMgr = self.CreateFilterManager()
524         aFilter = aFilterMgr.CreateFilter()
525         aCriteria = []
526         aCriteria.append(aCriterion)
527         aFilter.SetCriteria(aCriteria)
528         return aFilter
529
530     ## Creates a numerical functor by its type
531     #  @param theCriterion FT_...; functor type
532     #  @return SMESH_NumericalFunctor
533     #  @ingroup l1_controls
534     def GetFunctor(self,theCriterion):
535         aFilterMgr = self.CreateFilterManager()
536         if theCriterion == FT_AspectRatio:
537             return aFilterMgr.CreateAspectRatio()
538         elif theCriterion == FT_AspectRatio3D:
539             return aFilterMgr.CreateAspectRatio3D()
540         elif theCriterion == FT_Warping:
541             return aFilterMgr.CreateWarping()
542         elif theCriterion == FT_MinimumAngle:
543             return aFilterMgr.CreateMinimumAngle()
544         elif theCriterion == FT_Taper:
545             return aFilterMgr.CreateTaper()
546         elif theCriterion == FT_Skew:
547             return aFilterMgr.CreateSkew()
548         elif theCriterion == FT_Area:
549             return aFilterMgr.CreateArea()
550         elif theCriterion == FT_Volume3D:
551             return aFilterMgr.CreateVolume3D()
552         elif theCriterion == FT_MultiConnection:
553             return aFilterMgr.CreateMultiConnection()
554         elif theCriterion == FT_MultiConnection2D:
555             return aFilterMgr.CreateMultiConnection2D()
556         elif theCriterion == FT_Length:
557             return aFilterMgr.CreateLength()
558         elif theCriterion == FT_Length2D:
559             return aFilterMgr.CreateLength2D()
560         else:
561             print "Error: given parameter is not numerucal functor type."
562
563
564 import omniORB
565 #Registering the new proxy for SMESH_Gen
566 omniORB.registerObjref(SMESH._objref_SMESH_Gen._NP_RepositoryId, smeshDC)
567
568
569 # Public class: Mesh
570 # ==================
571
572 ## This class allows defining and managing a mesh.
573 #  It has a set of methods to build a mesh on the given geometry, including the definition of sub-meshes.
574 #  It also has methods to define groups of mesh elements, to modify a mesh (by addition of
575 #  new nodes and elements and by changing the existing entities), to get information
576 #  about a mesh and to export a mesh into different formats.
577 class Mesh:
578
579     geom = 0
580     mesh = 0
581     editor = 0
582
583     ## Constructor
584     #
585     #  Creates a mesh on the shape \a obj (or an empty mesh if \a obj is equal to 0) and
586     #  sets the GUI name of this mesh to \a name.
587     #  @param smeshpyD an instance of smeshDC class
588     #  @param geompyD an instance of geompyDC class
589     #  @param obj Shape to be meshed or SMESH_Mesh object
590     #  @param name Study name of the mesh
591     #  @ingroup l2_construct
592     def __init__(self, smeshpyD, geompyD, obj=0, name=0):
593         self.smeshpyD=smeshpyD
594         self.geompyD=geompyD
595         if obj is None:
596             obj = 0
597         if obj != 0:
598             if isinstance(obj, geompyDC.GEOM._objref_GEOM_Object):
599                 self.geom = obj
600                 self.mesh = self.smeshpyD.CreateMesh(self.geom)
601             elif isinstance(obj, SMESH._objref_SMESH_Mesh):
602                 self.SetMesh(obj)
603         else:
604             self.mesh = self.smeshpyD.CreateEmptyMesh()
605         if name != 0:
606             SetName(self.mesh, name)
607         elif obj != 0:
608             SetName(self.mesh, GetName(obj))
609
610         if not self.geom:
611             self.geom = self.mesh.GetShapeToMesh()
612
613         self.editor = self.mesh.GetMeshEditor()
614
615     ## Initializes the Mesh object from an instance of SMESH_Mesh interface
616     #  @param theMesh a SMESH_Mesh object
617     #  @ingroup l2_construct
618     def SetMesh(self, theMesh):
619         self.mesh = theMesh
620         self.geom = self.mesh.GetShapeToMesh()
621
622     ## Returns the mesh, that is an instance of SMESH_Mesh interface
623     #  @return a SMESH_Mesh object
624     #  @ingroup l2_construct
625     def GetMesh(self):
626         return self.mesh
627
628     ## Gets the name of the mesh
629     #  @return the name of the mesh as a string
630     #  @ingroup l2_construct
631     def GetName(self):
632         name = GetName(self.GetMesh())
633         return name
634
635     ## Sets a name to the mesh
636     #  @param name a new name of the mesh
637     #  @ingroup l2_construct
638     def SetName(self, name):
639         SetName(self.GetMesh(), name)
640
641     ## Gets the subMesh object associated to a \a theSubObject geometrical object.
642     #  The subMesh object gives access to the IDs of nodes and elements.
643     #  @param theSubObject a geometrical object (shape)
644     #  @param theName a name for the submesh
645     #  @return an object of type SMESH_SubMesh, representing a part of mesh, which lies on the given shape
646     #  @ingroup l2_submeshes
647     def GetSubMesh(self, theSubObject, theName):
648         submesh = self.mesh.GetSubMesh(theSubObject, theName)
649         return submesh
650
651     ## Returns the shape associated to the mesh
652     #  @return a GEOM_Object
653     #  @ingroup l2_construct
654     def GetShape(self):
655         return self.geom
656
657     ## Associates the given shape to the mesh (entails the recreation of the mesh)
658     #  @param geom the shape to be meshed (GEOM_Object)
659     #  @ingroup l2_construct
660     def SetShape(self, geom):
661         self.mesh = self.smeshpyD.CreateMesh(geom)
662
663     ## Returns true if the hypotheses are defined well
664     #  @param theSubObject a subshape of a mesh shape
665     #  @return True or False
666     #  @ingroup l2_construct
667     def IsReadyToCompute(self, theSubObject):
668         return self.smeshpyD.IsReadyToCompute(self.mesh, theSubObject)
669
670     ## Returns errors of hypotheses definition.
671     #  The list of errors is empty if everything is OK.
672     #  @param theSubObject a subshape of a mesh shape
673     #  @return a list of errors
674     #  @ingroup l2_construct
675     def GetAlgoState(self, theSubObject):
676         return self.smeshpyD.GetAlgoState(self.mesh, theSubObject)
677
678     ## Returns a geometrical object on which the given element was built.
679     #  The returned geometrical object, if not nil, is either found in the
680     #  study or published by this method with the given name
681     #  @param theElementID the id of the mesh element
682     #  @param theGeomName the user-defined name of the geometrical object
683     #  @return GEOM::GEOM_Object instance
684     #  @ingroup l2_construct
685     def GetGeometryByMeshElement(self, theElementID, theGeomName):
686         return self.smeshpyD.GetGeometryByMeshElement( self.mesh, theElementID, theGeomName )
687
688     ## Returns the mesh dimension depending on the dimension of the underlying shape
689     #  @return mesh dimension as an integer value [0,3]
690     #  @ingroup l1_auxiliary
691     def MeshDimension(self):
692         shells = self.geompyD.SubShapeAllIDs( self.geom, geompyDC.ShapeType["SHELL"] )
693         if len( shells ) > 0 :
694             return 3
695         elif self.geompyD.NumberOfFaces( self.geom ) > 0 :
696             return 2
697         elif self.geompyD.NumberOfEdges( self.geom ) > 0 :
698             return 1
699         else:
700             return 0;
701         pass
702
703     ## Creates a segment discretization 1D algorithm.
704     #  If the optional \a algo parameter is not set, this algorithm is REGULAR.
705     #  \n If the optional \a geom parameter is not set, this algorithm is global.
706     #  Otherwise, this algorithm defines a submesh based on \a geom subshape.
707     #  @param algo the type of the required algorithm. Possible values are:
708     #     - smesh.REGULAR,
709     #     - smesh.PYTHON for discretization via a python function,
710     #     - smesh.COMPOSITE for meshing a set of edges on one face side as a whole.
711     #  @param geom If defined is the subshape to be meshed
712     #  @return an instance of Mesh_Segment or Mesh_Segment_Python, or Mesh_CompositeSegment class
713     #  @ingroup l3_algos_basic
714     def Segment(self, algo=REGULAR, geom=0):
715         ## if Segment(geom) is called by mistake
716         if isinstance( algo, geompyDC.GEOM._objref_GEOM_Object):
717             algo, geom = geom, algo
718             if not algo: algo = REGULAR
719             pass
720         if algo == REGULAR:
721             return Mesh_Segment(self,  geom)
722         elif algo == PYTHON:
723             return Mesh_Segment_Python(self, geom)
724         elif algo == COMPOSITE:
725             return Mesh_CompositeSegment(self, geom)
726         else:
727             return Mesh_Segment(self, geom)
728
729     ## Enables creation of nodes and segments usable by 2D algoritms.
730     #  The added nodes and segments must be bound to edges and vertices by
731     #  SetNodeOnVertex(), SetNodeOnEdge() and SetMeshElementOnShape()
732     #  If the optional \a geom parameter is not set, this algorithm is global.
733     #  \n Otherwise, this algorithm defines a submesh based on \a geom subshape.
734     #  @param geom the subshape to be manually meshed
735     #  @return StdMeshers_UseExisting_1D algorithm that generates nothing
736     #  @ingroup l3_algos_basic
737     def UseExistingSegments(self, geom=0):
738         algo = Mesh_UseExisting(1,self,geom)
739         return algo.GetAlgorithm()
740
741     ## Enables creation of nodes and faces usable by 3D algoritms.
742     #  The added nodes and faces must be bound to geom faces by SetNodeOnFace()
743     #  and SetMeshElementOnShape()
744     #  If the optional \a geom parameter is not set, this algorithm is global.
745     #  \n Otherwise, this algorithm defines a submesh based on \a geom subshape.
746     #  @param geom the subshape to be manually meshed
747     #  @return StdMeshers_UseExisting_2D algorithm that generates nothing
748     #  @ingroup l3_algos_basic
749     def UseExistingFaces(self, geom=0):
750         algo = Mesh_UseExisting(2,self,geom)
751         return algo.GetAlgorithm()
752
753     ## Creates a triangle 2D algorithm for faces.
754     #  If the optional \a geom parameter is not set, this algorithm is global.
755     #  \n Otherwise, this algorithm defines a submesh based on \a geom subshape.
756     #  @param algo values are: smesh.MEFISTO || smesh.NETGEN_1D2D || smesh.NETGEN_2D || smesh.BLSURF
757     #  @param geom If defined, the subshape to be meshed (GEOM_Object)
758     #  @return an instance of Mesh_Triangle algorithm
759     #  @ingroup l3_algos_basic
760     def Triangle(self, algo=MEFISTO, geom=0):
761         ## if Triangle(geom) is called by mistake
762         if (isinstance(algo, geompyDC.GEOM._objref_GEOM_Object)):
763             geom = algo
764             algo = MEFISTO
765
766         return Mesh_Triangle(self, algo, geom)
767
768     ## Creates a quadrangle 2D algorithm for faces.
769     #  If the optional \a geom parameter is not set, this algorithm is global.
770     #  \n Otherwise, this algorithm defines a submesh based on \a geom subshape.
771     #  @param geom If defined, the subshape to be meshed (GEOM_Object)
772     #  @return an instance of Mesh_Quadrangle algorithm
773     #  @ingroup l3_algos_basic
774     def Quadrangle(self, geom=0):
775         return Mesh_Quadrangle(self,  geom)
776
777     ## Creates a tetrahedron 3D algorithm for solids.
778     #  The parameter \a algo permits to choose the algorithm: NETGEN or GHS3D
779     #  If the optional \a geom parameter is not set, this algorithm is global.
780     #  \n Otherwise, this algorithm defines a submesh based on \a geom subshape.
781     #  @param algo values are: smesh.NETGEN, smesh.GHS3D, smesh.GHS3DPRL, smesh.FULL_NETGEN
782     #  @param geom If defined, the subshape to be meshed (GEOM_Object)
783     #  @return an instance of Mesh_Tetrahedron algorithm
784     #  @ingroup l3_algos_basic
785     def Tetrahedron(self, algo=NETGEN, geom=0):
786         ## if Tetrahedron(geom) is called by mistake
787         if ( isinstance( algo, geompyDC.GEOM._objref_GEOM_Object)):
788             algo, geom = geom, algo
789             if not algo: algo = NETGEN
790             pass
791         return Mesh_Tetrahedron(self,  algo, geom)
792
793     ## Creates a hexahedron 3D algorithm for solids.
794     #  If the optional \a geom parameter is not set, this algorithm is global.
795     #  \n Otherwise, this algorithm defines a submesh based on \a geom subshape.
796     #  @param algo possible values are: smesh.Hexa, smesh.Hexotic
797     #  @param geom If defined, the subshape to be meshed (GEOM_Object)
798     #  @return an instance of Mesh_Hexahedron algorithm
799     #  @ingroup l3_algos_basic
800     def Hexahedron(self, algo=Hexa, geom=0):
801         ## if Hexahedron(geom, algo) or Hexahedron(geom) is called by mistake
802         if ( isinstance(algo, geompyDC.GEOM._objref_GEOM_Object) ):
803             if   geom in [Hexa, Hexotic]: algo, geom = geom, algo
804             elif geom == 0:               algo, geom = Hexa, algo
805         return Mesh_Hexahedron(self, algo, geom)
806
807     ## Deprecated, used only for compatibility!
808     #  @return an instance of Mesh_Netgen algorithm
809     #  @ingroup l3_algos_basic
810     def Netgen(self, is3D, geom=0):
811         return Mesh_Netgen(self,  is3D, geom)
812
813     ## Creates a projection 1D algorithm for edges.
814     #  If the optional \a geom parameter is not set, this algorithm is global.
815     #  Otherwise, this algorithm defines a submesh based on \a geom subshape.
816     #  @param geom If defined, the subshape to be meshed
817     #  @return an instance of Mesh_Projection1D algorithm
818     #  @ingroup l3_algos_proj
819     def Projection1D(self, geom=0):
820         return Mesh_Projection1D(self,  geom)
821
822     ## Creates a projection 2D algorithm for faces.
823     #  If the optional \a geom parameter is not set, this algorithm is global.
824     #  Otherwise, this algorithm defines a submesh based on \a geom subshape.
825     #  @param geom If defined, the subshape to be meshed
826     #  @return an instance of Mesh_Projection2D algorithm
827     #  @ingroup l3_algos_proj
828     def Projection2D(self, geom=0):
829         return Mesh_Projection2D(self,  geom)
830
831     ## Creates a projection 3D algorithm for solids.
832     #  If the optional \a geom parameter is not set, this algorithm is global.
833     #  Otherwise, this algorithm defines a submesh based on \a geom subshape.
834     #  @param geom If defined, the subshape to be meshed
835     #  @return an instance of Mesh_Projection3D algorithm
836     #  @ingroup l3_algos_proj
837     def Projection3D(self, geom=0):
838         return Mesh_Projection3D(self,  geom)
839
840     ## Creates a 3D extrusion (Prism 3D) or RadialPrism 3D algorithm for solids.
841     #  If the optional \a geom parameter is not set, this algorithm is global.
842     #  Otherwise, this algorithm defines a submesh based on \a geom subshape.
843     #  @param geom If defined, the subshape to be meshed
844     #  @return an instance of Mesh_Prism3D or Mesh_RadialPrism3D algorithm
845     #  @ingroup l3_algos_radialp l3_algos_3dextr
846     def Prism(self, geom=0):
847         shape = geom
848         if shape==0:
849             shape = self.geom
850         nbSolids = len( self.geompyD.SubShapeAll( shape, geompyDC.ShapeType["SOLID"] ))
851         nbShells = len( self.geompyD.SubShapeAll( shape, geompyDC.ShapeType["SHELL"] ))
852         if nbSolids == 0 or nbSolids == nbShells:
853             return Mesh_Prism3D(self,  geom)
854         return Mesh_RadialPrism3D(self,  geom)
855
856     ## Computes the mesh and returns the status of the computation
857     #  @return True or False
858     #  @ingroup l2_construct
859     def Compute(self, geom=0):
860         if geom == 0 or not isinstance(geom, geompyDC.GEOM._objref_GEOM_Object):
861             if self.geom == 0:
862                 geom = self.mesh.GetShapeToMesh()
863             else:
864                 geom = self.geom
865         ok = False
866         try:
867             ok = self.smeshpyD.Compute(self.mesh, geom)
868         except SALOME.SALOME_Exception, ex:
869             print "Mesh computation failed, exception caught:"
870             print "    ", ex.details.text
871         except:
872             import traceback
873             print "Mesh computation failed, exception caught:"
874             traceback.print_exc()
875         if True:#not ok:
876             errors = self.smeshpyD.GetAlgoState( self.mesh, geom )
877             allReasons = ""
878             for err in errors:
879                 if err.isGlobalAlgo:
880                     glob = "global"
881                 else:
882                     glob = "local"
883                     pass
884                 dim = err.algoDim
885                 name = err.algoName
886                 if len(name) == 0:
887                     reason = '%s %sD algorithm is missing' % (glob, dim)
888                 elif err.state == HYP_MISSING:
889                     reason = ('%s %sD algorithm "%s" misses %sD hypothesis'
890                               % (glob, dim, name, dim))
891                 elif err.state == HYP_NOTCONFORM:
892                     reason = 'Global "Not Conform mesh allowed" hypothesis is missing'
893                 elif err.state == HYP_BAD_PARAMETER:
894                     reason = ('Hypothesis of %s %sD algorithm "%s" has a bad parameter value'
895                               % ( glob, dim, name ))
896                 elif err.state == HYP_BAD_GEOMETRY:
897                     reason = ('%s %sD algorithm "%s" is assigned to mismatching'
898                               'geometry' % ( glob, dim, name ))
899                 else:
900                     reason = "For unknown reason."+\
901                              " Revise Mesh.Compute() implementation in smeshDC.py!"
902                     pass
903                 if allReasons != "":
904                     allReasons += "\n"
905                     pass
906                 allReasons += reason
907                 pass
908             if allReasons != "":
909                 print '"' + GetName(self.mesh) + '"',"has not been computed:"
910                 print allReasons
911                 ok = False
912             elif not ok:
913                 print '"' + GetName(self.mesh) + '"',"has not been computed."
914                 pass
915             pass
916         if salome.sg.hasDesktop():
917             smeshgui = salome.ImportComponentGUI("SMESH")
918             smeshgui.Init(salome.myStudyId)
919             smeshgui.SetMeshIcon( salome.ObjectToID( self.mesh ), ok, (self.NbNodes()==0) )
920             salome.sg.updateObjBrowser(1)
921             pass
922         return ok
923
924     ## Removes all nodes and elements
925     #  @ingroup l2_construct
926     def Clear(self):
927         self.mesh.Clear()
928         if salome.sg.hasDesktop():
929             smeshgui = salome.ImportComponentGUI("SMESH")
930             smeshgui.Init(salome.myStudyId)
931             smeshgui.SetMeshIcon( salome.ObjectToID( self.mesh ), False, True )
932             salome.sg.updateObjBrowser(1)
933
934     ## Computes a tetrahedral mesh using AutomaticLength + MEFISTO + NETGEN
935     #  @param fineness [0,-1] defines mesh fineness
936     #  @return True or False
937     #  @ingroup l3_algos_basic
938     def AutomaticTetrahedralization(self, fineness=0):
939         dim = self.MeshDimension()
940         # assign hypotheses
941         self.RemoveGlobalHypotheses()
942         self.Segment().AutomaticLength(fineness)
943         if dim > 1 :
944             self.Triangle().LengthFromEdges()
945             pass
946         if dim > 2 :
947             self.Tetrahedron(NETGEN)
948             pass
949         return self.Compute()
950
951     ## Computes an hexahedral mesh using AutomaticLength + Quadrangle + Hexahedron
952     #  @param fineness [0,-1] defines mesh fineness
953     #  @return True or False
954     #  @ingroup l3_algos_basic
955     def AutomaticHexahedralization(self, fineness=0):
956         dim = self.MeshDimension()
957         # assign the hypotheses
958         self.RemoveGlobalHypotheses()
959         self.Segment().AutomaticLength(fineness)
960         if dim > 1 :
961             self.Quadrangle()
962             pass
963         if dim > 2 :
964             self.Hexahedron()
965             pass
966         return self.Compute()
967
968     ## Assigns a hypothesis
969     #  @param hyp a hypothesis to assign
970     #  @param geom a subhape of mesh geometry
971     #  @return SMESH.Hypothesis_Status
972     #  @ingroup l2_hypotheses
973     def AddHypothesis(self, hyp, geom=0):
974         if isinstance( hyp, Mesh_Algorithm ):
975             hyp = hyp.GetAlgorithm()
976             pass
977         if not geom:
978             geom = self.geom
979             if not geom:
980                 geom = self.mesh.GetShapeToMesh()
981             pass
982         status = self.mesh.AddHypothesis(geom, hyp)
983         isAlgo = hyp._narrow( SMESH_Algo )
984         TreatHypoStatus( status, GetName( hyp ), GetName( geom ), isAlgo )
985         return status
986
987     ## Unassigns a hypothesis
988     #  @param hyp a hypothesis to unassign
989     #  @param geom a subshape of mesh geometry
990     #  @return SMESH.Hypothesis_Status
991     #  @ingroup l2_hypotheses
992     def RemoveHypothesis(self, hyp, geom=0):
993         if isinstance( hyp, Mesh_Algorithm ):
994             hyp = hyp.GetAlgorithm()
995             pass
996         if not geom:
997             geom = self.geom
998             pass
999         status = self.mesh.RemoveHypothesis(geom, hyp)
1000         return status
1001
1002     ## Gets the list of hypotheses added on a geometry
1003     #  @param geom a subshape of mesh geometry
1004     #  @return the sequence of SMESH_Hypothesis
1005     #  @ingroup l2_hypotheses
1006     def GetHypothesisList(self, geom):
1007         return self.mesh.GetHypothesisList( geom )
1008
1009     ## Removes all global hypotheses
1010     #  @ingroup l2_hypotheses
1011     def RemoveGlobalHypotheses(self):
1012         current_hyps = self.mesh.GetHypothesisList( self.geom )
1013         for hyp in current_hyps:
1014             self.mesh.RemoveHypothesis( self.geom, hyp )
1015             pass
1016         pass
1017
1018     ## Creates a mesh group based on the geometric object \a grp
1019     #  and gives a \a name, \n if this parameter is not defined
1020     #  the name is the same as the geometric group name \n
1021     #  Note: Works like GroupOnGeom().
1022     #  @param grp  a geometric group, a vertex, an edge, a face or a solid
1023     #  @param name the name of the mesh group
1024     #  @return SMESH_GroupOnGeom
1025     #  @ingroup l2_grps_create
1026     def Group(self, grp, name=""):
1027         return self.GroupOnGeom(grp, name)
1028
1029     ## Deprecated, used only for compatibility! Please, use ExportMED() method instead.
1030     #  Exports the mesh in a file in MED format and chooses the \a version of MED format
1031     #  @param f the file name
1032     #  @param version values are SMESH.MED_V2_1, SMESH.MED_V2_2
1033     #  @ingroup l2_impexp
1034     def ExportToMED(self, f, version, opt=0):
1035         self.mesh.ExportToMED(f, opt, version)
1036
1037     ## Exports the mesh in a file in MED format
1038     #  @param f is the file name
1039     #  @param auto_groups boolean parameter for creating/not creating
1040     #  the groups Group_On_All_Nodes, Group_On_All_Faces, ... ;
1041     #  the typical use is auto_groups=false.
1042     #  @param version MED format version(MED_V2_1 or MED_V2_2)
1043     #  @ingroup l2_impexp
1044     def ExportMED(self, f, auto_groups=0, version=MED_V2_2):
1045         self.mesh.ExportToMED(f, auto_groups, version)
1046
1047     ## Exports the mesh in a file in DAT format
1048     #  @param f the file name
1049     #  @ingroup l2_impexp
1050     def ExportDAT(self, f):
1051         self.mesh.ExportDAT(f)
1052
1053     ## Exports the mesh in a file in UNV format
1054     #  @param f the file name
1055     #  @ingroup l2_impexp
1056     def ExportUNV(self, f):
1057         self.mesh.ExportUNV(f)
1058
1059     ## Export the mesh in a file in STL format
1060     #  @param f the file name
1061     #  @param ascii defines the file encoding
1062     #  @ingroup l2_impexp
1063     def ExportSTL(self, f, ascii=1):
1064         self.mesh.ExportSTL(f, ascii)
1065
1066
1067     # Operations with groups:
1068     # ----------------------
1069
1070     ## Creates an empty mesh group
1071     #  @param elementType the type of elements in the group
1072     #  @param name the name of the mesh group
1073     #  @return SMESH_Group
1074     #  @ingroup l2_grps_create
1075     def CreateEmptyGroup(self, elementType, name):
1076         return self.mesh.CreateGroup(elementType, name)
1077
1078     ## Creates a mesh group based on the geometrical object \a grp
1079     #  and gives a \a name, \n if this parameter is not defined
1080     #  the name is the same as the geometrical group name
1081     #  @param grp  a geometrical group, a vertex, an edge, a face or a solid
1082     #  @param name the name of the mesh group
1083     #  @param typ  the type of elements in the group. If not set, it is
1084     #              automatically detected by the type of the geometry
1085     #  @return SMESH_GroupOnGeom
1086     #  @ingroup l2_grps_create
1087     def GroupOnGeom(self, grp, name="", typ=None):
1088         if name == "":
1089             name = grp.GetName()
1090
1091         if typ == None:
1092             tgeo = str(grp.GetShapeType())
1093             if tgeo == "VERTEX":
1094                 typ = NODE
1095             elif tgeo == "EDGE":
1096                 typ = EDGE
1097             elif tgeo == "FACE":
1098                 typ = FACE
1099             elif tgeo == "SOLID":
1100                 typ = VOLUME
1101             elif tgeo == "SHELL":
1102                 typ = VOLUME
1103             elif tgeo == "COMPOUND":
1104                 if len( self.geompyD.GetObjectIDs( grp )) == 0:
1105                     print "Mesh.Group: empty geometric group", GetName( grp )
1106                     return 0
1107                 tgeo = self.geompyD.GetType(grp)
1108                 if tgeo == geompyDC.ShapeType["VERTEX"]:
1109                     typ = NODE
1110                 elif tgeo == geompyDC.ShapeType["EDGE"]:
1111                     typ = EDGE
1112                 elif tgeo == geompyDC.ShapeType["FACE"]:
1113                     typ = FACE
1114                 elif tgeo == geompyDC.ShapeType["SOLID"]:
1115                     typ = VOLUME
1116
1117         if typ == None:
1118             print "Mesh.Group: bad first argument: expected a group, a vertex, an edge, a face or a solid"
1119             return 0
1120         else:
1121             return self.mesh.CreateGroupFromGEOM(typ, name, grp)
1122
1123     ## Creates a mesh group by the given ids of elements
1124     #  @param groupName the name of the mesh group
1125     #  @param elementType the type of elements in the group
1126     #  @param elemIDs the list of ids
1127     #  @return SMESH_Group
1128     #  @ingroup l2_grps_create
1129     def MakeGroupByIds(self, groupName, elementType, elemIDs):
1130         group = self.mesh.CreateGroup(elementType, groupName)
1131         group.Add(elemIDs)
1132         return group
1133
1134     ## Creates a mesh group by the given conditions
1135     #  @param groupName the name of the mesh group
1136     #  @param elementType the type of elements in the group
1137     #  @param CritType the type of criterion( FT_Taper, FT_Area, FT_RangeOfIds, FT_LyingOnGeom etc. )
1138     #  @param Compare belongs to {FT_LessThan, FT_MoreThan, FT_EqualTo}
1139     #  @param Treshold the threshold value (range of id ids as string, shape, numeric)
1140     #  @param UnaryOp FT_LogicalNOT or FT_Undefined
1141     #  @return SMESH_Group
1142     #  @ingroup l2_grps_create
1143     def MakeGroup(self,
1144                   groupName,
1145                   elementType,
1146                   CritType=FT_Undefined,
1147                   Compare=FT_EqualTo,
1148                   Treshold="",
1149                   UnaryOp=FT_Undefined):
1150         aCriterion = self.smeshpyD.GetCriterion(elementType, CritType, Compare, Treshold, UnaryOp, FT_Undefined)
1151         group = self.MakeGroupByCriterion(groupName, aCriterion)
1152         return group
1153
1154     ## Creates a mesh group by the given criterion
1155     #  @param groupName the name of the mesh group
1156     #  @param Criterion the instance of Criterion class
1157     #  @return SMESH_Group
1158     #  @ingroup l2_grps_create
1159     def MakeGroupByCriterion(self, groupName, Criterion):
1160         aFilterMgr = self.smeshpyD.CreateFilterManager()
1161         aFilter = aFilterMgr.CreateFilter()
1162         aCriteria = []
1163         aCriteria.append(Criterion)
1164         aFilter.SetCriteria(aCriteria)
1165         group = self.MakeGroupByFilter(groupName, aFilter)
1166         return group
1167
1168     ## Creates a mesh group by the given criteria (list of criteria)
1169     #  @param groupName the name of the mesh group
1170     #  @param theCriteria the list of criteria
1171     #  @return SMESH_Group
1172     #  @ingroup l2_grps_create
1173     def MakeGroupByCriteria(self, groupName, theCriteria):
1174         aFilterMgr = self.smeshpyD.CreateFilterManager()
1175         aFilter = aFilterMgr.CreateFilter()
1176         aFilter.SetCriteria(theCriteria)
1177         group = self.MakeGroupByFilter(groupName, aFilter)
1178         return group
1179
1180     ## Creates a mesh group by the given filter
1181     #  @param groupName the name of the mesh group
1182     #  @param theFilter the instance of Filter class
1183     #  @return SMESH_Group
1184     #  @ingroup l2_grps_create
1185     def MakeGroupByFilter(self, groupName, theFilter):
1186         anIds = theFilter.GetElementsId(self.mesh)
1187         anElemType = theFilter.GetElementType()
1188         group = self.MakeGroupByIds(groupName, anElemType, anIds)
1189         return group
1190
1191     ## Passes mesh elements through the given filter and return IDs of fitting elements
1192     #  @param theFilter SMESH_Filter
1193     #  @return a list of ids
1194     #  @ingroup l1_controls
1195     def GetIdsFromFilter(self, theFilter):
1196         return theFilter.GetElementsId(self.mesh)
1197
1198     ## Verifies whether a 2D mesh element has free edges (edges connected to one face only)\n
1199     #  Returns a list of special structures (borders).
1200     #  @return a list of SMESH.FreeEdges.Border structure: edge id and ids of two its nodes.
1201     #  @ingroup l1_controls
1202     def GetFreeBorders(self):
1203         aFilterMgr = self.smeshpyD.CreateFilterManager()
1204         aPredicate = aFilterMgr.CreateFreeEdges()
1205         aPredicate.SetMesh(self.mesh)
1206         aBorders = aPredicate.GetBorders()
1207         return aBorders
1208
1209     ## Removes a group
1210     #  @ingroup l2_grps_delete
1211     def RemoveGroup(self, group):
1212         self.mesh.RemoveGroup(group)
1213
1214     ## Removes a group with its contents
1215     #  @ingroup l2_grps_delete
1216     def RemoveGroupWithContents(self, group):
1217         self.mesh.RemoveGroupWithContents(group)
1218
1219     ## Gets the list of groups existing in the mesh
1220     #  @return a sequence of SMESH_GroupBase
1221     #  @ingroup l2_grps_create
1222     def GetGroups(self):
1223         return self.mesh.GetGroups()
1224
1225     ## Gets the number of groups existing in the mesh
1226     #  @return the quantity of groups as an integer value
1227     #  @ingroup l2_grps_create
1228     def NbGroups(self):
1229         return self.mesh.NbGroups()
1230
1231     ## Gets the list of names of groups existing in the mesh
1232     #  @return list of strings
1233     #  @ingroup l2_grps_create
1234     def GetGroupNames(self):
1235         groups = self.GetGroups()
1236         names = []
1237         for group in groups:
1238             names.append(group.GetName())
1239         return names
1240
1241     ## Produces a union of two groups
1242     #  A new group is created. All mesh elements that are
1243     #  present in the initial groups are added to the new one
1244     #  @return an instance of SMESH_Group
1245     #  @ingroup l2_grps_operon
1246     def UnionGroups(self, group1, group2, name):
1247         return self.mesh.UnionGroups(group1, group2, name)
1248
1249     ## Prodices an intersection of two groups
1250     #  A new group is created. All mesh elements that are common
1251     #  for the two initial groups are added to the new one.
1252     #  @return an instance of SMESH_Group
1253     #  @ingroup l2_grps_operon
1254     def IntersectGroups(self, group1, group2, name):
1255         return self.mesh.IntersectGroups(group1, group2, name)
1256
1257     ## Produces a cut of two groups
1258     #  A new group is created. All mesh elements that are present in
1259     #  the main group but are not present in the tool group are added to the new one
1260     #  @return an instance of SMESH_Group
1261     #  @ingroup l2_grps_operon
1262     def CutGroups(self, mainGroup, toolGroup, name):
1263         return self.mesh.CutGroups(mainGroup, toolGroup, name)
1264
1265
1266     # Get some info about mesh:
1267     # ------------------------
1268
1269     ## Returns the log of nodes and elements added or removed
1270     #  since the previous clear of the log.
1271     #  @param clearAfterGet log is emptied after Get (safe if concurrents access)
1272     #  @return list of log_block structures:
1273     #                                        commandType
1274     #                                        number
1275     #                                        coords
1276     #                                        indexes
1277     #  @ingroup l1_auxiliary
1278     def GetLog(self, clearAfterGet):
1279         return self.mesh.GetLog(clearAfterGet)
1280
1281     ## Clears the log of nodes and elements added or removed since the previous
1282     #  clear. Must be used immediately after GetLog if clearAfterGet is false.
1283     #  @ingroup l1_auxiliary
1284     def ClearLog(self):
1285         self.mesh.ClearLog()
1286
1287     ## Toggles auto color mode on the object.
1288     #  @param theAutoColor the flag which toggles auto color mode.
1289     #  @ingroup l1_auxiliary
1290     def SetAutoColor(self, theAutoColor):
1291         self.mesh.SetAutoColor(theAutoColor)
1292
1293     ## Gets flag of object auto color mode.
1294     #  @return True or False
1295     #  @ingroup l1_auxiliary
1296     def GetAutoColor(self):
1297         return self.mesh.GetAutoColor()
1298
1299     ## Gets the internal ID
1300     #  @return integer value, which is the internal Id of the mesh
1301     #  @ingroup l1_auxiliary
1302     def GetId(self):
1303         return self.mesh.GetId()
1304
1305     ## Get the study Id
1306     #  @return integer value, which is the study Id of the mesh
1307     #  @ingroup l1_auxiliary
1308     def GetStudyId(self):
1309         return self.mesh.GetStudyId()
1310
1311     ## Checks the group names for duplications.
1312     #  Consider the maximum group name length stored in MED file.
1313     #  @return True or False
1314     #  @ingroup l1_auxiliary
1315     def HasDuplicatedGroupNamesMED(self):
1316         return self.mesh.HasDuplicatedGroupNamesMED()
1317
1318     ## Obtains the mesh editor tool
1319     #  @return an instance of SMESH_MeshEditor
1320     #  @ingroup l1_modifying
1321     def GetMeshEditor(self):
1322         return self.mesh.GetMeshEditor()
1323
1324     ## Gets MED Mesh
1325     #  @return an instance of SALOME_MED::MESH
1326     #  @ingroup l1_auxiliary
1327     def GetMEDMesh(self):
1328         return self.mesh.GetMEDMesh()
1329
1330
1331     # Get informations about mesh contents:
1332     # ------------------------------------
1333
1334     ## Returns the number of nodes in the mesh
1335     #  @return an integer value
1336     #  @ingroup l1_meshinfo
1337     def NbNodes(self):
1338         return self.mesh.NbNodes()
1339
1340     ## Returns the number of elements in the mesh
1341     #  @return an integer value
1342     #  @ingroup l1_meshinfo
1343     def NbElements(self):
1344         return self.mesh.NbElements()
1345
1346     ## Returns the number of edges in the mesh
1347     #  @return an integer value
1348     #  @ingroup l1_meshinfo
1349     def NbEdges(self):
1350         return self.mesh.NbEdges()
1351
1352     ## Returns the number of edges with the given order in the mesh
1353     #  @param elementOrder the order of elements:
1354     #         ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC
1355     #  @return an integer value
1356     #  @ingroup l1_meshinfo
1357     def NbEdgesOfOrder(self, elementOrder):
1358         return self.mesh.NbEdgesOfOrder(elementOrder)
1359
1360     ## Returns the number of faces in the mesh
1361     #  @return an integer value
1362     #  @ingroup l1_meshinfo
1363     def NbFaces(self):
1364         return self.mesh.NbFaces()
1365
1366     ## Returns the number of faces with the given order in the mesh
1367     #  @param elementOrder the order of elements:
1368     #         ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC
1369     #  @return an integer value
1370     #  @ingroup l1_meshinfo
1371     def NbFacesOfOrder(self, elementOrder):
1372         return self.mesh.NbFacesOfOrder(elementOrder)
1373
1374     ## Returns the number of triangles in the mesh
1375     #  @return an integer value
1376     #  @ingroup l1_meshinfo
1377     def NbTriangles(self):
1378         return self.mesh.NbTriangles()
1379
1380     ## Returns the number of triangles with the given order in the mesh
1381     #  @param elementOrder is the order of elements:
1382     #         ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC
1383     #  @return an integer value
1384     #  @ingroup l1_meshinfo
1385     def NbTrianglesOfOrder(self, elementOrder):
1386         return self.mesh.NbTrianglesOfOrder(elementOrder)
1387
1388     ## Returns the number of quadrangles in the mesh
1389     #  @return an integer value
1390     #  @ingroup l1_meshinfo
1391     def NbQuadrangles(self):
1392         return self.mesh.NbQuadrangles()
1393
1394     ## Returns the number of quadrangles with the given order in the mesh
1395     #  @param elementOrder the order of elements:
1396     #         ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC
1397     #  @return an integer value
1398     #  @ingroup l1_meshinfo
1399     def NbQuadranglesOfOrder(self, elementOrder):
1400         return self.mesh.NbQuadranglesOfOrder(elementOrder)
1401
1402     ## Returns the number of polygons in the mesh
1403     #  @return an integer value
1404     #  @ingroup l1_meshinfo
1405     def NbPolygons(self):
1406         return self.mesh.NbPolygons()
1407
1408     ## Returns the number of volumes in the mesh
1409     #  @return an integer value
1410     #  @ingroup l1_meshinfo
1411     def NbVolumes(self):
1412         return self.mesh.NbVolumes()
1413
1414     ## Returns the number of volumes with the given order in the mesh
1415     #  @param elementOrder  the order of elements:
1416     #         ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC
1417     #  @return an integer value
1418     #  @ingroup l1_meshinfo
1419     def NbVolumesOfOrder(self, elementOrder):
1420         return self.mesh.NbVolumesOfOrder(elementOrder)
1421
1422     ## Returns the number of tetrahedrons in the mesh
1423     #  @return an integer value
1424     #  @ingroup l1_meshinfo
1425     def NbTetras(self):
1426         return self.mesh.NbTetras()
1427
1428     ## Returns the number of tetrahedrons with the given order in the mesh
1429     #  @param elementOrder  the order of elements:
1430     #         ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC
1431     #  @return an integer value
1432     #  @ingroup l1_meshinfo
1433     def NbTetrasOfOrder(self, elementOrder):
1434         return self.mesh.NbTetrasOfOrder(elementOrder)
1435
1436     ## Returns the number of hexahedrons in the mesh
1437     #  @return an integer value
1438     #  @ingroup l1_meshinfo
1439     def NbHexas(self):
1440         return self.mesh.NbHexas()
1441
1442     ## Returns the number of hexahedrons with the given order in the mesh
1443     #  @param elementOrder  the order of elements:
1444     #         ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC
1445     #  @return an integer value
1446     #  @ingroup l1_meshinfo
1447     def NbHexasOfOrder(self, elementOrder):
1448         return self.mesh.NbHexasOfOrder(elementOrder)
1449
1450     ## Returns the number of pyramids in the mesh
1451     #  @return an integer value
1452     #  @ingroup l1_meshinfo
1453     def NbPyramids(self):
1454         return self.mesh.NbPyramids()
1455
1456     ## Returns the number of pyramids with the given order in the mesh
1457     #  @param elementOrder  the order of elements:
1458     #         ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC
1459     #  @return an integer value
1460     #  @ingroup l1_meshinfo
1461     def NbPyramidsOfOrder(self, elementOrder):
1462         return self.mesh.NbPyramidsOfOrder(elementOrder)
1463
1464     ## Returns the number of prisms in the mesh
1465     #  @return an integer value
1466     #  @ingroup l1_meshinfo
1467     def NbPrisms(self):
1468         return self.mesh.NbPrisms()
1469
1470     ## Returns the number of prisms with the given order in the mesh
1471     #  @param elementOrder  the order of elements:
1472     #         ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC
1473     #  @return an integer value
1474     #  @ingroup l1_meshinfo
1475     def NbPrismsOfOrder(self, elementOrder):
1476         return self.mesh.NbPrismsOfOrder(elementOrder)
1477
1478     ## Returns the number of polyhedrons in the mesh
1479     #  @return an integer value
1480     #  @ingroup l1_meshinfo
1481     def NbPolyhedrons(self):
1482         return self.mesh.NbPolyhedrons()
1483
1484     ## Returns the number of submeshes in the mesh
1485     #  @return an integer value
1486     #  @ingroup l1_meshinfo
1487     def NbSubMesh(self):
1488         return self.mesh.NbSubMesh()
1489
1490     ## Returns the list of mesh elements IDs
1491     #  @return the list of integer values
1492     #  @ingroup l1_meshinfo
1493     def GetElementsId(self):
1494         return self.mesh.GetElementsId()
1495
1496     ## Returns the list of IDs of mesh elements with the given type
1497     #  @param elementType  the required type of elements
1498     #  @return list of integer values
1499     #  @ingroup l1_meshinfo
1500     def GetElementsByType(self, elementType):
1501         return self.mesh.GetElementsByType(elementType)
1502
1503     ## Returns the list of mesh nodes IDs
1504     #  @return the list of integer values
1505     #  @ingroup l1_meshinfo
1506     def GetNodesId(self):
1507         return self.mesh.GetNodesId()
1508
1509     # Get the information about mesh elements:
1510     # ------------------------------------
1511
1512     ## Returns the type of mesh element
1513     #  @return the value from SMESH::ElementType enumeration
1514     #  @ingroup l1_meshinfo
1515     def GetElementType(self, id, iselem):
1516         return self.mesh.GetElementType(id, iselem)
1517
1518     ## Returns the list of submesh elements IDs
1519     #  @param Shape a geom object(subshape) IOR
1520     #         Shape must be the subshape of a ShapeToMesh()
1521     #  @return the list of integer values
1522     #  @ingroup l1_meshinfo
1523     def GetSubMeshElementsId(self, Shape):
1524         if ( isinstance( Shape, geompyDC.GEOM._objref_GEOM_Object)):
1525             ShapeID = Shape.GetSubShapeIndices()[0]
1526         else:
1527             ShapeID = Shape
1528         return self.mesh.GetSubMeshElementsId(ShapeID)
1529
1530     ## Returns the list of submesh nodes IDs
1531     #  @param Shape a geom object(subshape) IOR
1532     #         Shape must be the subshape of a ShapeToMesh()
1533     #  @param all If true, gives all nodes of submesh elements, otherwise gives only submesh nodes
1534     #  @return the list of integer values
1535     #  @ingroup l1_meshinfo
1536     def GetSubMeshNodesId(self, Shape, all):
1537         if ( isinstance( Shape, geompyDC.GEOM._objref_GEOM_Object)):
1538             ShapeID = Shape.GetSubShapeIndices()[0]
1539         else:
1540             ShapeID = Shape
1541         return self.mesh.GetSubMeshNodesId(ShapeID, all)
1542
1543     ## Returns the list of IDs of submesh elements with the given type
1544     #  @param Shape a geom object(subshape) IOR
1545     #         Shape must be a subshape of a ShapeToMesh()
1546     #  @return the list of integer values
1547     #  @ingroup l1_meshinfo
1548     def GetSubMeshElementType(self, Shape):
1549         if ( isinstance( Shape, geompyDC.GEOM._objref_GEOM_Object)):
1550             ShapeID = Shape.GetSubShapeIndices()[0]
1551         else:
1552             ShapeID = Shape
1553         return self.mesh.GetSubMeshElementType(ShapeID)
1554
1555     ## Gets the mesh description
1556     #  @return string value
1557     #  @ingroup l1_meshinfo
1558     def Dump(self):
1559         return self.mesh.Dump()
1560
1561
1562     # Get the information about nodes and elements of a mesh by its IDs:
1563     # -----------------------------------------------------------
1564
1565     ## Gets XYZ coordinates of a node
1566     #  \n If there is no nodes for the given ID - returns an empty list
1567     #  @return a list of double precision values
1568     #  @ingroup l1_meshinfo
1569     def GetNodeXYZ(self, id):
1570         return self.mesh.GetNodeXYZ(id)
1571
1572     ## Returns list of IDs of inverse elements for the given node
1573     #  \n If there is no node for the given ID - returns an empty list
1574     #  @return a list of integer values
1575     #  @ingroup l1_meshinfo
1576     def GetNodeInverseElements(self, id):
1577         return self.mesh.GetNodeInverseElements(id)
1578
1579     ## @brief Returns the position of a node on the shape
1580     #  @return SMESH::NodePosition
1581     #  @ingroup l1_meshinfo
1582     def GetNodePosition(self,NodeID):
1583         return self.mesh.GetNodePosition(NodeID)
1584
1585     ## If the given element is a node, returns the ID of shape
1586     #  \n If there is no node for the given ID - returns -1
1587     #  @return an integer value
1588     #  @ingroup l1_meshinfo
1589     def GetShapeID(self, id):
1590         return self.mesh.GetShapeID(id)
1591
1592     ## Returns the ID of the result shape after
1593     #  FindShape() from SMESH_MeshEditor for the given element
1594     #  \n If there is no element for the given ID - returns -1
1595     #  @return an integer value
1596     #  @ingroup l1_meshinfo
1597     def GetShapeIDForElem(self,id):
1598         return self.mesh.GetShapeIDForElem(id)
1599
1600     ## Returns the number of nodes for the given element
1601     #  \n If there is no element for the given ID - returns -1
1602     #  @return an integer value
1603     #  @ingroup l1_meshinfo
1604     def GetElemNbNodes(self, id):
1605         return self.mesh.GetElemNbNodes(id)
1606
1607     ## Returns the node ID the given index for the given element
1608     #  \n If there is no element for the given ID - returns -1
1609     #  \n If there is no node for the given index - returns -2
1610     #  @return an integer value
1611     #  @ingroup l1_meshinfo
1612     def GetElemNode(self, id, index):
1613         return self.mesh.GetElemNode(id, index)
1614
1615     ## Returns the IDs of nodes of the given element
1616     #  @return a list of integer values
1617     #  @ingroup l1_meshinfo
1618     def GetElemNodes(self, id):
1619         return self.mesh.GetElemNodes(id)
1620
1621     ## Returns true if the given node is the medium node in the given quadratic element
1622     #  @ingroup l1_meshinfo
1623     def IsMediumNode(self, elementID, nodeID):
1624         return self.mesh.IsMediumNode(elementID, nodeID)
1625
1626     ## Returns true if the given node is the medium node in one of quadratic elements
1627     #  @ingroup l1_meshinfo
1628     def IsMediumNodeOfAnyElem(self, nodeID, elementType):
1629         return self.mesh.IsMediumNodeOfAnyElem(nodeID, elementType)
1630
1631     ## Returns the number of edges for the given element
1632     #  @ingroup l1_meshinfo
1633     def ElemNbEdges(self, id):
1634         return self.mesh.ElemNbEdges(id)
1635
1636     ## Returns the number of faces for the given element
1637     #  @ingroup l1_meshinfo
1638     def ElemNbFaces(self, id):
1639         return self.mesh.ElemNbFaces(id)
1640
1641     ## Returns true if the given element is a polygon
1642     #  @ingroup l1_meshinfo
1643     def IsPoly(self, id):
1644         return self.mesh.IsPoly(id)
1645
1646     ## Returns true if the given element is quadratic
1647     #  @ingroup l1_meshinfo
1648     def IsQuadratic(self, id):
1649         return self.mesh.IsQuadratic(id)
1650
1651     ## Returns XYZ coordinates of the barycenter of the given element
1652     #  \n If there is no element for the given ID - returns an empty list
1653     #  @return a list of three double values
1654     #  @ingroup l1_meshinfo
1655     def BaryCenter(self, id):
1656         return self.mesh.BaryCenter(id)
1657
1658
1659     # Mesh edition (SMESH_MeshEditor functionality):
1660     # ---------------------------------------------
1661
1662     ## Removes the elements from the mesh by ids
1663     #  @param IDsOfElements is a list of ids of elements to remove
1664     #  @return True or False
1665     #  @ingroup l2_modif_del
1666     def RemoveElements(self, IDsOfElements):
1667         return self.editor.RemoveElements(IDsOfElements)
1668
1669     ## Removes nodes from mesh by ids
1670     #  @param IDsOfNodes is a list of ids of nodes to remove
1671     #  @return True or False
1672     #  @ingroup l2_modif_del
1673     def RemoveNodes(self, IDsOfNodes):
1674         return self.editor.RemoveNodes(IDsOfNodes)
1675
1676     ## Add a node to the mesh by coordinates
1677     #  @return Id of the new node
1678     #  @ingroup l2_modif_add
1679     def AddNode(self, x, y, z):
1680         return self.editor.AddNode( x, y, z)
1681
1682     ## Creates a linear or quadratic edge (this is determined
1683     #  by the number of given nodes).
1684     #  @param IDsOfNodes the list of node IDs for creation of the element.
1685     #  The order of nodes in this list should correspond to the description
1686     #  of MED. \n This description is located by the following link:
1687     #  http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3.
1688     #  @return the Id of the new edge
1689     #  @ingroup l2_modif_add
1690     def AddEdge(self, IDsOfNodes):
1691         return self.editor.AddEdge(IDsOfNodes)
1692
1693     ## Creates a linear or quadratic face (this is determined
1694     #  by the number of given nodes).
1695     #  @param IDsOfNodes the list of node IDs for creation of the element.
1696     #  The order of nodes in this list should correspond to the description
1697     #  of MED. \n This description is located by the following link:
1698     #  http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3.
1699     #  @return the Id of the new face
1700     #  @ingroup l2_modif_add
1701     def AddFace(self, IDsOfNodes):
1702         return self.editor.AddFace(IDsOfNodes)
1703
1704     ## Adds a polygonal face to the mesh by the list of node IDs
1705     #  @param IdsOfNodes the list of node IDs for creation of the element.
1706     #  @return the Id of the new face
1707     #  @ingroup l2_modif_add
1708     def AddPolygonalFace(self, IdsOfNodes):
1709         return self.editor.AddPolygonalFace(IdsOfNodes)
1710
1711     ## Creates both simple and quadratic volume (this is determined
1712     #  by the number of given nodes).
1713     #  @param IDsOfNodes the list of node IDs for creation of the element.
1714     #  The order of nodes in this list should correspond to the description
1715     #  of MED. \n This description is located by the following link:
1716     #  http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3.
1717     #  @return the Id of the new volumic element
1718     #  @ingroup l2_modif_add
1719     def AddVolume(self, IDsOfNodes):
1720         return self.editor.AddVolume(IDsOfNodes)
1721
1722     ## Creates a volume of many faces, giving nodes for each face.
1723     #  @param IdsOfNodes the list of node IDs for volume creation face by face.
1724     #  @param Quantities the list of integer values, Quantities[i]
1725     #         gives the quantity of nodes in face number i.
1726     #  @return the Id of the new volumic element
1727     #  @ingroup l2_modif_add
1728     def AddPolyhedralVolume (self, IdsOfNodes, Quantities):
1729         return self.editor.AddPolyhedralVolume(IdsOfNodes, Quantities)
1730
1731     ## Creates a volume of many faces, giving the IDs of the existing faces.
1732     #  @param IdsOfFaces the list of face IDs for volume creation.
1733     #
1734     #  Note:  The created volume will refer only to the nodes
1735     #         of the given faces, not to the faces themselves.
1736     #  @return the Id of the new volumic element
1737     #  @ingroup l2_modif_add
1738     def AddPolyhedralVolumeByFaces (self, IdsOfFaces):
1739         return self.editor.AddPolyhedralVolumeByFaces(IdsOfFaces)
1740
1741
1742     ## @brief Binds a node to a vertex
1743     #  @param NodeID a node ID
1744     #  @param Vertex a vertex or vertex ID
1745     #  @return True if succeed else raises an exception
1746     #  @ingroup l2_modif_add
1747     def SetNodeOnVertex(self, NodeID, Vertex):
1748         if ( isinstance( Vertex, geompyDC.GEOM._objref_GEOM_Object)):
1749             VertexID = Vertex.GetSubShapeIndices()[0]
1750         else:
1751             VertexID = Vertex
1752         try:
1753             self.editor.SetNodeOnVertex(NodeID, VertexID)
1754         except SALOME.SALOME_Exception, inst:
1755             raise ValueError, inst.details.text
1756         return True
1757
1758
1759     ## @brief Stores the node position on an edge
1760     #  @param NodeID a node ID
1761     #  @param Edge an edge or edge ID
1762     #  @param paramOnEdge a parameter on the edge where the node is located
1763     #  @return True if succeed else raises an exception
1764     #  @ingroup l2_modif_add
1765     def SetNodeOnEdge(self, NodeID, Edge, paramOnEdge):
1766         if ( isinstance( Edge, geompyDC.GEOM._objref_GEOM_Object)):
1767             EdgeID = Edge.GetSubShapeIndices()[0]
1768         else:
1769             EdgeID = Edge
1770         try:
1771             self.editor.SetNodeOnEdge(NodeID, EdgeID, paramOnEdge)
1772         except SALOME.SALOME_Exception, inst:
1773             raise ValueError, inst.details.text
1774         return True
1775
1776     ## @brief Stores node position on a face
1777     #  @param NodeID a node ID
1778     #  @param Face a face or face ID
1779     #  @param u U parameter on the face where the node is located
1780     #  @param v V parameter on the face where the node is located
1781     #  @return True if succeed else raises an exception
1782     #  @ingroup l2_modif_add
1783     def SetNodeOnFace(self, NodeID, Face, u, v):
1784         if ( isinstance( Face, geompyDC.GEOM._objref_GEOM_Object)):
1785             FaceID = Face.GetSubShapeIndices()[0]
1786         else:
1787             FaceID = Face
1788         try:
1789             self.editor.SetNodeOnFace(NodeID, FaceID, u, v)
1790         except SALOME.SALOME_Exception, inst:
1791             raise ValueError, inst.details.text
1792         return True
1793
1794     ## @brief Binds a node to a solid
1795     #  @param NodeID a node ID
1796     #  @param Solid  a solid or solid ID
1797     #  @return True if succeed else raises an exception
1798     #  @ingroup l2_modif_add
1799     def SetNodeInVolume(self, NodeID, Solid):
1800         if ( isinstance( Solid, geompyDC.GEOM._objref_GEOM_Object)):
1801             SolidID = Solid.GetSubShapeIndices()[0]
1802         else:
1803             SolidID = Solid
1804         try:
1805             self.editor.SetNodeInVolume(NodeID, SolidID)
1806         except SALOME.SALOME_Exception, inst:
1807             raise ValueError, inst.details.text
1808         return True
1809
1810     ## @brief Bind an element to a shape
1811     #  @param ElementID an element ID
1812     #  @param Shape a shape or shape ID
1813     #  @return True if succeed else raises an exception
1814     #  @ingroup l2_modif_add
1815     def SetMeshElementOnShape(self, ElementID, Shape):
1816         if ( isinstance( Shape, geompyDC.GEOM._objref_GEOM_Object)):
1817             ShapeID = Shape.GetSubShapeIndices()[0]
1818         else:
1819             ShapeID = Shape
1820         try:
1821             self.editor.SetMeshElementOnShape(ElementID, ShapeID)
1822         except SALOME.SALOME_Exception, inst:
1823             raise ValueError, inst.details.text
1824         return True
1825
1826
1827     ## Moves the node with the given id
1828     #  @param NodeID the id of the node
1829     #  @param x  a new X coordinate
1830     #  @param y  a new Y coordinate
1831     #  @param z  a new Z coordinate
1832     #  @return True if succeed else False
1833     #  @ingroup l2_modif_movenode
1834     def MoveNode(self, NodeID, x, y, z):
1835         return self.editor.MoveNode(NodeID, x, y, z)
1836
1837     ## Finds the node closest to a point
1838     #  @param x  the X coordinate of a point
1839     #  @param y  the Y coordinate of a point
1840     #  @param z  the Z coordinate of a point
1841     #  @return the ID of a node
1842     #  @ingroup l2_modif_throughp
1843     def FindNodeClosestTo(self, x, y, z):
1844         preview = self.mesh.GetMeshEditPreviewer()
1845         return preview.MoveClosestNodeToPoint(x, y, z, -1)
1846
1847     ## Finds the node closest to a point and moves it to a point location
1848     #  @param x  the X coordinate of a point
1849     #  @param y  the Y coordinate of a point
1850     #  @param z  the Z coordinate of a point
1851     #  @return the ID of a moved node
1852     #  @ingroup l2_modif_throughp
1853     def MeshToPassThroughAPoint(self, x, y, z):
1854         return self.editor.MoveClosestNodeToPoint(x, y, z, -1)
1855
1856     ## Replaces two neighbour triangles sharing Node1-Node2 link
1857     #  with the triangles built on the same 4 nodes but having other common link.
1858     #  @param NodeID1  the ID of the first node
1859     #  @param NodeID2  the ID of the second node
1860     #  @return false if proper faces were not found
1861     #  @ingroup l2_modif_invdiag
1862     def InverseDiag(self, NodeID1, NodeID2):
1863         return self.editor.InverseDiag(NodeID1, NodeID2)
1864
1865     ## Replaces two neighbour triangles sharing Node1-Node2 link
1866     #  with a quadrangle built on the same 4 nodes.
1867     #  @param NodeID1  the ID of the first node
1868     #  @param NodeID2  the ID of the second node
1869     #  @return false if proper faces were not found
1870     #  @ingroup l2_modif_unitetri
1871     def DeleteDiag(self, NodeID1, NodeID2):
1872         return self.editor.DeleteDiag(NodeID1, NodeID2)
1873
1874     ## Reorients elements by ids
1875     #  @param IDsOfElements if undefined reorients all mesh elements
1876     #  @return True if succeed else False
1877     #  @ingroup l2_modif_changori
1878     def Reorient(self, IDsOfElements=None):
1879         if IDsOfElements == None:
1880             IDsOfElements = self.GetElementsId()
1881         return self.editor.Reorient(IDsOfElements)
1882
1883     ## Reorients all elements of the object
1884     #  @param theObject mesh, submesh or group
1885     #  @return True if succeed else False
1886     #  @ingroup l2_modif_changori
1887     def ReorientObject(self, theObject):
1888         if ( isinstance( theObject, Mesh )):
1889             theObject = theObject.GetMesh()
1890         return self.editor.ReorientObject(theObject)
1891
1892     ## Fuses the neighbouring triangles into quadrangles.
1893     #  @param IDsOfElements The triangles to be fused,
1894     #  @param theCriterion  is FT_...; used to choose a neighbour to fuse with.
1895     #  @param MaxAngle      is the maximum angle between element normals at which the fusion
1896     #                       is still performed; theMaxAngle is mesured in radians.
1897     #  @return TRUE in case of success, FALSE otherwise.
1898     #  @ingroup l2_modif_unitetri
1899     def TriToQuad(self, IDsOfElements, theCriterion, MaxAngle):
1900         if IDsOfElements == []:
1901             IDsOfElements = self.GetElementsId()
1902         return self.editor.TriToQuad(IDsOfElements, self.smeshpyD.GetFunctor(theCriterion), MaxAngle)
1903
1904     ## Fuses the neighbouring triangles of the object into quadrangles
1905     #  @param theObject is mesh, submesh or group
1906     #  @param theCriterion is FT_...; used to choose a neighbour to fuse with.
1907     #  @param MaxAngle   a max angle between element normals at which the fusion
1908     #                   is still performed; theMaxAngle is mesured in radians.
1909     #  @return TRUE in case of success, FALSE otherwise.
1910     #  @ingroup l2_modif_unitetri
1911     def TriToQuadObject (self, theObject, theCriterion, MaxAngle):
1912         if ( isinstance( theObject, Mesh )):
1913             theObject = theObject.GetMesh()
1914         return self.editor.TriToQuadObject(theObject, self.smeshpyD.GetFunctor(theCriterion), MaxAngle)
1915
1916     ## Splits quadrangles into triangles.
1917     #  @param IDsOfElements the faces to be splitted.
1918     #  @param theCriterion   FT_...; used to choose a diagonal for splitting.
1919     #  @return TRUE in case of success, FALSE otherwise.
1920     #  @ingroup l2_modif_cutquadr
1921     def QuadToTri (self, IDsOfElements, theCriterion):
1922         if IDsOfElements == []:
1923             IDsOfElements = self.GetElementsId()
1924         return self.editor.QuadToTri(IDsOfElements, self.smeshpyD.GetFunctor(theCriterion))
1925
1926     ## Splits quadrangles into triangles.
1927     #  @param theObject  the object from which the list of elements is taken, this is mesh, submesh or group
1928     #  @param theCriterion   FT_...; used to choose a diagonal for splitting.
1929     #  @return TRUE in case of success, FALSE otherwise.
1930     #  @ingroup l2_modif_cutquadr
1931     def QuadToTriObject (self, theObject, theCriterion):
1932         if ( isinstance( theObject, Mesh )):
1933             theObject = theObject.GetMesh()
1934         return self.editor.QuadToTriObject(theObject, self.smeshpyD.GetFunctor(theCriterion))
1935
1936     ## Splits quadrangles into triangles.
1937     #  @param IDsOfElements the faces to be splitted
1938     #  @param Diag13        is used to choose a diagonal for splitting.
1939     #  @return TRUE in case of success, FALSE otherwise.
1940     #  @ingroup l2_modif_cutquadr
1941     def SplitQuad (self, IDsOfElements, Diag13):
1942         if IDsOfElements == []:
1943             IDsOfElements = self.GetElementsId()
1944         return self.editor.SplitQuad(IDsOfElements, Diag13)
1945
1946     ## Splits quadrangles into triangles.
1947     #  @param theObject the object from which the list of elements is taken, this is mesh, submesh or group
1948     #  @param Diag13    is used to choose a diagonal for splitting.
1949     #  @return TRUE in case of success, FALSE otherwise.
1950     #  @ingroup l2_modif_cutquadr
1951     def SplitQuadObject (self, theObject, Diag13):
1952         if ( isinstance( theObject, Mesh )):
1953             theObject = theObject.GetMesh()
1954         return self.editor.SplitQuadObject(theObject, Diag13)
1955
1956     ## Finds a better splitting of the given quadrangle.
1957     #  @param IDOfQuad   the ID of the quadrangle to be splitted.
1958     #  @param theCriterion  FT_...; a criterion to choose a diagonal for splitting.
1959     #  @return 1 if 1-3 diagonal is better, 2 if 2-4
1960     #          diagonal is better, 0 if error occurs.
1961     #  @ingroup l2_modif_cutquadr
1962     def BestSplit (self, IDOfQuad, theCriterion):
1963         return self.editor.BestSplit(IDOfQuad, self.smeshpyD.GetFunctor(theCriterion))
1964
1965     ## Splits quadrangle faces near triangular facets of volumes
1966     #
1967     #  @ingroup l1_auxiliary
1968     def SplitQuadsNearTriangularFacets(self):
1969         faces_array = self.GetElementsByType(SMESH.FACE)
1970         for face_id in faces_array:
1971             if self.GetElemNbNodes(face_id) == 4: # quadrangle
1972                 quad_nodes = self.mesh.GetElemNodes(face_id)
1973                 node1_elems = self.GetNodeInverseElements(quad_nodes[1 -1])
1974                 isVolumeFound = False
1975                 for node1_elem in node1_elems:
1976                     if not isVolumeFound:
1977                         if self.GetElementType(node1_elem, True) == SMESH.VOLUME:
1978                             nb_nodes = self.GetElemNbNodes(node1_elem)
1979                             if 3 < nb_nodes and nb_nodes < 7: # tetra or penta, or prism
1980                                 volume_elem = node1_elem
1981                                 volume_nodes = self.mesh.GetElemNodes(volume_elem)
1982                                 if volume_nodes.count(quad_nodes[2 -1]) > 0: # 1,2
1983                                     if volume_nodes.count(quad_nodes[4 -1]) > 0: # 1,2,4
1984                                         isVolumeFound = True
1985                                         if volume_nodes.count(quad_nodes[3 -1]) == 0: # 1,2,4 & !3
1986                                             self.SplitQuad([face_id], False) # diagonal 2-4
1987                                     elif volume_nodes.count(quad_nodes[3 -1]) > 0: # 1,2,3 & !4
1988                                         isVolumeFound = True
1989                                         self.SplitQuad([face_id], True) # diagonal 1-3
1990                                 elif volume_nodes.count(quad_nodes[4 -1]) > 0: # 1,4 & !2
1991                                     if volume_nodes.count(quad_nodes[3 -1]) > 0: # 1,4,3 & !2
1992                                         isVolumeFound = True
1993                                         self.SplitQuad([face_id], True) # diagonal 1-3
1994
1995     ## @brief Splits hexahedrons into tetrahedrons.
1996     #
1997     #  This operation uses pattern mapping functionality for splitting.
1998     #  @param theObject the object from which the list of hexahedrons is taken; this is mesh, submesh or group.
1999     #  @param theNode000,theNode001 within the range [0,7]; gives the orientation of the
2000     #         pattern relatively each hexahedron: the (0,0,0) key-point of the pattern
2001     #         will be mapped into <VAR>theNode000</VAR>-th node of each volume, the (0,0,1)
2002     #         key-point will be mapped into <VAR>theNode001</VAR>-th node of each volume.
2003     #         The (0,0,0) key-point of the used pattern corresponds to a non-split corner.
2004     #  @return TRUE in case of success, FALSE otherwise.
2005     #  @ingroup l1_auxiliary
2006     def SplitHexaToTetras (self, theObject, theNode000, theNode001):
2007         # Pattern:     5.---------.6
2008         #              /|#*      /|
2009         #             / | #*    / |
2010         #            /  |  # * /  |
2011         #           /   |   # /*  |
2012         # (0,0,1) 4.---------.7 * |
2013         #          |#*  |1   | # *|
2014         #          | # *.----|---#.2
2015         #          |  #/ *   |   /
2016         #          |  /#  *  |  /
2017         #          | /   # * | /
2018         #          |/      #*|/
2019         # (0,0,0) 0.---------.3
2020         pattern_tetra = "!!! Nb of points: \n 8 \n\
2021         !!! Points: \n\
2022         0 0 0  !- 0 \n\
2023         0 1 0  !- 1 \n\
2024         1 1 0  !- 2 \n\
2025         1 0 0  !- 3 \n\
2026         0 0 1  !- 4 \n\
2027         0 1 1  !- 5 \n\
2028         1 1 1  !- 6 \n\
2029         1 0 1  !- 7 \n\
2030         !!! Indices of points of 6 tetras: \n\
2031         0 3 4 1 \n\
2032         7 4 3 1 \n\
2033         4 7 5 1 \n\
2034         6 2 5 7 \n\
2035         1 5 2 7 \n\
2036         2 3 1 7 \n"
2037
2038         pattern = self.smeshpyD.GetPattern()
2039         isDone  = pattern.LoadFromFile(pattern_tetra)
2040         if not isDone:
2041             print 'Pattern.LoadFromFile :', pattern.GetErrorCode()
2042             return isDone
2043
2044         pattern.ApplyToHexahedrons(self.mesh, theObject.GetIDs(), theNode000, theNode001)
2045         isDone = pattern.MakeMesh(self.mesh, False, False)
2046         if not isDone: print 'Pattern.MakeMesh :', pattern.GetErrorCode()
2047
2048         # split quafrangle faces near triangular facets of volumes
2049         self.SplitQuadsNearTriangularFacets()
2050
2051         return isDone
2052
2053     ## @brief Split hexahedrons into prisms.
2054     #
2055     #  Uses the pattern mapping functionality for splitting.
2056     #  @param theObject the object (mesh, submesh or group) from where the list of hexahedrons is taken;
2057     #  @param theNode000,theNode001 (within the range [0,7]) gives the orientation of the
2058     #         pattern relatively each hexahedron: keypoint (0,0,0) of the pattern
2059     #         will be mapped into the <VAR>theNode000</VAR>-th node of each volume, keypoint (0,0,1)
2060     #         will be mapped into the <VAR>theNode001</VAR>-th node of each volume.
2061     #         Edge (0,0,0)-(0,0,1) of used pattern connects two not split corners.
2062     #  @return TRUE in case of success, FALSE otherwise.
2063     #  @ingroup l1_auxiliary
2064     def SplitHexaToPrisms (self, theObject, theNode000, theNode001):
2065         # Pattern:     5.---------.6
2066         #              /|#       /|
2067         #             / | #     / |
2068         #            /  |  #   /  |
2069         #           /   |   # /   |
2070         # (0,0,1) 4.---------.7   |
2071         #          |    |    |    |
2072         #          |   1.----|----.2
2073         #          |   / *   |   /
2074         #          |  /   *  |  /
2075         #          | /     * | /
2076         #          |/       *|/
2077         # (0,0,0) 0.---------.3
2078         pattern_prism = "!!! Nb of points: \n 8 \n\
2079         !!! Points: \n\
2080         0 0 0  !- 0 \n\
2081         0 1 0  !- 1 \n\
2082         1 1 0  !- 2 \n\
2083         1 0 0  !- 3 \n\
2084         0 0 1  !- 4 \n\
2085         0 1 1  !- 5 \n\
2086         1 1 1  !- 6 \n\
2087         1 0 1  !- 7 \n\
2088         !!! Indices of points of 2 prisms: \n\
2089         0 1 3 4 5 7 \n\
2090         2 3 1 6 7 5 \n"
2091
2092         pattern = self.smeshpyD.GetPattern()
2093         isDone  = pattern.LoadFromFile(pattern_prism)
2094         if not isDone:
2095             print 'Pattern.LoadFromFile :', pattern.GetErrorCode()
2096             return isDone
2097
2098         pattern.ApplyToHexahedrons(self.mesh, theObject.GetIDs(), theNode000, theNode001)
2099         isDone = pattern.MakeMesh(self.mesh, False, False)
2100         if not isDone: print 'Pattern.MakeMesh :', pattern.GetErrorCode()
2101
2102         # Splits quafrangle faces near triangular facets of volumes
2103         self.SplitQuadsNearTriangularFacets()
2104
2105         return isDone
2106
2107     ## Smoothes elements
2108     #  @param IDsOfElements the list if ids of elements to smooth
2109     #  @param IDsOfFixedNodes the list of ids of fixed nodes.
2110     #  Note that nodes built on edges and boundary nodes are always fixed.
2111     #  @param MaxNbOfIterations the maximum number of iterations
2112     #  @param MaxAspectRatio varies in range [1.0, inf]
2113     #  @param Method is Laplacian(LAPLACIAN_SMOOTH) or Centroidal(CENTROIDAL_SMOOTH)
2114     #  @return TRUE in case of success, FALSE otherwise.
2115     #  @ingroup l2_modif_smooth
2116     def Smooth(self, IDsOfElements, IDsOfFixedNodes,
2117                MaxNbOfIterations, MaxAspectRatio, Method):
2118         if IDsOfElements == []:
2119             IDsOfElements = self.GetElementsId()
2120         return self.editor.Smooth(IDsOfElements, IDsOfFixedNodes,
2121                                   MaxNbOfIterations, MaxAspectRatio, Method)
2122
2123     ## Smoothes elements which belong to the given object
2124     #  @param theObject the object to smooth
2125     #  @param IDsOfFixedNodes the list of ids of fixed nodes.
2126     #  Note that nodes built on edges and boundary nodes are always fixed.
2127     #  @param MaxNbOfIterations the maximum number of iterations
2128     #  @param MaxAspectRatio varies in range [1.0, inf]
2129     #  @param Method is Laplacian(LAPLACIAN_SMOOTH) or Centroidal(CENTROIDAL_SMOOTH)
2130     #  @return TRUE in case of success, FALSE otherwise.
2131     #  @ingroup l2_modif_smooth
2132     def SmoothObject(self, theObject, IDsOfFixedNodes,
2133                      MaxNbOfIterations, MaxAspectRatio, Method):
2134         if ( isinstance( theObject, Mesh )):
2135             theObject = theObject.GetMesh()
2136         return self.editor.SmoothObject(theObject, IDsOfFixedNodes,
2137                                         MaxNbOfIterations, MaxAspectRatio, Method)
2138
2139     ## Parametrically smoothes the given elements
2140     #  @param IDsOfElements the list if ids of elements to smooth
2141     #  @param IDsOfFixedNodes the list of ids of fixed nodes.
2142     #  Note that nodes built on edges and boundary nodes are always fixed.
2143     #  @param MaxNbOfIterations the maximum number of iterations
2144     #  @param MaxAspectRatio varies in range [1.0, inf]
2145     #  @param Method is Laplacian(LAPLACIAN_SMOOTH) or Centroidal(CENTROIDAL_SMOOTH)
2146     #  @return TRUE in case of success, FALSE otherwise.
2147     #  @ingroup l2_modif_smooth
2148     def SmoothParametric(self, IDsOfElements, IDsOfFixedNodes,
2149                          MaxNbOfIterations, MaxAspectRatio, Method):
2150         if IDsOfElements == []:
2151             IDsOfElements = self.GetElementsId()
2152         return self.editor.SmoothParametric(IDsOfElements, IDsOfFixedNodes,
2153                                             MaxNbOfIterations, MaxAspectRatio, Method)
2154
2155     ## Parametrically smoothes the elements which belong to the given object
2156     #  @param theObject the object to smooth
2157     #  @param IDsOfFixedNodes the list of ids of fixed nodes.
2158     #  Note that nodes built on edges and boundary nodes are always fixed.
2159     #  @param MaxNbOfIterations the maximum number of iterations
2160     #  @param MaxAspectRatio varies in range [1.0, inf]
2161     #  @param Method Laplacian(LAPLACIAN_SMOOTH) or Centroidal(CENTROIDAL_SMOOTH)
2162     #  @return TRUE in case of success, FALSE otherwise.
2163     #  @ingroup l2_modif_smooth
2164     def SmoothParametricObject(self, theObject, IDsOfFixedNodes,
2165                                MaxNbOfIterations, MaxAspectRatio, Method):
2166         if ( isinstance( theObject, Mesh )):
2167             theObject = theObject.GetMesh()
2168         return self.editor.SmoothParametricObject(theObject, IDsOfFixedNodes,
2169                                                   MaxNbOfIterations, MaxAspectRatio, Method)
2170
2171     ## Converts the mesh to quadratic, deletes old elements, replacing
2172     #  them with quadratic with the same id.
2173     #  @ingroup l2_modif_tofromqu
2174     def ConvertToQuadratic(self, theForce3d):
2175         self.editor.ConvertToQuadratic(theForce3d)
2176
2177     ## Converts the mesh from quadratic to ordinary,
2178     #  deletes old quadratic elements, \n replacing
2179     #  them with ordinary mesh elements with the same id.
2180     #  @return TRUE in case of success, FALSE otherwise.
2181     #  @ingroup l2_modif_tofromqu
2182     def ConvertFromQuadratic(self):
2183         return self.editor.ConvertFromQuadratic()
2184
2185     ## Renumber mesh nodes
2186     #  @ingroup l2_modif_renumber
2187     def RenumberNodes(self):
2188         self.editor.RenumberNodes()
2189
2190     ## Renumber mesh elements
2191     #  @ingroup l2_modif_renumber
2192     def RenumberElements(self):
2193         self.editor.RenumberElements()
2194
2195     ## Generates new elements by rotation of the elements around the axis
2196     #  @param IDsOfElements the list of ids of elements to sweep
2197     #  @param Axis the axis of rotation, AxisStruct or line(geom object)
2198     #  @param AngleInRadians the angle of Rotation
2199     #  @param NbOfSteps the number of steps
2200     #  @param Tolerance tolerance
2201     #  @param MakeGroups forces the generation of new groups from existing ones
2202     #  @param TotalAngle gives meaning of AngleInRadians: if True then it is an angular size
2203     #                    of all steps, else - size of each step
2204     #  @return the list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
2205     #  @ingroup l2_modif_extrurev
2206     def RotationSweep(self, IDsOfElements, Axis, AngleInRadians, NbOfSteps, Tolerance,
2207                       MakeGroups=False, TotalAngle=False):
2208         if IDsOfElements == []:
2209             IDsOfElements = self.GetElementsId()
2210         if ( isinstance( Axis, geompyDC.GEOM._objref_GEOM_Object)):
2211             Axis = self.smeshpyD.GetAxisStruct(Axis)
2212         if TotalAngle and NbOfSteps:
2213             AngleInRadians /= NbOfSteps
2214         if MakeGroups:
2215             return self.editor.RotationSweepMakeGroups(IDsOfElements, Axis,
2216                                                        AngleInRadians, NbOfSteps, Tolerance)
2217         self.editor.RotationSweep(IDsOfElements, Axis, AngleInRadians, NbOfSteps, Tolerance)
2218         return []
2219
2220     ## Generates new elements by rotation of the elements of object around the axis
2221     #  @param theObject object which elements should be sweeped
2222     #  @param Axis the axis of rotation, AxisStruct or line(geom object)
2223     #  @param AngleInRadians the angle of Rotation
2224     #  @param NbOfSteps number of steps
2225     #  @param Tolerance tolerance
2226     #  @param MakeGroups forces the generation of new groups from existing ones
2227     #  @param TotalAngle gives meaning of AngleInRadians: if True then it is an angular size
2228     #                    of all steps, else - size of each step
2229     #  @return the list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
2230     #  @ingroup l2_modif_extrurev
2231     def RotationSweepObject(self, theObject, Axis, AngleInRadians, NbOfSteps, Tolerance,
2232                             MakeGroups=False, TotalAngle=False):
2233         if ( isinstance( theObject, Mesh )):
2234             theObject = theObject.GetMesh()
2235         if ( isinstance( Axis, geompyDC.GEOM._objref_GEOM_Object)):
2236             Axis = self.smeshpyD.GetAxisStruct(Axis)
2237         if TotalAngle and NbOfSteps:
2238             AngleInRadians /= NbOfSteps
2239         if MakeGroups:
2240             return self.editor.RotationSweepObjectMakeGroups(theObject, Axis, AngleInRadians,
2241                                                              NbOfSteps, Tolerance)
2242         self.editor.RotationSweepObject(theObject, Axis, AngleInRadians, NbOfSteps, Tolerance)
2243         return []
2244
2245     ## Generates new elements by extrusion of the elements with given ids
2246     #  @param IDsOfElements the list of elements ids for extrusion
2247     #  @param StepVector vector, defining the direction and value of extrusion
2248     #  @param NbOfSteps the number of steps
2249     #  @param MakeGroups forces the generation of new groups from existing ones
2250     #  @return the list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
2251     #  @ingroup l2_modif_extrurev
2252     def ExtrusionSweep(self, IDsOfElements, StepVector, NbOfSteps, MakeGroups=False):
2253         if IDsOfElements == []:
2254             IDsOfElements = self.GetElementsId()
2255         if ( isinstance( StepVector, geompyDC.GEOM._objref_GEOM_Object)):
2256             StepVector = self.smeshpyD.GetDirStruct(StepVector)
2257         if MakeGroups:
2258             return self.editor.ExtrusionSweepMakeGroups(IDsOfElements, StepVector, NbOfSteps)
2259         self.editor.ExtrusionSweep(IDsOfElements, StepVector, NbOfSteps)
2260         return []
2261
2262     ## Generates new elements by extrusion of the elements with given ids
2263     #  @param IDsOfElements is ids of elements
2264     #  @param StepVector vector, defining the direction and value of extrusion
2265     #  @param NbOfSteps the number of steps
2266     #  @param ExtrFlags sets flags for extrusion
2267     #  @param SewTolerance uses for comparing locations of nodes if flag
2268     #         EXTRUSION_FLAG_SEW is set
2269     #  @param MakeGroups forces the generation of new groups from existing ones
2270     #  @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
2271     #  @ingroup l2_modif_extrurev
2272     def AdvancedExtrusion(self, IDsOfElements, StepVector, NbOfSteps,
2273                           ExtrFlags, SewTolerance, MakeGroups=False):
2274         if ( isinstance( StepVector, geompyDC.GEOM._objref_GEOM_Object)):
2275             StepVector = self.smeshpyD.GetDirStruct(StepVector)
2276         if MakeGroups:
2277             return self.editor.AdvancedExtrusionMakeGroups(IDsOfElements, StepVector, NbOfSteps,
2278                                                            ExtrFlags, SewTolerance)
2279         self.editor.AdvancedExtrusion(IDsOfElements, StepVector, NbOfSteps,
2280                                       ExtrFlags, SewTolerance)
2281         return []
2282
2283     ## Generates new elements by extrusion of the elements which belong to the object
2284     #  @param theObject the object which elements should be processed
2285     #  @param StepVector vector, defining the direction and value of extrusion
2286     #  @param NbOfSteps the number of steps
2287     #  @param MakeGroups forces the generation of new groups from existing ones
2288     #  @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
2289     #  @ingroup l2_modif_extrurev
2290     def ExtrusionSweepObject(self, theObject, StepVector, NbOfSteps, MakeGroups=False):
2291         if ( isinstance( theObject, Mesh )):
2292             theObject = theObject.GetMesh()
2293         if ( isinstance( StepVector, geompyDC.GEOM._objref_GEOM_Object)):
2294             StepVector = self.smeshpyD.GetDirStruct(StepVector)
2295         if MakeGroups:
2296             return self.editor.ExtrusionSweepObjectMakeGroups(theObject, StepVector, NbOfSteps)
2297         self.editor.ExtrusionSweepObject(theObject, StepVector, NbOfSteps)
2298         return []
2299
2300     ## Generates new elements by extrusion of the elements which belong to the object
2301     #  @param theObject object which elements should be processed
2302     #  @param StepVector vector, defining the direction and value of extrusion
2303     #  @param NbOfSteps the number of steps
2304     #  @param MakeGroups to generate new groups from existing ones
2305     #  @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
2306     #  @ingroup l2_modif_extrurev
2307     def ExtrusionSweepObject1D(self, theObject, StepVector, NbOfSteps, MakeGroups=False):
2308         if ( isinstance( theObject, Mesh )):
2309             theObject = theObject.GetMesh()
2310         if ( isinstance( StepVector, geompyDC.GEOM._objref_GEOM_Object)):
2311             StepVector = self.smeshpyD.GetDirStruct(StepVector)
2312         if MakeGroups:
2313             return self.editor.ExtrusionSweepObject1DMakeGroups(theObject, StepVector, NbOfSteps)
2314         self.editor.ExtrusionSweepObject1D(theObject, StepVector, NbOfSteps)
2315         return []
2316
2317     ## Generates new elements by extrusion of the elements which belong to the object
2318     #  @param theObject object which elements should be processed
2319     #  @param StepVector vector, defining the direction and value of extrusion
2320     #  @param NbOfSteps the number of steps
2321     #  @param MakeGroups forces the generation of new groups from existing ones
2322     #  @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
2323     #  @ingroup l2_modif_extrurev
2324     def ExtrusionSweepObject2D(self, theObject, StepVector, NbOfSteps, MakeGroups=False):
2325         if ( isinstance( theObject, Mesh )):
2326             theObject = theObject.GetMesh()
2327         if ( isinstance( StepVector, geompyDC.GEOM._objref_GEOM_Object)):
2328             StepVector = self.smeshpyD.GetDirStruct(StepVector)
2329         if MakeGroups:
2330             return self.editor.ExtrusionSweepObject2DMakeGroups(theObject, StepVector, NbOfSteps)
2331         self.editor.ExtrusionSweepObject2D(theObject, StepVector, NbOfSteps)
2332         return []
2333
2334     ## Generates new elements by extrusion of the given elements
2335     #  The path of extrusion must be a meshed edge.
2336     #  @param IDsOfElements ids of elements
2337     #  @param PathMesh mesh containing a 1D sub-mesh on the edge, along which proceeds the extrusion
2338     #  @param PathShape shape(edge) defines the sub-mesh for the path
2339     #  @param NodeStart the first or the last node on the edge. Defines the direction of extrusion
2340     #  @param HasAngles allows the shape to be rotated around the path
2341     #                   to get the resulting mesh in a helical fashion
2342     #  @param Angles list of angles
2343     #  @param HasRefPoint allows using the reference point
2344     #  @param RefPoint the point around which the shape is rotated (the mass center of the shape by default).
2345     #         The User can specify any point as the Reference Point.
2346     #  @param MakeGroups forces the generation of new groups from existing ones
2347     #  @param LinearVariation forces the computation of rotation angles as linear
2348     #                         variation of the given Angles along path steps
2349     #  @return list of created groups (SMESH_GroupBase) and SMESH::Extrusion_Error if MakeGroups=True,
2350     #          only SMESH::Extrusion_Error otherwise
2351     #  @ingroup l2_modif_extrurev
2352     def ExtrusionAlongPath(self, IDsOfElements, PathMesh, PathShape, NodeStart,
2353                            HasAngles, Angles, HasRefPoint, RefPoint,
2354                            MakeGroups=False, LinearVariation=False):
2355         if IDsOfElements == []:
2356             IDsOfElements = self.GetElementsId()
2357         if ( isinstance( RefPoint, geompyDC.GEOM._objref_GEOM_Object)):
2358             RefPoint = self.smeshpyD.GetPointStruct(RefPoint)
2359             pass
2360         if ( isinstance( PathMesh, Mesh )):
2361             PathMesh = PathMesh.GetMesh()
2362         if HasAngles and Angles and LinearVariation:
2363             Angles = self.editor.LinearAnglesVariation( PathMesh, PathShape, Angles )
2364             pass
2365         if MakeGroups:
2366             return self.editor.ExtrusionAlongPathMakeGroups(IDsOfElements, PathMesh,
2367                                                             PathShape, NodeStart, HasAngles,
2368                                                             Angles, HasRefPoint, RefPoint)
2369         return self.editor.ExtrusionAlongPath(IDsOfElements, PathMesh, PathShape,
2370                                               NodeStart, HasAngles, Angles, HasRefPoint, RefPoint)
2371
2372     ## Generates new elements by extrusion of the elements which belong to the object
2373     #  The path of extrusion must be a meshed edge.
2374     #  @param theObject the object which elements should be processed
2375     #  @param PathMesh mesh containing a 1D sub-mesh on the edge, along which the extrusion proceeds
2376     #  @param PathShape shape(edge) defines the sub-mesh for the path
2377     #  @param NodeStart the first or the last node on the edge. Defines the direction of extrusion
2378     #  @param HasAngles allows the shape to be rotated around the path
2379     #                   to get the resulting mesh in a helical fashion
2380     #  @param Angles list of angles
2381     #  @param HasRefPoint allows using the reference point
2382     #  @param RefPoint the point around which the shape is rotated (the mass center of the shape by default).
2383     #         The User can specify any point as the Reference Point.
2384     #  @param MakeGroups forces the generation of new groups from existing ones
2385     #  @param LinearVariation forces the computation of rotation angles as linear
2386     #                         variation of the given Angles along path steps
2387     #  @return list of created groups (SMESH_GroupBase) and SMESH::Extrusion_Error if MakeGroups=True,
2388     #          only SMESH::Extrusion_Error otherwise
2389     #  @ingroup l2_modif_extrurev
2390     def ExtrusionAlongPathObject(self, theObject, PathMesh, PathShape, NodeStart,
2391                                  HasAngles, Angles, HasRefPoint, RefPoint,
2392                                  MakeGroups=False, LinearVariation=False):
2393         if ( isinstance( theObject, Mesh )):
2394             theObject = theObject.GetMesh()
2395         if ( isinstance( RefPoint, geompyDC.GEOM._objref_GEOM_Object)):
2396             RefPoint = self.smeshpyD.GetPointStruct(RefPoint)
2397         if ( isinstance( PathMesh, Mesh )):
2398             PathMesh = PathMesh.GetMesh()
2399         if HasAngles and Angles and LinearVariation:
2400             Angles = self.editor.LinearAnglesVariation( PathMesh, PathShape, Angles )
2401             pass
2402         if MakeGroups:
2403             return self.editor.ExtrusionAlongPathObjectMakeGroups(theObject, PathMesh,
2404                                                                   PathShape, NodeStart, HasAngles,
2405                                                                   Angles, HasRefPoint, RefPoint)
2406         return self.editor.ExtrusionAlongPathObject(theObject, PathMesh, PathShape,
2407                                                     NodeStart, HasAngles, Angles, HasRefPoint,
2408                                                     RefPoint)
2409
2410     ## Creates a symmetrical copy of mesh elements
2411     #  @param IDsOfElements list of elements ids
2412     #  @param Mirror is AxisStruct or geom object(point, line, plane)
2413     #  @param theMirrorType is  POINT, AXIS or PLANE
2414     #  If the Mirror is a geom object this parameter is unnecessary
2415     #  @param Copy allows to copy element (Copy is 1) or to replace with its mirroring (Copy is 0)
2416     #  @param MakeGroups forces the generation of new groups from existing ones (if Copy)
2417     #  @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
2418     #  @ingroup l2_modif_trsf
2419     def Mirror(self, IDsOfElements, Mirror, theMirrorType, Copy=0, MakeGroups=False):
2420         if IDsOfElements == []:
2421             IDsOfElements = self.GetElementsId()
2422         if ( isinstance( Mirror, geompyDC.GEOM._objref_GEOM_Object)):
2423             Mirror = self.smeshpyD.GetAxisStruct(Mirror)
2424         if Copy and MakeGroups:
2425             return self.editor.MirrorMakeGroups(IDsOfElements, Mirror, theMirrorType)
2426         self.editor.Mirror(IDsOfElements, Mirror, theMirrorType, Copy)
2427         return []
2428
2429     ## Creates a new mesh by a symmetrical copy of mesh elements
2430     #  @param IDsOfElements the list of elements ids
2431     #  @param Mirror is AxisStruct or geom object (point, line, plane)
2432     #  @param theMirrorType is  POINT, AXIS or PLANE
2433     #  If the Mirror is a geom object this parameter is unnecessary
2434     #  @param MakeGroups to generate new groups from existing ones
2435     #  @param NewMeshName a name of the new mesh to create
2436     #  @return instance of Mesh class
2437     #  @ingroup l2_modif_trsf
2438     def MirrorMakeMesh(self, IDsOfElements, Mirror, theMirrorType, MakeGroups=0, NewMeshName=""):
2439         if IDsOfElements == []:
2440             IDsOfElements = self.GetElementsId()
2441         if ( isinstance( Mirror, geompyDC.GEOM._objref_GEOM_Object)):
2442             Mirror = self.smeshpyD.GetAxisStruct(Mirror)
2443         mesh = self.editor.MirrorMakeMesh(IDsOfElements, Mirror, theMirrorType,
2444                                           MakeGroups, NewMeshName)
2445         return Mesh(self.smeshpyD,self.geompyD,mesh)
2446
2447     ## Creates a symmetrical copy of the object
2448     #  @param theObject mesh, submesh or group
2449     #  @param Mirror AxisStruct or geom object (point, line, plane)
2450     #  @param theMirrorType is  POINT, AXIS or PLANE
2451     #  If the Mirror is a geom object this parameter is unnecessary
2452     #  @param Copy allows copying the element (Copy is 1) or replacing it with its mirror (Copy is 0)
2453     #  @param MakeGroups forces the generation of new groups from existing ones (if Copy)
2454     #  @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
2455     #  @ingroup l2_modif_trsf
2456     def MirrorObject (self, theObject, Mirror, theMirrorType, Copy=0, MakeGroups=False):
2457         if ( isinstance( theObject, Mesh )):
2458             theObject = theObject.GetMesh()
2459         if ( isinstance( Mirror, geompyDC.GEOM._objref_GEOM_Object)):
2460             Mirror = self.smeshpyD.GetAxisStruct(Mirror)
2461         if Copy and MakeGroups:
2462             return self.editor.MirrorObjectMakeGroups(theObject, Mirror, theMirrorType)
2463         self.editor.MirrorObject(theObject, Mirror, theMirrorType, Copy)
2464         return []
2465
2466     ## Creates a new mesh by a symmetrical copy of the object
2467     #  @param theObject mesh, submesh or group
2468     #  @param Mirror AxisStruct or geom object (point, line, plane)
2469     #  @param theMirrorType POINT, AXIS or PLANE
2470     #  If the Mirror is a geom object this parameter is unnecessary
2471     #  @param MakeGroups forces the generation of new groups from existing ones
2472     #  @param NewMeshName the name of the new mesh to create
2473     #  @return instance of Mesh class
2474     #  @ingroup l2_modif_trsf
2475     def MirrorObjectMakeMesh (self, theObject, Mirror, theMirrorType,MakeGroups=0, NewMeshName=""):
2476         if ( isinstance( theObject, Mesh )):
2477             theObject = theObject.GetMesh()
2478         if (isinstance(Mirror, geompyDC.GEOM._objref_GEOM_Object)):
2479             Mirror = self.smeshpyD.GetAxisStruct(Mirror)
2480         mesh = self.editor.MirrorObjectMakeMesh(theObject, Mirror, theMirrorType,
2481                                                 MakeGroups, NewMeshName)
2482         return Mesh( self.smeshpyD,self.geompyD,mesh )
2483
2484     ## Translates the elements
2485     #  @param IDsOfElements list of elements ids
2486     #  @param Vector the direction of translation (DirStruct or vector)
2487     #  @param Copy allows copying the translated elements
2488     #  @param MakeGroups forces the generation of new groups from existing ones (if Copy)
2489     #  @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
2490     #  @ingroup l2_modif_trsf
2491     def Translate(self, IDsOfElements, Vector, Copy, MakeGroups=False):
2492         if IDsOfElements == []:
2493             IDsOfElements = self.GetElementsId()
2494         if ( isinstance( Vector, geompyDC.GEOM._objref_GEOM_Object)):
2495             Vector = self.smeshpyD.GetDirStruct(Vector)
2496         if Copy and MakeGroups:
2497             return self.editor.TranslateMakeGroups(IDsOfElements, Vector)
2498         self.editor.Translate(IDsOfElements, Vector, Copy)
2499         return []
2500
2501     ## Creates a new mesh of translated elements
2502     #  @param IDsOfElements list of elements ids
2503     #  @param Vector the direction of translation (DirStruct or vector)
2504     #  @param MakeGroups forces the generation of new groups from existing ones
2505     #  @param NewMeshName the name of the newly created mesh
2506     #  @return instance of Mesh class
2507     #  @ingroup l2_modif_trsf
2508     def TranslateMakeMesh(self, IDsOfElements, Vector, MakeGroups=False, NewMeshName=""):
2509         if IDsOfElements == []:
2510             IDsOfElements = self.GetElementsId()
2511         if ( isinstance( Vector, geompyDC.GEOM._objref_GEOM_Object)):
2512             Vector = self.smeshpyD.GetDirStruct(Vector)
2513         mesh = self.editor.TranslateMakeMesh(IDsOfElements, Vector, MakeGroups, NewMeshName)
2514         return Mesh ( self.smeshpyD, self.geompyD, mesh )
2515
2516     ## Translates the object
2517     #  @param theObject the object to translate (mesh, submesh, or group)
2518     #  @param Vector direction of translation (DirStruct or geom vector)
2519     #  @param Copy allows copying the translated elements
2520     #  @param MakeGroups forces the generation of new groups from existing ones (if Copy)
2521     #  @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
2522     #  @ingroup l2_modif_trsf
2523     def TranslateObject(self, theObject, Vector, Copy, MakeGroups=False):
2524         if ( isinstance( theObject, Mesh )):
2525             theObject = theObject.GetMesh()
2526         if ( isinstance( Vector, geompyDC.GEOM._objref_GEOM_Object)):
2527             Vector = self.smeshpyD.GetDirStruct(Vector)
2528         if Copy and MakeGroups:
2529             return self.editor.TranslateObjectMakeGroups(theObject, Vector)
2530         self.editor.TranslateObject(theObject, Vector, Copy)
2531         return []
2532
2533     ## Creates a new mesh from the translated object
2534     #  @param theObject the object to translate (mesh, submesh, or group)
2535     #  @param Vector the direction of translation (DirStruct or geom vector)
2536     #  @param MakeGroups forces the generation of new groups from existing ones
2537     #  @param NewMeshName the name of the newly created mesh
2538     #  @return instance of Mesh class
2539     #  @ingroup l2_modif_trsf
2540     def TranslateObjectMakeMesh(self, theObject, Vector, MakeGroups=False, NewMeshName=""):
2541         if (isinstance(theObject, Mesh)):
2542             theObject = theObject.GetMesh()
2543         if (isinstance(Vector, geompyDC.GEOM._objref_GEOM_Object)):
2544             Vector = self.smeshpyD.GetDirStruct(Vector)
2545         mesh = self.editor.TranslateObjectMakeMesh(theObject, Vector, MakeGroups, NewMeshName)
2546         return Mesh( self.smeshpyD, self.geompyD, mesh )
2547
2548     ## Rotates the elements
2549     #  @param IDsOfElements list of elements ids
2550     #  @param Axis the axis of rotation (AxisStruct or geom line)
2551     #  @param AngleInRadians the angle of rotation (in radians)
2552     #  @param Copy allows copying the rotated elements
2553     #  @param MakeGroups forces the generation of new groups from existing ones (if Copy)
2554     #  @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
2555     #  @ingroup l2_modif_trsf
2556     def Rotate (self, IDsOfElements, Axis, AngleInRadians, Copy, MakeGroups=False):
2557         if IDsOfElements == []:
2558             IDsOfElements = self.GetElementsId()
2559         if ( isinstance( Axis, geompyDC.GEOM._objref_GEOM_Object)):
2560             Axis = self.smeshpyD.GetAxisStruct(Axis)
2561         if Copy and MakeGroups:
2562             return self.editor.RotateMakeGroups(IDsOfElements, Axis, AngleInRadians)
2563         self.editor.Rotate(IDsOfElements, Axis, AngleInRadians, Copy)
2564         return []
2565
2566     ## Creates a new mesh of rotated elements
2567     #  @param IDsOfElements list of element ids
2568     #  @param Axis the axis of rotation (AxisStruct or geom line)
2569     #  @param AngleInRadians the angle of rotation (in radians)
2570     #  @param MakeGroups forces the generation of new groups from existing ones
2571     #  @param NewMeshName the name of the newly created mesh
2572     #  @return instance of Mesh class
2573     #  @ingroup l2_modif_trsf
2574     def RotateMakeMesh (self, IDsOfElements, Axis, AngleInRadians, MakeGroups=0, NewMeshName=""):
2575         if IDsOfElements == []:
2576             IDsOfElements = self.GetElementsId()
2577         if ( isinstance( Axis, geompyDC.GEOM._objref_GEOM_Object)):
2578             Axis = self.smeshpyD.GetAxisStruct(Axis)
2579         mesh = self.editor.RotateMakeMesh(IDsOfElements, Axis, AngleInRadians,
2580                                           MakeGroups, NewMeshName)
2581         return Mesh( self.smeshpyD, self.geompyD, mesh )
2582
2583     ## Rotates the object
2584     #  @param theObject the object to rotate( mesh, submesh, or group)
2585     #  @param Axis the axis of rotation (AxisStruct or geom line)
2586     #  @param AngleInRadians the angle of rotation (in radians)
2587     #  @param Copy allows copying the rotated elements
2588     #  @param MakeGroups forces the generation of new groups from existing ones (if Copy)
2589     #  @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
2590     #  @ingroup l2_modif_trsf
2591     def RotateObject (self, theObject, Axis, AngleInRadians, Copy, MakeGroups=False):
2592         if (isinstance(theObject, Mesh)):
2593             theObject = theObject.GetMesh()
2594         if (isinstance(Axis, geompyDC.GEOM._objref_GEOM_Object)):
2595             Axis = self.smeshpyD.GetAxisStruct(Axis)
2596         if Copy and MakeGroups:
2597             return self.editor.RotateObjectMakeGroups(theObject, Axis, AngleInRadians)
2598         self.editor.RotateObject(theObject, Axis, AngleInRadians, Copy)
2599         return []
2600
2601     ## Creates a new mesh from the rotated object
2602     #  @param theObject the object to rotate (mesh, submesh, or group)
2603     #  @param Axis the axis of rotation (AxisStruct or geom line)
2604     #  @param AngleInRadians the angle of rotation (in radians)
2605     #  @param MakeGroups forces the generation of new groups from existing ones
2606     #  @param NewMeshName the name of the newly created mesh
2607     #  @return instance of Mesh class
2608     #  @ingroup l2_modif_trsf
2609     def RotateObjectMakeMesh(self, theObject, Axis, AngleInRadians, MakeGroups=0,NewMeshName=""):
2610         if (isinstance( theObject, Mesh )):
2611             theObject = theObject.GetMesh()
2612         if (isinstance(Axis, geompyDC.GEOM._objref_GEOM_Object)):
2613             Axis = self.smeshpyD.GetAxisStruct(Axis)
2614         mesh = self.editor.RotateObjectMakeMesh(theObject, Axis, AngleInRadians,
2615                                                        MakeGroups, NewMeshName)
2616         return Mesh( self.smeshpyD, self.geompyD, mesh )
2617
2618     ## Finds groups of ajacent nodes within Tolerance.
2619     #  @param Tolerance the value of tolerance
2620     #  @return the list of groups of nodes
2621     #  @ingroup l2_modif_trsf
2622     def FindCoincidentNodes (self, Tolerance):
2623         return self.editor.FindCoincidentNodes(Tolerance)
2624
2625     ## Finds groups of ajacent nodes within Tolerance.
2626     #  @param Tolerance the value of tolerance
2627     #  @param SubMeshOrGroup SubMesh or Group
2628     #  @return the list of groups of nodes
2629     #  @ingroup l2_modif_trsf
2630     def FindCoincidentNodesOnPart (self, SubMeshOrGroup, Tolerance):
2631         return self.editor.FindCoincidentNodesOnPart(SubMeshOrGroup, Tolerance)
2632
2633     ## Merges nodes
2634     #  @param GroupsOfNodes the list of groups of nodes
2635     #  @ingroup l2_modif_trsf
2636     def MergeNodes (self, GroupsOfNodes):
2637         self.editor.MergeNodes(GroupsOfNodes)
2638
2639     ## Finds the elements built on the same nodes.
2640     #  @param MeshOrSubMeshOrGroup Mesh or SubMesh, or Group of elements for searching
2641     #  @return a list of groups of equal elements
2642     #  @ingroup l2_modif_trsf
2643     def FindEqualElements (self, MeshOrSubMeshOrGroup):
2644         return self.editor.FindEqualElements(MeshOrSubMeshOrGroup)
2645
2646     ## Merges elements in each given group.
2647     #  @param GroupsOfElementsID groups of elements for merging
2648     #  @ingroup l2_modif_trsf
2649     def MergeElements(self, GroupsOfElementsID):
2650         self.editor.MergeElements(GroupsOfElementsID)
2651
2652     ## Leaves one element and removes all other elements built on the same nodes.
2653     #  @ingroup l2_modif_trsf
2654     def MergeEqualElements(self):
2655         self.editor.MergeEqualElements()
2656
2657     ## Sews free borders
2658     #  @return SMESH::Sew_Error
2659     #  @ingroup l2_modif_trsf
2660     def SewFreeBorders (self, FirstNodeID1, SecondNodeID1, LastNodeID1,
2661                         FirstNodeID2, SecondNodeID2, LastNodeID2,
2662                         CreatePolygons, CreatePolyedrs):
2663         return self.editor.SewFreeBorders(FirstNodeID1, SecondNodeID1, LastNodeID1,
2664                                           FirstNodeID2, SecondNodeID2, LastNodeID2,
2665                                           CreatePolygons, CreatePolyedrs)
2666
2667     ## Sews conform free borders
2668     #  @return SMESH::Sew_Error
2669     #  @ingroup l2_modif_trsf
2670     def SewConformFreeBorders (self, FirstNodeID1, SecondNodeID1, LastNodeID1,
2671                                FirstNodeID2, SecondNodeID2):
2672         return self.editor.SewConformFreeBorders(FirstNodeID1, SecondNodeID1, LastNodeID1,
2673                                                  FirstNodeID2, SecondNodeID2)
2674
2675     ## Sews border to side
2676     #  @return SMESH::Sew_Error
2677     #  @ingroup l2_modif_trsf
2678     def SewBorderToSide (self, FirstNodeIDOnFreeBorder, SecondNodeIDOnFreeBorder, LastNodeIDOnFreeBorder,
2679                          FirstNodeIDOnSide, LastNodeIDOnSide, CreatePolygons, CreatePolyedrs):
2680         return self.editor.SewBorderToSide(FirstNodeIDOnFreeBorder, SecondNodeIDOnFreeBorder, LastNodeIDOnFreeBorder,
2681                                            FirstNodeIDOnSide, LastNodeIDOnSide, CreatePolygons, CreatePolyedrs)
2682
2683     ## Sews two sides of a mesh. The nodes belonging to Side1 are
2684     #  merged with the nodes of elements of Side2.
2685     #  The number of elements in theSide1 and in theSide2 must be
2686     #  equal and they should have similar nodal connectivity.
2687     #  The nodes to merge should belong to side borders and
2688     #  the first node should be linked to the second.
2689     #  @return SMESH::Sew_Error
2690     #  @ingroup l2_modif_trsf
2691     def SewSideElements (self, IDsOfSide1Elements, IDsOfSide2Elements,
2692                          NodeID1OfSide1ToMerge, NodeID1OfSide2ToMerge,
2693                          NodeID2OfSide1ToMerge, NodeID2OfSide2ToMerge):
2694         return self.editor.SewSideElements(IDsOfSide1Elements, IDsOfSide2Elements,
2695                                            NodeID1OfSide1ToMerge, NodeID1OfSide2ToMerge,
2696                                            NodeID2OfSide1ToMerge, NodeID2OfSide2ToMerge)
2697
2698     ## Sets new nodes for the given element.
2699     #  @param ide the element id
2700     #  @param newIDs nodes ids
2701     #  @return If the number of nodes does not correspond to the type of element - returns false
2702     #  @ingroup l2_modif_edit
2703     def ChangeElemNodes(self, ide, newIDs):
2704         return self.editor.ChangeElemNodes(ide, newIDs)
2705
2706     ## If during the last operation of MeshEditor some nodes were
2707     #  created, this method returns the list of their IDs, \n
2708     #  if new nodes were not created - returns empty list
2709     #  @return the list of integer values (can be empty)
2710     #  @ingroup l1_auxiliary
2711     def GetLastCreatedNodes(self):
2712         return self.editor.GetLastCreatedNodes()
2713
2714     ## If during the last operation of MeshEditor some elements were
2715     #  created this method returns the list of their IDs, \n
2716     #  if new elements were not created - returns empty list
2717     #  @return the list of integer values (can be empty)
2718     #  @ingroup l1_auxiliary
2719     def GetLastCreatedElems(self):
2720         return self.editor.GetLastCreatedElems()
2721
2722 ## The mother class to define algorithm, it is not recommended to use it directly.
2723 #
2724 #  More details.
2725 #  @ingroup l2_algorithms
2726 class Mesh_Algorithm:
2727     #  @class Mesh_Algorithm
2728     #  @brief Class Mesh_Algorithm
2729
2730     #def __init__(self,smesh):
2731     #    self.smesh=smesh
2732     def __init__(self):
2733         self.mesh = None
2734         self.geom = None
2735         self.subm = None
2736         self.algo = None
2737
2738     ## Finds a hypothesis in the study by its type name and parameters.
2739     #  Finds only the hypotheses created in smeshpyD engine.
2740     #  @return SMESH.SMESH_Hypothesis
2741     def FindHypothesis (self, hypname, args, CompareMethod, smeshpyD):
2742         study = smeshpyD.GetCurrentStudy()
2743         #to do: find component by smeshpyD object, not by its data type
2744         scomp = study.FindComponent(smeshpyD.ComponentDataType())
2745         if scomp is not None:
2746             res,hypRoot = scomp.FindSubObject(SMESH.Tag_HypothesisRoot)
2747             # Check if the root label of the hypotheses exists
2748             if res and hypRoot is not None:
2749                 iter = study.NewChildIterator(hypRoot)
2750                 # Check all published hypotheses
2751                 while iter.More():
2752                     hypo_so_i = iter.Value()
2753                     attr = hypo_so_i.FindAttribute("AttributeIOR")[1]
2754                     if attr is not None:
2755                         anIOR = attr.Value()
2756                         hypo_o_i = salome.orb.string_to_object(anIOR)
2757                         if hypo_o_i is not None:
2758                             # Check if this is a hypothesis
2759                             hypo_i = hypo_o_i._narrow(SMESH.SMESH_Hypothesis)
2760                             if hypo_i is not None:
2761                                 # Check if the hypothesis belongs to current engine
2762                                 if smeshpyD.GetObjectId(hypo_i) > 0:
2763                                     # Check if this is the required hypothesis
2764                                     if hypo_i.GetName() == hypname:
2765                                         # Check arguments
2766                                         if CompareMethod(hypo_i, args):
2767                                             # found!!!
2768                                             return hypo_i
2769                                         pass
2770                                     pass
2771                                 pass
2772                             pass
2773                         pass
2774                     iter.Next()
2775                     pass
2776                 pass
2777             pass
2778         return None
2779
2780     ## Finds the algorithm in the study by its type name.
2781     #  Finds only the algorithms, which have been created in smeshpyD engine.
2782     #  @return SMESH.SMESH_Algo
2783     def FindAlgorithm (self, algoname, smeshpyD):
2784         study = smeshpyD.GetCurrentStudy()
2785         #to do: find component by smeshpyD object, not by its data type
2786         scomp = study.FindComponent(smeshpyD.ComponentDataType())
2787         if scomp is not None:
2788             res,hypRoot = scomp.FindSubObject(SMESH.Tag_AlgorithmsRoot)
2789             # Check if the root label of the algorithms exists
2790             if res and hypRoot is not None:
2791                 iter = study.NewChildIterator(hypRoot)
2792                 # Check all published algorithms
2793                 while iter.More():
2794                     algo_so_i = iter.Value()
2795                     attr = algo_so_i.FindAttribute("AttributeIOR")[1]
2796                     if attr is not None:
2797                         anIOR = attr.Value()
2798                         algo_o_i = salome.orb.string_to_object(anIOR)
2799                         if algo_o_i is not None:
2800                             # Check if this is an algorithm
2801                             algo_i = algo_o_i._narrow(SMESH.SMESH_Algo)
2802                             if algo_i is not None:
2803                                 # Checks if the algorithm belongs to the current engine
2804                                 if smeshpyD.GetObjectId(algo_i) > 0:
2805                                     # Check if this is the required algorithm
2806                                     if algo_i.GetName() == algoname:
2807                                         # found!!!
2808                                         return algo_i
2809                                     pass
2810                                 pass
2811                             pass
2812                         pass
2813                     iter.Next()
2814                     pass
2815                 pass
2816             pass
2817         return None
2818
2819     ## If the algorithm is global, returns 0; \n
2820     #  else returns the submesh associated to this algorithm.
2821     def GetSubMesh(self):
2822         return self.subm
2823
2824     ## Returns the wrapped mesher.
2825     def GetAlgorithm(self):
2826         return self.algo
2827
2828     ## Gets the list of hypothesis that can be used with this algorithm
2829     def GetCompatibleHypothesis(self):
2830         mylist = []
2831         if self.algo:
2832             mylist = self.algo.GetCompatibleHypothesis()
2833         return mylist
2834
2835     ## Gets the name of the algorithm
2836     def GetName(self):
2837         GetName(self.algo)
2838
2839     ## Sets the name to the algorithm
2840     def SetName(self, name):
2841         SetName(self.algo, name)
2842
2843     ## Gets the id of the algorithm
2844     def GetId(self):
2845         return self.algo.GetId()
2846
2847     ## Private method.
2848     def Create(self, mesh, geom, hypo, so="libStdMeshersEngine.so"):
2849         if geom is None:
2850             raise RuntimeError, "Attemp to create " + hypo + " algoritm on None shape"
2851         algo = self.FindAlgorithm(hypo, mesh.smeshpyD)
2852         if algo is None:
2853             algo = mesh.smeshpyD.CreateHypothesis(hypo, so)
2854             pass
2855         self.Assign(algo, mesh, geom)
2856         return self.algo
2857
2858     ## Private method
2859     def Assign(self, algo, mesh, geom):
2860         if geom is None:
2861             raise RuntimeError, "Attemp to create " + algo + " algoritm on None shape"
2862         self.mesh = mesh
2863         piece = mesh.geom
2864         if not geom:
2865             self.geom = piece
2866         else:
2867             self.geom = geom
2868             name = GetName(geom)
2869             if name==NO_NAME:
2870                 name = mesh.geompyD.SubShapeName(geom, piece)
2871                 mesh.geompyD.addToStudyInFather(piece, geom, name)
2872             self.subm = mesh.mesh.GetSubMesh(geom, algo.GetName())
2873
2874         self.algo = algo
2875         status = mesh.mesh.AddHypothesis(self.geom, self.algo)
2876         TreatHypoStatus( status, algo.GetName(), GetName(self.geom), True )
2877
2878     def CompareHyp (self, hyp, args):
2879         print "CompareHyp is not implemented for ", self.__class__.__name__, ":", hyp.GetName()
2880         return False
2881
2882     def CompareEqualHyp (self, hyp, args):
2883         return True
2884
2885     ## Private method
2886     def Hypothesis (self, hyp, args=[], so="libStdMeshersEngine.so",
2887                     UseExisting=0, CompareMethod=""):
2888         hypo = None
2889         if UseExisting:
2890             if CompareMethod == "": CompareMethod = self.CompareHyp
2891             hypo = self.FindHypothesis(hyp, args, CompareMethod, self.mesh.smeshpyD)
2892             pass
2893         if hypo is None:
2894             hypo = self.mesh.smeshpyD.CreateHypothesis(hyp, so)
2895             a = ""
2896             s = "="
2897             i = 0
2898             n = len(args)
2899             while i<n:
2900                 a = a + s + str(args[i])
2901                 s = ","
2902                 i = i + 1
2903                 pass
2904             SetName(hypo, hyp + a)
2905             pass
2906         status = self.mesh.mesh.AddHypothesis(self.geom, hypo)
2907         TreatHypoStatus( status, GetName(hypo), GetName(self.geom), 0 )
2908         return hypo
2909
2910
2911 # Public class: Mesh_Segment
2912 # --------------------------
2913
2914 ## Class to define a segment 1D algorithm for discretization
2915 #
2916 #  More details.
2917 #  @ingroup l3_algos_basic
2918 class Mesh_Segment(Mesh_Algorithm):
2919
2920     ## Private constructor.
2921     def __init__(self, mesh, geom=0):
2922         Mesh_Algorithm.__init__(self)
2923         self.Create(mesh, geom, "Regular_1D")
2924
2925     ## Defines "LocalLength" hypothesis to cut an edge in several segments with the same length
2926     #  @param l for the length of segments that cut an edge
2927     #  @param UseExisting if ==true - searches for an  existing hypothesis created with
2928     #                    the same parameters, else (default) - creates a new one
2929     #  @param p precision, used for calculation of the number of segments.
2930     #           The precision should be a positive, meaningful value within the range [0,1].
2931     #           In general, the number of segments is calculated with the formula:
2932     #           nb = ceil((edge_length / l) - p)<