Merge branch 'gni/evolution' of https://codev-tuleap.cea.fr/plugins/git/salome/smesh into gni/evolution

src/Tools/blocFissure/CasTests/cubeAngle.py

@@ -62,7 +62,8 @@ class cubeAngle(fissureGenerique):
                                    rayonPipe   = 10)
 
   # ---------------------------------------------------------------------------
-  def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams):
+  def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams, \
+                                mailleur="MeshGems"):
     """Importe la géométrie de la fissure"""
     texte = "genereShapeFissure pour '{}'".format(self.nomCas)
     logging.info(texte)
@@ -75,8 +76,8 @@ class cubeAngle(fissureGenerique):
     geompy.addToStudy( shellFiss, 'shellFiss' )
     geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' )
 
-
+    mailleur = self.mailleur2d3d()
-    coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,10)
+    coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,10, mailleur)
 
     centre = None
 
@@ -101,12 +102,16 @@ class cubeAngle(fissureGenerique):
   # ---------------------------------------------------------------------------
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                                   shapesFissure, shapeFissureParams,
-                            maillageFissureParams, elementsDefaut, step):
+                                  maillageFissureParams, elementsDefaut, step, \
+                                  mailleur="MeshGems"):
     texte = "genereMaillageFissure pour '{}'".format(self.nomCas)
     logging.info(texte)
+
+    mailleur = self.mailleur2d3d()
     maillageFissure = construitFissureGenerale(maillagesSains,
                                                shapesFissure, shapeFissureParams,
-                                               maillageFissureParams, elementsDefaut, step)
+                                               maillageFissureParams, elementsDefaut, step, \
+                                               mailleur)
     return maillageFissure
 
   # ---------------------------------------------------------------------------

src/Tools/blocFissure/CasTests/cylindre.py

@@ -64,7 +64,8 @@ class cylindre(fissureGenerique):
                                    rayonPipe   = 5)
 
   # ---------------------------------------------------------------------------
-  def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams):
+  def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams, \
+                                mailleur="MeshGems"):
     logging.info("genereShapeFissure %s", self.nomCas)
 
     lgInfluence = shapeFissureParams['lgInfluence']
@@ -75,8 +76,8 @@ class cylindre(fissureGenerique):
     geompy.addToStudy( shellFiss, 'shellFiss' )
     geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' )
 
-
+    mailleur = self.mailleur2d3d()
-    coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,15)
+    coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,15, mailleur)
 
     centre = None
     return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss]
@@ -98,10 +99,14 @@ class cylindre(fissureGenerique):
   # ---------------------------------------------------------------------------
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                             shapesFissure, shapeFissureParams,
-                            maillageFissureParams, elementsDefaut, step):
+                            maillageFissureParams, elementsDefaut, step, \
+                                  mailleur="MeshGems"):
+
+    mailleur = self.mailleur2d3d()
     maillageFissure = construitFissureGenerale(maillagesSains,
                                                shapesFissure, shapeFissureParams,
-                                               maillageFissureParams, elementsDefaut, step)
+                                               maillageFissureParams, elementsDefaut, step, \
+                                               mailleur)
     return maillageFissure
 
   # ---------------------------------------------------------------------------

src/Tools/blocFissure/CasTests/cylindre_2.py

@@ -39,7 +39,8 @@ class cylindre_2(cylindre):
   nomProbleme = "cylindre2"
 
   # ---------------------------------------------------------------------------
-  def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams):
+  def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams, \
+                                mailleur="MeshGems"):
     logging.info("genereShapeFissure %s", self.nomCas)
 
     lgInfluence = shapeFissureParams['lgInfluence']
@@ -50,8 +51,8 @@ class cylindre_2(cylindre):
     geompy.addToStudy( shellFiss, 'shellFiss' )
     geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' )
 
-
+    mailleur = self.mailleur2d3d()
-    coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,15)
+    coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,15, mailleur)
 
     centre = None
     return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss]

src/Tools/blocFissure/CasTests/ellipse_1.py

@@ -70,7 +70,8 @@ class ellipse_1(fissureGenerique):
                                    rayonPipe   = 20)
 
   # ---------------------------------------------------------------------------
-  def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams):
+  def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams, \
+                                mailleur="MeshGems"):
     """Importe la géométrie de la fissure"""
     texte = "genereShapeFissure pour '{}'".format(self.nomCas)
     logging.info(texte)
@@ -83,7 +84,8 @@ class ellipse_1(fissureGenerique):
     geompy.addToStudy( shellFiss, 'shellFiss' )
     geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' )
 
-    coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,25)
+    mailleur = self.mailleur2d3d()
+    coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,25, mailleur)
 
     centre = None
 
@@ -108,12 +110,17 @@ class ellipse_1(fissureGenerique):
   # ---------------------------------------------------------------------------
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                             shapesFissure, shapeFissureParams,
-                            maillageFissureParams, elementsDefaut, step):
+                            maillageFissureParams, elementsDefaut, step, \
+                                  mailleur="MeshGems"):
+
     texte = "genereMaillageFissure pour '{}'".format(self.nomCas)
     logging.info(texte)
+
+    mailleur = self.mailleur2d3d()
     maillageFissure = construitFissureGenerale(maillagesSains,
                                                shapesFissure, shapeFissureParams,
-                                               maillageFissureParams, elementsDefaut, step)
+                                               maillageFissureParams, elementsDefaut, step, \
+                                               mailleur)
     return maillageFissure
 
   # ---------------------------------------------------------------------------

src/Tools/blocFissure/CasTests/ellipse_2.py

@@ -25,10 +25,7 @@ import logging
 
 from blocFissure import gmu
 from blocFissure.gmu.geomsmesh import geompy, smesh
-from blocFissure.gmu.fissureGenerique import fissureGenerique
 from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
-from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
-from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale
 
 import GEOM
 import SALOMEDS
@@ -42,7 +39,8 @@ class ellipse_2(ellipse_1):
   nomProbleme = "ellipse2"
 
   # ---------------------------------------------------------------------------
-  def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams):
+  def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams, \
+                                mailleur="MeshGems"):
     """Importe la géométrie de la fissure"""
     texte = "genereShapeFissure pour '{}'".format(self.nomCas)
     logging.info(texte)
@@ -55,7 +53,8 @@ class ellipse_2(ellipse_1):
     geompy.addToStudy( shellFiss, 'shellFiss' )
     geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' )
 
-    coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,25)
+    mailleur = self.mailleur2d3d()
+    coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,25, mailleur)
 
     centre = None
 

src/Tools/blocFissure/CasTests/eprouvetteCourbe.py

@@ -64,7 +64,8 @@ class eprouvetteCourbe(fissureGenerique):
                                    rayonPipe   = 10)
 
   # ---------------------------------------------------------------------------
-  def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams):
+  def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams, \
+                                mailleur="MeshGems"):
     """Importe la géométrie de la fissure"""
     texte = "genereShapeFissure pour '{}'".format(self.nomCas)
     logging.info(texte)
@@ -77,7 +78,8 @@ class eprouvetteCourbe(fissureGenerique):
     geompy.addToStudy( shellFiss, 'shellFiss' )
     geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' )
 
-    coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,10)
+    mailleur = self.mailleur2d3d()
+    coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,10, mailleur)
 
     centre = None
 
@@ -102,12 +104,17 @@ class eprouvetteCourbe(fissureGenerique):
   # ---------------------------------------------------------------------------
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                             shapesFissure, shapeFissureParams,
-                            maillageFissureParams, elementsDefaut, step):
+                            maillageFissureParams, elementsDefaut, step, \
+                                  mailleur="MeshGems"):
+
     texte = "genereMaillageFissure pour '{}'".format(self.nomCas)
     logging.info(texte)
+
+    mailleur = self.mailleur2d3d()
     maillageFissure = construitFissureGenerale(maillagesSains,
                                                shapesFissure, shapeFissureParams,
-                                               maillageFissureParams, elementsDefaut, step)
+                                               maillageFissureParams, elementsDefaut, step, \
+                                               mailleur)
     return maillageFissure
 
   # ---------------------------------------------------------------------------

src/Tools/blocFissure/CasTests/eprouvetteDroite.py

@@ -22,8 +22,6 @@ import os
 from blocFissure import gmu
 from blocFissure.gmu.geomsmesh import geompy, smesh
 
-import os
-import math
 import GEOM
 import SALOMEDS
 import SMESH
@@ -52,7 +50,7 @@ class eprouvetteDroite(fissureGenerique):
   def genereMaillageSain(self, geometriesSaines, meshParams):
     logging.info("genereMaillageSain %s", self.nomCas)
 
-    ([objetSain], status) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests", "eprouvetteDroite.med"))
+    ([objetSain], _) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests", "eprouvetteDroite.med"))
     smesh.SetName(objetSain.GetMesh(), 'objetSain')
 
     return [objetSain, True] # True : maillage hexa
@@ -72,7 +70,8 @@ class eprouvetteDroite(fissureGenerique):
                                    lenSegPipe  = 6)
 
   # ---------------------------------------------------------------------------
-  def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams):
+  def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams, \
+                                mailleur="MeshGems"):
     logging.info("genereShapeFissure %s", self.nomCas)
 
     lgInfluence = shapeFissureParams['lgInfluence']
@@ -83,8 +82,8 @@ class eprouvetteDroite(fissureGenerique):
     geompy.addToStudy( shellFiss, 'shellFiss' )
     geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' )
 
