Préparation pour MG-CADSurf

diff --git a/src/Tools/blocFissure/CasTests/cubeAngle.py b/src/Tools/blocFissure/CasTests/cubeAngle.py
index 9ed946f58271cfb4116f7c724ac4eae445c2ecf6..304494adc7507f25a5cd3f107588f2a32ce366ad 100644 (file)
--- a/src/Tools/blocFissure/CasTests/cubeAngle.py
+++ b/src/Tools/blocFissure/CasTests/cubeAngle.py
@@ -62,7 +62,8 @@ class cubeAngle(fissureGenerique):
                                    rayonPipe   = 10)
 
   # ---------------------------------------------------------------------------
                                    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)
     """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' )
 
     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
 
 
     centre = None
 


@@ -100,13 +101,17 @@ class cubeAngle(fissureGenerique):
 
   # ---------------------------------------------------------------------------
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
 
   # ---------------------------------------------------------------------------
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,

-                            shapesFissure, shapeFissureParams,
-                            maillageFissureParams, elementsDefaut, step):
+                                  shapesFissure, shapeFissureParams,
+                                  maillageFissureParams, elementsDefaut, step, \
+                                  mailleur="MeshGems"):

     texte = "genereMaillageFissure pour '{}'".format(self.nomCas)
     logging.info(texte)
     texte = "genereMaillageFissure pour '{}'".format(self.nomCas)
     logging.info(texte)

+
+    mailleur = self.mailleur2d3d()

     maillageFissure = construitFissureGenerale(maillagesSains,
                                                shapesFissure, shapeFissureParams,
     maillageFissure = construitFissureGenerale(maillagesSains,
                                                shapesFissure, shapeFissureParams,

-                                               maillageFissureParams, elementsDefaut, step)
+                                               maillageFissureParams, elementsDefaut, step, \
+                                               mailleur)

     return maillageFissure
 
   # ---------------------------------------------------------------------------
     return maillageFissure
 
   # ---------------------------------------------------------------------------

diff --git a/src/Tools/blocFissure/CasTests/cylindre.py b/src/Tools/blocFissure/CasTests/cylindre.py
index 9e29286af8d03cfa03ba8f8001bcf152b1ff1e19..2ec1daaeae86fd5f4e3098215cce23fcdcc5d274 100644 (file)
--- a/src/Tools/blocFissure/CasTests/cylindre.py
+++ b/src/Tools/blocFissure/CasTests/cylindre.py
@@ -64,7 +64,8 @@ class cylindre(fissureGenerique):
                                    rayonPipe   = 5)
 
   # ---------------------------------------------------------------------------
                                    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']
     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' )
 
     geompy.addToStudy( shellFiss, 'shellFiss' )
     geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' )
 

-
-    coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,15)
+    mailleur = self.mailleur2d3d()
+    coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,15, mailleur)

 
     centre = None
     return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss]
 
     centre = None
     return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss]


@@ -98,10 +99,14 @@ class cylindre(fissureGenerique):
   # ---------------------------------------------------------------------------
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                             shapesFissure, shapeFissureParams,
   # ---------------------------------------------------------------------------
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                             shapesFissure, shapeFissureParams,

-                            maillageFissureParams, elementsDefaut, step):
+                            maillageFissureParams, elementsDefaut, step, \
+                                  mailleur="MeshGems"):
+
+    mailleur = self.mailleur2d3d()

     maillageFissure = construitFissureGenerale(maillagesSains,
                                                shapesFissure, shapeFissureParams,
     maillageFissure = construitFissureGenerale(maillagesSains,
                                                shapesFissure, shapeFissureParams,

-                                               maillageFissureParams, elementsDefaut, step)
+                                               maillageFissureParams, elementsDefaut, step, \
+                                               mailleur)

     return maillageFissure
 
   # ---------------------------------------------------------------------------
     return maillageFissure
 
   # ---------------------------------------------------------------------------

diff --git a/src/Tools/blocFissure/CasTests/cylindre_2.py b/src/Tools/blocFissure/CasTests/cylindre_2.py
index 6b17ff383b7441ecbceaa516453995250bc548af..4cde6a3829bbd4367df75a3abc62bda83d5f2743 100644 (file)
--- a/src/Tools/blocFissure/CasTests/cylindre_2.py
+++ b/src/Tools/blocFissure/CasTests/cylindre_2.py
@@ -39,7 +39,8 @@ class cylindre_2(cylindre):
   nomProbleme = "cylindre2"
 
   # ---------------------------------------------------------------------------
   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']
     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' )
 
     geompy.addToStudy( shellFiss, 'shellFiss' )
     geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' )
 

-
-    coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,15)
+    mailleur = self.mailleur2d3d()
+    coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,15, mailleur)

 
     centre = None
     return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss]
 
     centre = None
     return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss]

diff --git a/src/Tools/blocFissure/CasTests/ellipse_1.py b/src/Tools/blocFissure/CasTests/ellipse_1.py
index 80811a5be80d03a9388c9b8832b0333ef6d836dc..5008debbbcfa07a43cd99c8ad1a578cf138de78b 100644 (file)
--- a/src/Tools/blocFissure/CasTests/ellipse_1.py
+++ b/src/Tools/blocFissure/CasTests/ellipse_1.py
@@ -70,7 +70,8 @@ class ellipse_1(fissureGenerique):
                                    rayonPipe   = 20)
 
   # ---------------------------------------------------------------------------
                                    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)
     """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' )
 
     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
 
 
     centre = None
 


@@ -108,12 +110,17 @@ class ellipse_1(fissureGenerique):
   # ---------------------------------------------------------------------------
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                             shapesFissure, shapeFissureParams,
   # ---------------------------------------------------------------------------
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                             shapesFissure, shapeFissureParams,

-                            maillageFissureParams, elementsDefaut, step):
+                            maillageFissureParams, elementsDefaut, step, \
+                                  mailleur="MeshGems"):
+

     texte = "genereMaillageFissure pour '{}'".format(self.nomCas)
     logging.info(texte)
     texte = "genereMaillageFissure pour '{}'".format(self.nomCas)
     logging.info(texte)

+
+    mailleur = self.mailleur2d3d()

     maillageFissure = construitFissureGenerale(maillagesSains,
                                                shapesFissure, shapeFissureParams,
     maillageFissure = construitFissureGenerale(maillagesSains,
                                                shapesFissure, shapeFissureParams,

-                                               maillageFissureParams, elementsDefaut, step)
+                                               maillageFissureParams, elementsDefaut, step, \
+                                               mailleur)

     return maillageFissure
 
   # ---------------------------------------------------------------------------
     return maillageFissure
 
   # ---------------------------------------------------------------------------

diff --git a/src/Tools/blocFissure/CasTests/ellipse_2.py b/src/Tools/blocFissure/CasTests/ellipse_2.py
index 9fbef92925341d0888fd438017efa85c10eb9e36..5d70a1ba14a7f142e69e7b842b06a77eeaf09d9a 100644 (file)
--- a/src/Tools/blocFissure/CasTests/ellipse_2.py
+++ b/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 import gmu
 from blocFissure.gmu.geomsmesh import geompy, smesh

-from blocFissure.gmu.fissureGenerique import fissureGenerique

 from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
 from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut

-from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
-from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale

 
 import GEOM
 import SALOMEDS
 
 import GEOM
 import SALOMEDS


@@ -42,7 +39,8 @@ class ellipse_2(ellipse_1):
   nomProbleme = "ellipse2"
 
   # ---------------------------------------------------------------------------
   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)
     """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' )
 
     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
 
 
     centre = None
 

diff --git a/src/Tools/blocFissure/CasTests/eprouvetteCourbe.py b/src/Tools/blocFissure/CasTests/eprouvetteCourbe.py
index ddfb85757ed5d346753f538f1df87cfc2de9d83a..9e3dfde2dfd7223fc9bd3d6ea59cfec44fb0f37e 100644 (file)
--- a/src/Tools/blocFissure/CasTests/eprouvetteCourbe.py
+++ b/src/Tools/blocFissure/CasTests/eprouvetteCourbe.py
@@ -64,7 +64,8 @@ class eprouvetteCourbe(fissureGenerique):
                                    rayonPipe   = 10)
 
   # ---------------------------------------------------------------------------
                                    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)
     """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' )
 
     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
 
 
     centre = None
 


@@ -102,12 +104,17 @@ class eprouvetteCourbe(fissureGenerique):
   # ---------------------------------------------------------------------------
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                             shapesFissure, shapeFissureParams,
   # ---------------------------------------------------------------------------
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                             shapesFissure, shapeFissureParams,

-                            maillageFissureParams, elementsDefaut, step):
+                            maillageFissureParams, elementsDefaut, step, \
+                                  mailleur="MeshGems"):
+

     texte = "genereMaillageFissure pour '{}'".format(self.nomCas)
     logging.info(texte)
     texte = "genereMaillageFissure pour '{}'".format(self.nomCas)
     logging.info(texte)

