]> SALOME platform Git repositories - plugins/blsurfplugin.git/blob - src/BLSURFPlugin/BLSURFPluginBuilder.py
Salome HOME
19b197b59cd5f4b9695b53792967fb41315b570f
[plugins/blsurfplugin.git] / src / BLSURFPlugin / BLSURFPluginBuilder.py
1 # Copyright (C) 2007-2016  CEA/DEN, EDF R&D
2 #
3 # This library is free software; you can redistribute it and/or
4 # modify it under the terms of the GNU Lesser General Public
5 # License as published by the Free Software Foundation; either
6 # version 2.1 of the License, or (at your option) any later version.
7 #
8 # This library is distributed in the hope that it will be useful,
9 # but WITHOUT ANY WARRANTY; without even the implied warranty of
10 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11 # Lesser General Public License for more details.
12 #
13 # You should have received a copy of the GNU Lesser General Public
14 # License along with this library; if not, write to the Free Software
15 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
16 #
17 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
18 #
19
20 ##
21 # @package BLSURFPluginBuilder
22 # Python API for the MG-CADSurf meshing plug-in module.
23
24 from salome.smesh.smesh_algorithm import Mesh_Algorithm
25 import GEOM
26
27 LIBRARY = "libBLSURFEngine.so"
28
29 # ElementType enum
30 Triangles, QuadrangleDominant, Quadrangles = 0, 1, 2
31
32 # Topology treatment way of MG-CADSurf
33 FromCAD, PreProcess, PreProcessPlus, PreCAD = 0,1,2,3
34
35 # Element size flag of MG-CADSurf
36 DefaultSize, DefaultGeom, MG_CADSURF_GlobalSize, MG_CADSURF_LocalSize = 0,0,1,2
37 # Retrocompatibility
38 MG_CADSURF_Custom, SizeMap = MG_CADSURF_GlobalSize, MG_CADSURF_LocalSize
39 BLSURF_Custom, BLSURF_GlobalSize, BLSURF_LocalSize = MG_CADSURF_Custom, MG_CADSURF_GlobalSize, MG_CADSURF_LocalSize
40
41 # import BLSURFPlugin module if possible
42 noBLSURFPlugin = 0
43 try:
44   import BLSURFPlugin
45 except ImportError:
46   noBLSURFPlugin = 1
47   pass
48
49 #----------------------------
50 # Mesh algo type identifiers
51 #----------------------------
52
53 ## Algorithm type: MG-CADSurf triangle algorithm, see BLSURF_Algorithm
54 MG_CADSurf = "MG-CADSurf"
55 BLSURF = MG_CADSurf
56
57 #----------------------
58 # Algorithms
59 #----------------------
60
61 ## MG-CADSurf 2D algorithm.
62 #
63 #  It can be created by calling smeshBuilder.Mesh.Triangle(smeshBuilder.MG-CADSurf,geom=0)
64 #
65 class BLSURF_Algorithm(Mesh_Algorithm):
66
67   ## name of the dynamic method in smeshBuilder.Mesh class
68   #  @internal
69   meshMethod = "Triangle"
70   ## type of algorithm used with helper function in smeshBuilder.Mesh class
71   #  @internal
72   algoType   = MG_CADSurf
73   ## doc string of the method
74   #  @internal
75   docHelper  = "Creates triangle algorithm for faces"
76
77   _anisotropic_ratio = 0
78   _bad_surface_element_aspect_ratio = 1000
79   _geometric_approximation = 22
80   _gradation  = 1.3
81   _volume_gradation  = 2
82   _metric = "isotropic"
83   _remove_tiny_edges = 0
84
85   ## Private constructor.
86   #  @param mesh parent mesh object algorithm is assigned to
87   #  @param geom geometry (shape/sub-shape) algorithm is assigned to;
88   #              if it is @c 0 (default), the algorithm is assigned to the main shape
89   def __init__(self, mesh, geom=0):
90     Mesh_Algorithm.__init__(self)
91     if noBLSURFPlugin:
92       print("Warning: BLSURFPlugin module unavailable")
93     if mesh.GetMesh().HasShapeToMesh():
94       self.Create(mesh, geom, self.algoType, LIBRARY)
95     else:
96       self.Create(mesh, geom, self.algoType+"_NOGEOM", LIBRARY)
97       mesh.smeshpyD.SetName( self.algo, self.algoType )
98     self.params=None
99     self.geompyD = mesh.geompyD
100     #self.SetPhysicalMesh() - PAL19680
101     pass
102
103   ## Sets a way to define size of mesh elements to generate.
104   #  @param thePhysicalMesh is: DefaultSize, MG_CADSURF_Custom or SizeMap.
105   def SetPhysicalMesh(self, thePhysicalMesh=DefaultSize):
106     physical_size_mode = thePhysicalMesh
107     if self.Parameters().GetGeometricMesh() == DefaultGeom:
108       if physical_size_mode == DefaultSize:
109         physical_size_mode = MG_CADSURF_GlobalSize
110     self.Parameters().SetPhysicalMesh(physical_size_mode)
111     pass
112
113   ## Sets a way to define maximum angular deflection of mesh from CAD model.
114   #  @param theGeometricMesh is: DefaultGeom (0)) or MG_CADSURF_GlobalSize (1))
115   def SetGeometricMesh(self, theGeometricMesh=DefaultGeom):
116     geometric_size_mode = theGeometricMesh
117     if self.Parameters().GetPhysicalMesh() == DefaultSize:
118       if geometric_size_mode == DefaultGeom:
119         geometric_size_mode = MG_CADSURF_GlobalSize
120     self.Parameters().SetGeometricMesh(geometric_size_mode)
121     pass
122
123   ## Sets size of mesh elements to generate.
124   #  @param theVal : constant global size when using a global physical size.
125   #  @param isRelative : if True, the value is relative to the length of the diagonal of the bounding box
126   def SetPhySize(self, theVal, isRelative = False):
127     if self.Parameters().GetPhysicalMesh() == DefaultSize:
128       self.SetPhysicalMesh(MG_CADSURF_GlobalSize)
129     if isRelative:
130       self.Parameters().SetPhySizeRel(theVal)
131     else:
132       self.Parameters().SetPhySize(theVal)
133     pass
134
135   ## Sets lower boundary of mesh element size.
136   #  @param theVal : global minimal cell size desired.
137   #  @param isRelative : if True, the value is relative to the length of the diagonal of the bounding box
138   def SetMinSize(self, theVal=-1, isRelative = False):
139     if isRelative:
140       self.Parameters().SetMinSizeRel(theVal)
141     else:
142       self.Parameters().SetMinSize(theVal)
143     pass
144
145   ## Sets upper boundary of mesh element size.
146   #  @param theVal : global maximal cell size desired.
147   #  @param isRelative : if True, the value is relative to the length of the diagonal of the bounding box
148   def SetMaxSize(self, theVal=-1, isRelative = False):
149     if isRelative:
150       self.Parameters().SetMaxSizeRel(theVal)
151     else:
152       self.Parameters().SetMaxSize(theVal)
153     pass
154
155   ## Sets angular deflection (in degrees) from CAD surface.
156   #  @param theVal value of angular deflection
157   def SetAngleMesh(self, theVal=_geometric_approximation):
158     if self.Parameters().GetGeometricMesh() == DefaultGeom:
159       self.SetGeometricMesh(MG_CADSURF_GlobalSize)
160     self.Parameters().SetAngleMesh(theVal)
161     pass
162
163   ## Sets the maximum desired distance between a triangle and its supporting CAD surface
164   #  @param distance the distance between a triangle and a surface
165   def SetChordalError(self, distance):
166     self.Parameters().SetChordalError(distance)
167     pass
168
169   ## Sets maximal allowed ratio between the lengths of two adjacent edges.
170   #  @param toUseGradation to use gradation
171   #  @param theVal value of maximal length ratio
172   def SetGradation(self, toUseGradation=True, theVal=_gradation):
173     if isinstance( toUseGradation, float ): ## backward compatibility
174       toUseGradation, theVal = True, toUseGradation
175     if self.Parameters().GetGeometricMesh() == 0: theVal = self._gradation
176     self.Parameters().SetUseGradation(toUseGradation)
177     self.Parameters().SetGradation(theVal)
178     pass
179
180   ## Sets maximal allowed ratio between the lengths of two adjacent edges in 3D mesh.
181   #  @param toUseGradation to use gradation
182   #  @param theVal value of maximal length ratio
183   def SetVolumeGradation(self, toUseGradation=True, theVal=_gradation):
184     if self.Parameters().GetGeometricMesh() == 0: theVal = self._volume_gradation
185     self.Parameters().SetUseVolumeGradation(toUseGradation)
186     self.Parameters().SetVolumeGradation(theVal)
187     pass
188
189   ## Sets topology usage way.
190   # @param way defines how mesh conformity is assured <ul>
191   # <li>FromCAD - mesh conformity is assured by conformity of a shape</li>
192   # <li>PreProcess or PreProcessPlus - by pre-processing a CAD model (OBSOLETE: FromCAD will be used)</li>
193   # <li>PreCAD - by pre-processing with PreCAD a CAD model</li></ul>
194   def SetTopology(self, way):
195     if way != PreCAD and way != FromCAD:
196       print("Warning: topology mode %d is no longer supported. Mode FromCAD is used."%way)
197       way = FromCAD
198     self.Parameters().SetTopology(way)
199     pass
200
201   ## To respect geometrical edges or not.
202   #  @param toIgnoreEdges "ignore edges" flag value
203   def SetDecimesh(self, toIgnoreEdges=False):
204     if toIgnoreEdges:
205       self.SetOptionValue("respect_geometry","0")
206     else:
207       self.SetOptionValue("respect_geometry","1")
208     pass
209
210   ## Sets verbosity level in the range 0 to 100.
211   #  @param level verbosity level
212   def SetVerbosity(self, level):
213     self.Parameters().SetVerbosity(level)
214     pass
215
216   ## Set enforce_cad_edge_sizes parameter
217   #  
218   #  Relaxes the given sizemap constraint around CAD edges to allow a better
219   #  element quality and a better geometric approximation. It is only useful in 
220   #  combination with the gradation option.
221   #  
222   def SetEnforceCadEdgesSize( self, toEnforce ):
223     self.Parameters().SetEnforceCadEdgesSize( toEnforce )
224
225   ## Set jacobian_rectification_respect_geometry parameter
226   #  
227   #  While making the mesh quadratic, allows to lose the CAD-mesh associativity in order
228   #  to correct elements with nagative Jacobian
229   #  
230   def SetJacobianRectificationRespectGeometry( self, allowRectification ):
231     self.Parameters().SetJacobianRectificationRespectGeometry( allowRectification )
232     
233   ## Set rectify_jacobian parameter
234   #  
235   #  While making the mesh quadratic, allow to fix nagative Jacobian surface elements
236   #  
237   def SetJacobianRectification( self, allowRectification ):
238     self.Parameters().SetJacobianRectification( allowRectification )
239
240   ## Set use_deprecated_patch_mesher parameter (compatibility with older versions of Meshgems)
241   #  
242   # the use_deprecated_patch_mesher parameter allows to keep the same behaviour than
243   # in salome < 8.3 (meshgems 2.1.11 instead of meshgems >= 2.4.5)
244   #  
245   def SetUseDeprecatedPatchMesher( self, useDeprecatedPatchMesher ):
246     self.Parameters().SetUseDeprecatedPatchMesher( useDeprecatedPatchMesher )
247
248   ## Set respect_geometry parameter
249   #  
250   #  This patch independent option can be deactivated to allow MeshGems-CADSurf
251   #  to lower the geometry accuracy in its patch independent process.
252   #  
253   def SetRespectGeometry( self, toRespect ):
254     self.Parameters().SetRespectGeometry( toRespect )
255
256   ## Set max_number_of_points_per_patch parameter
257   #  
258   #  This parameter controls the maximum amount of points MeshGems-CADSurf is allowed
259   #  to generate on a single CAD patch. For an automatic gestion of the memory, one
260   #  can set this parameter to 0
261   #  
262   def SetMaxNumberOfPointsPerPatch( self, nb ):
263     self.Parameters().SetMaxNumberOfPointsPerPatch( nb )
264
265   ## Set max_number_of_threads parameter
266   #
267   #  Set the maximum of threads to use for multithreading mesh computation
268   #
269   def SetMaxNumberOfThreads( self, nb ):
270     self.Parameters().SetMaxNumberOfThreads( nb )
271
272   ## Set respect_geometry parameter
273   #  
274   #  This patch independent option can be deactivated to allow MeshGems-CADSurf
275   #  to lower the geometry accuracy in its patch independent process.
276   #  
277   def SetRespectGeometry( self, toRespect ):
278     self.Parameters().SetRespectGeometry( toRespect )
279
280   ## Set tiny_edges_avoid_surface_intersections parameter
281   #  
282   #  This option defines the priority between the tiny feature
283   #  suppression and the surface intersection prevention. 
284   #  
285   def SetTinyEdgesAvoidSurfaceIntersections( self, toAvoidIntersection ):
286     self.Parameters().SetTinyEdgesAvoidSurfaceIntersections( toAvoidIntersection )
287
288   ## Set closed_geometry parameter parameter
289   #  
290   #  Describes whether the geometry is expected to be closed or not. 
291   #  When activated, this option helps MeshGems-PreCAD to treat the dirtiest geometries.
292   #  
293   def SetClosedGeometry( self, isClosed ):
294     self.Parameters().SetClosedGeometry( isClosed )
295
296   ## Set debug parameter
297   #  
298   #  Make MeshGems-CADSurf will be very verbose and will output some intermediate
299   #  files in the working directory. This option is mainly meant for Distene support issues.
300   #  
301   def SetDebug( self, isDebug ):
302     self.Parameters().SetDebug( isDebug )
303
304   ## Set periodic_tolerance parameter
305   #  
306   #  This parameter defines the maximum size difference between two periodic edges
307   #  and also the maximum distance error between two periodic entities.
308   #  
309   def SetPeriodicTolerance( self, tol ):
310     self.Parameters().SetPeriodicTolerance( tol )
311
312   ## Set required_entities parameter
313   #  
314   #  The required entities control the correction operations. 
315   #  Accepted values for this parameter are :
316   #  - "respect" : MeshGems-CADSurf is not allowed to alter any required entity, 
317   #                even for correction purposes,
318   #  - "ignore" : MeshGems-CADSurf will ignore the required entities in its processing,
319   #  - "clear" : MeshGems-CADSurf will clear any required status for the entities. 
320   #              There will not be any entity marked as required in the generated mesh.
321   #  
322   def SetRequiredEntities( self, howToTreat ):
323     self.Parameters().SetRequiredEntities( howToTreat )
324
325   ## Set sewing_tolerance parameter
326   #  
327   #  This parameter is the tolerance of the assembly.
328   #  
329   def SetSewingTolerance( self, tol ):
330     self.Parameters().SetSewingTolerance( tol )
331
332   ## Set tags parameter
333   #  
334   #  The tag (attribute) system controls the optimisation process. 
335   #  Accepted values for this parameter are :
336   #  - "respect"  : the CAD tags will be preserved and unaltered by the optimisation operations,
337   #  - "ignore" : the CAD tags will be ignored by the optimisation operations 
338   #               but they will still be present in the output mesh,
339   #  - "clear" : MeshGems-CADSurf will clear any tag on any entity and optimise accordingly. 
340   #              There will not be any tag in the generated mesh.
341   #  
342   def SetTags( self, howToTreat ):
343     self.Parameters().SetTags( howToTreat )
344
345   ## Activate removal of the tiny edges from the generated
346   # mesh when it improves the local mesh quality, without taking into account the
347   # tags (attributes) specifications.
348   #  @param toOptimise "to optimize" flag value
349   #  @param length minimal length under which an edge is considered to be a tiny
350   def SetOptimiseTinyEdges(self, toOptimise, length=-1):
351     self.Parameters().SetOptimiseTinyEdges( toOptimise )
352     if toOptimise:
353       self.Parameters().SetTinyEdgeOptimisationLength( length )
354
355   ## Activate correction of all surface intersections
356   #  @param toCorrect "to correct" flag value
357   #  @param maxCost  the time the user is ready to spend in the intersection prevention process
358   #         For example, maxCost = 3 means that MeshGems-CADSurf will not spend more time
359   #         in the intersection removal process than 3 times the time required to mesh
360   #         without processing the intersections.
361   def SetCorrectSurfaceIntersection(self, toCorrect, maxCost ):
362     self.Parameters().SetCorrectSurfaceIntersection( toCorrect )
363     if toCorrect:
364       self.Parameters().SetCorrectSurfaceIntersectionMaxCost( maxCost )
365
366   ## To optimize merges edges.
367   #  @param toMergeEdges "merge edges" flag value
368   def SetPreCADMergeEdges(self, toMergeEdges=False):
369     self.Parameters().SetPreCADMergeEdges(toMergeEdges)
370     pass
371
372   ## To remove duplicate CAD Faces
373   #  @param toRemoveDuplicateCADFaces "remove_duplicate_cad_faces" flag value
374   def SetPreCADRemoveDuplicateCADFaces(self, toRemoveDuplicateCADFaces=False):
375     self.Parameters().SetPreCADRemoveDuplicateCADFaces(toRemoveDuplicateCADFaces)
376     pass
377
378   ## To process 3D topology.
379   #  @param toProcess "PreCAD process 3D" flag value
380   def SetPreCADProcess3DTopology(self, toProcess=False):
381     self.Parameters().SetPreCADProcess3DTopology(toProcess)
382     pass
383
384   ## To remove nano edges.
385   #  @param toRemoveNanoEdges "remove nano edges" flag value
386   def SetPreCADRemoveNanoEdges(self, toRemoveNanoEdges=False):
387     if toRemoveNanoEdges:
388       self.SetPreCADOptionValue("remove_tiny_edges","1")
389     else:
390       self.SetPreCADOptionValue("remove_tiny_edges","0")
391     pass
392
393   ## To compute topology from scratch
394   #  @param toDiscardInput "discard input" flag value
395   def SetPreCADDiscardInput(self, toDiscardInput=False):
396     self.Parameters().SetPreCADDiscardInput(toDiscardInput)
397     pass
398
399   ## Sets the length below which an edge is considered as nano
400   #  for the topology processing.
401   #  @param epsNano nano edge length threshold value
402   def SetPreCADEpsNano(self, epsNano):
403     self.SetPreCADOptionValue("tiny_edge_length","%f"%epsNano)
404     pass
405
406   ## Sets advanced option value.
407   #  @param optionName advanced option name
408   #  @param level advanced option value
409   def SetOptionValue(self, optionName, level):
410     self.Parameters().SetOptionValue(optionName,level)
411     pass
412
413   ## Sets advanced PreCAD option value.
414   #  @param optionName name of the option
415   #  @param optionValue value of the option
416   def SetPreCADOptionValue(self, optionName, optionValue):
417     self.Parameters().SetPreCADOptionValue(optionName,optionValue)
418     pass
419   
420   ## Adds custom advanced option values
421   #  @param optionsAndValues options and values in a form "option_1 v1 option_2 v2'"
422   def SetAdvancedOption(self, optionsAndValues):
423     self.Parameters().SetAdvancedOption(optionsAndValues)
424     pass
425
426   ## Adds custom advanced option value.
427   #  @param optionName custom advanced option name
428   #  @param level custom advanced option value
429   def AddOption(self, optionName, level):
430     self.Parameters().AddOption(optionName,level)
431     pass
432
433   ## Adds custom advanced PreCAD option value.
434   #  @param optionName custom name of the option
435   #  @param optionValue value of the option
436   def AddPreCADOption(self, optionName, optionValue):
437     self.Parameters().AddPreCADOption(optionName,optionValue)
438     pass
439
440   ## Sets GMF file for export at computation
441   #  @param fileName GMF file name
442   def SetGMFFile(self, fileName):
443     self.Parameters().SetGMFFile(fileName)
444     pass
445
446   #-----------------------------------------
447   # Enforced vertices (BLSURF)
448   #-----------------------------------------
449
450   ## To get all the enforced vertices
451   def GetAllEnforcedVertices(self):
452     return self.Parameters().GetAllEnforcedVertices()
453
454   ## To get all the enforced vertices sorted by face (or group, compound)
455   def GetAllEnforcedVerticesByFace(self):
456     return self.Parameters().GetAllEnforcedVerticesByFace()
457
458   ## To get all the enforced vertices sorted by coords of input vertices
459   def GetAllEnforcedVerticesByCoords(self):
460     return self.Parameters().GetAllEnforcedVerticesByCoords()
461
462   ## To get all the coords of input vertices sorted by face (or group, compound)
463   def GetAllCoordsByFace(self):
464     return self.Parameters().GetAllCoordsByFace()
465
466   ## To get all the enforced vertices on a face (or group, compound)
467   #  @param theFace : GEOM face (or group, compound) on which to define an enforced vertex
468   def GetEnforcedVertices(self, theFace):
469     from salome.smesh.smeshBuilder import AssureGeomPublished
470     AssureGeomPublished( self.mesh, theFace )
471     return self.Parameters().GetEnforcedVertices(theFace)
472
473   ## To clear all the enforced vertices
474   def ClearAllEnforcedVertices(self):
475     return self.Parameters().ClearAllEnforcedVertices()
476
477   ## To set an enforced vertex on a face (or group, compound) given the coordinates of a point. If the point is not on the face, it will projected on it. If there is no projection, no enforced vertex is created.
478   #  @param theFace      : GEOM face (or group, compound) on which to define an enforced vertex
479   #  @param x            : x coordinate
480   #  @param y            : y coordinate
481   #  @param z            : z coordinate
482   #  @param vertexName   : name of the enforced vertex
483   #  @param groupName    : name of the group
484   def SetEnforcedVertex(self, theFace, x, y, z, vertexName = "", groupName = ""):
485     from salome.smesh.smeshBuilder import AssureGeomPublished
486     AssureGeomPublished( self.mesh, theFace )
487     if vertexName == "":
488       if groupName == "":
489         return self.Parameters().SetEnforcedVertex(theFace, x, y, z)
490       else:
491         return self.Parameters().SetEnforcedVertexWithGroup(theFace, x, y, z, groupName)
492       pass
493     else:
494       if groupName == "":
495         return self.Parameters().SetEnforcedVertexNamed(theFace, x, y, z, vertexName)
496       else:
497         return self.Parameters().SetEnforcedVertexNamedWithGroup(theFace, x, y, z, vertexName, groupName)
498       pass
499     pass
500
501   ## To set an enforced vertex on a face (or group, compound) given a GEOM vertex, group or compound.
502   #  @param theFace      : GEOM face (or group, compound) on which to define an enforced vertex
503   #  @param theVertex    : GEOM vertex (or group, compound) to be projected on theFace.
504   #  @param groupName    : name of the group
505   def SetEnforcedVertexGeom(self, theFace, theVertex, groupName = ""):
506     from salome.smesh.smeshBuilder import AssureGeomPublished
507     AssureGeomPublished( self.mesh, theFace )
508     AssureGeomPublished( self.mesh, theVertex )
509     if groupName == "":
510       return self.Parameters().SetEnforcedVertexGeom(theFace, theVertex)
511     else:
512       return self.Parameters().SetEnforcedVertexGeomWithGroup(theFace, theVertex,groupName)
513     pass
514
515   ## Set an enforced vertex on a face given the coordinates of a point.
516   #  The face if found by the application.
517   #  @param x            : x coordinate
518   #  @param y            : y coordinate
519   #  @param z            : z coordinate
520   #  @param vertexName   : name of the enforced vertex
521   #  @param groupName    : name of the group
522   def AddEnforcedVertex(self, x, y, z, vertexName = "", groupName = ""):
523     from salome.smesh.smeshBuilder import AssureGeomPublished
524     if vertexName == "":
525       if groupName == "":
526         return self.Parameters().AddEnforcedVertex(x, y, z)
527       else:
528         return self.Parameters().AddEnforcedVertexWithGroup(x, y, z, groupName)
529       pass
530     else:
531       if groupName == "":
532         return self.Parameters().AddEnforcedVertexNamed(x, y, z, vertexName)
533       else:
534         return self.Parameters().AddEnforcedVertexNamedWithGroup( x, y, z, vertexName, groupName)
535       pass
536     pass
537
538   ## To set an enforced vertex on a face given a GEOM vertex, group or compound.
539   #  The face if found by the application.
540   #  @param theVertex    : GEOM vertex (or group, compound).
541   #  @param groupName    : name of the group
542   def AddEnforcedVertexGeom(self, theVertex, groupName = ""):
543     from salome.smesh.smeshBuilder import AssureGeomPublished
544     AssureGeomPublished( self.mesh, theVertex )
545     if groupName == "":
546       return self.Parameters().AddEnforcedVertexGeom(theVertex)
547     else:
548       return self.Parameters().AddEnforcedVertexGeomWithGroup(theVertex,groupName)
549     pass
550
551   ## To remove an enforced vertex on a given GEOM face (or group, compound) given the coordinates.
552   #  @param theFace      : GEOM face (or group, compound) on which to remove the enforced vertex
553   #  @param x            : x coordinate
554   #  @param y            : y coordinate
555   #  @param z            : z coordinate
556   def UnsetEnforcedVertex(self, theFace, x, y, z):
557     from salome.smesh.smeshBuilder import AssureGeomPublished
558     AssureGeomPublished( self.mesh, theFace )
559     return self.Parameters().UnsetEnforcedVertex(theFace, x, y, z)
560
561   ## To remove an enforced vertex on a given GEOM face (or group, compound) given a GEOM vertex, group or compound.
562   #  @param theFace      : GEOM face (or group, compound) on which to remove the enforced vertex
563   #  @param theVertex    : GEOM vertex (or group, compound) to remove.
564   def UnsetEnforcedVertexGeom(self, theFace, theVertex):
565     from salome.smesh.smeshBuilder import AssureGeomPublished
566     AssureGeomPublished( self.mesh, theFace )
567     AssureGeomPublished( self.mesh, theVertex )
568     return self.Parameters().UnsetEnforcedVertexGeom(theFace, theVertex)
569
570   ## To remove all enforced vertices on a given face.
571   #  @param theFace      : face (or group/compound of faces) on which to remove all enforced vertices
572   def UnsetEnforcedVertices(self, theFace):
573     from salome.smesh.smeshBuilder import AssureGeomPublished
574     AssureGeomPublished( self.mesh, theFace )
575     return self.Parameters().UnsetEnforcedVertices(theFace)
576
577   ## To tell BLSURF to add a node on internal vertices
578   #  @param toEnforceInternalVertices : boolean; if True the internal vertices are added as enforced vertices
579   def SetInternalEnforcedVertexAllFaces(self, toEnforceInternalVertices):
580     return self.Parameters().SetInternalEnforcedVertexAllFaces(toEnforceInternalVertices)
581
582   ## To know if BLSURF will add a node on internal vertices
583   def GetInternalEnforcedVertexAllFaces(self):
584     return self.Parameters().GetInternalEnforcedVertexAllFaces()
585
586   ## To define a group for the nodes of internal vertices
587   #  @param groupName : string; name of the group
588   def SetInternalEnforcedVertexAllFacesGroup(self, groupName):
589     return self.Parameters().SetInternalEnforcedVertexAllFacesGroup(groupName)
590
591   ## To get the group name of the nodes of internal vertices
592   def GetInternalEnforcedVertexAllFacesGroup(self):
593     return self.Parameters().GetInternalEnforcedVertexAllFacesGroup()
594
595   #-----------------------------------------
596   #  Attractors
597   #-----------------------------------------
598
599   ## Sets an attractor on the chosen face. The mesh size will decrease exponentially with the distance from theAttractor, following the rule h(d) = theEndSize - (theEndSize - theStartSize) * exp [ - ( d / theInfluenceDistance ) ^ 2 ]
600   #  @param theFace      : face on which the attractor will be defined
601   #  @param theAttractor : geometrical object from which the mesh size "h" decreases exponentially
602   #  @param theStartSize : mesh size on theAttractor
603   #  @param theEndSize   : maximum size that will be reached on theFace
604   #  @param theInfluenceDistance : influence of the attractor ( the size grow slower on theFace if it's high)
605   #  @param theConstantSizeDistance : distance until which the mesh size will be kept constant on theFace
606   def SetAttractorGeom(self, theFace, theAttractor, theStartSize, theEndSize, theInfluenceDistance, theConstantSizeDistance):
607     from salome.smesh.smeshBuilder import AssureGeomPublished
608     AssureGeomPublished( self.mesh, theFace )
609     AssureGeomPublished( self.mesh, theAttractor )
610     self.Parameters().SetAttractorGeom(theFace, theAttractor, theStartSize, theEndSize, theInfluenceDistance, theConstantSizeDistance)
611     pass
612
613   ## Unsets an attractor on the chosen face.
614   #  @param theFace      : face on which the attractor has to be removed
615   def UnsetAttractorGeom(self, theFace):
616     from salome.smesh.smeshBuilder import AssureGeomPublished
617     AssureGeomPublished( self.mesh, theFace )
618     self.Parameters().SetAttractorGeom(theFace)
619     pass
620
621   #-----------------------------------------
622   # Size maps (BLSURF)
623   #-----------------------------------------
624
625   ## To set a size map on a face, edge or vertex (or group, compound) given Python function.
626   #  If theObject is a face, the function can be: def f(u,v): return u+v
627   #  If theObject is an edge, the function can be: def f(t): return t/2
628   #  If theObject is a vertex, the function can be: def f(): return 10
629   #  @param theObject   : GEOM face, edge or vertex (or group, compound) on which to define a size map
630   #  @param theSizeMap  : Size map defined as a string
631   def SetSizeMap(self, theObject, theSizeMap):
632     from salome.smesh.smeshBuilder import AssureGeomPublished
633     AssureGeomPublished( self.mesh, theObject )
634     self.Parameters().SetSizeMap(theObject, theSizeMap)
635     pass
636
637   ## To set a constant size map on a face, edge or vertex (or group, compound).
638   #  @param theObject   : GEOM face, edge or vertex (or group, compound) on which to define a size map
639   #  @param theSizeMap  : Size map defined as a double
640   def SetConstantSizeMap(self, theObject, theSizeMap):
641     from salome.smesh.smeshBuilder import AssureGeomPublished
642     AssureGeomPublished( self.mesh, theObject )
643     self.Parameters().SetConstantSizeMap(theObject, theSizeMap)
644
645   ## To remove a size map defined on a face, edge or vertex (or group, compound)
646   #  @param theObject   : GEOM face, edge or vertex (or group, compound) on which to define a size map
647   def UnsetSizeMap(self, theObject):
648     from salome.smesh.smeshBuilder import AssureGeomPublished
649     AssureGeomPublished( self.mesh, theObject )
650     self.Parameters().UnsetSizeMap(theObject)
651     pass
652
653   ## To remove all the size maps
654   def ClearSizeMaps(self):
655     self.Parameters().ClearSizeMaps()
656     pass
657
658   ## Sets QuadAllowed flag (DEPRECATED: use SetElementType)
659   #  @param toAllow "allow quadrangles" flag value
660   # TODO: to remove in Salome 9
661   def SetQuadAllowed(self, toAllow=True):
662     self.Parameters().SetQuadAllowed(toAllow)
663     pass
664
665   ## Sets elements type
666   #  @param theElementType: 0 (Triangles), 1 (QuadrangleDominant), 2 (Quadrangles)
667   def SetElementType(self, theElementType=Triangles):
668     self.Parameters().SetElementType(theElementType)
669     pass
670
671   ## Defines hypothesis having several parameters
672   #  @return hypothesis object
673   def Parameters(self):
674     if not self.params:
675       hypType = "MG-CADSurf Parameters"
676       hasGeom = self.mesh.GetMesh().HasShapeToMesh()
677       if hasGeom:
678         self.params = self.Hypothesis(hypType, [], LIBRARY, UseExisting=0)
679       else:
680         self.params = self.Hypothesis(hypType + "_NOGEOM", [], LIBRARY, UseExisting=0)
681         self.mesh.smeshpyD.SetName( self.params, hypType )
682       pass
683     return self.params
684
685   #-----------------------------------------
686   # Periodicity (BLSURF with PreCAD)
687   #-----------------------------------------
688   
689   ## Defines periodicity between two groups of faces, using PreCAD
690   #  @param theFace1 : GEOM face (or group, compound) to associate with theFace2
691   #  @param theFace2 : GEOM face (or group, compound) associated with theFace1
692   #  @param theSourceVertices (optionnal): list of GEOM vertices on theFace1 defining the transformation from theFace1 to theFace2.
693   #    If None, PreCAD tries to find a simple translation. Else, need at least 3 not aligned vertices.
694   #  @param theTargetVertices (optionnal): list of GEOM vertices on theFace2 defining the transformation from theFace1 to theFace2.
695   #    If None, PreCAD tries to find a simple translation. Else, need at least 3 not aligned vertices.
696   def AddPreCadFacesPeriodicity(self, theFace1, theFace2, theSourceVertices=[], theTargetVertices=[]):
697     """calls preCad function:
698     status_t cad_add_face_multiple_periodicity_with_transformation_function(cad t *cad,
699           integer *fid1, integer size1, integer *fid2, integer size2,
700           periodicity_transformation_t transf, void *user data);
701     """
702     if theSourceVertices and theTargetVertices:
703       self.Parameters().AddPreCadFacesPeriodicityWithVertices(theFace1, theFace2, theSourceVertices, theTargetVertices)
704     else:
705       self.Parameters().AddPreCadFacesPeriodicity(theFace1, theFace2)
706     pass
707
708   ## Defines periodicity between two groups of edges, using PreCAD
709   #  @param theEdge1 : GEOM edge (or group, compound) to associate with theEdge2
710   #  @param theEdge2 : GEOM edge (or group, compound) associated with theEdge1
711   #  @param theSourceVertices (optionnal): list of GEOM vertices on theEdge1 defining the transformation from theEdge1 to theEdge2.
712   #    If None, PreCAD tries to find a simple translation. Else, need at least 3 not aligned vertices.
713   #  @param  theTargetVertices (optionnal): list of GEOM vertices on theEdge2 defining the transformation from theEdge1 to theEdge2.
714   #    If None, PreCAD tries to find a simple translation. Else, need at least 3 not aligned vertices.
715   def AddPreCadEdgesPeriodicity(self, theEdge1, theEdge2, theSourceVertices=[], theTargetVertices=[]):
716     """calls preCad function:
717     status_t cad_add_edge_multiple_periodicity_with_transformation_function(cad t *cad,
718           integer *eid1, integer size1, integer *eid2, integer size2,
719           periodicity_transformation_t transf, void *user data);
720     """
721     if theSourceVertices and theTargetVertices:
722         self.Parameters().AddPreCadEdgesPeriodicityWithVertices(theEdge1, theEdge2, theSourceVertices, theTargetVertices)
723     else:
724         self.Parameters().AddPreCadEdgesPeriodicity(theEdge1, theEdge2)
725     pass
726
727   #-----------------------------------------
728   # Hyper-Patches
729   #-----------------------------------------
730   
731   ## Defines hyper-patches. A hyper-patch is a set of adjacent faces meshed as a whole,
732   #  ignoring edges between them
733   #  @param hyperPatchList : list of hyper-patches. A hyper-patch is defined as a list of
734   #         faces or groups of faces. A face can be identified either as a GEOM object or
735   #         a face ID (returned e.g. by geompy.GetSubShapeID( mainShape, subShape )).
736   #         
737   #  Example: cadsurf.SetHyperPatches([[ Face_1, Group_2 ],[ 13, 23 ]])
738   def SetHyperPatches(self, hyperPatchList):
739     hpl = []
740     for patch in hyperPatchList:
741       ids = []
742       for face in patch:
743         if isinstance( face, int ):
744           ids.append( face )
745         elif isinstance( face, GEOM._objref_GEOM_Object):
746           faces = self.mesh.geompyD.SubShapeAll( face, self.mesh.geompyD.ShapeType["FACE"] )
747           for f in faces:
748             ids.append( self.mesh.geompyD.GetSubShapeID( self.mesh.geom, f ))
749         else:
750           raise TypeError("Face of hyper-patch should be either ID or GEOM_Object, not %s" % type(face))
751         pass
752       hpl.append( ids )
753       pass
754     self.Parameters().SetHyperPatches( hpl )
755     return
756
757   #=====================
758   # Obsolete methods
759   #=====================
760   #
761   # SALOME 6.6.0
762   #
763
764   ## Sets lower boundary of mesh element size (PhySize).
765   def SetPhyMin(self, theVal=-1):
766     """
767     Obsolete function. Use SetMinSize.
768     """
769     print("Warning: SetPhyMin is obsolete. Please use SetMinSize")
770     self.SetMinSize(theVal)
771     pass
772
773   ## Sets upper boundary of mesh element size (PhySize).
774   def SetPhyMax(self, theVal=-1):
775     """
776     Obsolete function. Use SetMaxSize.
777     """
778     print("Warning: SetPhyMax is obsolete. Please use SetMaxSize")
779     self.SetMaxSize(theVal)
780     pass
781
782   ## Sets angular deflection (in degrees) of a mesh face from CAD surface.
783   def SetAngleMeshS(self, theVal=_geometric_approximation):
784     """
785     Obsolete function. Use SetAngleMesh.
786     """
787     print("Warning: SetAngleMeshS is obsolete. Please use SetAngleMesh")
788     self.SetAngleMesh(theVal)
789     pass
790
791   ## Sets angular deflection (in degrees) of a mesh edge from CAD curve.
792   def SetAngleMeshC(self, theVal=_geometric_approximation):
793     """
794     Obsolete function. Use SetAngleMesh.
795     """
796     print("Warning: SetAngleMeshC is obsolete. Please use SetAngleMesh")
797     self.SetAngleMesh(theVal)
798     pass
799
800   ## Sets lower boundary of mesh element size computed to respect angular deflection.
801   def SetGeoMin(self, theVal=-1):
802     """
803     Obsolete function. Use SetMinSize.
804     """
805     print("Warning: SetGeoMin is obsolete. Please use SetMinSize")
806     self.SetMinSize(theVal)
807     pass
808
809   ## Sets upper boundary of mesh element size computed to respect angular deflection.
810   def SetGeoMax(self, theVal=-1):
811     """
812     Obsolete function. Use SetMaxSize.
813     """
814     print("Warning: SetGeoMax is obsolete. Please use SetMaxSize")
815     self.SetMaxSize(theVal)
816     pass
817
818
819   pass # end of BLSURF_Algorithm class