-
+    mailleur = self.mailleur2d3d()
-    coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,10)
+    coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,10, mailleur)
 
     centre = None
     return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss]
@@ -106,10 +105,14 @@ class eprouvetteDroite(fissureGenerique):
   # ---------------------------------------------------------------------------
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                             shapesFissure, shapeFissureParams,
-                            maillageFissureParams, elementsDefaut, step):
+                            maillageFissureParams, elementsDefaut, step, \
+                                  mailleur="MeshGems"):
+
+    mailleur = self.mailleur2d3d()
     maillageFissure = construitFissureGenerale(maillagesSains,
                                                shapesFissure, shapeFissureParams,
-                                               maillageFissureParams, elementsDefaut, step)
+                                               maillageFissureParams, elementsDefaut, step, \
+                                               mailleur)
     return maillageFissure
 
   # ---------------------------------------------------------------------------

src/Tools/blocFissure/CasTests/eprouvetteDroite_2.py

@@ -35,8 +35,6 @@ from .eprouvetteDroite import eprouvetteDroite
 
 from blocFissure.gmu.triedreBase import triedreBase
 from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
-from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
-from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale
 
 O, OX, OY, OZ = triedreBase()
 
@@ -46,7 +44,8 @@ class eprouvetteDroite_2(eprouvetteDroite):
   nomProbleme = "eprouvetteDroite_2"
 
   # ---------------------------------------------------------------------------
-  def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams):
+  def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams, \
+                                mailleur="MeshGems"):
     logging.info("genereShapeFissure %s", self.nomCas)
 
     lgInfluence = shapeFissureParams['lgInfluence']
@@ -57,8 +56,8 @@ class eprouvetteDroite_2(eprouvetteDroite):
     geompy.addToStudy( shellFiss, 'shellFiss' )
     geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' )
 
-
+    mailleur = self.mailleur2d3d()
-    coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,10)
+    coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,10, mailleur)
 
     centre = None
     return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss]

src/Tools/blocFissure/CasTests/faceGauche.py

@@ -68,7 +68,8 @@ class faceGauche(fissureGenerique):
                                    rayonPipe   = 20)
 
   # ---------------------------------------------------------------------------
-  def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams):
+  def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams, \
+                                mailleur="MeshGems"):
     logging.info("genereShapeFissure %s", self.nomCas)
 
     lgInfluence = shapeFissureParams['lgInfluence']
@@ -79,8 +80,8 @@ class faceGauche(fissureGenerique):
     geompy.addToStudy( shellFiss, 'shellFiss' )
     geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' )
 
-
+    mailleur = self.mailleur2d3d()
-    coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,50)
+    coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,50, mailleur)
 
     centre = None
     return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss]
@@ -102,10 +103,14 @@ class faceGauche(fissureGenerique):
   # ---------------------------------------------------------------------------
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                             shapesFissure, shapeFissureParams,
-                            maillageFissureParams, elementsDefaut, step):
+                            maillageFissureParams, elementsDefaut, step, \
+                                  mailleur="MeshGems"):
+
+    mailleur = self.mailleur2d3d()
     maillageFissure = construitFissureGenerale(maillagesSains,
                                                shapesFissure, shapeFissureParams,
-                                               maillageFissureParams, elementsDefaut, step)
+                                               maillageFissureParams, elementsDefaut, step, \
+                                               mailleur)
     return maillageFissure
 
   # ---------------------------------------------------------------------------

src/Tools/blocFissure/CasTests/faceGauche_2.py

@@ -22,7 +22,6 @@ import os
 from blocFissure import gmu
 from blocFissure.gmu.geomsmesh import geompy, smesh
 
-import math
 import GEOM
 import SALOMEDS
 import SMESH
@@ -50,7 +49,7 @@ class faceGauche_2(fissureGenerique):
   def genereMaillageSain(self, geometriesSaines, meshParams):
     logging.info("genereMaillageSain %s", self.nomCas)
 
-    ([objetSain], status) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests", "boiteSaine.med"))
+    ([objetSain], _) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests", "boiteSaine.med"))
     smesh.SetName(objetSain.GetMesh(), 'objetSain')
 
     return [objetSain, True] # True : maillage hexa
@@ -69,7 +68,8 @@ class faceGauche_2(fissureGenerique):
                                    rayonPipe   = 20)
 
   # ---------------------------------------------------------------------------
-  def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams):
+  def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams, \
+                                mailleur="MeshGems"):
     logging.info("genereShapeFissure %s", self.nomCas)
 
     lgInfluence = shapeFissureParams['lgInfluence']
@@ -80,7 +80,8 @@ class faceGauche_2(fissureGenerique):
     geompy.addToStudy( shellFiss, 'shellFiss' )
     geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' )
 
-    coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,25)
+    mailleur = self.mailleur2d3d()
+    coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,25, mailleur)
 
     centre = None
     return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss]
@@ -102,10 +103,14 @@ class faceGauche_2(fissureGenerique):
   # ---------------------------------------------------------------------------
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                             shapesFissure, shapeFissureParams,
-                            maillageFissureParams, elementsDefaut, step):
+                            maillageFissureParams, elementsDefaut, step, \
+                                  mailleur="MeshGems"):
+
+    mailleur = self.mailleur2d3d()
     maillageFissure = construitFissureGenerale(maillagesSains,
                                                shapesFissure, shapeFissureParams,
-                                               maillageFissureParams, elementsDefaut, step)
+                                               maillageFissureParams, elementsDefaut, step, \
+                                               mailleur)
     return maillageFissure
 
   # ---------------------------------------------------------------------------

src/Tools/blocFissure/CasTests/fissure_Coude.py

@@ -258,14 +258,14 @@ class fissure_Coude(fissureGenerique):
     smesh.SetName(algo1d_long_p2, "algo1d_long_p2")
     smesh.SetName(hypo1d_long_p2, "hypo1d_long_p2")
 
-    mp1 = maillageSain.GroupOnGeom(P1,'P1',SMESH.NODE)
+    _ = maillageSain.GroupOnGeom(P1,'P1',SMESH.NODE)
-    mp2 = maillageSain.GroupOnGeom(P2,'P2',SMESH.NODE)
+    _ = maillageSain.GroupOnGeom(P2,'P2',SMESH.NODE)
-    ext = maillageSain.GroupOnGeom(EXTUBE,'EXTUBE',SMESH.FACE)
+    _ = maillageSain.GroupOnGeom(EXTUBE,'EXTUBE',SMESH.FACE)
-    btu = maillageSain.GroupOnGeom(BORDTU,'BORDTU',SMESH.EDGE)
+    _ = maillageSain.GroupOnGeom(BORDTU,'BORDTU',SMESH.EDGE)
-    clg = maillageSain.GroupOnGeom(CLGV,'CLGV',SMESH.FACE)
+    _ = maillageSain.GroupOnGeom(CLGV,'CLGV',SMESH.FACE)
-    pei = maillageSain.GroupOnGeom(PEAUINT,'PEAUINT',SMESH.FACE)
+    _ = maillageSain.GroupOnGeom(PEAUINT,'PEAUINT',SMESH.FACE)
-    pex = maillageSain.GroupOnGeom(PEAUEXT,'PEAUEXT',SMESH.FACE)
+    _ = maillageSain.GroupOnGeom(PEAUEXT,'PEAUEXT',SMESH.FACE)
-    cou = maillageSain.GroupOnGeom(COUDE,'COUDSAIN',SMESH.VOLUME)
+    _ = maillageSain.GroupOnGeom(COUDE,'COUDSAIN',SMESH.VOLUME)
 
     isDone = maillageSain.Compute()
 
@@ -294,7 +294,8 @@ class fissure_Coude(fissureGenerique):
                                    externe     = True)
 
   # ---------------------------------------------------------------------------
-  def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams):
+  def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams, \
+                                mailleur="MeshGems"):
     logging.info("genereShapeFissure %s", self.nomCas)
     logging.info("shapeFissureParams %s", shapeFissureParams)
 
@@ -473,7 +474,8 @@ class fissure_Coude(fissureGenerique):
     else:
       pass
 
-    coordsNoeudsFissure = genereMeshCalculZoneDefaut(facefiss, 5 ,10)
+    mailleur = self.mailleur2d3d()
+    coordsNoeudsFissure = genereMeshCalculZoneDefaut(facefiss, 5 ,10, mailleur)
 
     return [facefiss, centre, lgInfluence, coordsNoeudsFissure, wiretube, facetubel, facetuber, planfiss, pipefiss]
 
@@ -498,10 +500,14 @@ class fissure_Coude(fissureGenerique):
   # ---------------------------------------------------------------------------
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                             shapesFissure, shapeFissureParams,
-                            maillageFissureParams, elementsDefaut, step):
+                            maillageFissureParams, elementsDefaut, step, \
+                                  mailleur="MeshGems"):
+
+    mailleur = self.mailleur2d3d()
     maillageFissure = insereFissureLongue(geometriesSaines, maillagesSains,
                                           shapesFissure, shapeFissureParams,
-                                          maillageFissureParams, elementsDefaut, step)
+                                          maillageFissureParams, elementsDefaut, step, \
+                                               mailleur)
     return maillageFissure
 
   # ---------------------------------------------------------------------------

src/Tools/blocFissure/CasTests/tube.py

@@ -62,7 +62,8 @@ class tube(fissureGenerique):
                                    rayonPipe   = 0.05)
 
   # ---------------------------------------------------------------------------
-  def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams):
+  def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams, \
+                                mailleur="MeshGems"):
     """Importe la géométrie de la fissure"""
     texte = "genereShapeFissure pour '{}'".format(self.nomCas)
     logging.info(texte)