+
+    mailleur = self.mailleur2d3d()

     maillageFissure = construitFissureGenerale(maillagesSains,
                                                shapesFissure, shapeFissureParams,
     maillageFissure = construitFissureGenerale(maillagesSains,
                                                shapesFissure, shapeFissureParams,

-                                               maillageFissureParams, elementsDefaut, step)
+                                               maillageFissureParams, elementsDefaut, step, \
+                                               mailleur)

     return maillageFissure
 
   # ---------------------------------------------------------------------------
     return maillageFissure
 
   # ---------------------------------------------------------------------------

diff --git a/src/Tools/blocFissure/CasTests/eprouvetteDroite.py b/src/Tools/blocFissure/CasTests/eprouvetteDroite.py
index 9b4d131f018a2da39f16acd366d6def5fce6638b..c07ed26ae44065dd1ab640647f6d8a1d268680a6 100644 (file)
--- a/src/Tools/blocFissure/CasTests/eprouvetteDroite.py
+++ b/src/Tools/blocFissure/CasTests/eprouvetteDroite.py
@@ -22,8 +22,6 @@ import os
 from blocFissure import gmu
 from blocFissure.gmu.geomsmesh import geompy, smesh
 
 from blocFissure import gmu
 from blocFissure.gmu.geomsmesh import geompy, smesh
 

-import os
-import math

 import GEOM
 import SALOMEDS
 import SMESH
 import GEOM
 import SALOMEDS
 import SMESH


@@ -52,7 +50,7 @@ class eprouvetteDroite(fissureGenerique):
   def genereMaillageSain(self, geometriesSaines, meshParams):
     logging.info("genereMaillageSain %s", self.nomCas)
 
   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
     smesh.SetName(objetSain.GetMesh(), 'objetSain')
 
     return [objetSain, True] # True : maillage hexa


@@ -72,7 +70,8 @@ class eprouvetteDroite(fissureGenerique):
                                    lenSegPipe  = 6)
 
   # ---------------------------------------------------------------------------
                                    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']
     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' )
 
     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
     return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss]
 
     centre = None
     return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss]


@@ -106,10 +105,14 @@ class eprouvetteDroite(fissureGenerique):
   # ---------------------------------------------------------------------------
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                             shapesFissure, shapeFissureParams,
   # ---------------------------------------------------------------------------
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                             shapesFissure, shapeFissureParams,

-                            maillageFissureParams, elementsDefaut, step):
+                            maillageFissureParams, elementsDefaut, step, \
+                                  mailleur="MeshGems"):
+
+    mailleur = self.mailleur2d3d()

     maillageFissure = construitFissureGenerale(maillagesSains,
                                                shapesFissure, shapeFissureParams,
     maillageFissure = construitFissureGenerale(maillagesSains,
                                                shapesFissure, shapeFissureParams,

-                                               maillageFissureParams, elementsDefaut, step)
+                                               maillageFissureParams, elementsDefaut, step, \
+                                               mailleur)

     return maillageFissure
 
   # ---------------------------------------------------------------------------
     return maillageFissure
 
   # ---------------------------------------------------------------------------

diff --git a/src/Tools/blocFissure/CasTests/eprouvetteDroite_2.py b/src/Tools/blocFissure/CasTests/eprouvetteDroite_2.py
index 1db76fcbcbd3437b443b83672589bd72958839ce..0a2327610a3dbdadb020d939b4780e8280b3631f 100644 (file)
--- a/src/Tools/blocFissure/CasTests/eprouvetteDroite_2.py
+++ b/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.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()
 
 
 O, OX, OY, OZ = triedreBase()
 


@@ -46,7 +44,8 @@ class eprouvetteDroite_2(eprouvetteDroite):
   nomProbleme = "eprouvetteDroite_2"
 
   # ---------------------------------------------------------------------------
   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']
     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' )
 
     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
     return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss]
 
     centre = None
     return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss]

diff --git a/src/Tools/blocFissure/CasTests/faceGauche.py b/src/Tools/blocFissure/CasTests/faceGauche.py
index 1a554736c4c128b4d6a92d3268555d1745491605..20afd5c28bc0d38d9f17aa7ff9566d9a638cc8c5 100644 (file)
--- a/src/Tools/blocFissure/CasTests/faceGauche.py
+++ b/src/Tools/blocFissure/CasTests/faceGauche.py
@@ -68,7 +68,8 @@ class faceGauche(fissureGenerique):
                                    rayonPipe   = 20)
 
   # ---------------------------------------------------------------------------
                                    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']
     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' )
 
     geompy.addToStudy( shellFiss, 'shellFiss' )
     geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' )
 

-
-    coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,50)
+    mailleur = self.mailleur2d3d()
+    coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,50, mailleur)

 
     centre = None
     return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss]
 
     centre = None
     return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss]


@@ -102,10 +103,14 @@ class faceGauche(fissureGenerique):
   # ---------------------------------------------------------------------------
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                             shapesFissure, shapeFissureParams,
   # ---------------------------------------------------------------------------
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                             shapesFissure, shapeFissureParams,

-                            maillageFissureParams, elementsDefaut, step):
+                            maillageFissureParams, elementsDefaut, step, \
+                                  mailleur="MeshGems"):
+
+    mailleur = self.mailleur2d3d()

     maillageFissure = construitFissureGenerale(maillagesSains,
                                                shapesFissure, shapeFissureParams,
     maillageFissure = construitFissureGenerale(maillagesSains,
                                                shapesFissure, shapeFissureParams,

-                                               maillageFissureParams, elementsDefaut, step)
+                                               maillageFissureParams, elementsDefaut, step, \
+                                               mailleur)

     return maillageFissure
 
   # ---------------------------------------------------------------------------
     return maillageFissure
 
   # ---------------------------------------------------------------------------

diff --git a/src/Tools/blocFissure/CasTests/faceGauche_2.py b/src/Tools/blocFissure/CasTests/faceGauche_2.py
index e9271d21da0eb0aea17ce05c3d25fe47d633458c..08f2bc06cc3b494ce04581e473a011c5fc4c8026 100644 (file)
--- a/src/Tools/blocFissure/CasTests/faceGauche_2.py
+++ b/src/Tools/blocFissure/CasTests/faceGauche_2.py
@@ -22,7 +22,6 @@ import os
 from blocFissure import gmu
 from blocFissure.gmu.geomsmesh import geompy, smesh
 
 from blocFissure import gmu
 from blocFissure.gmu.geomsmesh import geompy, smesh
 

-import math

 import GEOM
 import SALOMEDS
 import SMESH
 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)
 
   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
     smesh.SetName(objetSain.GetMesh(), 'objetSain')
 
     return [objetSain, True] # True : maillage hexa


@@ -69,7 +68,8 @@ class faceGauche_2(fissureGenerique):
                                    rayonPipe   = 20)
 
   # ---------------------------------------------------------------------------
                                    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']
     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' )
 
     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]
 
     centre = None
     return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss]


@@ -102,10 +103,14 @@ class faceGauche_2(fissureGenerique):
   # ---------------------------------------------------------------------------
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                             shapesFissure, shapeFissureParams,
   # ---------------------------------------------------------------------------
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                             shapesFissure, shapeFissureParams,

-                            maillageFissureParams, elementsDefaut, step):
+                            maillageFissureParams, elementsDefaut, step, \
+                                  mailleur="MeshGems"):
+
+    mailleur = self.mailleur2d3d()

     maillageFissure = construitFissureGenerale(maillagesSains,
                                                shapesFissure, shapeFissureParams,
     maillageFissure = construitFissureGenerale(maillagesSains,
                                                shapesFissure, shapeFissureParams,

-                                               maillageFissureParams, elementsDefaut, step)
+                                               maillageFissureParams, elementsDefaut, step, \
+                                               mailleur)

     return maillageFissure
 
   # ---------------------------------------------------------------------------
     return maillageFissure
 
   # ---------------------------------------------------------------------------

diff --git a/src/Tools/blocFissure/CasTests/fissureCoude_6.py b/src/Tools/blocFissure/CasTests/fissureCoude_6.py
index c002de469093bb0ce2b81e805e7f807934125cb3..43c9ebf2e101ddcb390c42fe2fd8b4f3033d67fb 100644 (file)
--- a/src/Tools/blocFissure/CasTests/fissureCoude_6.py
+++ b/src/Tools/blocFissure/CasTests/fissureCoude_6.py
@@ -82,7 +82,7 @@ class fissureCoude_6(fissureCoude):
                                    externe     = True)
 
   # ---------------------------------------------------------------------------
                                    externe     = True)
 
   # ---------------------------------------------------------------------------

-                                   
+

   def setParamMaillageFissure(self):
     """
     Paramètres du maillage de la fissure pour le tuyau coudé
   def setParamMaillageFissure(self):
     """
     Paramètres du maillage de la fissure pour le tuyau coudé


@@ -96,7 +96,7 @@ class fissureCoude_6(fissureCoude):
                                       nomFicFissure = self.nomCas + "_fissure",
                                       nbsegRad      = 5,
                                       nbsegCercle   = 12,
                                       nomFicFissure = self.nomCas + "_fissure",
                                       nbsegRad      = 5,
                                       nbsegCercle   = 12,