@@ -79,7 +80,8 @@ class tube(fissureGenerique):
     geompy.addToStudy( shellFiss, 'shellFiss' )
     geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' )
 
-    coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 0.025, 0.1)
+    mailleur = self.mailleur2d3d()
+    coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 0.025, 0.1, mailleur)
 
     centre = None
 
@@ -104,12 +106,17 @@ class tube(fissureGenerique):
   # ---------------------------------------------------------------------------
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                             shapesFissure, shapeFissureParams,
-                            maillageFissureParams, elementsDefaut, step):
+                            maillageFissureParams, elementsDefaut, step, \
+                                  mailleur="MeshGems"):
+
     texte = "genereMaillageFissure pour '{}'".format(self.nomCas)
     logging.info(texte)
+
+    mailleur = self.mailleur2d3d()
     maillageFissure = construitFissureGenerale(maillagesSains,
                                                shapesFissure, shapeFissureParams,
-                                               maillageFissureParams, elementsDefaut, step)
+                                               maillageFissureParams, elementsDefaut, step, \
+                                               mailleur)
     return maillageFissure
 
   # ---------------------------------------------------------------------------

src/Tools/blocFissure/CasTests/vis_1.py

@@ -70,7 +70,8 @@ class vis_1(fissureGenerique):
                                    rayonPipe   = 0.1)
 
   # ---------------------------------------------------------------------------
-  def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams):
+  def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams, \
+                                mailleur="MeshGems"):
     """Importe la géométrie de la fissure et crée le groupe du fond de la fissure"""
     texte = "genereShapeFissure pour '{}'".format(self.nomCas)
     logging.info(texte)
@@ -83,7 +84,8 @@ class vis_1(fissureGenerique):
     geompy.addToStudy( shellFiss, 'shellFiss' )
     geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' )
 
-    coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 0.1 ,0.2)
+    mailleur = self.mailleur2d3d()
+    coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 0.1 ,0.2, mailleur)
 
     centre = None
 
@@ -108,12 +110,17 @@ class vis_1(fissureGenerique):
   # ---------------------------------------------------------------------------
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                             shapesFissure, shapeFissureParams,
-                            maillageFissureParams, elementsDefaut, step):
+                            maillageFissureParams, elementsDefaut, step, \
+                                  mailleur="MeshGems"):
+
     texte = "genereMaillageFissure pour '{}'".format(self.nomCas)
     logging.info(texte)
+
+    mailleur = self.mailleur2d3d()
     maillageFissure = construitFissureGenerale(maillagesSains,
                                                shapesFissure, shapeFissureParams,
-                                               maillageFissureParams, elementsDefaut, step)
+                                               maillageFissureParams, elementsDefaut, step, \
+                                               mailleur)
     return maillageFissure
 
   # ---------------------------------------------------------------------------

src/Tools/blocFissure/gmu/casStandard.py

@@ -116,8 +116,8 @@ class casStandard(fissureGenerique):
                                      lenSegPipe  = self.lenSegPipe)
 
   # ---------------------------------------------------------------------------
-  def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams):
+  def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams, \
-    logging.info("genereShapeFissure %s", self.nomCas)
+                                mailleur="MeshGems"):
 
     lgInfluence = shapeFissureParams['lgInfluence']
 
@@ -147,7 +147,8 @@ class casStandard(fissureGenerique):
     geomPublishInFather(initLog.debug, shellFiss, fondFiss, 'fondFiss' )
 
 
-    coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, self.dicoParams['meshBrep'][0] ,self.dicoParams['meshBrep'][1])
+    coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, self.dicoParams['meshBrep'][0] ,self.dicoParams['meshBrep'][1], \
+                                                     mailleur)
 
     centre = None
     return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss]
@@ -168,12 +169,14 @@ class casStandard(fissureGenerique):
     return elementsDefaut
 
   # ---------------------------------------------------------------------------
-  def genereMaillageFissure(self, geometriesSaines, maillagesSains,
+  def genereMaillageFissure(self, geometriesSaines, maillagesSains, \
-                            shapesFissure, shapeFissureParams,
+                                  shapesFissure, shapeFissureParams, \
-                            maillageFissureParams, elementsDefaut, step):
+                                  maillageFissureParams, elementsDefaut, step, \
+                                  mailleur="MeshGems"):
     maillageFissure = construitFissureGenerale(maillagesSains, \
                                                shapesFissure, shapeFissureParams, \
-                                              maillageFissureParams, elementsDefaut, step)
+                                               maillageFissureParams, elementsDefaut, \
+                                               step, mailleur)
     return maillageFissure
 
   # ---------------------------------------------------------------------------

src/Tools/blocFissure/gmu/construitFissureGenerale.py

@@ -77,13 +77,15 @@ from .fissError import fissError
 # -----------------------------------------------------------------------------
 # --- procédure complète fissure générale
 
-def construitFissureGenerale(maillagesSains,
+def construitFissureGenerale(maillagesSains, \
-                             shapesFissure, shapeFissureParams,
+                             shapesFissure, shapeFissureParams, \
-                             maillageFissureParams, elementsDefaut, step=-1):
+                             maillageFissureParams, elementsDefaut, \
+                             step=-1, mailleur="MeshGems"):
   """
   TODO: a completer
   """
   logging.info('start')
+  logging.info(mailleur)
 
   shapeDefaut       = shapesFissure[0] # faces de fissure, débordant
   fondFiss          = shapesFissure[4] # groupe d'edges de fond de fissure
@@ -277,16 +279,19 @@ def construitFissureGenerale(maillagesSains,
 
   # --- maillage faces de fissure
 
-  (meshFaceFiss, grpFaceFissureExterne,
+  (meshFaceFiss, grpFaceFissureExterne, grpEdgesPeauFissureExterne, grpEdgesPipeFissureExterne) = \
-   grpEdgesPeauFissureExterne, grpEdgesPipeFissureExterne) = mailleFacesFissure(faceFissureExterne, edgesPipeFissureExterneC, edgesPeauFissureExterneC,
+      mailleFacesFissure(faceFissureExterne, \
-                                                                                meshPipeGroups, areteFaceFissure, rayonPipe, nbsegRad)
+                         edgesPipeFissureExterneC, edgesPeauFissureExterneC, \
+                         meshPipeGroups, areteFaceFissure, rayonPipe, nbsegRad, \
+                         mailleur)
 
   # --- maillage faces de peau
 
-  meshesFacesPeau = mailleFacesPeau(partitionsPeauFissFond, idFillingFromBout, facesDefaut,
+  meshesFacesPeau = mailleFacesPeau(partitionsPeauFissFond, idFillingFromBout, facesDefaut, \
-                                    facesPeaux, edCircPeau, ptCircPeau, gpedgeBord, gpedgeVifs, edFissPeau,
+                                    facesPeaux, edCircPeau, ptCircPeau, gpedgeBord, gpedgeVifs, edFissPeau, \
-                                    bordsLibres, grpEdgesPeauFissureExterne, grpAretesVives,
+                                    bordsLibres, grpEdgesPeauFissureExterne, grpAretesVives, \
-                                    edgesCircPipeGroup, dmoyen, rayonPipe, nbsegRad)
+                                    edgesCircPipeGroup, dmoyen, rayonPipe, nbsegRad, \
+                                    mailleur)
 
   # --- regroupement des maillages du défaut
 
@@ -309,13 +314,17 @@ def construitFissureGenerale(maillagesSains,
       elif grp.GetName() == "fisInPi":
         group_faceFissInPipe = grp
 
-  # le maillage NETGEN ne passe pas toujours ==> utiliser GHS3D
+  # le maillage NETGEN ne passe pas toujours ==> on force l'usage de MG_Tetra
-  distene=True
+  mailleur = "MeshGems"
-  if distene:
+  logging.info("Maillage avec %s", mailleur)
-    algo3d = meshBoiteDefaut.Tetrahedron(algo=smeshBuilder.GHS3D)
+  if ( mailleur == "MeshGems"):
+    algo3d = meshBoiteDefaut.Tetrahedron(algo=smeshBuilder.MG_Tetra)
   else:
     algo3d = meshBoiteDefaut.Tetrahedron(algo=smeshBuilder.NETGEN)
     hypo3d = algo3d.MaxElementVolume(1000.0)
+    hypo3d.SetVerboseLevel( 0 )
+    hypo3d.SetStandardOutputLog( 0 )
+    hypo3d.SetRemoveLogOnSuccess( 1 )
   putName(algo3d.GetSubMesh(), "boiteDefaut")
   putName(algo3d, "algo3d_boiteDefaut")
   putName(meshBoiteDefaut, "boiteDefaut")

src/Tools/blocFissure/gmu/fissureCoude.py

@@ -29,9 +29,6 @@ import math
 import GEOM
 import SALOMEDS
 import SMESH
-#import StdMeshers
-#import GHS3DPlugin
-#import NETGENPlugin
 import logging
 
 from .fissureGenerique import fissureGenerique
@@ -72,6 +69,7 @@ class fissureCoude(fissureGenerique):
 
   # ---------------------------------------------------------------------------
   def genereGeometrieSaine(self, geomParams):
+    """a écrire"""
     logging.info("genereGeometrieSaine %s", self.nomCas)
 
     angleCoude = geomParams['angleCoude']
@@ -304,14 +302,14 @@ class fissureCoude(fissureGenerique):
       logging.info(text)
       raise Exception(text)
 
-    mp1 = maillageSain.GroupOnGeom(P1,'P1',SMESH.NODE)
+    _ = maillageSain.GroupOnGeom(P1,'P1',SMESH.NODE)
-    mp2 = maillageSain.GroupOnGeom(P2,'P2',SMESH.NODE)
+    _ = maillageSain.GroupOnGeom(P2,'P2',SMESH.NODE)
-    ext = maillageSain.GroupOnGeom(EXTUBE,'EXTUBE',SMESH.FACE)
+    _ = maillageSain.GroupOnGeom(EXTUBE,'EXTUBE',SMESH.FACE)
-    btu = maillageSain.GroupOnGeom(BORDTU,'BORDTU',SMESH.EDGE)
+    _ = maillageSain.GroupOnGeom(BORDTU,'BORDTU',SMESH.EDGE)
-    clg = maillageSain.GroupOnGeom(CLGV,'CLGV',SMESH.FACE)
+    _ = maillageSain.GroupOnGeom(CLGV,'CLGV',SMESH.FACE)
-    pei = maillageSain.GroupOnGeom(PEAUINT,'PEAUINT',SMESH.FACE)
+    _ = maillageSain.GroupOnGeom(PEAUINT,'PEAUINT',SMESH.FACE)
-    pex = maillageSain.GroupOnGeom(PEAUEXT,'PEAUEXT',SMESH.FACE)
+    _ = maillageSain.GroupOnGeom(PEAUEXT,'PEAUEXT',SMESH.FACE)
-    cou = maillageSain.GroupOnGeom(COUDE,'COUDSAIN',SMESH.VOLUME)
+    _ = maillageSain.GroupOnGeom(COUDE,'COUDSAIN',SMESH.VOLUME)
 
     return [maillageSain, True] # True : maillage hexa
 
@@ -344,7 +342,8 @@ class fissureCoude(fissureGenerique):
                                    externe     = True)
 
   # ---------------------------------------------------------------------------
-  def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams):
+  def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams, \
+                                mailleur="MeshGems"):
     logging.info("genereShapeFissure %s", self.nomCas)
     logging.info("shapeFissureParams %s", shapeFissureParams)
 