-                                      areteFaceFissure = 5)                                   
+                                      areteFaceFissure = 5)

 
   # ---------------------------------------------------------------------------
   def setReferencesMaillageFissure(self):
 
   # ---------------------------------------------------------------------------
   def setReferencesMaillageFissure(self):

diff --git a/src/Tools/blocFissure/CasTests/fissureCoude_7.py b/src/Tools/blocFissure/CasTests/fissureCoude_7.py
index e86736a5f0576eead9997934d72e5575cd471722..43369a22a10d9d4d7db2f8cdfa391ae867d909c6 100644 (file)
--- a/src/Tools/blocFissure/CasTests/fissureCoude_7.py
+++ b/src/Tools/blocFissure/CasTests/fissureCoude_7.py
@@ -83,7 +83,7 @@ class fissureCoude_7(fissureCoude):
                                    externe     = True)
 
   # ---------------------------------------------------------------------------
                                    externe     = True)
 
   # ---------------------------------------------------------------------------

-                                   
+

   def setParamMaillageFissure(self):
     """
     Paramètres du maillage de la fissure pour le tuyau coudé
   def setParamMaillageFissure(self):
     """
     Paramètres du maillage de la fissure pour le tuyau coudé


@@ -97,7 +97,7 @@ class fissureCoude_7(fissureCoude):
                                       nomFicFissure = self.nomCas + "_fissure",
                                       nbsegRad      = 5,
                                       nbsegCercle   = 12,
                                       nomFicFissure = self.nomCas + "_fissure",
                                       nbsegRad      = 5,
                                       nbsegCercle   = 12,

-                                      areteFaceFissure = 5)                                   
+                                      areteFaceFissure = 5)

 
   # ---------------------------------------------------------------------------
   def setReferencesMaillageFissure(self):
 
   # ---------------------------------------------------------------------------
   def setReferencesMaillageFissure(self):

diff --git a/src/Tools/blocFissure/CasTests/fissure_Coude.py b/src/Tools/blocFissure/CasTests/fissure_Coude.py
index 861a921419541a05ca657639a392d163c2b23df3..f493b1ba6891d7afec073db293bda985cb896db2 100644 (file)
--- a/src/Tools/blocFissure/CasTests/fissure_Coude.py
+++ b/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")
 
     smesh.SetName(algo1d_long_p2, "algo1d_long_p2")
     smesh.SetName(hypo1d_long_p2, "hypo1d_long_p2")
 

-    mp1 = maillageSain.GroupOnGeom(P1,'P1',SMESH.NODE)
-    mp2 = maillageSain.GroupOnGeom(P2,'P2',SMESH.NODE)
-    ext = maillageSain.GroupOnGeom(EXTUBE,'EXTUBE',SMESH.FACE)
-    btu = maillageSain.GroupOnGeom(BORDTU,'BORDTU',SMESH.EDGE)
-    clg = maillageSain.GroupOnGeom(CLGV,'CLGV',SMESH.FACE)
-    pei = maillageSain.GroupOnGeom(PEAUINT,'PEAUINT',SMESH.FACE)
-    pex = maillageSain.GroupOnGeom(PEAUEXT,'PEAUEXT',SMESH.FACE)
-    cou = maillageSain.GroupOnGeom(COUDE,'COUDSAIN',SMESH.VOLUME)
+    _ = maillageSain.GroupOnGeom(P1,'P1',SMESH.NODE)
+    _ = maillageSain.GroupOnGeom(P2,'P2',SMESH.NODE)
+    _ = maillageSain.GroupOnGeom(EXTUBE,'EXTUBE',SMESH.FACE)
+    _ = maillageSain.GroupOnGeom(BORDTU,'BORDTU',SMESH.EDGE)
+    _ = maillageSain.GroupOnGeom(CLGV,'CLGV',SMESH.FACE)
+    _ = maillageSain.GroupOnGeom(PEAUINT,'PEAUINT',SMESH.FACE)
+    _ = maillageSain.GroupOnGeom(PEAUEXT,'PEAUEXT',SMESH.FACE)
+    _ = maillageSain.GroupOnGeom(COUDE,'COUDSAIN',SMESH.VOLUME)

 
     isDone = maillageSain.Compute()
 
 
     isDone = maillageSain.Compute()
 


@@ -294,7 +294,8 @@ class fissure_Coude(fissureGenerique):
                                    externe     = True)
 
   # ---------------------------------------------------------------------------
                                    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)
 
     logging.info("genereShapeFissure %s", self.nomCas)
     logging.info("shapeFissureParams %s", shapeFissureParams)
 


@@ -473,7 +474,8 @@ class fissure_Coude(fissureGenerique):
     else:
       pass
 
     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]
 
 
     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,
   # ---------------------------------------------------------------------------
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                             shapesFissure, shapeFissureParams,

-                            maillageFissureParams, elementsDefaut, step):
+                            maillageFissureParams, elementsDefaut, step, \
+                                  mailleur="MeshGems"):
+
+    mailleur = self.mailleur2d3d()

     maillageFissure = insereFissureLongue(geometriesSaines, maillagesSains,
                                           shapesFissure, shapeFissureParams,
     maillageFissure = insereFissureLongue(geometriesSaines, maillagesSains,
                                           shapesFissure, shapeFissureParams,

-                                          maillageFissureParams, elementsDefaut, step)
+                                          maillageFissureParams, elementsDefaut, step, \
+                                               mailleur)

     return maillageFissure
 
   # ---------------------------------------------------------------------------
     return maillageFissure
 
   # ---------------------------------------------------------------------------

diff --git a/src/Tools/blocFissure/CasTests/tube.py b/src/Tools/blocFissure/CasTests/tube.py
index 880df4cd77326ad3c8fe3e4f151dba7afa6a1778..ec8ffdf2307ce46ca61481e070b9c60e127c6810 100644 (file)
--- a/src/Tools/blocFissure/CasTests/tube.py
+++ b/src/Tools/blocFissure/CasTests/tube.py
@@ -62,7 +62,8 @@ class tube(fissureGenerique):
                                    rayonPipe   = 0.05)
 
   # ---------------------------------------------------------------------------
                                    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)
     """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' )
 
     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
 
 
     centre = None
 


@@ -104,12 +106,17 @@ class tube(fissureGenerique):
   # ---------------------------------------------------------------------------
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                             shapesFissure, shapeFissureParams,
   # ---------------------------------------------------------------------------
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                             shapesFissure, shapeFissureParams,

-                            maillageFissureParams, elementsDefaut, step):
+                            maillageFissureParams, elementsDefaut, step, \
+                                  mailleur="MeshGems"):
+

     texte = "genereMaillageFissure pour '{}'".format(self.nomCas)
     logging.info(texte)
     texte = "genereMaillageFissure pour '{}'".format(self.nomCas)
     logging.info(texte)

+
+    mailleur = self.mailleur2d3d()

     maillageFissure = construitFissureGenerale(maillagesSains,
                                                shapesFissure, shapeFissureParams,
     maillageFissure = construitFissureGenerale(maillagesSains,
                                                shapesFissure, shapeFissureParams,

-                                               maillageFissureParams, elementsDefaut, step)
+                                               maillageFissureParams, elementsDefaut, step, \
+                                               mailleur)

     return maillageFissure
 
   # ---------------------------------------------------------------------------
     return maillageFissure
 
   # ---------------------------------------------------------------------------

diff --git a/src/Tools/blocFissure/CasTests/vis_1.py b/src/Tools/blocFissure/CasTests/vis_1.py
index 9963dd1bd05c6393e5e311d89e56934315934d44..cf3d56e35917c71c83876e9fd617926397ce845e 100644 (file)
--- a/src/Tools/blocFissure/CasTests/vis_1.py
+++ b/src/Tools/blocFissure/CasTests/vis_1.py
@@ -70,7 +70,8 @@ class vis_1(fissureGenerique):
                                    rayonPipe   = 0.1)
 
   # ---------------------------------------------------------------------------
                                    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)
     """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' )
 
     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
 
 
     centre = None
 


@@ -108,12 +110,17 @@ class vis_1(fissureGenerique):
   # ---------------------------------------------------------------------------
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                             shapesFissure, shapeFissureParams,
   # ---------------------------------------------------------------------------
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                             shapesFissure, shapeFissureParams,

-                            maillageFissureParams, elementsDefaut, step):
+                            maillageFissureParams, elementsDefaut, step, \
+                                  mailleur="MeshGems"):
+

     texte = "genereMaillageFissure pour '{}'".format(self.nomCas)
     logging.info(texte)
     texte = "genereMaillageFissure pour '{}'".format(self.nomCas)
     logging.info(texte)

+
+    mailleur = self.mailleur2d3d()

     maillageFissure = construitFissureGenerale(maillagesSains,
                                                shapesFissure, shapeFissureParams,
     maillageFissure = construitFissureGenerale(maillagesSains,
                                                shapesFissure, shapeFissureParams,

-                                               maillageFissureParams, elementsDefaut, step)
+                                               maillageFissureParams, elementsDefaut, step, \
+                                               mailleur)

     return maillageFissure
 
   # ---------------------------------------------------------------------------
     return maillageFissure
 
   # ---------------------------------------------------------------------------

diff --git a/src/Tools/blocFissure/gmu/casStandard.py b/src/Tools/blocFissure/gmu/casStandard.py
index 52cd10547128ea7937779d44b8872d93dcf81c6f..00f19300f63696d48d475d40c4a3b874915adedf 100644 (file)
--- a/src/Tools/blocFissure/gmu/casStandard.py
+++ b/src/Tools/blocFissure/gmu/casStandard.py
@@ -116,8 +116,8 @@ class casStandard(fissureGenerique):
                                      lenSegPipe  = self.lenSegPipe)
 
   # ---------------------------------------------------------------------------
                                      lenSegPipe  = self.lenSegPipe)
 
   # ---------------------------------------------------------------------------

-  def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams):
-    logging.info("genereShapeFissure %s", self.nomCas)
+  def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams, \
+                                mailleur="MeshGems"):

 
     lgInfluence = shapeFissureParams['lgInfluence']
 
 
     lgInfluence = shapeFissureParams['lgInfluence']
 


@@ -147,7 +147,8 @@ class casStandard(fissureGenerique):
     geomPublishInFather(initLog.debug, shellFiss, fondFiss, 'fondFiss' )
 
 
     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]
 
     centre = None
     return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss]


@@ -168,12 +169,14 @@ class casStandard(fissureGenerique):
     return elementsDefaut
 
   # ---------------------------------------------------------------------------
     return elementsDefaut
 
   # ---------------------------------------------------------------------------

-  def genereMaillageFissure(self, geometriesSaines, maillagesSains,
-                            shapesFissure, shapeFissureParams,
-                            maillageFissureParams, elementsDefaut, step):
+  def genereMaillageFissure(self, geometriesSaines, maillagesSains, \
+                                  shapesFissure, shapeFissureParams, \
+                                  maillageFissureParams, elementsDefaut, step, \
+                                  mailleur="MeshGems"):

     maillageFissure = construitFissureGenerale(maillagesSains, \
     maillageFissure = construitFissureGenerale(maillagesSains, \

-                                              shapesFissure, shapeFissureParams, \
-                                              maillageFissureParams, elementsDefaut, step)
+                                               shapesFissure, shapeFissureParams, \
+                                               maillageFissureParams, elementsDefaut, \
+                                               step, mailleur)

     return maillageFissure
 
   # ---------------------------------------------------------------------------
     return maillageFissure
 
   # ---------------------------------------------------------------------------

diff --git a/src/Tools/blocFissure/gmu/construitFissureGenerale.py b/src/Tools/blocFissure/gmu/construitFissureGenerale.py
index 8dfcfa5272a6ac0c8af50c1a3300d7a28dc42c26..097225e61948c4a8bb7167114f758c064ddfe6ff 100644 (file)
--- a/src/Tools/blocFissure/gmu/construitFissureGenerale.py
+++ b/src/Tools/blocFissure/gmu/construitFissureGenerale.py
@@ -77,13 +77,15 @@ from .fissError import fissError
 # -----------------------------------------------------------------------------
 # --- procédure complète fissure générale
 
 # -----------------------------------------------------------------------------
 # --- procédure complète fissure générale
 