@@ -652,7 +651,8 @@ class fissureCoude(fissureGenerique):
       centre = geompy.MakeRotation(pc, axe, alfrd)
       geomPublish(initLog.debug,  centre, 'centrefissPlace' )
 
-    coordsNoeudsFissure = genereMeshCalculZoneDefaut(facefiss, profondeur/2. ,profondeur)
+    coordsNoeudsFissure = genereMeshCalculZoneDefaut(facefiss, profondeur/2. ,profondeur, \
+                                                     mailleur)
 
     return [facefiss, centre, lgInfluence, coordsNoeudsFissure, wiretube, edgetube]
 
@@ -678,12 +678,14 @@ class fissureCoude(fissureGenerique):
     return elementsDefaut
 
   # ---------------------------------------------------------------------------
-  def genereMaillageFissure(self, geometriesSaines, maillagesSains,
+  def genereMaillageFissure(self, geometriesSaines, maillagesSains, \
-                            shapesFissure, shapeFissureParams,
+                            shapesFissure, shapeFissureParams, \
-                            maillageFissureParams, elementsDefaut, step):
+                            maillageFissureParams, elementsDefaut, step, \
-    maillageFissure = construitFissureGenerale(maillagesSains,
+                            mailleur="MeshGems"):
-                                               shapesFissure, shapeFissureParams,
+    maillageFissure = construitFissureGenerale(maillagesSains, \
-                                               maillageFissureParams, elementsDefaut, step)
+                                               shapesFissure, shapeFissureParams, \
+                                               maillageFissureParams, elementsDefaut, \
+                                               step, mailleur)
     return maillageFissure
 
   # ---------------------------------------------------------------------------
@@ -696,4 +698,3 @@ class fissureCoude(fissureGenerique):
                                           Entity_Quad_Hexa       = 8994,
                                           Entity_Quad_Penta      = 972,
                                           Entity_Quad_Pyramid    = 1038)
-

src/Tools/blocFissure/gmu/fissureGenerique.py

@@ -63,7 +63,7 @@ class fissureGenerique(object):
     """setParamShapeFissure"""
     self.shapeFissureParams = dict()
 
-  def genereShapeFissure(self, geometriesSaines, geomParams, shapeFissureParams):
+  def genereShapeFissure(self, geometriesSaines, geomParams, shapeFissureParams, mailleur="MeshGems"):
     """genereShapeFissure"""
     shapesFissure = [None]
     return shapesFissure
@@ -77,8 +77,10 @@ class fissureGenerique(object):
     elementsDefaut = [None]
     return elementsDefaut
 
-  def genereMaillageFissure(self, geometriesSaines, maillagesSains, shapesFissure,
+  def genereMaillageFissure(self, geometriesSaines, maillagesSains, \
-                            maillageFissureParams, elementsDefaut):
+                                  shapesFissure, maillageFissureParams, \
+                                  elementsDefaut, \
+                                  mailleur="MeshGems"):
     """genereMaillageFissure"""
     maillageFissure = None
     return maillageFissure
@@ -88,6 +90,12 @@ class fissureGenerique(object):
     referencesMaillageFissure = dict()
     return referencesMaillageFissure
 
+  def mailleur2d3d(self):
+    """Le mailleur : NETGEN ou MeshGems"""
+    #mailleur = "MeshGems"
+    mailleur = "NETGEN"
+    return mailleur
+
 # ---------------------------------------------------------------------------
 
   def executeProbleme(self, step=-1):
@@ -101,26 +109,33 @@ class fissureGenerique(object):
     geometriesSaines = self.genereGeometrieSaine(self.geomParams)
     if step == 1:
       return
+    logging.info("AAAAAAAAAAAAAAAAAAAA")
 
     self.setParamMaillageSain()
     maillagesSains = self.genereMaillageSain(geometriesSaines, self.meshParams)
     if step == 2:
       return
+    logging.info("BBBBBBBBBBBBBBBBBBBBB")
 
     self.setParamShapeFissure()
-    shapesFissure = self.genereShapeFissure(geometriesSaines, self.geomParams, self.shapeFissureParams)
+    mailleur = self.mailleur2d3d()
+    shapesFissure = self.genereShapeFissure(geometriesSaines, self.geomParams, self.shapeFissureParams, mailleur)
     if step == 3:
       return
+    logging.info("CCCCCCCCCCCCCCCCCCCCCCCC")
 
     self.setParamMaillageFissure()
-    elementsDefaut = self.genereZoneDefaut(geometriesSaines, maillagesSains, shapesFissure, self.shapeFissureParams, self.maillageFissureParams)
+    elementsDefaut = self.genereZoneDefaut(geometriesSaines, maillagesSains, \
+                                           shapesFissure, self.shapeFissureParams, self.maillageFissureParams)
     if step == 4:
       return
+    logging.info("DDDDDDDDDDDDDDDDDDDD")
 
-    maillageFissure = self.genereMaillageFissure(geometriesSaines, maillagesSains,
+    maillageFissure = self.genereMaillageFissure(geometriesSaines, maillagesSains, \
-                                                 shapesFissure, self.shapeFissureParams,
+                                                 shapesFissure, self.shapeFissureParams, self.maillageFissureParams, \
-                                                 self.maillageFissureParams, elementsDefaut, step)
+                                                 elementsDefaut, step, mailleur)
 
+    logging.info("EEEEEEEEEEEEEEEEEES")
     self.setReferencesMaillageFissure()
     ok_maillage = getStatsMaillageFissure(maillageFissure, self.referencesMaillageFissure, self.maillageFissureParams)
     return ok_maillage

src/Tools/blocFissure/gmu/genereElemsFissureElliptique.py

@@ -32,7 +32,8 @@ from .genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
 # -----------------------------------------------------------------------------
 # --- création élements géométriques fissure elliptique
 
-def genereElemsFissureElliptique(shapeFissureParams):
+def genereElemsFissureElliptique(shapeFissureParams, \
+                                 mailleur="MeshGems"):
   """
   TODO: a completer
   """
@@ -49,7 +50,7 @@ def genereElemsFissureElliptique(shapeFissureParams):
 
   allonge = demiGrandAxe/demiPetitAxe
   rayonTore = demiPetitAxe/5.0
-  generatrice, FaceGenFiss, Pipe_1, FaceFissure, Plane_1, Pipe1Part = toreFissure(demiPetitAxe, allonge, rayonTore)
+  generatrice, _, Pipe_1, FaceFissure, Plane_1, Pipe1Part = toreFissure(demiPetitAxe, allonge, rayonTore)
   ellipsoide = ellipsoideDefaut(demiPetitAxe, allonge, rayonTore)
 
   # --- positionnement sur le bloc defaut de generatrice, tore et plan fissure
@@ -70,6 +71,7 @@ def genereElemsFissureElliptique(shapeFissureParams):
 
   shapeDefaut = facefis1
   xyz_defaut = geompy.PointCoordinates(centreDefaut)
-  coordsNoeudsFissure = genereMeshCalculZoneDefaut(facefis1, demiPetitAxe/10.0, demiPetitAxe/5.0)
+  coordsNoeudsFissure = genereMeshCalculZoneDefaut(facefis1, demiPetitAxe/10.0, demiPetitAxe/5.0, \
+                                                   mailleur)
 
   return shapeDefaut, xyz_defaut, tailleDefaut, coordsNoeudsFissure, pipe0, gener1, pipe1, facefis1, plane1, ellipsoide1

src/Tools/blocFissure/gmu/genereMeshCalculZoneDefaut.py

@@ -25,10 +25,17 @@ from salome.smesh import smeshBuilder
 # -----------------------------------------------------------------------------
 # --- maillage face de fissure pour identification zone de defaut
 
-def genereMeshCalculZoneDefaut(facefiss, minSize, maxSize):
+def genereMeshCalculZoneDefaut(facefiss, minSize, maxSize, \
-  """
+                               mailleur="MeshGems"):
-  -Permet de générer un maillage sur l'objet géométrique 'facefiss' via
+  """Maillage de l'objet géométrique 'facefiss'
-   l'algorithme NETGEN_1D2D :
+
+. Avec l'algorithme MG_CADSurf :
+      -SetMaxSize     = dimension max d'un élément (maxSize)
+      -SetSecondOrder = élément quadratique (Y=1, N=0)
+      -SetOptimize    = élément régulier (Y=1, N=0)
+      -SetFineness    = finesse du maillage
+
+. Avec l'algorithme NETGEN_1D2D :
       -SetMaxSize     = dimension max d'un élément (maxSize)
       -SetSecondOrder = élément quadratique (Y=1, N=0)
       -SetOptimize    = élément régulier (Y=1, N=0)
@@ -37,14 +44,24 @@ def genereMeshCalculZoneDefaut(facefiss, minSize, maxSize):
        [0,           1,      2,        3,    4,         5     ]
       -SetMinSize     = dimension min d'un élément (minSize)
       -SetQuadAllowed = permission quadrangle dans maillage triangle
-  -On récupère les coordonnées de chaque noeud de la fissure qu'on stocke
+
+-On récupère les coordonnées de chaque noeud de la fissure qu'on stocke
    dans une liste sous la forme : [X0, Y0, Z0, ..., Xn, Yn, Zn]"""
 
   logging.info('start')
-  text = "Maillage de '{}'".format(facefiss.GetName())
-  logging.info(text)
 
   meshFissure = smesh.Mesh(facefiss)
+  text = "Maillage de '{}' avec {}".format(facefiss.GetName(),mailleur)
+  logging.info(text)
+  if ( mailleur == "MeshGems"):
+    algo2d = meshFissure.Triangle(algo=smeshBuilder.MG_CADSurf)
+    hypo2d = algo2d.Parameters()
+    hypo2d.SetPhySize( maxSize )
+    hypo2d.SetMinSize( maxSize/4. )
+    hypo2d.SetMaxSize( maxSize*2. )
+    hypo2d.SetChordalError( maxSize*0.25 )
+    hypo2d.SetVerbosity( 0 )
+  else:
     algo2d = meshFissure.Triangle(algo=smeshBuilder.NETGEN_1D2D)
     hypo2d = algo2d.Parameters()
     hypo2d.SetMaxSize( maxSize )
@@ -67,8 +84,8 @@ def genereMeshCalculZoneDefaut(facefiss, minSize, maxSize):
 
   coordsNoeudsFissure = list()
   nodeIds = meshFissure.GetNodesId()
-  for id in nodeIds:
+  for indice in nodeIds:
-    coords = meshFissure.GetNodeXYZ(id)
+    coords = meshFissure.GetNodeXYZ(indice)
     coordsNoeudsFissure.append(coords[0])
     coordsNoeudsFissure.append(coords[1])
     coordsNoeudsFissure.append(coords[2])

src/Tools/blocFissure/gmu/insereFissureGenerale.py

@@ -39,22 +39,18 @@ from .extractionOrientee import extractionOrientee
 from .extractionOrienteeMulti import extractionOrienteeMulti
 from .sortFaces import sortFaces
 from .sortEdges import sortEdges
-from .eliminateDoubles import eliminateDoubles
 from .substractSubShapes import substractSubShapes
 from .produitMixte import produitMixte
 from .findWireEndVertices import findWireEndVertices
 from .findWireIntermediateVertices import findWireIntermediateVertices
 from .orderEdgesFromWire import orderEdgesFromWire
-from .getSubshapeIds import getSubshapeIds
 from .putName import putName
-from .distance2 import distance2
 from .enleveDefaut import enleveDefaut
 from .shapeSurFissure import shapeSurFissure
 from .regroupeSainEtDefaut import RegroupeSainEtDefaut
 from .triedreBase import triedreBase
 from .checkDecoupePartition import checkDecoupePartition
 from .whichSide import whichSide
-from .whichSideMulti import whichSideMulti
 from .whichSideVertex import whichSideVertex
 from .projettePointSurCourbe import projettePointSurCourbe
 from .prolongeWire import prolongeWire
@@ -62,10 +58,9 @@ from .prolongeWire import prolongeWire
 
 def insereFissureGenerale(maillagesSains,
                           shapesFissure, shapeFissureParams,
-                          maillageFissureParams, elementsDefaut, step=-1):
+                          maillageFissureParams, elementsDefaut, \
-  """
+                          step=-1, mailleur="MeshGems"):
-  TODO: a completer
+  """ TODO: a completer"""
-  """
   logging.info('start')
 
   shapeDefaut       = shapesFissure[0] # faces de fissure, débordant
@@ -273,11 +268,11 @@ def insereFissureGenerale(maillagesSains,
       geomPublishInFather(initLog.debug,partitionPeauFissFond, edgesFondC, "edgesFondFiss")
 
       if aretesVivesC is None: #= global facesInside facesOnside
-        [edgesInside, edgesOutside, edgesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "EDGE", 1.e-3)
+        [edgesInside, _, _] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "EDGE", 1.e-3)
-        [facesInside, facesOutside, facesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "FACE", 1.e-3)
+        [facesInside, _, facesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "FACE", 1.e-3)
       else:
-        [edgesInside, edgesOutside, edgesOnside] = extractionOrienteeMulti(facesDefaut, ifil, partitionPeauFissFond, centreFondFiss, "EDGE", 1.e-3)
+        [edgesInside, _, _] = extractionOrienteeMulti(facesDefaut, ifil, partitionPeauFissFond, centreFondFiss, "EDGE", 1.e-3)
-        [facesInside, facesOutside, facesOnside] = extractionOrienteeMulti(facesDefaut, ifil, partitionPeauFissFond, centreFondFiss, "FACE", 1.e-3)
+        [facesInside, _, facesOnside] = extractionOrienteeMulti(facesDefaut, ifil, partitionPeauFissFond, centreFondFiss, "FACE", 1.e-3)
 
       edgesPipeIn = geompy.GetSharedShapesMulti([edgesPipeC, geompy.MakeCompound(edgesInside)], geompy.ShapeType["EDGE"]) #= global
       verticesPipePeau = list() #= global
@@ -407,7 +402,6 @@ def insereFissureGenerale(maillagesSains,
             logging.debug("    edgesFondIn %s ", edgesPipeFnd)
           except:
             logging.debug("  pb edges communes %s %s %s",edgesPeauFis, edgesPipeFis, edgesPipeFnd)
-            pass
           if (len(edgesPeauFis) > 0) and (len(edgesPipeFis) > 0) and (len(edgesPipeFnd) == 0):
             dist = geompy.MinDistance(geompy.MakeCompound(edgesPeauFis), ptPeau)
             logging.debug("    test distance extrémité reference %s", dist)
@@ -417,8 +411,8 @@ def insereFissureGenerale(maillagesSains,
               name="faceFissExt%d"%iedf
               geomPublishInFather(initLog.debug,partitionPeauFissFond, face, name)
               dist = 1.
-              for ipe, edpe in enumerate(edgesPeauFis):
+              for _, edpe in enumerate(edgesPeauFis):
-                for ipi, edpi in enumerate(edgesPipeFis):
+                for _, edpi in enumerate(edgesPipeFis):
                   dist = geompy.MinDistance(edpe, edpi)
                   if dist < 1.e-3:
                     edgesFissExtPeau.append(edpe)
@@ -473,7 +467,7 @@ def insereFissureGenerale(maillagesSains,
         edgeEnTrop = list()
         outilPart = pipexts
         facesPeau = geompy.ExtractShapes(partitionPeauByPipe, geompy.ShapeType["FACE"], False)
-        facesPeauSorted, minsur, maxsurf = sortFaces(facesPeau)
+        facesPeauSorted, _, _ = sortFaces(facesPeau)
         for i, face in enumerate(facesPeauSorted[:-1]): # on ne teste que la ou les petites faces "circulaires"
           nbv = geompy.NumberOfEdges(face)
           logging.debug("nombre d'edges sur face circulaire: %s", nbv)
@@ -495,9 +489,7 @@ def insereFissureGenerale(maillagesSains,
               j = 1-i
             if bad:
               outilPart[j] = geompy.MakeProjection(cercles[j],facesOnside[0])
-            pass
           partitionPeauByPipe = geompy.MakePartition(facesAndFond, outilPart, list(), list(), geompy.ShapeType["FACE"], 0, list(), 1)
-          pass
 
       name="partitionPeauByPipe%d"%ifil
       geomPublish(initLog.debug, partitionPeauByPipe, name)
@@ -505,7 +497,7 @@ def insereFissureGenerale(maillagesSains,
       [facesPeauFondIn, facesPeauFondOut, facesPeauFondOn] = extractionOrientee(fillingFaceExterne, partitionPeauByPipe, centreFondFiss, "FACE", 1.e-3)
 
       if len(verticesPipePeau) > 0: # --- au moins une extrémité du pipe sur cette face de peau
-        facesPeauSorted, minsur, maxsurf = sortFaces(facesPeauFondOn)
+        facesPeauSorted, _, _ = sortFaces(facesPeauFondOn)
         facePeau = facesPeauSorted[-1] # la plus grande face
       else:
         facePeau =geompy.MakePartition(facesPeauFondOn, list(), list(), list(), geompy.ShapeType["FACE"], 0, list(), 1)
@@ -545,10 +537,6 @@ def insereFissureGenerale(maillagesSains,
                   edgeRadFacePipePeau[i] = edge
                   geomPublish(initLog.debug, edge, nameEdge)
                   break
-                pass
-              pass
-            pass
-          pass
 
         # --- edges circulaires de la face de peau et points de jonction de la face externe de fissure
         logging.debug("facesPipePeau: %s", facesPipePeau)
@@ -568,8 +556,7 @@ def insereFissureGenerale(maillagesSains,
           verticesCircPeau[i] = grpVertCircPeau
           name = "pointEdgeCirc%d"%i
           geomPublishInFather(initLog.debug,facePeau, grpVertCircPeau, name)
-          pass
+        # --- au moins une extrémité du pipe sur cette face de peau
-        pass # --- au moins une extrémité du pipe sur cette face de peau
 
       # --- edges de bord de la face de peau
 
@@ -821,7 +808,7 @@ def insereFissureGenerale(maillagesSains,
   pt1 = centres[-1]
   idFillingFromBout = [None, None]                 # contiendra l'index du filling pour les extrémités 0 et 1
   for ifil in range(nbFacesFilling):
-    for ipt, pt in enumerate(ptEdgeFond[ifil]): # il y a un ou deux points débouchant sur cette face
+    for _, pt in enumerate(ptEdgeFond[ifil]): # il y a un ou deux points débouchant sur cette face
       if geompy.MinDistance(pt,pt0) < geompy.MinDistance(pt,pt1): # TODO: trouver plus fiable pour les cas tordus...
         idFillingFromBout[0] = ifil
       else:
@@ -912,12 +899,12 @@ def insereFissureGenerale(maillagesSains,
   # --- construction des listes d'edges radiales sur chaque extrémité débouchante
   listEdges = list()
   for i, nappes in enumerate(listNappes):
-    id = idFacesDebouchantes[i] # indice de face débouchante (facesPipePeau)
+    indice = idFacesDebouchantes[i] # indice de face débouchante (facesPipePeau)
-    if id < 0:
+    if indice < 0:
       listEdges.append(list())
     else:
-      face = facesPipePeau[id]
+      face = facesPipePeau[indice]
-      edges = [edgeRadFacePipePeau[id]]
+      edges = [edgeRadFacePipePeau[indice]]
       for k, nappe in enumerate(nappes):
         if k > 0:
           obj = geompy.MakeSection(face, nappes[k]) # normalement une edge, parfois un compound d'edges dont un tout petit
@@ -955,15 +942,15 @@ def insereFissureGenerale(maillagesSains,
 
   # --- création des points du maillage du pipe sur la face de peau
   for i, edges in enumerate(listEdges):
-    id = idFacesDebouchantes[i] # indice de face débouchante (facesPipePeau)
+    indice = idFacesDebouchantes[i] # indice de face débouchante (facesPipePeau)
-    if id >= 0:
+    if indice >= 0:
       gptdsk = list()
-      if id > 0: # id vaut 0 ou 1
+      if indice > 0: # indice vaut 0 ou 1
-        id = -1  # si id vaut 1, on prend le dernier élément de la liste (1 ou 2 extrémités débouchent sur la face)
+        indice = -1  # si indice vaut 1, on prend le dernier élément de la liste (1 ou 2 extrémités débouchent sur la face)
-      centre = ptEdgeFond[idFillingFromBout[i]][id]
+      centre = ptEdgeFond[idFillingFromBout[i]][indice]
-      name = "centre%d"%id
+      name = "centre%d"%indice
       geomPublish(initLog.debug, centre, name)
-      vertPipePeau = ptFisExtPi[idFillingFromBout[i]][id]
+      vertPipePeau = ptFisExtPi[idFillingFromBout[i]][indice]
       geomPublishInFather(initLog.debug,centre, vertPipePeau, "vertPipePeau")
       grpsEdgesCirc = edCircPeau[idFillingFromBout[i]] # liste de groupes
       edgesCirc = list()
@@ -987,7 +974,6 @@ def insereFissureGenerale(maillagesSains,
             bout = extrCircs[0]
           else:
             bout = extrCircs[1]
-          pass
         else:
           bout = geompy.MakeVertexOnCurve(distEdgeCirc[0][2], u)
         name ="bout%d"%k
@@ -1073,11 +1059,11 @@ def insereFissureGenerale(maillagesSains,
       mptids = list()
       for j, pt in enumerate(points):
         if j == 0 and k > 0:
-          id = mptdsk[0][0]
+          indice = mptdsk[0][0]
         else:
           coords = geompy.PointCoordinates(pt)
-          id = meshPipe.AddNode(coords[0], coords[1], coords[2])
+          indice = meshPipe.AddNode(coords[0], coords[1], coords[2])
-        mptids.append(id)
+        mptids.append(indice)
       mptdsk.append(mptids)
     mptsdisks.append(mptdsk)
 
@@ -1182,14 +1168,14 @@ def insereFissureGenerale(maillagesSains,
   pipeFissGroup = meshPipe.CreateEmptyGroup( SMESH.VOLUME, 'PIPEFISS' )
   nbAdd = pipeFissGroup.AddFrom( meshPipe.GetMesh() )
 
-  nb, new_mesh, new_group = meshPipe.MakeBoundaryElements(SMESH.BND_2DFROM3D, "pipeBoundaries")
+  nb, _, new_group = meshPipe.MakeBoundaryElements(SMESH.BND_2DFROM3D, "pipeBoundaries")
   edgesCircPipeGroup = [edgeCircPipe0Group, edgeCircPipe1Group]
 
   # --- fin du maillage du pipe
   # -----------------------------------------------------------------------
   # --- edges de bord, faces défaut à respecter
 
-  aFilterManager = smesh.CreateFilterManager()
+  _ = smesh.CreateFilterManager()
   nbAdded, internalBoundary, _NoneGroup = internalBoundary.MakeBoundaryElements( SMESH.BND_1DFROM2D, '', '', 0, [  ])
   criteres = list()
   unCritere = smesh.GetCriterion(SMESH.EDGE,SMESH.FT_FreeBorders,SMESH.FT_Undefined,0)
@@ -1233,6 +1219,16 @@ def insereFissureGenerale(maillagesSains,
   logging.debug("---------------------------- maillage faces de fissure externes au pipe :%s --------------", len(facesFissExt))
 
   meshFaceFiss = smesh.Mesh(faceFissureExterne)
+  logging.info("Maillage avec %s", mailleur)
+  if ( mailleur == "MeshGems"):
+    algo2d = meshFaceFiss.Triangle(algo=smeshBuilder.MG_CADSurf)
+    hypo2d = algo2d.Parameters()
+    hypo2d.SetPhySize( areteFaceFissure )
+    hypo2d.SetMinSize( rayonPipe/float(nbsegRad) )
+    hypo2d.SetMaxSize( areteFaceFissure*3. )
+    hypo2d.SetChordalError( areteFaceFissure*0.25 )
+    hypo2d.SetVerbosity( 0 )
+  else:
     algo2d = meshFaceFiss.Triangle(algo=smeshBuilder.NETGEN_1D2D)
     hypo2d = algo2d.Parameters()
     hypo2d.SetMaxSize( areteFaceFissure )
@@ -1334,9 +1330,19 @@ def insereFissureGenerale(maillagesSains,
           putName(algo1d, "algo1d_" + name, ifil)
           putName(hypo1d, "hypo1d_" + name, ifil)
 
+    logging.info("Maillage avec %s", mailleur)
+    if ( mailleur == "MeshGems"):
+      algo2d = meshFacePeau.Triangle(algo=smeshBuilder.MG_CADSurf)
+      hypo2d = algo2d.Parameters()
+      hypo2d.SetPhySize( dmoyen )
+      hypo2d.SetMinSize( rayonPipe/float(nbsegRad) )
+      hypo2d.SetMaxSize( dmoyen*3. )
+      hypo2d.SetChordalError( dmoyen*0.25 )
+      hypo2d.SetVerbosity( 0 )
+    else:
       algo2d = meshFacePeau.Triangle(algo=smeshBuilder.NETGEN_1D2D)
       hypo2d = algo2d.Parameters()
-    hypo2d.SetMaxSize( dmoyen )
+      hypo2d.SetMaxSize( dmoyen*0.75 )
       hypo2d.SetOptimize( 1 )
       hypo2d.SetFineness( 2 )
       hypo2d.SetMinSize( rayonPipe/float(nbsegRad) )
@@ -1381,13 +1387,17 @@ def insereFissureGenerale(maillagesSains,
       elif grp.GetName() == "fisInPi":
         group_faceFissInPipe = grp
 
-  # le maillage NETGEN ne passe pas toujours ==> utiliser GHS3D
+  # le maillage NETGEN ne passe pas toujours ==> on force l'usage de MG_Tetra
-  distene=True
+  mailleur = "MeshGems"
-  if distene:
+  logging.info("Maillage avec %s", mailleur)
-    algo3d = meshBoiteDefaut.Tetrahedron(algo=smeshBuilder.GHS3D)
+  if ( mailleur == "MeshGems"):
+    algo3d = meshBoiteDefaut.Tetrahedron(algo=smeshBuilder.MG_Tetra)
   else:
     algo3d = meshBoiteDefaut.Tetrahedron(algo=smeshBuilder.NETGEN)
     hypo3d = algo3d.MaxElementVolume(1000.0)
+    hypo3d.SetVerboseLevel( 0 )
+    hypo3d.SetStandardOutputLog( 0 )
+    hypo3d.SetRemoveLogOnSuccess( 1 )
   putName(algo3d.GetSubMesh(), "boiteDefaut")
   putName(algo3d, "algo3d_boiteDefaut")
   putName(meshBoiteDefaut, "boiteDefaut")
@@ -1401,7 +1411,7 @@ def insereFissureGenerale(maillagesSains,
     logging.info(text)
     raise Exception(text)
 
-  faceFissure = meshBoiteDefaut.GetMesh().UnionListOfGroups( [ group_faceFissOutPipe, group_faceFissInPipe ], 'FACE1' )
+  _ = meshBoiteDefaut.GetMesh().UnionListOfGroups( [ group_faceFissOutPipe, group_faceFissInPipe ], 'FACE1' )
   maillageSain = enleveDefaut(maillageSain, zoneDefaut, zoneDefaut_skin,
                               zoneDefaut_internalFaces, zoneDefaut_internalEdges)
   putName(maillageSain, nomFicSain+"_coupe")
@@ -1414,7 +1424,7 @@ def insereFissureGenerale(maillagesSains,
   logging.info("groupes")
   groups = maillageComplet.GetGroups()
   grps = [ grp for grp in groups if grp.GetName() == 'FONDFISS']
-  fond = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FONDFISS' )
+  _ = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FONDFISS' )
 
   logging.info("réorientation face de fissure FACE1")
   grps = [ grp for grp in groups if grp.GetName() == 'FACE1']
@@ -1425,7 +1435,7 @@ def insereFissureGenerale(maillagesSains,
   fissnorm = geompy.MakeMirrorByPlane(normfiss, plansim)
   grps = [ grp for grp in groups if grp.GetName() == 'FACE2']
   nb = maillageComplet.Reorient2D( grps[0], fissnorm, grps[0].GetID(1))
-  fond = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FACE2' )
+  _ = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FACE2' )
 
   logging.info("export maillage fini")
   maillageComplet.ExportMED(fichierMaillageFissure)

src/Tools/blocFissure/gmu/insereFissureLongue.py

@@ -54,9 +54,10 @@ from blocFissure.gmu.insereFissureLongue_d import insereFissureLongue_d
 # -----------------------------------------------------------------------------
 # --- procedure complete fissure longue
 
-def insereFissureLongue(geometriesSaines, maillagesSains,
+def insereFissureLongue(geometriesSaines, maillagesSains, \
-                        shapesFissure, shapeFissureParams,
+                        shapesFissure, shapeFissureParams, \
-                        maillageFissureParams, elementsDefaut, step=-1):
+                        maillageFissureParams, elementsDefaut, \
+                        step=-1, mailleur="MeshGems"):
   """
   TODO: a completer
   """
@@ -436,10 +437,9 @@ def insereFissureLongue(geometriesSaines, maillagesSains,
 
   # --- maillage meshBoiteDefaut
 
-  distene=True
   meshBoiteDefaut, group_faceFissInPipe, group_faceFissOutPipe = \
             insereFissureLongue_d (internalBoundary, meshFondFiss, meshFacePeau, meshFaceFiss, \
-            distene)
+            mailleur)
 
 
   groups = maillageSain.GetGroups()

src/Tools/blocFissure/gmu/insereFissureLongue_b.py

@@ -30,11 +30,22 @@ from .putName import putName
 
 def insereFissureLongue_b (facePeau, edgePeauFiss, groupEdgesBordPeau, bordsLibres, \
                            groupsDemiCerclesPeau, groups_demiCercles, verticesOutCercles, \
-                           nbSegGenLong, nbSegGenBout, profondeur):
+                           nbSegGenLong, nbSegGenBout, profondeur, \
+                           mailleur="MeshGems"):
   """maillage face de peau"""
   logging.info('start')
 
   meshFacePeau = smesh.Mesh(facePeau)
+  logging.info("Maillage avec %s", mailleur)
+  if ( mailleur == "MeshGems"):
+    algo2d = meshFacePeau.Triangle(algo=smeshBuilder.MG_CADSurf)
+    hypo2d = algo2d.Parameters()
+    hypo2d.SetPhySize( 1000 )
+    hypo2d.SetMinSize( 100 )
+    hypo2d.SetMaxSize( 3000. )
+    hypo2d.SetChordalError( 250. )
+    hypo2d.SetVerbosity( 0 )
+  else:
     algo2d = meshFacePeau.Triangle(algo=smeshBuilder.NETGEN_2D)
     hypo2d = algo2d.Parameters()
     hypo2d.SetMaxSize( 1000 )

src/Tools/blocFissure/gmu/insereFissureLongue_c.py

@@ -30,14 +30,26 @@ from .putName import putName
 import math
 
 def insereFissureLongue_c (faceFiss, edgePeauFiss, groupEdgesPeauFiss, group_generFiss, groupEdgesFaceFissPipe, \
-                           profondeur, rayonPipe):
+                           profondeur, rayonPipe, \
+                           mailleur="MeshGems"):
   """maillage face de fissure"""
   logging.info('start')
 
   meshFaceFiss = smesh.Mesh(faceFiss)
+  mesh_size = (profondeur - rayonPipe)/math.sqrt(3.0) # pour avoir deux couches de triangles equilateraux partout sur la fissure
+  logging.info("Maillage avec %s", mailleur)
+  if ( mailleur == "MeshGems"):
+    algo2d = meshFaceFiss.Triangle(algo=smeshBuilder.MG_CADSurf)
+    hypo2d = algo2d.Parameters()
+    hypo2d.SetPhySize( mesh_size )
+    hypo2d.SetMinSize( mesh_size/10. )
+    hypo2d.SetMaxSize( mesh_size*3. )
+    hypo2d.SetChordalError( mesh_size*0.25 )
+    hypo2d.SetVerbosity( 0 )
+  else:
     algo2d = meshFaceFiss.Triangle(algo=smeshBuilder.NETGEN_2D)
     hypo2d = algo2d.Parameters()
-  hypo2d.SetMaxSize( (profondeur - rayonPipe)/math.sqrt(3.0) ) # pour avoir deux couches de triangles equilateraux partout sur la fissure
+    hypo2d.SetMaxSize( mesh_size )
     hypo2d.SetOptimize( 1 )
     hypo2d.SetFineness( 2 )
     hypo2d.SetMinSize( 2 )

src/Tools/blocFissure/gmu/insereFissureLongue_d.py

@@ -28,9 +28,10 @@ import SMESH
 from .putName import putName
 
 def insereFissureLongue_d (internalBoundary, meshFondFiss, meshFacePeau, meshFaceFiss, \
-                           distene = True):
+                           mailleur="MeshGems"):
   """maillage meshBoiteDefaut"""
   logging.info('start')
+  logging.info("insereFissureLongue_d (%s)", mailleur)
 
   meshBoiteDefaut = smesh.Concatenate( [internalBoundary.GetMesh(), \
                                         meshFondFiss.GetMesh(), \
@@ -51,12 +52,17 @@ def insereFissureLongue_d (internalBoundary, meshFondFiss, meshFacePeau, meshFac
       elif grp.GetName() == "fisInPi":
         group_faceFissInPipe = grp
 
-  # le maillage NETGEN ne passe pas toujours ==> utiliser GHS3D
+  # le maillage NETGEN ne passe pas toujours ==> on force l'usage de MG_Tetra
-  if distene:
+  mailleur = "MeshGems"
-    algo3d = meshBoiteDefaut.Tetrahedron(algo=smeshBuilder.GHS3D)
+  logging.info("Maillage avec %s", mailleur)
+  if ( mailleur == "MeshGems"):
+    algo3d = meshBoiteDefaut.Tetrahedron(algo=smeshBuilder.MG_Tetra)
   else:
     algo3d = meshBoiteDefaut.Tetrahedron(algo=smeshBuilder.NETGEN)
     hypo3d = algo3d.MaxElementVolume(1000.0)
+    hypo3d.SetVerboseLevel( 0 )
+    hypo3d.SetStandardOutputLog( 0 )
+    hypo3d.SetRemoveLogOnSuccess( 1 )
   putName(algo3d.GetSubMesh(), "boiteDefaut")
   putName(algo3d, "algo3d_boiteDefaut")
   putName(meshBoiteDefaut, "boiteDefaut")

src/Tools/blocFissure/gmu/mailleFacesFissure.py

@@ -27,14 +27,24 @@ import SMESH
 
 from .putName import putName
 
-def mailleFacesFissure(faceFissureExterne, edgesPipeFissureExterneC, edgesPeauFissureExterneC, \
+def mailleFacesFissure(faceFissureExterne, \
-                        meshPipeGroups, areteFaceFissure, rayonPipe, nbsegRad):
+                       edgesPipeFissureExterneC, edgesPeauFissureExterneC, \
+                       meshPipeGroups, areteFaceFissure, rayonPipe, nbsegRad, \
+                       mailleur="MeshGems"):
   """maillage faces de fissure"""
   logging.info('start')
-  texte = "Maillage de {}".format(faceFissureExterne.GetName())
-  logging.info(texte)
 
   meshFaceFiss = smesh.Mesh(faceFissureExterne)
+  logging.info("Maillage avec %s", mailleur)
+  if ( mailleur == "MeshGems"):
+    algo2d = meshFaceFiss.Triangle(algo=smeshBuilder.MG_CADSurf)
+    hypo2d = algo2d.Parameters()
+    hypo2d.SetPhySize( areteFaceFissure )
+    hypo2d.SetMinSize( rayonPipe/float(nbsegRad) )
+    hypo2d.SetMaxSize( areteFaceFissure*3. )
+    hypo2d.SetChordalError( areteFaceFissure*0.25 )
+    hypo2d.SetVerbosity( 0 )
+  else:
     algo2d = meshFaceFiss.Triangle(algo=smeshBuilder.NETGEN_1D2D)
     hypo2d = algo2d.Parameters()
     hypo2d.SetMaxSize( areteFaceFissure )

src/Tools/blocFissure/gmu/mailleFacesPeau.py

@@ -32,12 +32,14 @@ import SMESH
 
 from .putName import putName
 
-def mailleFacesPeau(partitionsPeauFissFond, idFillingFromBout, facesDefaut,
+def mailleFacesPeau(partitionsPeauFissFond, idFillingFromBout, facesDefaut, \
-                    facesPeaux, edCircPeau, ptCircPeau, gpedgeBord, gpedgeVifs, edFissPeau,
+                    facesPeaux, edCircPeau, ptCircPeau, gpedgeBord, gpedgeVifs, edFissPeau, \
-                    bordsLibres, grpEdgesPeauFissureExterne, grpAretesVives,
+                    bordsLibres, grpEdgesPeauFissureExterne, grpAretesVives, \
-                    edgesCircPipeGroup, dmoyen, rayonPipe, nbsegRad):
+                    edgesCircPipeGroup, dmoyen, rayonPipe, nbsegRad, \
+                    mailleur="MeshGems"):
   """maillage faces de peau"""
   logging.info('start')
+  logging.info(mailleur)
   nbFacesFilling = len(partitionsPeauFissFond)
   boutFromIfil = [None for i in range(nbFacesFilling)]
   if idFillingFromBout[0] != idFillingFromBout[1]: # repérage des extremites du pipe quand elles débouchent sur des faces différentes
@@ -72,12 +74,12 @@ def mailleFacesPeau(partitionsPeauFissFond, idFillingFromBout, facesDefaut,
       logging.info("meshFacePeau %d coupée par la fissure", ifil)
       facePeau           = facesPeaux[ifil] # pour chaque face : la face de peau finale a mailler (percée des faces débouchantes)
       edgesCircPeau      = edCircPeau[ifil] # pour chaque face de peau : [subshape edge circulaire aux débouchés du pipe]
-      verticesCircPeau   = ptCircPeau[ifil] # pour chaque face de peau : [subshape point sur edge circulaire aux débouchés du pipe]
+      _                  = ptCircPeau[ifil] # pour chaque face de peau : [subshape point sur edge circulaire aux débouchés du pipe]
       groupEdgesBordPeau = gpedgeBord[ifil] # pour chaque face de peau : groupe subshape des edges aux bords liés à la partie saine
       bordsVifs          = gpedgeVifs[ifil] # pour chaque face de peau : groupe subshape des edges aux bords correspondant à des arêtes vives
       edgesFissurePeau   = edFissPeau[ifil] # pour chaque face de peau : [subshape edge en peau des faces de fissure externes]
 
-      print ("a")
+      logging.info("a")
       meshFacePeau = smesh.Mesh(facePeau)
 
       algo1d = meshFacePeau.UseExisting1DElements(geom=groupEdgesBordPeau)
@@ -86,14 +88,13 @@ def mailleFacesPeau(partitionsPeauFissFond, idFillingFromBout, facesDefaut,
       putName(algo1d, "algo1d_bordsLibres", ifil)
       putName(hypo1d, "hypo1d_bordsLibres", ifil)
 
-      print ("b")
+      logging.info("b")
       algo1d = meshFacePeau.UseExisting1DElements(geom=geompy.MakeCompound(edgesFissurePeau))
       hypo1d = algo1d.SourceEdges([ grpEdgesPeauFissureExterne ],0,0)
       putName(algo1d.GetSubMesh(), "edgePeauFiss", ifil)
       putName(algo1d, "algo1d_edgePeauFiss", ifil)
       putName(hypo1d, "hypo1d_edgePeauFiss", ifil)
 
-      print ("bordsVifs = {}".format(bordsVifs))
       if bordsVifs is not None:
         algo1d = meshFacePeau.UseExisting1DElements(geom=bordsVifs)
         hypo1d = algo1d.SourceEdges([ grpAretesVives ],0,0)
@@ -102,7 +103,7 @@ def mailleFacesPeau(partitionsPeauFissFond, idFillingFromBout, facesDefaut,
         putName(hypo1d, "hypo1d_bordsVifs", ifil)
 
       for i, edgeCirc in enumerate(edgesCircPeau):
-        print ("i = {}".format(i))
+        logging.info("i = {}".format(i))
         if edgeCirc is not None:
           algo1d = meshFacePeau.UseExisting1DElements(geom=edgeCirc)
           if boutFromIfil[ifil] is None:
@@ -114,7 +115,17 @@ def mailleFacesPeau(partitionsPeauFissFond, idFillingFromBout, facesDefaut,
           putName(algo1d, "algo1d_" + name, ifil)
           putName(hypo1d, "hypo1d_" + name, ifil)
 
-    print ("c")
+    logging.info("c")
+    logging.info("Maillage avec %s", mailleur)
+    if ( mailleur == "MeshGems"):
+      algo2d = meshFacePeau.Triangle(algo=smeshBuilder.MG_CADSurf)
+      hypo2d = algo2d.Parameters()
+      hypo2d.SetPhySize( dmoyen )
+      hypo2d.SetMinSize( rayonPipe/float(nbsegRad) )
+      hypo2d.SetMaxSize( dmoyen*2. )
+      hypo2d.SetChordalError( dmoyen*0.25 )
+      hypo2d.SetVerbosity( 0 )
+    else:
       algo2d = meshFacePeau.Triangle(algo=smeshBuilder.NETGEN_1D2D)
       hypo2d = algo2d.Parameters()
       hypo2d.SetMaxSize( dmoyen )
@@ -122,7 +133,7 @@ def mailleFacesPeau(partitionsPeauFissFond, idFillingFromBout, facesDefaut,
       hypo2d.SetFineness( 2 )
       hypo2d.SetMinSize( rayonPipe/float(nbsegRad) )
       hypo2d.SetQuadAllowed( 0 )
-    print ("d")
+    logging.info("d")
     putName(algo2d.GetSubMesh(), "facePeau", ifil)
     putName(algo2d, "algo2d_facePeau", ifil)
     putName(hypo2d, "hypo2d_facePeau", ifil)
@@ -137,7 +148,7 @@ def mailleFacesPeau(partitionsPeauFissFond, idFillingFromBout, facesDefaut,
       raise Exception(text)
 
     GroupFaces = meshFacePeau.CreateEmptyGroup( SMESH.FACE, "facePeau%d"%ifil )
-    nbAdd = GroupFaces.AddFrom( meshFacePeau.GetMesh() )
+    _ = GroupFaces.AddFrom( meshFacePeau.GetMesh() )
     meshesFacesPeau.append(meshFacePeau)
 
   return meshesFacesPeau

src/Tools/blocFissure/gmu/meshBlocPart.py

@@ -32,7 +32,8 @@ from .putName import putName
 def meshBlocPart(blocPartition, faceFissure, tore, centres, edges, diams, circles, faces, \
                 gencnt, facefissoutore, edgeext, facesExternes, facesExtBloc, facesExtElli, \
                 aretesInternes, internalBoundary, ellipsoidep, sharedFaces, sharedEdges, edgesBords, \
-                nbsegExt, nbsegGen, nbsegRad, scaleRad, reverses, reverext, nbsegCercle, nbsegFis, dmoyen, lensegEllipsoide):
+                nbsegExt, nbsegGen, nbsegRad, scaleRad, reverses, reverext, nbsegCercle, nbsegFis, dmoyen, lensegEllipsoide, \
+                mailleur="MeshGems"):
   """Maillage du bloc partitionné
 
   TODO: a completer