-def construitFissureGenerale(maillagesSains,
-                             shapesFissure, shapeFissureParams,
-                             maillageFissureParams, elementsDefaut, step=-1):
+def construitFissureGenerale(maillagesSains, \
+                             shapesFissure, shapeFissureParams, \
+                             maillageFissureParams, elementsDefaut, \
+                             step=-1, mailleur="MeshGems"):

   """
   TODO: a completer
   """
   logging.info('start')
   """
   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
 
   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
 
 
   # --- maillage faces de fissure
 

-  (meshFaceFiss, grpFaceFissureExterne,
-   grpEdgesPeauFissureExterne, grpEdgesPipeFissureExterne) = mailleFacesFissure(faceFissureExterne, edgesPipeFissureExterneC, edgesPeauFissureExterneC,
-                                                                                meshPipeGroups, areteFaceFissure, rayonPipe, nbsegRad)
+  (meshFaceFiss, grpFaceFissureExterne, grpEdgesPeauFissureExterne, grpEdgesPipeFissureExterne) = \
+      mailleFacesFissure(faceFissureExterne, \
+                         edgesPipeFissureExterneC, edgesPeauFissureExterneC, \
+                         meshPipeGroups, areteFaceFissure, rayonPipe, nbsegRad, \
+                         mailleur)

 
   # --- maillage faces de peau
 
 
   # --- maillage faces de peau
 

-  meshesFacesPeau = mailleFacesPeau(partitionsPeauFissFond, idFillingFromBout, facesDefaut,
-                                    facesPeaux, edCircPeau, ptCircPeau, gpedgeBord, gpedgeVifs, edFissPeau,
-                                    bordsLibres, grpEdgesPeauFissureExterne, grpAretesVives,
-                                    edgesCircPipeGroup, dmoyen, rayonPipe, nbsegRad)
+  meshesFacesPeau = mailleFacesPeau(partitionsPeauFissFond, idFillingFromBout, facesDefaut, \
+                                    facesPeaux, edCircPeau, ptCircPeau, gpedgeBord, gpedgeVifs, edFissPeau, \
+                                    bordsLibres, grpEdgesPeauFissureExterne, grpAretesVives, \
+                                    edgesCircPipeGroup, dmoyen, rayonPipe, nbsegRad, \
+                                    mailleur)

 
   # --- regroupement des maillages du défaut
 
 
   # --- regroupement des maillages du défaut
 


@@ -309,13 +314,17 @@ def construitFissureGenerale(maillagesSains,
       elif grp.GetName() == "fisInPi":
         group_faceFissInPipe = grp
 
       elif grp.GetName() == "fisInPi":
         group_faceFissInPipe = grp
 

-  # le maillage NETGEN ne passe pas toujours ==> utiliser GHS3D
-  distene=True
-  if distene:
-    algo3d = meshBoiteDefaut.Tetrahedron(algo=smeshBuilder.GHS3D)
+  # le maillage NETGEN ne passe pas toujours ==> on force l'usage de MG_Tetra
+  mailleur = "MeshGems"
+  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)
   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")
   putName(algo3d.GetSubMesh(), "boiteDefaut")
   putName(algo3d, "algo3d_boiteDefaut")
   putName(meshBoiteDefaut, "boiteDefaut")

diff --git a/src/Tools/blocFissure/gmu/fissureCoude.py b/src/Tools/blocFissure/gmu/fissureCoude.py
index 772ce40f3fd2decca63b7deb9ac829b4a69d04ab..edd101eb724e07e0ec257f8056d7fb2775199cf0 100644 (file)
--- a/src/Tools/blocFissure/gmu/fissureCoude.py
+++ b/src/Tools/blocFissure/gmu/fissureCoude.py
@@ -29,9 +29,6 @@ import math
 import GEOM
 import SALOMEDS
 import SMESH
 import GEOM
 import SALOMEDS
 import SMESH

-#import StdMeshers
-#import GHS3DPlugin
-#import NETGENPlugin

 import logging
 
 from .fissureGenerique import fissureGenerique
 import logging
 
 from .fissureGenerique import fissureGenerique


@@ -72,6 +69,7 @@ class fissureCoude(fissureGenerique):
 
   # ---------------------------------------------------------------------------
   def genereGeometrieSaine(self, geomParams):
 
   # ---------------------------------------------------------------------------
   def genereGeometrieSaine(self, geomParams):

+    """a écrire"""

     logging.info("genereGeometrieSaine %s", self.nomCas)
 
     angleCoude = geomParams['angleCoude']
     logging.info("genereGeometrieSaine %s", self.nomCas)
 
     angleCoude = geomParams['angleCoude']


@@ -304,14 +302,14 @@ class fissureCoude(fissureGenerique):
       logging.info(text)
       raise Exception(text)
 
       logging.info(text)
       raise Exception(text)
 

-    mp1 = maillageSain.GroupOnGeom(P1,'P1',SMESH.NODE)
-    mp2 = maillageSain.GroupOnGeom(P2,'P2',SMESH.NODE)
-    ext = maillageSain.GroupOnGeom(EXTUBE,'EXTUBE',SMESH.FACE)
-    btu = maillageSain.GroupOnGeom(BORDTU,'BORDTU',SMESH.EDGE)
-    clg = maillageSain.GroupOnGeom(CLGV,'CLGV',SMESH.FACE)
-    pei = maillageSain.GroupOnGeom(PEAUINT,'PEAUINT',SMESH.FACE)
-    pex = maillageSain.GroupOnGeom(PEAUEXT,'PEAUEXT',SMESH.FACE)
-    cou = maillageSain.GroupOnGeom(COUDE,'COUDSAIN',SMESH.VOLUME)
+    _ = maillageSain.GroupOnGeom(P1,'P1',SMESH.NODE)
+    _ = maillageSain.GroupOnGeom(P2,'P2',SMESH.NODE)
+    _ = maillageSain.GroupOnGeom(EXTUBE,'EXTUBE',SMESH.FACE)
+    _ = maillageSain.GroupOnGeom(BORDTU,'BORDTU',SMESH.EDGE)
+    _ = maillageSain.GroupOnGeom(CLGV,'CLGV',SMESH.FACE)
+    _ = maillageSain.GroupOnGeom(PEAUINT,'PEAUINT',SMESH.FACE)
+    _ = maillageSain.GroupOnGeom(PEAUEXT,'PEAUEXT',SMESH.FACE)
+    _ = maillageSain.GroupOnGeom(COUDE,'COUDSAIN',SMESH.VOLUME)

 
     return [maillageSain, True] # True : maillage hexa
 
 
     return [maillageSain, True] # True : maillage hexa
 


@@ -344,7 +342,8 @@ class fissureCoude(fissureGenerique):
                                    externe     = True)
 
   # ---------------------------------------------------------------------------
                                    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)
 
     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' )
 
       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]
 
 
     return [facefiss, centre, lgInfluence, coordsNoeudsFissure, wiretube, edgetube]
 


@@ -678,12 +678,14 @@ class fissureCoude(fissureGenerique):
     return elementsDefaut
 
   # ---------------------------------------------------------------------------
     return elementsDefaut
 
   # ---------------------------------------------------------------------------

-  def genereMaillageFissure(self, geometriesSaines, maillagesSains,
-                            shapesFissure, shapeFissureParams,
-                            maillageFissureParams, elementsDefaut, step):
-    maillageFissure = construitFissureGenerale(maillagesSains,
-                                               shapesFissure, shapeFissureParams,
-                                               maillageFissureParams, elementsDefaut, step)
+  def genereMaillageFissure(self, geometriesSaines, maillagesSains, \
+                            shapesFissure, shapeFissureParams, \
+                            maillageFissureParams, elementsDefaut, step, \
+                            mailleur="MeshGems"):
+    maillageFissure = construitFissureGenerale(maillagesSains, \
+                                               shapesFissure, shapeFissureParams, \
+                                               maillageFissureParams, elementsDefaut, \
+                                               step, mailleur)

     return maillageFissure
 
   # ---------------------------------------------------------------------------
     return maillageFissure
 
   # ---------------------------------------------------------------------------


@@ -696,4 +698,3 @@ class fissureCoude(fissureGenerique):
                                           Entity_Quad_Hexa       = 8994,
                                           Entity_Quad_Penta      = 972,
                                           Entity_Quad_Pyramid    = 1038)
                                           Entity_Quad_Hexa       = 8994,
                                           Entity_Quad_Penta      = 972,
                                           Entity_Quad_Pyramid    = 1038)

-

diff --git a/src/Tools/blocFissure/gmu/fissureGenerique.py b/src/Tools/blocFissure/gmu/fissureGenerique.py
index ccae1a82c6657e63ed488401475379595fb71ebe..7f77fa69325773629cc289e0e8e733cc8d135b2e 100644 (file)
--- a/src/Tools/blocFissure/gmu/fissureGenerique.py
+++ b/src/Tools/blocFissure/gmu/fissureGenerique.py
@@ -63,7 +63,7 @@ class fissureGenerique(object):
     """setParamShapeFissure"""
     self.shapeFissureParams = dict()
 
     """setParamShapeFissure"""
     self.shapeFissureParams = dict()
 

-  def genereShapeFissure(self, geometriesSaines, geomParams, shapeFissureParams):
+  def genereShapeFissure(self, geometriesSaines, geomParams, shapeFissureParams, mailleur="MeshGems"):

     """genereShapeFissure"""
     shapesFissure = [None]
     return shapesFissure
     """genereShapeFissure"""
     shapesFissure = [None]
     return shapesFissure


@@ -77,8 +77,10 @@ class fissureGenerique(object):
     elementsDefaut = [None]
     return elementsDefaut
 
     elementsDefaut = [None]
     return elementsDefaut
 

-  def genereMaillageFissure(self, geometriesSaines, maillagesSains, shapesFissure,
-                            maillageFissureParams, elementsDefaut):
+  def genereMaillageFissure(self, geometriesSaines, maillagesSains, \
+                                  shapesFissure, maillageFissureParams, \
+                                  elementsDefaut, \
+                                  mailleur="MeshGems"):

     """genereMaillageFissure"""
     maillageFissure = None
     return maillageFissure
     """genereMaillageFissure"""
     maillageFissure = None
     return maillageFissure


@@ -88,6 +90,12 @@ class fissureGenerique(object):
     referencesMaillageFissure = dict()
     return referencesMaillageFissure
 
     referencesMaillageFissure = dict()
     return referencesMaillageFissure
 

+  def mailleur2d3d(self):
+    """Le mailleur : NETGEN ou MeshGems"""
+    #mailleur = "MeshGems"
+    mailleur = "NETGEN"
+    return mailleur
+

 # ---------------------------------------------------------------------------
 
   def executeProbleme(self, step=-1):
 # ---------------------------------------------------------------------------
 
   def executeProbleme(self, step=-1):


@@ -101,26 +109,33 @@ class fissureGenerique(object):
     geometriesSaines = self.genereGeometrieSaine(self.geomParams)
     if step == 1:
       return
     geometriesSaines = self.genereGeometrieSaine(self.geomParams)
     if step == 1:
       return

+    logging.info("AAAAAAAAAAAAAAAAAAAA")

 
     self.setParamMaillageSain()
     maillagesSains = self.genereMaillageSain(geometriesSaines, self.meshParams)
     if step == 2:
       return
 
     self.setParamMaillageSain()
     maillagesSains = self.genereMaillageSain(geometriesSaines, self.meshParams)
     if step == 2:
       return

+    logging.info("BBBBBBBBBBBBBBBBBBBBB")

 
     self.setParamShapeFissure()
 
     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
     if step == 3:
       return

+    logging.info("CCCCCCCCCCCCCCCCCCCCCCCC")

 
     self.setParamMaillageFissure()
 
     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
     if step == 4:
       return

+    logging.info("DDDDDDDDDDDDDDDDDDDD")

 
 

-    maillageFissure = self.genereMaillageFissure(geometriesSaines, maillagesSains,
-                                                 shapesFissure, self.shapeFissureParams,
-                                                 self.maillageFissureParams, elementsDefaut, step)
+    maillageFissure = self.genereMaillageFissure(geometriesSaines, maillagesSains, \
+                                                 shapesFissure, self.shapeFissureParams, self.maillageFissureParams, \
+                                                 elementsDefaut, step, mailleur)

 
 

+    logging.info("EEEEEEEEEEEEEEEEEES")

     self.setReferencesMaillageFissure()
     ok_maillage = getStatsMaillageFissure(maillageFissure, self.referencesMaillageFissure, self.maillageFissureParams)
     return ok_maillage
     self.setReferencesMaillageFissure()
     ok_maillage = getStatsMaillageFissure(maillageFissure, self.referencesMaillageFissure, self.maillageFissureParams)
     return ok_maillage

diff --git a/src/Tools/blocFissure/gmu/genereElemsFissureElliptique.py b/src/Tools/blocFissure/gmu/genereElemsFissureElliptique.py
index 9a7225b72ad69aa9515cc368d22cd43ac02b6b7b..e6d1763fd622bdba28698b47f5e6ff82ecb39577 100644 (file)
--- a/src/Tools/blocFissure/gmu/genereElemsFissureElliptique.py
+++ b/src/Tools/blocFissure/gmu/genereElemsFissureElliptique.py
@@ -32,12 +32,13 @@ from .genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
 # -----------------------------------------------------------------------------
 # --- création élements géométriques fissure elliptique
 
 # -----------------------------------------------------------------------------
 # --- création élements géométriques fissure elliptique
 

-def genereElemsFissureElliptique(shapeFissureParams):
+def genereElemsFissureElliptique(shapeFissureParams, \
+                                 mailleur="MeshGems"):

   """
   TODO: a completer
   """
   logging.info('start')
   """
   TODO: a completer
   """
   logging.info('start')

-  
+

   centreDefaut  = shapeFissureParams['centreDefaut']
   vecteurDefaut = shapeFissureParams['vecteurDefaut']
   demiGrandAxe  = shapeFissureParams['demiGrandAxe']
   centreDefaut  = shapeFissureParams['centreDefaut']
   vecteurDefaut = shapeFissureParams['vecteurDefaut']
   demiGrandAxe  = shapeFissureParams['demiGrandAxe']


@@ -49,7 +50,7 @@ def genereElemsFissureElliptique(shapeFissureParams):
 
   allonge = demiGrandAxe/demiPetitAxe
   rayonTore = demiPetitAxe/5.0
 
   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
   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)
 
   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
 
   return shapeDefaut, xyz_defaut, tailleDefaut, coordsNoeudsFissure, pipe0, gener1, pipe1, facefis1, plane1, ellipsoide1

diff --git a/src/Tools/blocFissure/gmu/genereMeshCalculZoneDefaut.py b/src/Tools/blocFissure/gmu/genereMeshCalculZoneDefaut.py
index 90942514a20be717179206532c0789b3c23f9463..3a423775ac36ff2b257dc63cda8a53d2d58b4475 100644 (file)
--- a/src/Tools/blocFissure/gmu/genereMeshCalculZoneDefaut.py
+++ b/src/Tools/blocFissure/gmu/genereMeshCalculZoneDefaut.py
@@ -25,10 +25,17 @@ from salome.smesh import smeshBuilder
 # -----------------------------------------------------------------------------
 # --- maillage face de fissure pour identification zone de defaut
 
 # -----------------------------------------------------------------------------
 # --- maillage face de fissure pour identification zone de defaut
 

-def genereMeshCalculZoneDefaut(facefiss, minSize, maxSize):
-  """
-  -Permet de générer un maillage sur l'objet géométrique 'facefiss' via
-   l'algorithme NETGEN_1D2D :
+def genereMeshCalculZoneDefaut(facefiss, minSize, maxSize, \
+                               mailleur="MeshGems"):
+  """Maillage de l'objet géométrique 'facefiss'
+
+. 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)
       -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,22 +44,32 @@ 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
        [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')
    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)
 
   meshFissure = smesh.Mesh(facefiss)

-  algo2d = meshFissure.Triangle(algo=smeshBuilder.NETGEN_1D2D)
-  hypo2d = algo2d.Parameters()
-  hypo2d.SetMaxSize( maxSize )
-  hypo2d.SetSecondOrder( 0 )
-  hypo2d.SetOptimize( 1 )
-  hypo2d.SetFineness( 2 )
-  hypo2d.SetMinSize( minSize )
-  hypo2d.SetQuadAllowed( 0 )
+  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 )
+    hypo2d.SetSecondOrder( 0 )
+    hypo2d.SetOptimize( 1 )
+    hypo2d.SetFineness( 2 )
+    hypo2d.SetMinSize( minSize )
+    hypo2d.SetQuadAllowed( 0 )

   smesh.SetName(algo2d, "algo2d_zoneFiss")
   smesh.SetName(hypo2d, "hypo1d_zoneFiss")
 
   smesh.SetName(algo2d, "algo2d_zoneFiss")
   smesh.SetName(hypo2d, "hypo1d_zoneFiss")
 


@@ -67,8 +84,8 @@ def genereMeshCalculZoneDefaut(facefiss, minSize, maxSize):
 
   coordsNoeudsFissure = list()
   nodeIds = meshFissure.GetNodesId()
 
   coordsNoeudsFissure = list()
   nodeIds = meshFissure.GetNodesId()

-  for id in nodeIds:
-    coords = meshFissure.GetNodeXYZ(id)
+  for indice in nodeIds:
+    coords = meshFissure.GetNodeXYZ(indice)

     coordsNoeudsFissure.append(coords[0])
     coordsNoeudsFissure.append(coords[1])
     coordsNoeudsFissure.append(coords[2])
     coordsNoeudsFissure.append(coords[0])
     coordsNoeudsFissure.append(coords[1])
     coordsNoeudsFissure.append(coords[2])

diff --git a/src/Tools/blocFissure/gmu/insereFissureGenerale.py b/src/Tools/blocFissure/gmu/insereFissureGenerale.py
index b65478d751e20e6e8c703fe71d9ad35d7e7f7906..9067f7b8cfdf7cff5244a5b82519b7f5e96c2694 100644 (file)
--- a/src/Tools/blocFissure/gmu/insereFissureGenerale.py
+++ b/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 .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 .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 .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 .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
 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,
 
 def insereFissureGenerale(maillagesSains,
                           shapesFissure, shapeFissureParams,

-                          maillageFissureParams, elementsDefaut, step=-1):
-  """
-  TODO: a completer
-  """
+                          maillageFissureParams, elementsDefaut, \
+                          step=-1, mailleur="MeshGems"):
+  """ TODO: a completer"""

   logging.info('start')
 
   shapeDefaut       = shapesFissure[0] # faces de fissure, débordant
   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
       geomPublishInFather(initLog.debug,partitionPeauFissFond, edgesFondC, "edgesFondFiss")
 
       if aretesVivesC is None: #= global facesInside facesOnside

-        [edgesInside, edgesOutside, edgesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "EDGE", 1.e-3)
-        [facesInside, facesOutside, facesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "FACE", 1.e-3)
+        [edgesInside, _, _] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "EDGE", 1.e-3)
+        [facesInside, _, facesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "FACE", 1.e-3)

       else:
       else:

-        [edgesInside, edgesOutside, edgesOnside] = extractionOrienteeMulti(facesDefaut, ifil, partitionPeauFissFond, centreFondFiss, "EDGE", 1.e-3)
-        [facesInside, facesOutside, facesOnside] = extractionOrienteeMulti(facesDefaut, ifil, partitionPeauFissFond, centreFondFiss, "FACE", 1.e-3)
+        [edgesInside, _, _] = extractionOrienteeMulti(facesDefaut, ifil, partitionPeauFissFond, centreFondFiss, "EDGE", 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
 
       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)
             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)
           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.
               name="faceFissExt%d"%iedf
               geomPublishInFather(initLog.debug,partitionPeauFissFond, face, name)
               dist = 1.

-              for ipe, edpe in enumerate(edgesPeauFis):
-                for ipi, edpi in enumerate(edgesPipeFis):
+              for _, edpe in enumerate(edgesPeauFis):
+                for _, edpi in enumerate(edgesPipeFis):

                   dist = geompy.MinDistance(edpe, edpi)
                   if dist < 1.e-3:
                     edgesFissExtPeau.append(edpe)
                   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)
         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)
         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])
               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)
           partitionPeauByPipe = geompy.MakePartition(facesAndFond, outilPart, list(), list(), geompy.ShapeType["FACE"], 0, list(), 1)

-          pass

 
       name="partitionPeauByPipe%d"%ifil
       geomPublish(initLog.debug, partitionPeauByPipe, name)
 
       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
       [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)
         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
                   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)
 
         # --- 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)
           verticesCircPeau[i] = grpVertCircPeau
           name = "pointEdgeCirc%d"%i
           geomPublishInFather(initLog.debug,facePeau, grpVertCircPeau, name)

-          pass
-        pass # --- au moins une extrémité du pipe sur cette face de peau
+        # --- au moins une extrémité du pipe sur cette face de peau

 
       # --- edges de bord de la 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):
   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:
       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):
   # --- 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)
-    if id < 0:
+    indice = idFacesDebouchantes[i] # indice de face débouchante (facesPipePeau)
+    if indice < 0:

       listEdges.append(list())
     else:
       listEdges.append(list())
     else:

-      face = facesPipePeau[id]
-      edges = [edgeRadFacePipePeau[id]]
+      face = facesPipePeau[indice]
+      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
       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):
 
   # --- 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)
-    if id >= 0:
+    indice = idFacesDebouchantes[i] # indice de face débouchante (facesPipePeau)
+    if indice >= 0:

       gptdsk = list()
       gptdsk = list()

-      if id > 0: # id 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)
-      centre = ptEdgeFond[idFillingFromBout[i]][id]
-      name = "centre%d"%id
+      if indice > 0: # indice vaut 0 ou 1
+        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]][indice]
+      name = "centre%d"%indice

       geomPublish(initLog.debug, centre, name)
       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()
       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]
             bout = extrCircs[0]
           else:
             bout = extrCircs[1]

-          pass

         else:
           bout = geompy.MakeVertexOnCurve(distEdgeCirc[0][2], u)
         name ="bout%d"%k
         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:
       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)
         else:
           coords = geompy.PointCoordinates(pt)

-          id = meshPipe.AddNode(coords[0], coords[1], coords[2])
-        mptids.append(id)
+          indice = meshPipe.AddNode(coords[0], coords[1], coords[2])
+        mptids.append(indice)

       mptdsk.append(mptids)
     mptsdisks.append(mptdsk)
 
       mptdsk.append(mptids)
     mptsdisks.append(mptdsk)
 


@@ -1182,14 +1168,14 @@ def insereFissureGenerale(maillagesSains,
   pipeFissGroup = meshPipe.CreateEmptyGroup( SMESH.VOLUME, 'PIPEFISS' )
   nbAdd = pipeFissGroup.AddFrom( meshPipe.GetMesh() )
 
   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
 
   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)
   nbAdded, internalBoundary, _NoneGroup = internalBoundary.MakeBoundaryElements( SMESH.BND_1DFROM2D, '', '', 0, [  ])
   criteres = list()
   unCritere = smesh.GetCriterion(SMESH.EDGE,SMESH.FT_FreeBorders,SMESH.FT_Undefined,0)


@@ -1233,14 +1219,24 @@ def insereFissureGenerale(maillagesSains,
   logging.debug("---------------------------- maillage faces de fissure externes au pipe :%s --------------", len(facesFissExt))
 
   meshFaceFiss = smesh.Mesh(faceFissureExterne)
   logging.debug("---------------------------- maillage faces de fissure externes au pipe :%s --------------", len(facesFissExt))
 
   meshFaceFiss = smesh.Mesh(faceFissureExterne)

-  algo2d = meshFaceFiss.Triangle(algo=smeshBuilder.NETGEN_1D2D)
-  hypo2d = algo2d.Parameters()
-  hypo2d.SetMaxSize( areteFaceFissure )
-  hypo2d.SetSecondOrder( 0 )
-  hypo2d.SetOptimize( 1 )
-  hypo2d.SetFineness( 2 )
-  hypo2d.SetMinSize( rayonPipe/float(nbsegRad) )
-  hypo2d.SetQuadAllowed( 0 )
+  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 )
+    hypo2d.SetSecondOrder( 0 )
+    hypo2d.SetOptimize( 1 )
+    hypo2d.SetFineness( 2 )
+    hypo2d.SetMinSize( rayonPipe/float(nbsegRad) )
+    hypo2d.SetQuadAllowed( 0 )

   putName(algo2d.GetSubMesh(), "faceFiss")
   putName(algo2d, "algo2d_faceFiss")
   putName(hypo2d, "hypo2d_faceFiss")
   putName(algo2d.GetSubMesh(), "faceFiss")
   putName(algo2d, "algo2d_faceFiss")
   putName(hypo2d, "hypo2d_faceFiss")


@@ -1334,13 +1330,23 @@ def insereFissureGenerale(maillagesSains,
           putName(algo1d, "algo1d_" + name, ifil)
           putName(hypo1d, "hypo1d_" + name, ifil)
 
           putName(algo1d, "algo1d_" + name, ifil)
           putName(hypo1d, "hypo1d_" + name, ifil)
 

-    algo2d = meshFacePeau.Triangle(algo=smeshBuilder.NETGEN_1D2D)
-    hypo2d = algo2d.Parameters()
-    hypo2d.SetMaxSize( dmoyen )
-    hypo2d.SetOptimize( 1 )
-    hypo2d.SetFineness( 2 )
-    hypo2d.SetMinSize( rayonPipe/float(nbsegRad) )
-    hypo2d.SetQuadAllowed( 0 )
+    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*0.75 )
+      hypo2d.SetOptimize( 1 )
+      hypo2d.SetFineness( 2 )
+      hypo2d.SetMinSize( rayonPipe/float(nbsegRad) )
+      hypo2d.SetQuadAllowed( 0 )

     putName(algo2d.GetSubMesh(), "facePeau", ifil)
     putName(algo2d, "algo2d_facePeau", ifil)
     putName(hypo2d, "hypo2d_facePeau", ifil)
     putName(algo2d.GetSubMesh(), "facePeau", ifil)
     putName(algo2d, "algo2d_facePeau", ifil)
     putName(hypo2d, "hypo2d_facePeau", ifil)


@@ -1381,13 +1387,17 @@ def insereFissureGenerale(maillagesSains,
       elif grp.GetName() == "fisInPi":
         group_faceFissInPipe = grp
 
       elif grp.GetName() == "fisInPi":
         group_faceFissInPipe = grp
 

-  # le maillage NETGEN ne passe pas toujours ==> utiliser GHS3D
-  distene=True
-  if distene:
-    algo3d = meshBoiteDefaut.Tetrahedron(algo=smeshBuilder.GHS3D)
+  # le maillage NETGEN ne passe pas toujours ==> on force l'usage de MG_Tetra
+  mailleur = "MeshGems"
+  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)
   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")
   putName(algo3d.GetSubMesh(), "boiteDefaut")
   putName(algo3d, "algo3d_boiteDefaut")
   putName(meshBoiteDefaut, "boiteDefaut")


@@ -1401,7 +1411,7 @@ def insereFissureGenerale(maillagesSains,
     logging.info(text)
     raise Exception(text)
 
     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")
   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']
   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']
 
   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))
   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)
 
   logging.info("export maillage fini")
   maillageComplet.ExportMED(fichierMaillageFissure)

diff --git a/src/Tools/blocFissure/gmu/insereFissureLongue.py b/src/Tools/blocFissure/gmu/insereFissureLongue.py
index a2f17b4c8bb3d4a26ff723d711a320374bcb8507..dcc67d1381eadaa4ad2720e213bab4e779e5f5c9 100644 (file)
--- a/src/Tools/blocFissure/gmu/insereFissureLongue.py
+++ b/src/Tools/blocFissure/gmu/insereFissureLongue.py
@@ -54,9 +54,10 @@ from blocFissure.gmu.insereFissureLongue_d import insereFissureLongue_d
 # -----------------------------------------------------------------------------
 # --- procedure complete fissure longue
 
 # -----------------------------------------------------------------------------
 # --- procedure complete fissure longue
 

-def insereFissureLongue(geometriesSaines, maillagesSains,
-                        shapesFissure, shapeFissureParams,
-                        maillageFissureParams, elementsDefaut, step=-1):
+def insereFissureLongue(geometriesSaines, maillagesSains, \
+                        shapesFissure, shapeFissureParams, \
+                        maillageFissureParams, elementsDefaut, \
+                        step=-1, mailleur="MeshGems"):

   """
   TODO: a completer
   """
   """
   TODO: a completer
   """


@@ -436,10 +437,9 @@ def insereFissureLongue(geometriesSaines, maillagesSains,
 
   # --- maillage meshBoiteDefaut
 
 
   # --- maillage meshBoiteDefaut
 

-  distene=True

   meshBoiteDefaut, group_faceFissInPipe, group_faceFissOutPipe = \
             insereFissureLongue_d (internalBoundary, meshFondFiss, meshFacePeau, meshFaceFiss, \
   meshBoiteDefaut, group_faceFissInPipe, group_faceFissOutPipe = \
             insereFissureLongue_d (internalBoundary, meshFondFiss, meshFacePeau, meshFaceFiss, \

-            distene)
+            mailleur)

 
 
   groups = maillageSain.GetGroups()
 
 
   groups = maillageSain.GetGroups()

diff --git a/src/Tools/blocFissure/gmu/insereFissureLongue_b.py b/src/Tools/blocFissure/gmu/insereFissureLongue_b.py
index 8df253dde11b01115bfbda50205912b226049d8f..67eb3517586c4d8325100fe961efcae2513ccc3f 100644 (file)
--- a/src/Tools/blocFissure/gmu/insereFissureLongue_b.py
+++ b/src/Tools/blocFissure/gmu/insereFissureLongue_b.py
@@ -30,18 +30,29 @@ from .putName import putName
 
 def insereFissureLongue_b (facePeau, edgePeauFiss, groupEdgesBordPeau, bordsLibres, \
                            groupsDemiCerclesPeau, groups_demiCercles, verticesOutCercles, \
 
 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)
   """maillage face de peau"""
   logging.info('start')
 
   meshFacePeau = smesh.Mesh(facePeau)

-  algo2d = meshFacePeau.Triangle(algo=smeshBuilder.NETGEN_2D)
-  hypo2d = algo2d.Parameters()
-  hypo2d.SetMaxSize( 1000 )
-  hypo2d.SetOptimize( 1 )
-  hypo2d.SetFineness( 2 )
-  hypo2d.SetMinSize( 2 )
-  hypo2d.SetQuadAllowed( 0 )
+  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 )
+    hypo2d.SetOptimize( 1 )
+    hypo2d.SetFineness( 2 )
+    hypo2d.SetMinSize( 2 )
+    hypo2d.SetQuadAllowed( 0 )

   putName(algo2d.GetSubMesh(), "facePeau")
   putName(algo2d, "algo2d_facePeau")
   putName(hypo2d, "hypo2d_facePeau")
   putName(algo2d.GetSubMesh(), "facePeau")
   putName(algo2d, "algo2d_facePeau")
   putName(hypo2d, "hypo2d_facePeau")

diff --git a/src/Tools/blocFissure/gmu/insereFissureLongue_c.py b/src/Tools/blocFissure/gmu/insereFissureLongue_c.py
index 35988dc2ade27abba8ad05414498e5664230f7c6..4cdb8b29b595e27dfcc4e92173d97c3284c13b9d 100644 (file)
--- a/src/Tools/blocFissure/gmu/insereFissureLongue_c.py
+++ b/src/Tools/blocFissure/gmu/insereFissureLongue_c.py
@@ -30,18 +30,30 @@ from .putName import putName
 import math
 
 def insereFissureLongue_c (faceFiss, edgePeauFiss, groupEdgesPeauFiss, group_generFiss, groupEdgesFaceFissPipe, \
 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)
   """maillage face de fissure"""
   logging.info('start')
 
   meshFaceFiss = smesh.Mesh(faceFiss)

-  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.SetOptimize( 1 )
-  hypo2d.SetFineness( 2 )
-  hypo2d.SetMinSize( 2 )
-  hypo2d.SetQuadAllowed( 0 )
+  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( mesh_size )
+    hypo2d.SetOptimize( 1 )
+    hypo2d.SetFineness( 2 )
+    hypo2d.SetMinSize( 2 )
+    hypo2d.SetQuadAllowed( 0 )

   putName(algo2d.GetSubMesh(), "faceFiss")
   putName(algo2d, "algo2d_faceFiss")
   putName(hypo2d, "hypo2d_faceFiss")
   putName(algo2d.GetSubMesh(), "faceFiss")
   putName(algo2d, "algo2d_faceFiss")
   putName(hypo2d, "hypo2d_faceFiss")

diff --git a/src/Tools/blocFissure/gmu/insereFissureLongue_d.py b/src/Tools/blocFissure/gmu/insereFissureLongue_d.py
index ba9c382a3d910d801cf665c6bbff01bac4fc9868..03c2fae0e8cdc6f17d548a68a67379a414f631a8 100644 (file)
--- a/src/Tools/blocFissure/gmu/insereFissureLongue_d.py
+++ b/src/Tools/blocFissure/gmu/insereFissureLongue_d.py
@@ -28,9 +28,10 @@ import SMESH
 from .putName import putName
 
 def insereFissureLongue_d (internalBoundary, meshFondFiss, meshFacePeau, meshFaceFiss, \
 from .putName import putName
 
 def insereFissureLongue_d (internalBoundary, meshFondFiss, meshFacePeau, meshFaceFiss, \

-                           distene = True):
+                           mailleur="MeshGems"):

   """maillage meshBoiteDefaut"""
   logging.info('start')
   """maillage meshBoiteDefaut"""
   logging.info('start')

+  logging.info("insereFissureLongue_d (%s)", mailleur)

 
   meshBoiteDefaut = smesh.Concatenate( [internalBoundary.GetMesh(), \
                                         meshFondFiss.GetMesh(), \
 
   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
 
       elif grp.GetName() == "fisInPi":
         group_faceFissInPipe = grp
 

-  # le maillage NETGEN ne passe pas toujours ==> utiliser GHS3D
-  if distene:
-    algo3d = meshBoiteDefaut.Tetrahedron(algo=smeshBuilder.GHS3D)
+  # le maillage NETGEN ne passe pas toujours ==> on force l'usage de MG_Tetra
+  mailleur = "MeshGems"
+  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)
   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")
   putName(algo3d.GetSubMesh(), "boiteDefaut")
   putName(algo3d, "algo3d_boiteDefaut")
   putName(meshBoiteDefaut, "boiteDefaut")

diff --git a/src/Tools/blocFissure/gmu/mailleFacesFissure.py b/src/Tools/blocFissure/gmu/mailleFacesFissure.py
index d9eed2dbcd2adf6ef4ae2f8fe2ad10967fdb14e6..e67d7d8f4ef7452ce3a883727b0a72e43b29bd00 100644 (file)
--- a/src/Tools/blocFissure/gmu/mailleFacesFissure.py
+++ b/src/Tools/blocFissure/gmu/mailleFacesFissure.py
@@ -27,22 +27,32 @@ import SMESH
 
 from .putName import putName
 
 
 from .putName import putName
 

-def mailleFacesFissure(faceFissureExterne, edgesPipeFissureExterneC, edgesPeauFissureExterneC, \
-                        meshPipeGroups, areteFaceFissure, rayonPipe, nbsegRad):
+def mailleFacesFissure(faceFissureExterne, \
+                       edgesPipeFissureExterneC, edgesPeauFissureExterneC, \
+                       meshPipeGroups, areteFaceFissure, rayonPipe, nbsegRad, \
+                       mailleur="MeshGems"):

   """maillage faces de fissure"""
   logging.info('start')
   """maillage faces de fissure"""
   logging.info('start')

-  texte = "Maillage de {}".format(faceFissureExterne.GetName())
-  logging.info(texte)

 
   meshFaceFiss = smesh.Mesh(faceFissureExterne)
 
   meshFaceFiss = smesh.Mesh(faceFissureExterne)

-  algo2d = meshFaceFiss.Triangle(algo=smeshBuilder.NETGEN_1D2D)
-  hypo2d = algo2d.Parameters()
-  hypo2d.SetMaxSize( areteFaceFissure )
-  hypo2d.SetSecondOrder( 0 )
-  hypo2d.SetOptimize( 1 )
-  hypo2d.SetFineness( 2 )
-  hypo2d.SetMinSize( rayonPipe/float(nbsegRad) )
-  hypo2d.SetQuadAllowed( 0 )
+  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 )
+    hypo2d.SetSecondOrder( 0 )
+    hypo2d.SetOptimize( 1 )
+    hypo2d.SetFineness( 2 )
+    hypo2d.SetMinSize( rayonPipe/float(nbsegRad) )
+    hypo2d.SetQuadAllowed( 0 )

   putName(algo2d.GetSubMesh(), "faceFiss")
   putName(algo2d, "algo2d_faceFiss")
   putName(hypo2d, "hypo2d_faceFiss")
   putName(algo2d.GetSubMesh(), "faceFiss")
   putName(algo2d, "algo2d_faceFiss")
   putName(hypo2d, "hypo2d_faceFiss")

diff --git a/src/Tools/blocFissure/gmu/mailleFacesPeau.py b/src/Tools/blocFissure/gmu/mailleFacesPeau.py
index f3486985ea094fcff4880e3ed5ea50aeb53f29c7..8bd39dba936399f5f3255ca8f7be24c5180441b7 100644 (file)
--- a/src/Tools/blocFissure/gmu/mailleFacesPeau.py
+++ b/src/Tools/blocFissure/gmu/mailleFacesPeau.py
@@ -32,12 +32,14 @@ import SMESH
 
 from .putName import putName
 
 
 from .putName import putName
 

-def mailleFacesPeau(partitionsPeauFissFond, idFillingFromBout, facesDefaut,
-                    facesPeaux, edCircPeau, ptCircPeau, gpedgeBord, gpedgeVifs, edFissPeau,
-                    bordsLibres, grpEdgesPeauFissureExterne, grpAretesVives,
-                    edgesCircPipeGroup, dmoyen, rayonPipe, nbsegRad):
+def mailleFacesPeau(partitionsPeauFissFond, idFillingFromBout, facesDefaut, \
+                    facesPeaux, edCircPeau, ptCircPeau, gpedgeBord, gpedgeVifs, edFissPeau, \
+                    bordsLibres, grpEdgesPeauFissureExterne, grpAretesVives, \
+                    edgesCircPipeGroup, dmoyen, rayonPipe, nbsegRad, \
+                    mailleur="MeshGems"):

   """maillage faces de peau"""
   logging.info('start')
   """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
   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]
       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]
 
       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)
       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)
 
       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)
 
       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)
       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):
         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:
         if edgeCirc is not None:
           algo1d = meshFacePeau.UseExisting1DElements(geom=edgeCirc)
           if boutFromIfil[ifil] is None:


@@ -114,15 +115,25 @@ def mailleFacesPeau(partitionsPeauFissFond, idFillingFromBout, facesDefaut,
           putName(algo1d, "algo1d_" + name, ifil)
           putName(hypo1d, "hypo1d_" + name, ifil)
 
           putName(algo1d, "algo1d_" + name, ifil)
           putName(hypo1d, "hypo1d_" + name, ifil)
 

-    print ("c")
-    algo2d = meshFacePeau.Triangle(algo=smeshBuilder.NETGEN_1D2D)
-    hypo2d = algo2d.Parameters()
-    hypo2d.SetMaxSize( dmoyen )
-    hypo2d.SetOptimize( 1 )
-    hypo2d.SetFineness( 2 )
-    hypo2d.SetMinSize( rayonPipe/float(nbsegRad) )
-    hypo2d.SetQuadAllowed( 0 )
-    print ("d")
+    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 )
+      hypo2d.SetOptimize( 1 )
+      hypo2d.SetFineness( 2 )
+      hypo2d.SetMinSize( rayonPipe/float(nbsegRad) )
+      hypo2d.SetQuadAllowed( 0 )
+    logging.info("d")

     putName(algo2d.GetSubMesh(), "facePeau", ifil)
     putName(algo2d, "algo2d_facePeau", ifil)
     putName(hypo2d, "hypo2d_facePeau", ifil)
     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 )
       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
     meshesFacesPeau.append(meshFacePeau)
 
   return meshesFacesPeau

diff --git a/src/Tools/blocFissure/gmu/meshBlocPart.py b/src/Tools/blocFissure/gmu/meshBlocPart.py
index 1a6cf33e40a1043cba194b069e566dceee349bcc..c65742c78628da10f0214d56c0630196d320c679 100644 (file)
--- a/src/Tools/blocFissure/gmu/meshBlocPart.py
+++ b/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, \
 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
   """Maillage du bloc partitionné
 
   TODO: a completer

diff --git a/src/Tools/blocFissure/materielCasTests/genereMateriel.py b/src/Tools/blocFissure/materielCasTests/genereMateriel.py
index 9a32986824629d9e332fba57df76e1c09ec9b77f..a798c67eaebb9ebcabd721f374396d404d28f982 100644 (file)
--- a/src/Tools/blocFissure/materielCasTests/genereMateriel.py
+++ b/src/Tools/blocFissure/materielCasTests/genereMateriel.py
@@ -19,15 +19,15 @@
 #
 
 from blocFissure.materielCasTests import cubeAngle
 #
 
 from blocFissure.materielCasTests import cubeAngle

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