src/Tools/blocFissure/materielCasTests/genereMateriel.py

@@ -19,15 +19,15 @@
 #
 
 from blocFissure.materielCasTests import cubeAngle
-from blocFissure.materielCasTests import decoupeCylindre
+#from blocFissure.materielCasTests import decoupeCylindre
-from blocFissure.materielCasTests import eprouvetteCourbe
+#from blocFissure.materielCasTests import eprouvetteCourbe
-from blocFissure.materielCasTests import eprouvetteDroite
+#from blocFissure.materielCasTests import eprouvetteDroite
-from blocFissure.materielCasTests import fissureGauche
+#from blocFissure.materielCasTests import fissureGauche
-from blocFissure.materielCasTests import fissureGauche2
+#from blocFissure.materielCasTests import fissureGauche2
-from blocFissure.materielCasTests import ellipse
+#from blocFissure.materielCasTests import ellipse
-from blocFissure.materielCasTests import ellipse_probleme
+#from blocFissure.materielCasTests import ellipse_probleme
-from blocFissure.materielCasTests import disque_perce
+#from blocFissure.materielCasTests import disque_perce
-from blocFissure.materielCasTests import ellipse_disque
+#from blocFissure.materielCasTests import ellipse_disque
-from blocFissure.materielCasTests import vis
+#from blocFissure.materielCasTests import vis
-from blocFissure.materielCasTests import cubeFin
+#from blocFissure.materielCasTests import cubeFin
-from blocFissure.materielCasTests import tube
+#from blocFissure.materielCasTests import tube