decoupage insereFissureGenerale, renommée construitFissureGenerale, premiere phase : géometrie

src/Tools/blocFissure/CasTests/cubeAngle.py

@@ -18,7 +18,7 @@ from blocFissure.gmu.fissureGenerique import fissureGenerique
 from blocFissure.gmu.triedreBase import triedreBase
 from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
 from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
-from blocFissure.gmu.insereFissureGenerale import insereFissureGenerale
+from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale
 
 O, OX, OY, OZ = triedreBase()
 
@@ -41,7 +41,7 @@ class cubeAngle(fissureGenerique):
   # ---------------------------------------------------------------------------
   def setParamShapeFissure(self):
     """
-    paramètres de la fissure pour méthode insereFissureGenerale
+    paramètres de la fissure pour méthode construitFissureGenerale
     lgInfluence : distance autour de la shape de fissure a remailler (A ajuster selon le maillage)
     rayonPipe   : le rayon du pile maillé en hexa autour du fond de fissure
     """
@@ -85,9 +85,9 @@ class cubeAngle(fissureGenerique):
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                             shapesFissure, shapeFissureParams,
                             maillageFissureParams, elementsDefaut, step):
-    maillageFissure = insereFissureGenerale(maillagesSains,
+    maillageFissure = construitFissureGenerale(maillagesSains,
-                                            shapesFissure, shapeFissureParams,
+                                               shapesFissure, shapeFissureParams,
-                                            maillageFissureParams, elementsDefaut, step)
+                                               maillageFissureParams, elementsDefaut, step)
     return maillageFissure
 
   # ---------------------------------------------------------------------------

src/Tools/blocFissure/CasTests/cubeAngle2.py

@@ -13,7 +13,7 @@ class cubeAngle2(cubeAngle):
   # ---------------------------------------------------------------------------
   def setParamShapeFissure(self):
     """
-    paramètres de la fissure pour méthode insereFissureGenerale
+    paramètres de la fissure pour méthode construitFissureGenerale
     lgInfluence : distance autour de la shape de fissure a remailler (A ajuster selon le maillage)
     rayonPipe   : le rayon du pile maillé en hexa autour du fond de fissure
     """

src/Tools/blocFissure/CasTests/cylindre.py

@@ -18,7 +18,7 @@ from blocFissure.gmu.fissureGenerique import fissureGenerique
 from blocFissure.gmu.triedreBase import triedreBase
 from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
 from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
-from blocFissure.gmu.insereFissureGenerale import insereFissureGenerale
+from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale
 
 O, OX, OY, OZ = triedreBase()
 
@@ -45,7 +45,7 @@ class cylindre(fissureGenerique):
   # ---------------------------------------------------------------------------
   def setParamShapeFissure(self):
     """
-    paramètres de la fissure pour méthode insereFissureGenerale
+    paramètres de la fissure pour méthode construitFissureGenerale
     lgInfluence : distance autour de la shape de fissure a remailler (A ajuster selon le maillage)
     rayonPipe   : le rayon du pile maillé en hexa autour du fond de fissure
     """
@@ -89,9 +89,9 @@ class cylindre(fissureGenerique):
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                             shapesFissure, shapeFissureParams,
                             maillageFissureParams, elementsDefaut, step):
-    maillageFissure = insereFissureGenerale(maillagesSains,
+    maillageFissure = construitFissureGenerale(maillagesSains,
-                                            shapesFissure, shapeFissureParams,
+                                               shapesFissure, shapeFissureParams,
-                                            maillageFissureParams, elementsDefaut, step)
+                                               maillageFissureParams, elementsDefaut, step)
     return maillageFissure
 
   # ---------------------------------------------------------------------------

src/Tools/blocFissure/CasTests/cylindre_2.py

@@ -15,7 +15,7 @@ from cylindre import cylindre
 from blocFissure.gmu.triedreBase import triedreBase
 from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
 from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
-from blocFissure.gmu.insereFissureGenerale import insereFissureGenerale
+from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale
 
 O, OX, OY, OZ = triedreBase()
 

src/Tools/blocFissure/CasTests/ellipse_1.py

@@ -18,7 +18,7 @@ from blocFissure.gmu.fissureGenerique import fissureGenerique
 from blocFissure.gmu.triedreBase import triedreBase
 from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
 from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
-from blocFissure.gmu.insereFissureGenerale import insereFissureGenerale
+from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale
 
 O, OX, OY, OZ = triedreBase()
 
@@ -47,7 +47,7 @@ class ellipse_1(fissureGenerique):
   # ---------------------------------------------------------------------------
   def setParamShapeFissure(self):
     """
-    paramètres de la fissure pour méthode insereFissureGenerale
+    paramètres de la fissure pour méthode construitFissureGenerale
     lgInfluence : distance autour de la shape de fissure a remailler (A ajuster selon le maillage)
     rayonPipe   : le rayon du pile maillé en hexa autour du fond de fissure
     convexe     : optionnel, True : la face est convexe (vue de l'exterieur) sert si on ne donne pas de point interne
@@ -93,9 +93,9 @@ class ellipse_1(fissureGenerique):
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                             shapesFissure, shapeFissureParams,
                             maillageFissureParams, elementsDefaut, step):
-    maillageFissure = insereFissureGenerale(maillagesSains,
+    maillageFissure = construitFissureGenerale(maillagesSains,
-                                            shapesFissure, shapeFissureParams,
+                                               shapesFissure, shapeFissureParams,
-                                            maillageFissureParams, elementsDefaut, step)
+                                               maillageFissureParams, elementsDefaut, step)
     return maillageFissure
 
   # ---------------------------------------------------------------------------

src/Tools/blocFissure/CasTests/ellipse_2.py

@@ -18,7 +18,7 @@ from ellipse_1 import ellipse_1
 from blocFissure.gmu.triedreBase import triedreBase
 from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
 from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
-from blocFissure.gmu.insereFissureGenerale import insereFissureGenerale
+from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale
 
 O, OX, OY, OZ = triedreBase()
 

src/Tools/blocFissure/CasTests/eprouvetteCourbe.py

@@ -18,7 +18,7 @@ from blocFissure.gmu.fissureGenerique import fissureGenerique
 from blocFissure.gmu.triedreBase import triedreBase
 from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
 from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
-from blocFissure.gmu.insereFissureGenerale import insereFissureGenerale
+from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale
 
 O, OX, OY, OZ = triedreBase()
 
@@ -41,7 +41,7 @@ class eprouvetteCourbe(fissureGenerique):
   # ---------------------------------------------------------------------------
   def setParamShapeFissure(self):
     """
-    paramètres de la fissure pour méthode insereFissureGenerale
+    paramètres de la fissure pour méthode construitFissureGenerale
     lgInfluence : distance autour de la shape de fissure a remailler (A ajuster selon le maillage)
     rayonPipe   : le rayon du pile maillé en hexa autour du fond de fissure
     convexe     : optionnel True : la face est convexe (vue de l'exterieur) sert si on ne donne pas de point interne
@@ -87,9 +87,9 @@ class eprouvetteCourbe(fissureGenerique):
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                             shapesFissure, shapeFissureParams,
                             maillageFissureParams, elementsDefaut, step):
-    maillageFissure = insereFissureGenerale(maillagesSains,
+    maillageFissure = construitFissureGenerale(maillagesSains,
-                                            shapesFissure, shapeFissureParams,
+                                               shapesFissure, shapeFissureParams,
-                                            maillageFissureParams, elementsDefaut, step)
+                                               maillageFissureParams, elementsDefaut, step)
     return maillageFissure
 
   # ---------------------------------------------------------------------------

src/Tools/blocFissure/CasTests/eprouvetteDroite.py

@@ -19,7 +19,7 @@ from blocFissure.gmu.fissureGenerique import fissureGenerique
 from blocFissure.gmu.triedreBase import triedreBase
 from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
 from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
-from blocFissure.gmu.insereFissureGenerale import insereFissureGenerale
+from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale
 
 O, OX, OY, OZ = triedreBase()
 
@@ -42,7 +42,7 @@ class eprouvetteDroite(fissureGenerique):
   # ---------------------------------------------------------------------------
   def setParamShapeFissure(self):
     """
-    paramètres de la fissure pour méthode insereFissureGenerale
+    paramètres de la fissure pour méthode construitFissureGenerale
     lgInfluence : distance autour de la shape de fissure a remailler (A ajuster selon le maillage)
     rayonPipe   : le rayon du pile maillé en hexa autour du fond de fissure
     convexe     : optionnel True : la face est convexe (vue de l'exterieur) sert si on ne donne pas de point interne
@@ -89,9 +89,9 @@ class eprouvetteDroite(fissureGenerique):
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                             shapesFissure, shapeFissureParams,
                             maillageFissureParams, elementsDefaut, step):
-    maillageFissure = insereFissureGenerale(maillagesSains,
+    maillageFissure = construitFissureGenerale(maillagesSains,
-                                            shapesFissure, shapeFissureParams,
+                                               shapesFissure, shapeFissureParams,
-                                            maillageFissureParams, elementsDefaut, step)
+                                               maillageFissureParams, elementsDefaut, step)
     return maillageFissure
 
   # ---------------------------------------------------------------------------

src/Tools/blocFissure/CasTests/eprouvetteDroite_2.py

@@ -18,7 +18,7 @@ from eprouvetteDroite import eprouvetteDroite
 from blocFissure.gmu.triedreBase import triedreBase
 from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
 from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
-from blocFissure.gmu.insereFissureGenerale import insereFissureGenerale
+from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale
 
 O, OX, OY, OZ = triedreBase()
 

src/Tools/blocFissure/CasTests/execution_Cas.py

@@ -5,8 +5,8 @@ import logging
 from blocFissure import gmu
 from blocFissure.gmu import initLog
 #initLog.setDebug()
-#initLog.setVerbose()
+initLog.setVerbose()
-initLog.setPerfTests()
+#initLog.setPerfTests()
 
 from blocFissure.gmu import geomsmesh
 from blocFissure.gmu.casStandard import casStandard
@@ -131,7 +131,7 @@ runall = True
 if runall:
   torun = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,]
 else: #prob 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27   
-  torun = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,]
+  torun = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,]
   
 for i in range(len(problemes)):
   if torun[i]:

src/Tools/blocFissure/CasTests/faceGauche.py

@@ -18,7 +18,7 @@ from blocFissure.gmu.fissureGenerique import fissureGenerique
 from blocFissure.gmu.triedreBase import triedreBase
 from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
 from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
-from blocFissure.gmu.insereFissureGenerale import insereFissureGenerale
+from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale
 
 O, OX, OY, OZ = triedreBase()
 
@@ -41,7 +41,7 @@ class faceGauche(fissureGenerique):
   # ---------------------------------------------------------------------------
   def setParamShapeFissure(self):
     """
-    paramètres de la fissure pour méthode insereFissureGenerale
+    paramètres de la fissure pour méthode construitFissureGenerale
     lgInfluence : distance autour de la shape de fissure a remailler (A ajuster selon le maillage)
     rayonPipe   : le rayon du pile maillé en hexa autour du fond de fissure
     convexe     : optionnel True : la face est convexe (vue de l'exterieur) sert si on ne donne pas de point interne
@@ -87,9 +87,9 @@ class faceGauche(fissureGenerique):
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                             shapesFissure, shapeFissureParams,
                             maillageFissureParams, elementsDefaut, step):
-    maillageFissure = insereFissureGenerale(maillagesSains,
+    maillageFissure = construitFissureGenerale(maillagesSains,
-                                            shapesFissure, shapeFissureParams,
+                                               shapesFissure, shapeFissureParams,
-                                            maillageFissureParams, elementsDefaut, step)
+                                               maillageFissureParams, elementsDefaut, step)
     return maillageFissure
 
   # ---------------------------------------------------------------------------

src/Tools/blocFissure/CasTests/faceGauche_2.py

@@ -19,7 +19,7 @@ from blocFissure.gmu.fissureGenerique import fissureGenerique
 from blocFissure.gmu.triedreBase import triedreBase
 from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
 from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
-from blocFissure.gmu.insereFissureGenerale import insereFissureGenerale
+from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale
 
 O, OX, OY, OZ = triedreBase()
 
@@ -42,7 +42,7 @@ class faceGauche_2(fissureGenerique):
   # ---------------------------------------------------------------------------
   def setParamShapeFissure(self):
     """
-    paramètres de la fissure pour méthode insereFissureGenerale
+    paramètres de la fissure pour méthode construitFissureGenerale
     lgInfluence : distance autour de la shape de fissure a remailler (A ajuster selon le maillage)
     rayonPipe   : le rayon du pile maillé en hexa autour du fond de fissure
     convexe     : optionnel True : la face est convexe (vue de l'exterieur) sert si on ne donne pas de point interne
@@ -88,9 +88,9 @@ class faceGauche_2(fissureGenerique):
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                             shapesFissure, shapeFissureParams,
                             maillageFissureParams, elementsDefaut, step):
-    maillageFissure = insereFissureGenerale(maillagesSains,
+    maillageFissure = construitFissureGenerale(maillagesSains,
-                                            shapesFissure, shapeFissureParams,
+                                               shapesFissure, shapeFissureParams,
-                                            maillageFissureParams, elementsDefaut, step)
+                                               maillageFissureParams, elementsDefaut, step)
     return maillageFissure
 
   # ---------------------------------------------------------------------------

src/Tools/blocFissure/CasTests/vis_1.py

@@ -18,7 +18,7 @@ from blocFissure.gmu.fissureGenerique import fissureGenerique
 from blocFissure.gmu.triedreBase import triedreBase
 from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
 from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
-from blocFissure.gmu.insereFissureGenerale import insereFissureGenerale
+from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale
 
 O, OX, OY, OZ = triedreBase()
 
@@ -41,7 +41,7 @@ class vis_1(fissureGenerique):
   # ---------------------------------------------------------------------------
   def setParamShapeFissure(self):
     """
-    paramètres de la fissure pour méthode insereFissureGenerale
+    paramètres de la fissure pour méthode construitFissureGenerale
     lgInfluence : distance autour de la shape de fissure a remailler (A ajuster selon le maillage)
     rayonPipe   : le rayon du pile maillé en hexa autour du fond de fissure
     convexe     : optionnel True : la face est convexe (vue de l'exterieur) sert si on ne donne pas de point interne
@@ -87,9 +87,9 @@ class vis_1(fissureGenerique):
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                             shapesFissure, shapeFissureParams,
                             maillageFissureParams, elementsDefaut, step):
-    maillageFissure = insereFissureGenerale(maillagesSains,
+    maillageFissure = construitFissureGenerale(maillagesSains,
-                                            shapesFissure, shapeFissureParams,
+                                               shapesFissure, shapeFissureParams,
-                                            maillageFissureParams, elementsDefaut, step)
+                                               maillageFissureParams, elementsDefaut, step)
     return maillageFissure
 
   # ---------------------------------------------------------------------------

src/Tools/blocFissure/gmu/__init__.py

@@ -2,9 +2,6 @@
 
 import os
 import initLog
-#initLog.setDebug()
-#initLog.setVerbose()
-#initLog.setRelease()
 
 # --- calcul path blocFissure
 

src/Tools/blocFissure/gmu/casStandard.py

@@ -19,7 +19,7 @@ from blocFissure.gmu.initEtude import initEtude
 from blocFissure.gmu.triedreBase import triedreBase
 from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
 from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
-from blocFissure.gmu.insereFissureGenerale import insereFissureGenerale
+from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale
 
 O, OX, OY, OZ = triedreBase()
 
@@ -124,9 +124,9 @@ class casStandard(fissureGenerique):
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                             shapesFissure, shapeFissureParams,
                             maillageFissureParams, elementsDefaut, step):
-    maillageFissure = insereFissureGenerale(maillagesSains,
+    maillageFissure = construitFissureGenerale(maillagesSains,
-                                            shapesFissure, shapeFissureParams,
+                                              shapesFissure, shapeFissureParams,
-                                            maillageFissureParams, elementsDefaut, step)
+                                              maillageFissureParams, elementsDefaut, step)
     return maillageFissure
 
   # ---------------------------------------------------------------------------

src/Tools/blocFissure/gmu/compoundFromList.py

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+
+import logging
+from geomsmesh import geompy
+
+def compoundFromList(elements, nom=None):
+  """
+  
+  """
+  logging.debug('start')
+  
+  shapeList = []
+  for a in elements:
+    if not isinstance(a, list):
+      shapeList.append(a)
+    else:
+      if a[0] is not None:
+        shapeList.append(a[0])
+      
+  if nom is not None:
+    for i,a in enumerate(shapeList):
+      nom = nom +"%d"%i
+      logging.debug('nom: %s',nom)
+      geompy.addToStudy(a, nom)
+
+  shapeCompound = None
+  if len(shapeList) > 0:
+    shapeCompound =geompy.MakeCompound(shapeList)
+
+  return shapeCompound
+    

src/Tools/blocFissure/gmu/construitFissureGenerale.py

@@ -0,0 +1,937 @@
+# -*- coding: utf-8 -*-
+
+import logging
+import salome
+from geomsmesh import geompy
+import GEOM
+from geomsmesh import smesh
+from salome.smesh import smeshBuilder
+import SMESH
+import math
+import bisect
+
+from extractionOrientee import extractionOrientee
+from extractionOrienteeMulti import extractionOrienteeMulti
+from sortFaces import sortFaces
+from sortEdges import sortEdges
+from eliminateDoubles import eliminateDoubles
+from substractSubShapes import substractSubShapes
+from produitMixte import produitMixte
+from findWireEndVertices import findWireEndVertices
+from findWireIntermediateVertices import findWireIntermediateVertices
+from orderEdgesFromWire import orderEdgesFromWire
+from getSubshapeIds import getSubshapeIds
+from putName import putName
+from distance2 import distance2
+from enleveDefaut import enleveDefaut
+from shapeSurFissure import shapeSurFissure
+from regroupeSainEtDefaut import RegroupeSainEtDefaut
+from triedreBase import triedreBase
+from checkDecoupePartition import checkDecoupePartition
+from whichSide import whichSide
+from whichSideMulti import whichSideMulti
+from whichSideVertex import whichSideVertex
+from projettePointSurCourbe import projettePointSurCourbe
+from prolongeWire import prolongeWire
+from restreintFaceFissure import restreintFaceFissure
+from partitionneFissureParPipe import partitionneFissureParPipe
+from construitPartitionsPeauFissure import construitPartitionsPeauFissure
+from compoundFromList import compoundFromList
+from identifieElementsGeometriquesPeau import identifieElementsGeometriquesPeau
+
+# -----------------------------------------------------------------------------
+# --- procédure complète fissure générale
+
+def construitFissureGenerale(maillagesSains,
+                             shapesFissure, shapeFissureParams,
+                             maillageFissureParams, elementsDefaut, step=-1):
+  """
+  TODO: a completer
+  """
+  logging.info('start')
+  
+  shapeDefaut       = shapesFissure[0] # faces de fissure, débordant
+  fondFiss          = shapesFissure[4] # groupe d'edges de fond de fissure
+
+  rayonPipe = shapeFissureParams['rayonPipe']
+  if shapeFissureParams.has_key('lenSegPipe'):
+    lenSegPipe = shapeFissureParams['lenSegPipe']
+  else:
+    lenSegPipe = rayonPipe
+
+  nomRep            = maillageFissureParams['nomRep']
+  nomFicSain        = maillageFissureParams['nomFicSain']
+  nomFicFissure     = maillageFissureParams['nomFicFissure']
+
+  nbsegRad          = maillageFissureParams['nbsegRad']      # nombre de couches selon un rayon du pipe
+  nbsegCercle       = maillageFissureParams['nbsegCercle']   # nombre de secteur dans un cercle du pipe
+  areteFaceFissure  = maillageFissureParams['areteFaceFissure']
+
+  pointIn_x = 0.0
+  pointIn_y = 0.0
+  pointIn_z = 0.0
+  isPointInterne = False
+  if shapeFissureParams.has_key('pointIn_x'):
+    pointIn_x = shapeFissureParams['pointIn_x']
+    isPointInterne = True
+  if shapeFissureParams.has_key('pointIn_y'):
+    pointIn_y = shapeFissureParams['pointIn_y']
+    isPointInterne = True
+  if shapeFissureParams.has_key('pointIn_z'):
+    pointIn_z = shapeFissureParams['pointIn_z']
+    isPointInterne = True
+  if isPointInterne:
+    pointInterne = geompy.MakeVertex(pointIn_x, pointIn_y, pointIn_z)
+  else:
+    pointInterne = None
+
+  #fichierMaillageSain = nomRep + '/' + nomFicSain + '.med'
+  fichierMaillageFissure = nomRep + '/' + nomFicFissure + '.med'
+
+  # fillings des faces en peau
+  facesDefaut = elementsDefaut[0]
+  #centresDefaut            = elementsDefaut[1]
+  #normalsDefaut            = elementsDefaut[2]
+  #extrusionsDefaut         = elementsDefaut[3]
+  dmoyen                   = elementsDefaut[4]
+  bordsPartages = elementsDefaut[5]
+  fillconts                = elementsDefaut[6]
+  idFilToCont              = elementsDefaut[7]
+  maillageSain             = elementsDefaut[8]
+  internalBoundary         = elementsDefaut[9]
+  zoneDefaut               = elementsDefaut[10]
+  zoneDefaut_skin          = elementsDefaut[11]
+  zoneDefaut_internalFaces = elementsDefaut[12]
+  zoneDefaut_internalEdges = elementsDefaut[13]
+  edgeFondExt              = elementsDefaut[14]
+  centreFondFiss           = elementsDefaut[15]
+  tgtCentre                = elementsDefaut[16]
+
+  O, OX, OY, OZ = triedreBase()
+
+  # --- restriction de la face de fissure au domaine solide :
+  #     partition face fissure étendue par fillings, on garde la face interne
+  
+  facesPortFissure = restreintFaceFissure(shapeDefaut, facesDefaut, pointInterne)
+ 
+  # --- pipe de fond de fissure, prolongé, partition face fissure par pipe
+  #     identification des edges communes pipe et face fissure
+  
+  (fissPipe, edgesPipeFiss, edgesFondFiss, wirePipeFiss, wireFondFiss) = partitionneFissureParPipe(shapesFissure, elementsDefaut, rayonPipe)
+  edgesFondFiss, edgesIdByOrientation = orderEdgesFromWire(wireFondFiss)
+  for i,edge in enumerate(edgesFondFiss):
+    geompy.addToStudyInFather(wireFondFiss, edge, "edgeFondFiss%d"%i)
+  
+  # --- peau et face de fissure
+  #
+  # --- partition peau défaut - face de fissure prolongée - wire de fond de fissure prolongée
+  #     il peut y avoir plusieurs faces externes, dont certaines sont découpées par la fissure
+  #     liste de faces externes : facesDefaut
+  #     liste de partitions face externe - fissure : partitionPeauFissFond (None quand pas d'intersection)
+
+  partitionsPeauFissFond = construitPartitionsPeauFissure(facesDefaut, fissPipe)
+    
+  # --- arêtes vives détectées (dans quadranglesToShapeNoCorner
+  #                             et quadranglesToShapeWithCorner)
+    
+  aretesVivesCoupees = []  #= global
+  
+  aretesVivesC = compoundFromList(bordsPartages, "areteVive")
+ 
+  # -------------------------------------------------------
+  # --- inventaire des faces de peau coupées par la fissure
+  #     pour chaque face de peau : 0, 1 ou 2 faces débouchante du fond de fissure
+  #                                0, 1 ou plus edges de la face de fissure externe au pipe
+  
+  nbFacesFilling = len(partitionsPeauFissFond)
+  
+  ptEdgeFond = [ []  for i in range(nbFacesFilling)] # pour chaque face [points edge fond de fissure aux débouchés du pipe]
+  fsPipePeau = [ []  for i in range(nbFacesFilling)] # pour chaque face [faces du pipe débouchantes]
+  edRadFPiPo = [ []  for i in range(nbFacesFilling)] # pour chaque face [edge radiale des faces du pipe débouchantes ]
+  fsFissuExt = [ []  for i in range(nbFacesFilling)] # pour chaque face [faces de fissure externes au pipe]
+  edFisExtPe = [ []  for i in range(nbFacesFilling)] # pour chaque face [edge en peau des faces de fissure externes (pas subshape facePeau)]
+  edFisExtPi = [ []  for i in range(nbFacesFilling)] # pour chaque face [edge commun au pipe des faces de fissure externes]
+  facesPeaux = [None for i in range(nbFacesFilling)] # pour chaque face : la face de peau finale a mailler (percée des faces débouchantes)
+  edCircPeau = [ []  for i in range(nbFacesFilling)] # pour chaque face de peau : [subshape edge circulaire aux débouchés du pipe]
+  ptCircPeau = [ []  for i in range(nbFacesFilling)] # pour chaque face de peau : [subshape point sur edge circulaire aux débouchés du pipe]
+  gpedgeBord = [None for i in range(nbFacesFilling)] # pour chaque face de peau : groupe subshape des edges aux bords liés à la partie saine
+  gpedgeVifs = [None for i in range(nbFacesFilling)] # pour chaque face de peau : groupes subshape des edges aux arêtes vives entre fillings
+  edFissPeau = [ []  for i in range(nbFacesFilling)] # pour chaque face de peau : [subshape edge en peau des faces de fissure externes]
+  ptFisExtPi = [ []  for i in range(nbFacesFilling)] # pour chaque face de peau : [point commun edFissPeau edCircPeau]
+  
+  for ifil, partitionPeauFissFond in enumerate(partitionsPeauFissFond):
+    if partitionPeauFissFond is not None:
+      dataPPFF,aretesVivesCoupees = identifieElementsGeometriquesPeau(ifil, partitionPeauFissFond, edgesPipeFiss,
+                                                                      edgesFondFiss, wireFondFiss, aretesVivesC,
+                                                                      facesDefaut, centreFondFiss, rayonPipe,
+                                                                      aretesVivesCoupees)
+      
+      ptEdgeFond[ifil] = dataPPFF['endsEdgeFond']
+      fsPipePeau[ifil] = dataPPFF['facesPipePeau']
+      edRadFPiPo[ifil] = dataPPFF['edgeRadFacePipePeau']
+      fsFissuExt[ifil] = dataPPFF['facesFissExt']
+      edFisExtPe[ifil] = dataPPFF['edgesFissExtPeau']
+      edFisExtPi[ifil] = dataPPFF['edgesFissExtPipe']
+      facesPeaux[ifil] = dataPPFF['facePeau']
+      edCircPeau[ifil] = dataPPFF['edgesCircPeau']
+      ptCircPeau[ifil] = dataPPFF['verticesCircPeau']
+      gpedgeBord[ifil] = dataPPFF['groupEdgesBordPeau']
+      gpedgeVifs[ifil] = dataPPFF['bordsVifs']
+      edFissPeau[ifil] = dataPPFF['edgesFissurePeau']
+      ptFisExtPi[ifil] = dataPPFF['verticesPipePeau']
+
+  # -----------------------------------------------------------------------
+  # fin de la boucle sur les faces de filling
+  # -----------------------------------------------------------------------
+  
+  for i, avc in enumerate(aretesVivesCoupees):
+    name = "areteViveCoupee%d"%i
+    geompy.addToStudy(avc, name)
+  
+  # --- identification des faces et edges de fissure externe pour maillage
+  
+  facesFissExt = []
+  edgesFissExtPeau = []
+  edgesFissExtPipe = []
+  for ifil in range(nbFacesFilling): # TODO: éliminer les doublons (comparer tous les vertices triés, avec mesure de distance ?)
+    facesFissExt += fsFissuExt[ifil]
+    edgesFissExtPeau += edFisExtPe[ifil]
+    edgesFissExtPipe += edFisExtPi[ifil]
+  logging.debug("---------------------------- identification faces de fissure externes au pipe :%s ", len(facesFissExt))
+  # regroupement des faces de fissure externes au pipe.
+  
+  if len(facesFissExt) > 1:
+    faceFissureExterne = geompy.MakePartition(facesFissExt, [], [], [], geompy.ShapeType["FACE"], 0, [], 0)
+    edgesPipeFissureExterneC = geompy.GetInPlace(faceFissureExterne, geompy.MakeCompound(edgesPipeFiss))    # edgesFissExtPipe peut ne pas couvrir toute la longueur
+    # edgesPeauFissureExterneC = geompy.GetInPlace(faceFissureExterne, geompy.MakeCompound(edgesFissExtPeau))
+    # il peut manquer des edges de faceFissureExterne en contact avec la peau dans edgesFissExtPeau
+    (isDone, closedFreeBoundaries, openFreeBoundaries) = geompy.GetFreeBoundary(faceFissureExterne)
+    edgesBordFFE = []
+    for bound in closedFreeBoundaries:
+      edgesBordFFE += geompy.ExtractShapes(bound, geompy.ShapeType["EDGE"], False)
+    edgesBordFFEid = [ (ed,geompy.GetSubShapeID(faceFissureExterne, ed)) for ed in edgesBordFFE]
+    logging.debug("edgesBordFFEid %s", edgesBordFFEid)
+    edgesPPE = geompy.ExtractShapes(edgesPipeFissureExterneC, geompy.ShapeType["EDGE"], False)
+    edgesPPEid = [ geompy.GetSubShapeID(faceFissureExterne, ed) for ed in edgesPPE]
+    logging.debug("edgesPPEid %s", edgesPPEid)
+    edgesPFE = [ edid[0] for edid in edgesBordFFEid if edid[1] not in edgesPPEid] # on garde toutes les edges de bord non en contact avec le pipe
+    logging.debug("edgesPFE %s", edgesPFE)
+    edgesPeauFissureExterneC = geompy.MakeCompound(edgesPFE)
+  else:
+    faceFissureExterne = facesFissExt[0]
+    edgesPeauFissureExterneC = geompy.MakeCompound(edgesFissExtPeau)
+    edgesPipeFissureExterneC = geompy.MakeCompound(edgesFissExtPipe)
+  wirePipeFissureExterne = geompy.MakeWire(geompy.ExtractShapes(edgesPipeFissureExterneC, geompy.ShapeType["EDGE"], False))
+  geompy.addToStudy(faceFissureExterne, "faceFissureExterne")
+  geompy.addToStudyInFather(faceFissureExterne, edgesPeauFissureExterneC, "edgesPeauFissureExterne")
+  geompy.addToStudyInFather(faceFissureExterne, edgesPipeFissureExterneC, "edgesPipeFissureExterne")
+  
+  logging.debug("---------------------------- Preparation Maillage du Pipe --------------")
+  # -----------------------------------------------------------------------
+  # --- preparation maillage du pipe :
+  #     - détections des points a respecter : jonction des edges/faces constituant
+  #       la face de fissure externe au pipe
+  #     - points sur les edges de fond de fissure et edges pipe/face fissure,
+  #     - vecteurs tangents au fond de fissure (normal au disque maillé)
+
+  # --- option de maillage selon le rayon de courbure du fond de fissure 
+  lenEdgeFondExt = 0
+  for edff in edgesFondFiss:
+    lenEdgeFondExt += geompy.BasicProperties(edff)[0]
+  
+  disfond = []
+  for filling in facesDefaut:
+    disfond.append(geompy.MinDistance(centreFondFiss, filling))
+  disfond.sort()
+  rcourb = disfond[0]
+  nbSegQuart = 5 # on veut 5 segments min sur un quart de cercle
+  alpha = math.pi/(4*nbSegQuart)
+  deflexion = rcourb*(1.0 -math.cos(alpha))
+  lgmin = lenSegPipe*0.25
+  lgmax = lenSegPipe*1.5               
+  logging.debug("rcourb: %s, lenFond:%s, deflexion: %s, lgmin: %s, lgmax: %s", rcourb, lenEdgeFondExt, deflexion, lgmin, lgmax)  
+
+  meshFondExt = smesh.Mesh(wireFondFiss)
+  algo1d = meshFondExt.Segment()
+  hypo1d = algo1d.Adaptive(lgmin, lgmax, deflexion) # a ajuster selon la profondeur de la fissure
+  isDone = meshFondExt.Compute()
+  
+  ptGSdic = {} # dictionnaire [paramètre sur la courbe] --> point géométrique
+  allNodeIds = meshFondExt.GetNodesId()
+  for nodeId in allNodeIds:
+    xyz = meshFondExt.GetNodeXYZ(nodeId)
+    #logging.debug("nodeId %s, coords %s", nodeId, str(xyz))
+    pt = geompy.MakeVertex(xyz[0], xyz[1], xyz[2])
+    u, PointOnEdge, EdgeInWireIndex = geompy.MakeProjectionOnWire(pt, wireFondFiss) # u compris entre 0 et 1
+    edgeOrder = edgesIdByOrientation[EdgeInWireIndex]
+    ptGSdic[(edgeOrder, EdgeInWireIndex, u)] = pt
+    #logging.debug("nodeId %s, u %s", nodeId, str(u))
+  usort = sorted(ptGSdic)  
+  logging.debug("nombre de points obtenus par deflexion %s",len(usort))
+     
+  centres = []
+  origins = []
+  normals = []      
+  for edu in usort:
+    ied = edu[1]
+    u = edu[2]
+    vertcx = ptGSdic[edu]
+    norm = geompy.MakeTangentOnCurve(edgesFondFiss[ied], u)
+    plan = geompy.MakePlane(vertcx, norm, 3*rayonPipe)
+    part = geompy.MakePartition([plan], [wirePipeFiss], [], [], geompy.ShapeType["VERTEX"], 0, [], 0)
+    liste = geompy.ExtractShapes(part, geompy.ShapeType["VERTEX"], True)
+    if len(liste) == 5: # 4 coins du plan plus intersection recherchée
+      for point in liste:
+        if geompy.MinDistance(point, vertcx) < 1.1*rayonPipe: # les quatre coins sont plus loin
+          vertpx = point
+          break
+      centres.append(vertcx)
+      origins.append(vertpx)
+      normals.append(norm)
+#      name = "vertcx%d"%i
+#      geompy.addToStudyInFather(wireFondFiss, vertcx, name)
+#      name = "vertpx%d"%i
+#      geompy.addToStudyInFather(wireFondFiss, vertpx, name)
+#      name = "plan%d"%i
+#      geompy.addToStudyInFather(wireFondFiss, plan, name)
+
+  # --- maillage du pipe étendu, sans tenir compte de l'intersection avec la face de peau
+      
+  logging.debug("nbsegCercle %s", nbsegCercle)
+  
+  # -----------------------------------------------------------------------
+  # --- points géométriques
+  
+  gptsdisks = [] # vertices géométrie de tous les disques
+  raydisks = [[] for i in range(nbsegCercle)]
+  for i in range(len(centres)): # boucle sur les disques
+    gptdsk = [] # vertices géométrie d'un disque
+    vertcx = centres[i]
+    vertpx = origins[i]
+    normal = normals[i]
+    vec1 = geompy.MakeVector(vertcx, vertpx)
+    
+    points = [vertcx] # les points du rayon de référence
+    for j in range(nbsegRad):
+      pt = geompy.MakeTranslationVectorDistance(vertcx, vec1, (j+1)*float(rayonPipe)/nbsegRad)
+      points.append(pt)
+    gptdsk.append(points)
+    pt = geompy.MakeTranslationVectorDistance(vertcx, vec1, 1.5*rayonPipe)
+    rayon = geompy.MakeLineTwoPnt(vertcx, pt)
+    raydisks[0].append(rayon)
+    
+    for k in range(nbsegCercle-1):
+      angle = (k+1)*2*math.pi/nbsegCercle
+      pts = [vertcx] # les points d'un rayon obtenu par rotation
+      for j in range(nbsegRad):
+        pt = geompy.MakeRotation(points[j+1], normal, angle)
+        pts.append(pt)
+      gptdsk.append(pts)
+      ray = geompy.MakeRotation(rayon, normal, angle)
+      raydisks[k+1].append(ray)
+      
+    gptsdisks.append(gptdsk) 
+ 
+  # -----------------------------------------------------------------------
+  # --- recherche des points en trop (externes au volume à remailler)
+  #     - on associe chaque extrémité du pipe à une face filling 
+  #     - on part des disques aux extrémités du pipe
+  #     - pour chaque disque, on prend les vertices de géométrie,
+  #       on marque leur position relative à la face.
+  #     - on s'arrete quand tous les noeuds sont dedans
+  
+  logging.debug("---------------------------- recherche des points du pipe a éliminer --------------")
+
+  pt0 = centres[0]
+  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
+      if geompy.MinDistance(pt,pt0) < geompy.MinDistance(pt,pt1): # TODO: trouver plus fiable pour les cas tordus...
+        idFillingFromBout[0] = ifil
+      else: 
+        idFillingFromBout[1] = ifil
+  logging.debug("association bouts du pipe - faces de filling: %s", idFillingFromBout)
+  
+  facesPipePeau = []
+  edgeRadFacePipePeau = []
+  for ifil in range(nbFacesFilling):
+    facesPipePeau += fsPipePeau[ifil]
+    edgeRadFacePipePeau += edRadFPiPo[ifil]
+    
+  logging.debug("recherche des disques de noeuds complètement internes")
+  idisklim = [] # indices des premier et dernier disques internes
+  idiskout = [] # indices des premier et dernier disques externes
+  for bout in range(2):
+    if bout == 0:
+      idisk = -1
+      inc = 1
+      numout = -1
+    else:
+      idisk = len(gptsdisks)
+      inc = -1
+      numout = len(gptsdisks)
+    inside = False
+    outside = True
+    while not inside:
+      idisk = idisk + inc
+      logging.debug("examen disque %s", idisk)
+      gptdsk = gptsdisks[idisk]
+      inside = True
+      for k in range(nbsegCercle):
+        points = gptdsk[k]
+        for j, pt in enumerate(points):
+          side = whichSideVertex(facesDefaut[idFillingFromBout[bout]], pt)
+          if side < 0:
+            if outside: # premier point detecté dedans
+              outside = False
+              numout = idisk -inc # le disque précédent était dehors
+          else:
+            inside = False # ce point est dehors              
+        if not inside and not outside:
+          break
+    idisklim.append(idisk)  # premier et dernier disques internes
+    idiskout.append(numout) # premier et dernier disques externes
+    
+  # --- listes de nappes radiales en filling à chaque extrémité débouchante
+  facesDebouchantes = [False, False]
+  idFacesDebouchantes = [-1, -1] # contiendra les indices des faces disque débouchantes (facesPipePeau)
+  listNappes =[]
+  for i, idisk in enumerate(idisklim):
+    numout = idiskout[i]
+    logging.debug("extremité %s, indices disques interne %s, externe %s",i, idisk, numout)
+    nappes = []
+    if  (idisk != 0) and (idisk != len(gptsdisks)-1): # si extrémité débouchante
+      for k in range(nbsegCercle):
+        if i == 0:
+          iddeb = max(0, numout)
+          idfin = max(iddeb+3,idisk+1) # il faut 3 rayons pour faire un filling qui suive le fond de fissure
+          #logging.debug("extremité %s, indices retenus interne %s, externe %s",i, idfin, iddeb)
+          comp = geompy.MakeCompound(raydisks[k][iddeb:idfin])
+          name='compoundRay%d'%k
+          geompy.addToStudy(comp, name)
+        else:
+          idfin = min(len(gptsdisks), numout+1)
+          iddeb = min(idfin-3, idisk) # il faut 3 rayons pour faire un filling qui suive le fond de fissure
+          #logging.debug("extremité %s, indices retenus interne %s, externe %s",i, idfin, iddeb)
+          comp = geompy.MakeCompound(raydisks[k][iddeb:idfin])
+          name='compoundRay%d'%k
+          geompy.addToStudy(comp, name)
+        nappe = geompy.MakeFilling(comp, 2, 5, 0.0001, 0.0001, 0, GEOM.FOM_Default)
+        nappes.append(nappe)
+        name='nappe%d'%k
+        geompy.addToStudy(nappe, name)
+        facesDebouchantes[i] = True
+    listNappes.append(nappes)
+      
+  # --- mise en correspondance avec les indices des faces disque débouchantes (facesPipePeau)
+  for i, nappes in enumerate(listNappes):
+    if facesDebouchantes[i]:
+      for k, face in enumerate(facesPipePeau):
+        edge = geompy.MakeSection(face, nappes[0])
+        if geompy.NbShapes(edge, geompy.ShapeType["EDGE"]) > 0:
+          idFacesDebouchantes[i] = k
+          break
+  logging.debug("idFacesDebouchantes: %s", idFacesDebouchantes)
+
+  # --- construction des listes d'edges radiales sur chaque extrémité débouchante
+  listEdges = []
+  for i, nappes in enumerate(listNappes):
+    id = idFacesDebouchantes[i] # indice de face débouchante (facesPipePeau)
+    if id < 0:
+      listEdges.append([])
+    else:
+      face = facesPipePeau[id]
+      edges = [edgeRadFacePipePeau[id]]
+      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
+          edge = obj
+          vs = geompy.ExtractShapes(obj, geompy.ShapeType["VERTEX"], False)
+          if len(vs) > 2:
+            eds = geompy.ExtractShapes(obj, geompy.ShapeType["EDGE"], False)
+            [edsorted, minl,maxl] = sortEdges(eds)
+            edge = edsorted[-1]
+          else:
+            maxl = geompy.BasicProperties(edge)[0]
+          if maxl < 0.01: # problème MakeSection
+            logging.debug("problème MakeSection recherche edge radiale %s, longueur trop faible: %s, utilisation partition", k, maxl)
+            partNappeFace = geompy.MakePartition([face, nappes[k]], [] , [], [], geompy.ShapeType["FACE"], 0, [], 0)
+            edps= geompy.ExtractShapes(partNappeFace, geompy.ShapeType["EDGE"], False)
+            ednouv = []
+            for ii, ed in enumerate(edps):
+              vxs = geompy.ExtractShapes(ed, geompy.ShapeType["VERTEX"], False)
+              distx = [geompy.MinDistance(vx, face) for vx in vxs]
+              distx += [geompy.MinDistance(vx, nappes[k]) for vx in vxs]
+              dmax = max(distx)
+              logging.debug("  dmax %s",dmax)
+              if dmax < 0.01:
+                ednouv.append(ed)
+            logging.debug("  edges issues de la partition: %s", ednouv)
+            for ii, ed in enumerate(ednouv):
+              geompy.addToStudy(ed, "ednouv%d"%ii)
+            [edsorted, minl,maxl] = sortEdges(ednouv)
+            logging.debug("  longueur edge trouvée: %s", maxl) 
+            edge = edsorted[-1]
+          edges.append(edge)
+          name = 'edgeEndPipe%d'%k
+          geompy.addToStudy(edge, name)
+      listEdges.append(edges)
+
+  # --- 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:
+      gptdsk = []
+      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
+      geompy.addToStudy(centre, name)
+      vertPipePeau = ptFisExtPi[idFillingFromBout[i]][id]
+      geompy.addToStudyInFather(centre, vertPipePeau, "vertPipePeau")
+      grpsEdgesCirc = edCircPeau[idFillingFromBout[i]] # liste de groupes
+      edgesCirc = []
+      for grpEdgesCirc in grpsEdgesCirc:
+        edgesCirc += geompy.ExtractShapes(grpEdgesCirc, geompy.ShapeType["EDGE"], False)
+      for k, edge in enumerate(edges):
+        extrems = geompy.ExtractShapes(edge, geompy.ShapeType["VERTEX"], True)
+        if geompy.MinDistance(centre, extrems[0]) < geompy.MinDistance(centre, extrems[1]):
+          bout = extrems[1]
+        else:
+          bout = extrems[0]
+        # ajustement du point extrémité (bout) sur l'edge circulaire en face de peau
+        logging.debug("edgesCirc: %s", edgesCirc)
+        distEdgeCirc = [(geompy.MinDistance(bout, edgeCirc), k2, edgeCirc) for k2, edgeCirc in enumerate(edgesCirc)]
+        distEdgeCirc.sort()
+        logging.debug("distEdgeCirc: %s", distEdgeCirc)
+        u = projettePointSurCourbe(bout, distEdgeCirc[0][2])
+        if (abs(u) < 0.02) or (abs(1-u) < 0.02): # les points très proches d'une extrémité doivent y être mis précisément.
+          extrCircs = geompy.ExtractShapes(distEdgeCirc[0][2], geompy.ShapeType["VERTEX"], True)
+          if geompy.MinDistance(bout, extrCircs[0]) < geompy.MinDistance(bout, extrCircs[1]):
+            bout = extrCircs[0]
+          else:
+            bout = extrCircs[1]
+          pass
+        else:
+          bout = geompy.MakeVertexOnCurve(distEdgeCirc[0][2], u)
+        name ="bout%d"%k
+        geompy.addToStudyInFather(centre, bout, name)
+        # enregistrement des points dans la structure
+        points = []
+        for j in range(nbsegRad +1):
+          u = j/float(nbsegRad)
+          points.append(geompy.MakeVertexOnCurve(edge, u))
+        if geompy.MinDistance(bout, points[0]) < geompy.MinDistance(centre, points[0]):
+          points.reverse()
+        points[0] = centre
+        points[-1] = bout
+        gptdsk.append(points)
+      if i == 0:
+        gptsdisks[idisklim[0] -1] = gptdsk
+        idisklim[0] = idisklim[0] -1
+      else:
+        gptsdisks[idisklim[1] +1] = gptdsk
+        idisklim[1] = idisklim[1] +1
+
+  # --- ajustement precis des points sur edgesPipeFissureExterneC
+  
+  edgesPFE = geompy.ExtractShapes(edgesPipeFissureExterneC, geompy.ShapeType["EDGE"], False)
+  verticesPFE = findWireIntermediateVertices(wirePipeFissureExterne)  # vertices intermédiaires (des points en trop dans ptsInWireFissExtPipe)
+  idiskmin = idisklim[0] + 1 # on ne prend pas le disque sur la peau, déjà ajusté
+  idiskmax = idisklim[1]     # on ne prend pas le disque sur la peau, déjà ajusté
+  idiskint = []
+  for vtx in verticesPFE:
+    distPtVt = []
+    for idisk in range(idiskmin, idiskmax):
+      gptdsk = gptsdisks[idisk]
+      pt = gptdsk[0][-1]       # le point sur l'edge de la fissure externe au pipe
+      distPtVt.append((geompy.MinDistance(pt, vtx), idisk))
+    distPtVt.sort()
+    idiskint.append(distPtVt[0][1])
+    gptsdisks[idiskint[-1]][0][-1] = vtx
+    logging.debug("ajustement point sur edgePipeFissureExterne, vertex: %s %s", idiskint[-1], distPtVt[0][0])
+  for idisk in range(idiskmin, idiskmax):
+    if idisk in idiskint:
+      break
+    logging.debug("ajustement point sur edgePipeFissureExterne: %s", idisk)
+    gptdsk = gptsdisks[idisk]
+    pt = gptdsk[0][-1]       # le point sur l'edge de la fissure externe au pipe
+    distPtEd = [(geompy.MinDistance(pt, edgePFE), k, edgePFE) for k, edgePFE in enumerate(edgesPFE)]
+    distPtEd.sort()
+    edgePFE = distPtEd[0][2]
+    u = projettePointSurCourbe(pt, edgePFE)
+    ptproj = geompy.MakeVertexOnCurve(edgePFE, u)
+    gptsdisks[idisk][0][-1] = ptproj
+  
+  # -----------------------------------------------------------------------
+  # --- maillage effectif du pipe
+
+  logging.debug("---------------------------- maillage effectif du pipe --------------")
+  meshPipe = smesh.Mesh(None, "meshPipe")
+  fondFissGroup = meshPipe.CreateEmptyGroup(SMESH.EDGE, "FONDFISS")
+  nodesFondFissGroup = meshPipe.CreateEmptyGroup(SMESH.NODE, "nfondfis")
+  faceFissGroup = meshPipe.CreateEmptyGroup(SMESH.FACE, "fisInPi")
+  edgeFaceFissGroup = meshPipe.CreateEmptyGroup(SMESH.EDGE, "edgeFaceFiss")
+  edgeCircPipe0Group = meshPipe.CreateEmptyGroup(SMESH.EDGE, "edgeCircPipe0")
+  edgeCircPipe1Group = meshPipe.CreateEmptyGroup(SMESH.EDGE, "edgeCircPipe1")
+  faceCircPipe0Group = meshPipe.CreateEmptyGroup(SMESH.FACE, "faceCircPipe0")
+  faceCircPipe1Group = meshPipe.CreateEmptyGroup(SMESH.FACE, "faceCircPipe1")
+  mptsdisks = []  # vertices maillage de tous les disques
+  mEdges = []     # identifiants edges maillage fond de fissure
+  mEdgeFaces = [] # identifiants edges maillage edge face de fissure externe
+  mFaces = []     # identifiants faces maillage fissure
+  mVols  = []     # identifiants volumes maillage pipe
+
+  mptdsk = None
+  for idisk in range(idisklim[0], idisklim[1]+1): # boucle sur les disques internes
+    
+    # -----------------------------------------------------------------------
+    # --- points
+    
+    gptdsk = gptsdisks[idisk]
+    if idisk > idisklim[0]:
+      oldmpts = mptdsk
+    mptdsk = [] # vertices maillage d'un disque
+    for k in range(nbsegCercle):
+      points = gptdsk[k]
+      mptids = []
+      for j, pt in enumerate(points):
+        if j == 0 and k > 0:
+          id = mptdsk[0][0]
+        else:
+          coords = geompy.PointCoordinates(pt)
+          id = meshPipe.AddNode(coords[0], coords[1], coords[2])
+        mptids.append(id)
+      mptdsk.append(mptids)
+    mptsdisks.append(mptdsk)
+    
+    # -----------------------------------------------------------------------
+    # --- groupes edges cercles debouchants
+    
+    if idisk == idisklim[0]:
+      pts = []
+      for k in range(nbsegCercle):
+        pts.append(mptdsk[k][-1])
+      edges = []
+      for k in range(len(pts)):
+        k1 = (k+1)%len(pts)
+        idEdge = meshPipe.AddEdge([pts[k], pts[k1]])
+        edges.append(idEdge)
+      edgeCircPipe0Group.Add(edges)
+       
+    if idisk == idisklim[1]:
+      pts = []
+      for k in range(nbsegCercle):
+        pts.append(mptdsk[k][-1])
+      edges = []
+      for k in range(len(pts)):
+        k1 = (k+1)%len(pts)
+        idEdge = meshPipe.AddEdge([pts[k], pts[k1]])
+        edges.append(idEdge)
+      edgeCircPipe1Group.Add(edges)
+    
+    # -----------------------------------------------------------------------
+    # --- groupes faces  debouchantes
+    
+    if idisk == idisklim[0]:
+      faces = []
+      for j in range(nbsegRad):
+        for k in range(nbsegCercle):
+          k1 = k+1
+          if k ==  nbsegCercle-1:
+            k1 = 0
+          if j == 0:
+            idf = meshPipe.AddFace([mptdsk[k][0], mptdsk[k][1], mptdsk[k1][1]]) # triangle
+          else:
+            idf = meshPipe.AddFace([mptdsk[k][j], mptdsk[k][j+1], mptdsk[k1][j+1], mptdsk[k1][j]]) # quadrangle
+          faces.append(idf)
+      faceCircPipe0Group.Add(faces)
+
+    if idisk == idisklim[1]:
+      faces = []
+      for j in range(nbsegRad):
+        for k in range(nbsegCercle):
+          k1 = k+1
+          if k ==  nbsegCercle-1:
+            k1 = 0
+          if j == 0:
+            idf = meshPipe.AddFace([mptdsk[k][0], mptdsk[k][1], mptdsk[k1][1]]) # triangle
+          else:
+            idf = meshPipe.AddFace([mptdsk[k][j], mptdsk[k][j+1], mptdsk[k1][j+1], mptdsk[k1][j]]) # quadrangle
+          faces.append(idf)
+      faceCircPipe1Group.Add(faces)
+          
+    # -----------------------------------------------------------------------
+    # --- mailles volumiques, groupes noeuds et edges de fond de fissure, groupe de face de fissure
+    
+    if idisk == idisklim[0]:
+      mEdges.append(0)
+      mEdgeFaces.append(0)
+      mFaces.append([0])
+      mVols.append([[0]])
+      nodesFondFissGroup.Add([mptdsk[0][0]])
+    else:
+      ide = meshPipe.AddEdge([oldmpts[0][0], mptdsk[0][0]])
+      mEdges.append(ide)
+      fondFissGroup.Add([ide])
+      nodesFondFissGroup.Add([mptdsk[0][0]])
+      ide2 = meshPipe.AddEdge([oldmpts[0][-1], mptdsk[0][-1]])
+      mEdgeFaces.append(ide2)
+      edgeFaceFissGroup.Add([ide2])
+      idFaces = []
+      idVols = []
+      
+      for j in range(nbsegRad):
+        idf = meshPipe.AddFace([oldmpts[0][j], mptdsk[0][j], mptdsk[0][j+1], oldmpts[0][j+1]])
+        faceFissGroup.Add([idf])
+        idFaces.append(idf)
+        
+        idVolCercle = []
+        for k in range(nbsegCercle):
+          k1 = k+1
+          if k ==  nbsegCercle-1:
+            k1 = 0
+          if j == 0:
+            idv = meshPipe.AddVolume([mptdsk[k][j], mptdsk[k][j+1], mptdsk[k1][j+1],
+                                      oldmpts[k][j], oldmpts[k][j+1], oldmpts[k1][j+1]])
+          else:
+            idv = meshPipe.AddVolume([mptdsk[k][j], mptdsk[k][j+1], mptdsk[k1][j+1], mptdsk[k1][j],
+                                      oldmpts[k][j], oldmpts[k][j+1], oldmpts[k1][j+1], oldmpts[k1][j]])
+          idVolCercle.append(idv)
+        idVols.append(idVolCercle)  
+        
+      mFaces.append(idFaces)
+      mVols.append(idVols)
+
+  pipeFissGroup = meshPipe.CreateEmptyGroup( SMESH.VOLUME, 'PIPEFISS' )
+  nbAdd = pipeFissGroup.AddFrom( meshPipe.GetMesh() )
+
+  nb, new_mesh, new_group = meshPipe.MakeBoundaryElements(SMESH.BND_2DFROM3D, "pipeBoundaries")
+  edgesCircPipeGroup = [edgeCircPipe0Group, edgeCircPipe1Group]
+
+  # --- fin du maillage du pipe
+  # -----------------------------------------------------------------------
+  # --- edges de bord, faces défaut à respecter
+
+  aFilterManager = smesh.CreateFilterManager()
+  nbAdded, internalBoundary, _NoneGroup = internalBoundary.MakeBoundaryElements( SMESH.BND_1DFROM2D, '', '', 0, [  ])
+  criteres = []
+  unCritere = smesh.GetCriterion(SMESH.EDGE,SMESH.FT_FreeBorders,SMESH.FT_Undefined,0)
+  criteres.append(unCritere)
+  filtre = smesh.GetFilterFromCriteria(criteres)
+  bordsLibres = internalBoundary.MakeGroupByFilter( 'bords', filtre )
+  smesh.SetName(bordsLibres, 'bordsLibres')
+
+  # --- pour aider l'algo hexa-tetra à ne pas mettre de pyramides à l'exterieur des volumes repliés sur eux-mêmes
+  #     on désigne les faces de peau en quadrangles par le groupe "skinFaces"
+
+  skinFaces = internalBoundary.CreateEmptyGroup( SMESH.FACE, 'skinFaces' )
+  nbAdd = skinFaces.AddFrom( internalBoundary.GetMesh() )
+
+  # --- maillage des éventuelles arêtes vives entre faces reconstruites
+  
+  if len(aretesVivesCoupees) > 0:
+    aretesVivesC = geompy.MakeCompound(aretesVivesCoupees)
+    meshAretesVives = smesh.Mesh(aretesVivesC)
+    algo1d = meshAretesVives.Segment()
+    hypo1d = algo1d.LocalLength(dmoyen,[],1e-07)
+    putName(algo1d.GetSubMesh(), "aretesVives")
+    putName(algo1d, "algo1d_aretesVives")
+    putName(hypo1d, "hypo1d_aretesVives")
+    isDone = meshAretesVives.Compute()
+    logging.info("aretesVives fini")
+    grpAretesVives = meshAretesVives.CreateEmptyGroup( SMESH.EDGE, 'grpAretesVives' )
+    nbAdd = grpAretesVives.AddFrom( meshAretesVives.GetMesh() )
+
+  # -----------------------------------------------------------------------
+  # --- maillage faces de fissure
+  
+  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 )
+  putName(algo2d.GetSubMesh(), "faceFiss")
+  putName(algo2d, "algo2d_faceFiss")
+  putName(hypo2d, "hypo2d_faceFiss")
+  
+  algo1d = meshFaceFiss.UseExisting1DElements(geom=edgesPipeFissureExterneC)
+  hypo1d = algo1d.SourceEdges([ edgeFaceFissGroup ],0,0)
+  putName(algo1d.GetSubMesh(), "edgeFissPeau")
+  putName(algo1d, "algo1d_edgeFissPeau")
+  putName(hypo1d, "hypo1d_edgeFissPeau")
+  
+  isDone = meshFaceFiss.Compute()
+  logging.info("meshFaceFiss fini")
+
+  grpFaceFissureExterne = meshFaceFiss.GroupOnGeom(faceFissureExterne, "fisOutPi", SMESH.FACE)
+  grpEdgesPeauFissureExterne = meshFaceFiss.GroupOnGeom(edgesPeauFissureExterneC,'edgesPeauFissureExterne',SMESH.EDGE)
+  grpEdgesPipeFissureExterne = meshFaceFiss.GroupOnGeom(edgesPipeFissureExterneC,'edgesPipeFissureExterne',SMESH.EDGE)
+
+  # --- maillage faces de peau
+    
+  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
+    boutFromIfil[idFillingFromBout[0]] = 0
+    boutFromIfil[idFillingFromBout[1]] = 1
+  
+  logging.debug("---------------------------- maillage faces de peau --------------")
+  meshesFacesPeau = []
+  for ifil in range(nbFacesFilling):
+    meshFacePeau = None
+    if partitionsPeauFissFond[ifil] is None: # face de peau maillage sain intacte
+      
+      # --- edges de bord de la face de filling
+      filling = facesDefaut[ifil]
+      edgesFilling = geompy.ExtractShapes(filling, geompy.ShapeType["EDGE"], False)
+      groupEdgesBordPeau = geompy.CreateGroup(filling, geompy.ShapeType["EDGE"])
+      geompy.UnionList(groupEdgesBordPeau, edgesFilling)
+      geompy.addToStudyInFather(filling, groupEdgesBordPeau , "EdgesBords")
+      
+      meshFacePeau = smesh.Mesh(facesDefaut[ifil])
+      
+      algo1d = meshFacePeau.UseExisting1DElements(geom=groupEdgesBordPeau)
+      hypo1d = algo1d.SourceEdges([ bordsLibres ],0,0)
+      putName(algo1d.GetSubMesh(), "bordsLibres", ifil)
+      putName(algo1d, "algo1d_bordsLibres", ifil)
+      putName(hypo1d, "hypo1d_bordsLibres", ifil)
+      
+    else:
+      
+      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]
+      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]
+
+      meshFacePeau = smesh.Mesh(facePeau)
+      
+      algo1d = meshFacePeau.UseExisting1DElements(geom=groupEdgesBordPeau)
+      hypo1d = algo1d.SourceEdges([ bordsLibres ],0,0)
+      putName(algo1d.GetSubMesh(), "bordsLibres", ifil)
+      putName(algo1d, "algo1d_bordsLibres", ifil)
+      putName(hypo1d, "hypo1d_bordsLibres", 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)
+      
+      if bordsVifs is not None:
+        algo1d = meshFacePeau.UseExisting1DElements(geom=bordsVifs)
+        hypo1d = algo1d.SourceEdges([ grpAretesVives ],0,0)
+        putName(algo1d.GetSubMesh(), "bordsVifs", ifil)
+        putName(algo1d, "algo1d_bordsVifs", ifil)
+        putName(hypo1d, "hypo1d_bordsVifs", ifil)
+        
+      for i, edgeCirc in enumerate(edgesCircPeau):
+        if edgeCirc is not None:
+          algo1d = meshFacePeau.UseExisting1DElements(geom=edgeCirc)
+          if boutFromIfil[ifil] is None:
+            hypo1d = algo1d.SourceEdges([ edgesCircPipeGroup[i] ],0,0)
+          else:
+            hypo1d = algo1d.SourceEdges([ edgesCircPipeGroup[boutFromIfil[ifil]] ],0,0)
+          name = "cercle%d"%i
+          putName(algo1d.GetSubMesh(), 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 )
+    putName(algo2d.GetSubMesh(), "facePeau", ifil)
+    putName(algo2d, "algo2d_facePeau", ifil)
+    putName(hypo2d, "hypo2d_facePeau", ifil)
+      
+    isDone = meshFacePeau.Compute()
+    logging.info("meshFacePeau %d fini", ifil)
+    GroupFaces = meshFacePeau.CreateEmptyGroup( SMESH.FACE, "facePeau%d"%ifil )
+    nbAdd = GroupFaces.AddFrom( meshFacePeau.GetMesh() )
+    meshesFacesPeau.append(meshFacePeau)
+
+  # --- regroupement des maillages du défaut
+
+  listMeshes = [internalBoundary.GetMesh(),
+                meshPipe.GetMesh(),
+                meshFaceFiss.GetMesh()]
+  for mp in meshesFacesPeau:
+    listMeshes.append(mp.GetMesh())
+
+  meshBoiteDefaut = smesh.Concatenate(listMeshes, 1, 1, 1e-05,False)
+  # pour aider l'algo hexa-tetra à ne pas mettre de pyramides à l'exterieur des volumes repliés sur eux-mêmes
+  # on désigne les faces de peau en quadrangles par le groupe "skinFaces"
+  group_faceFissOutPipe = None
+  group_faceFissInPipe = None
+  groups = meshBoiteDefaut.GetGroups()
+  for grp in groups:
+    if grp.GetType() == SMESH.FACE:
+      #if "internalBoundary" in grp.GetName():
+      #  grp.SetName("skinFaces")
+      if grp.GetName() == "fisOutPi":
+        group_faceFissOutPipe = 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)
+  else:
+    algo3d = meshBoiteDefaut.Tetrahedron(algo=smeshBuilder.NETGEN)
+    hypo3d = algo3d.MaxElementVolume(1000.0)
+  putName(algo3d.GetSubMesh(), "boiteDefaut")
+  putName(algo3d, "algo3d_boiteDefaut")
+  isDone = meshBoiteDefaut.Compute()
+  putName(meshBoiteDefaut, "boiteDefaut")
+  logging.info("meshBoiteDefaut fini")
+  
+  faceFissure = meshBoiteDefaut.GetMesh().UnionListOfGroups( [ group_faceFissOutPipe, group_faceFissInPipe ], 'FACE1' )
+  maillageSain = enleveDefaut(maillageSain, zoneDefaut, zoneDefaut_skin,
+                              zoneDefaut_internalFaces, zoneDefaut_internalEdges)
+  putName(maillageSain, nomFicSain+"_coupe")
+  extrusionFaceFissure, normfiss = shapeSurFissure(facesPortFissure)
+  maillageComplet = RegroupeSainEtDefaut(maillageSain, meshBoiteDefaut,
+                                         None, None, 'COMPLET', normfiss)
+
+  logging.info("conversion quadratique")
+  maillageComplet.ConvertToQuadratic( 1 )
+  logging.info("groupes")
+  groups = maillageComplet.GetGroups()
+  grps = [ grp for grp in groups if grp.GetName() == 'FONDFISS']
+  fond = 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']
+  nb = maillageComplet.Reorient2D( grps[0], normfiss, grps[0].GetID(1))
+
+  logging.info("réorientation face de fissure FACE2")
+  plansim = geompy.MakePlane(O, normfiss, 10000)
+  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' )
+
+  logging.info("export maillage fini")
+  maillageComplet.ExportMED( fichierMaillageFissure, 0, SMESH.MED_V2_2, 1 )
+  putName(maillageComplet, nomFicFissure)
+  logging.info("fichier maillage fissure %s", fichierMaillageFissure)
+
+  if salome.sg.hasDesktop():
+    salome.sg.updateObjBrowser(1)
+
+  logging.info("maillage fissure fini")
+  
+  return maillageComplet

src/Tools/blocFissure/gmu/construitPartitionsPeauFissure.py

@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+
+import logging
+from geomsmesh import geompy
+from checkDecoupePartition import checkDecoupePartition
+
+  # -----------------------------------------------------------------------------
+  # --- peau et face de fissure
+  #
+  # --- partition peau défaut - face de fissure prolongée - wire de fond de fissure prolongée
+  #     il peut y avoir plusieurs faces externes, dont certaines sont découpées par la fissure
+  #     liste de faces externes : facesDefaut
+  #     liste de partitions face externe - fissure : partitionPeauFissFond (None quand pas d'intersection)
+
+def construitPartitionsPeauFissure(facesDefaut, fissPipe):
+  """
+  partition peau défaut - face de fissure prolongée - wire de fond de fissure prolongée.
+  Il peut y avoir plusieurs faces externes, dont certaines sont découpées par la fissure.
+  @param facesDefaut liste de faces externes
+  @param fissPipe    partition face de fissure etendue par pipe prolongé
+  @return partitionsPeauFissFond : liste de partitions face externe - fissure (None quand pas d'intersection)
+  """
+  
+  logging.info('start')
+  partitionsPeauFissFond = []
+  ipart = 0
+  for filling in facesDefaut: 
+    part = geompy.MakePartition([fissPipe, filling], [], [], [], geompy.ShapeType["FACE"], 0, [], 0)
+    isPart = checkDecoupePartition([fissPipe, filling], part)
+    if isPart: # on recrée la partition avec toutes les faces filling en outil pour avoir une face de fissure correcte
+      otherFD = [fd for fd in facesDefaut if fd != filling]
+      if len(otherFD) > 0:
+        fissPipePart = geompy.MakePartition([fissPipe], otherFD, [], [], geompy.ShapeType["FACE"], 0, [], 0)
+      else:
+        fissPipePart = fissPipe
+      part = geompy.MakePartition([fissPipePart, filling], [], [], [], geompy.ShapeType["FACE"], 0, [], 0)
+      partitionsPeauFissFond.append(part)
+      geompy.addToStudy( part, 'partitionPeauFissFond%d'%ipart )
+    else:
+      partitionsPeauFissFond.append(None)
+    ipart = ipart +1
+
+  return partitionsPeauFissFond

src/Tools/blocFissure/gmu/fissureCoude.py

@@ -16,7 +16,7 @@ from fissureGenerique import fissureGenerique
 from triedreBase import triedreBase
 from genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
 from creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
-from insereFissureGenerale import insereFissureGenerale
+from construitFissureGenerale import construitFissureGenerale
 from sortEdges import sortEdges
 
 O, OX, OY, OZ = triedreBase()
@@ -651,9 +651,9 @@ class fissureCoude(fissureGenerique):
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                             shapesFissure, shapeFissureParams,
                             maillageFissureParams, elementsDefaut, step):
-    maillageFissure = insereFissureGenerale(maillagesSains,
+    maillageFissure = construitFissureGenerale(maillagesSains,
-                                            shapesFissure, shapeFissureParams,
+                                               shapesFissure, shapeFissureParams,
-                                            maillageFissureParams, elementsDefaut, step)
+                                               maillageFissureParams, elementsDefaut, step)
     return maillageFissure
 
   # ---------------------------------------------------------------------------

src/Tools/blocFissure/gmu/getCentreFondFiss.py

@@ -9,14 +9,14 @@ publie = False
 def getCentreFondFiss(shapesFissure):
   """
   identification du centre de fond de fissure,
-  transformation fond de fissure en edge unique (seulement pour la procédure insereFissureGenerale).
+  transformation fond de fissure en edge unique (seulement pour la procédure construitFissureGenerale).
   On distingue le cas d'utilisation de la procédure insereFissureLongue par le nombre d'éléments de shapesFissure.
   """
   global publie
   logging.debug("start")
   
   fondFiss          = shapesFissure[4] # groupe d'edges de fond de fissure
-  if len(shapesFissure) == 6:          # procédure insereFissureGenerale, et edge fond de fissure fournie explicitement
+  if len(shapesFissure) == 6:          # procédure construitFissureGenerale, et edge fond de fissure fournie explicitement
     edgeFondExt     = shapesFissure[5]
   else:
     edgeFondExt     = None
@@ -24,7 +24,7 @@ def getCentreFondFiss(shapesFissure):
   if len(shapesFissure) > 6:           # procédure insereFissureLongue (fissure plane, plusieurs edges sur le fond de fissure)
     centreFondFiss = shapesFissure[1]
     tgtCentre = None
-  else:                                # procédure insereFissureGenerale, détermination edge unique et milieu de l'edge
+  else:                                # procédure construitFissureGenerale, détermination edge unique et milieu de l'edge
     if geompy.NumberOfEdges(fondFiss) > 1:
       if geompy.NbShapes(fondFiss, geompy.ShapeType["WIRE"]) > 0: # wire
         aWire = fondFiss

src/Tools/blocFissure/gmu/identifieEdgesPeau.py

@@ -0,0 +1,137 @@
+# -*- coding: utf-8 -*-
+
+import logging
+
+from geomsmesh import geompy
+from substractSubShapes import substractSubShapes
+
+def identifieEdgesPeau(edgesFissExtPipe,verticesPipePeau, facePeau, facesPeauSorted,
+                       edgesPeauFondIn, fillingFaceExterne, aretesVivesC, aretesVivesCoupees):
+  """
+  identification précise des edges et disques des faces de peau selon index extremité fissure
+  """
+  logging.info('start')
+  
+  facesPipePeau = [None for i in range(len(edgesFissExtPipe))]
+  endsEdgeFond = [None for i in range(len(edgesFissExtPipe))]
+  edgeRadFacePipePeau = [None for i in range(len(edgesFissExtPipe))]
+  
+  edgesListees = []
+  edgesCircPeau = []
+  verticesCircPeau = []
+  if len(verticesPipePeau) > 0: # --- au moins une extrémité du pipe sur cette face de peau
+    
+    for face in facesPeauSorted[:-1]: # la ou les faces débouchantes, pas la grande face de peau
+      logging.debug("examen face debouchante circulaire")
+      for i,efep in enumerate(edgesFissExtPipe):
+        dist = geompy.MinDistance(face, efep)
+        logging.debug("  distance face circulaire edge %s", dist)
+        if dist < 1e-3:
+          for ik, edpfi in enumerate(edgesPeauFondIn):
+            if geompy.MinDistance(face, edpfi) < 1e-3:
+              break
+          sharedVertices = geompy.GetSharedShapesMulti([face, edgesPeauFondIn[ik]], geompy.ShapeType["VERTEX"])
+          nameFace = "facePipePeau%d"%i
+          nameVert = "endEdgeFond%d"%i
+          nameEdge = "edgeRadFacePipePeau%d"%i
+          facesPipePeau[i] = face
+          endsEdgeFond[i] = sharedVertices[0]
+          geompy.addToStudy(face, nameFace)
+          geompy.addToStudy(sharedVertices[0], nameVert)
+          edgesFace = geompy.ExtractShapes(face, geompy.ShapeType["EDGE"], True)
+          for edge in edgesFace:
+            if geompy.MinDistance(edge, sharedVertices[0]) < 1e-3:
+              edgeRadFacePipePeau[i] = edge
+              geompy.addToStudy(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)
+    edgesCircPeau = [None for i in range(len(facesPipePeau))]
+    verticesCircPeau = [None for i in range(len(facesPipePeau))]        
+    for i,fcirc in enumerate(facesPipePeau):
+      edges = geompy.GetSharedShapesMulti([facePeau, fcirc], geompy.ShapeType["EDGE"])
+      grpEdgesCirc = geompy.CreateGroup(facePeau, geompy.ShapeType["EDGE"])
+      geompy.UnionList(grpEdgesCirc, edges)
+      edgesCircPeau[i] = grpEdgesCirc
+      name = "edgeCirc%d"%i
+      geompy.addToStudyInFather(facePeau, grpEdgesCirc, name)
+      edgesListees = edgesListees + edges
+      vertices = geompy.GetSharedShapesMulti([facePeau, fcirc], geompy.ShapeType["VERTEX"])
+      grpVertCircPeau = geompy.CreateGroup(facePeau, geompy.ShapeType["VERTEX"])
+      geompy.UnionList(grpVertCircPeau, vertices)
+      verticesCircPeau[i] = grpVertCircPeau
+      name = "pointEdgeCirc%d"%i
+      geompy.addToStudyInFather(facePeau, grpVertCircPeau, name)
+      pass
+    pass # --- au moins une extrémité du pipe sur cette face de peau
+
+  # --- edges de bord de la face de peau
+
+  edgesFilling = geompy.ExtractShapes(fillingFaceExterne, geompy.ShapeType["EDGE"], False)
+  edgesBords = []
+  for i, edge in enumerate(edgesFilling):
+    edgepeau = geompy.GetInPlace(facePeau, edge)
+    name = "edgepeau%d"%i
+    geompy.addToStudyInFather(facePeau,edgepeau, name)
+    logging.debug("edgepeau %s", geompy.ShapeInfo(edgepeau))
+    if geompy.ShapeInfo(edgepeau)['EDGE'] > 1:
+      logging.debug("  EDGES multiples")
+      edgs = geompy.ExtractShapes(edgepeau, geompy.ShapeType["EDGE"], False)
+      edgesBords += edgs
+      edgesListees += edgs
+    else:
+      logging.debug("  EDGE")
+      edgesBords.append(edgepeau)
+      edgesListees.append(edgepeau)
+  groupEdgesBordPeau = geompy.CreateGroup(facePeau, geompy.ShapeType["EDGE"])
+  geompy.UnionList(groupEdgesBordPeau, edgesBords)
+  bordsVifs = None
+  if aretesVivesC is not None:
+    bordsVifs = geompy.GetInPlace(facePeau, aretesVivesC)
+  if bordsVifs is not None:
+    geompy.addToStudyInFather(facePeau, bordsVifs, "bordsVifs")
+    groupEdgesBordPeau = geompy.CutGroups(groupEdgesBordPeau, bordsVifs)
+    grptmp = None
+    if len(aretesVivesCoupees) > 0:
+      grpC = geompy.MakeCompound(aretesVivesCoupees)
+      grptmp = geompy.GetInPlace(facePeau, grpC)
+    if grptmp is not None:
+      grpnew = geompy.CutGroups(bordsVifs, grptmp) # ce qui est nouveau dans bordsVifs
+    else:
+      grpnew = bordsVifs
+    if grpnew is not None:
+      edv = geompy.ExtractShapes(grpnew, geompy.ShapeType["EDGE"], False)
+      aretesVivesCoupees += edv
+  logging.debug("aretesVivesCoupees %s",aretesVivesCoupees)
+  geompy.addToStudyInFather(facePeau, groupEdgesBordPeau , "EdgesBords")
+    
+  # ---  edges de la face de peau partagées avec la face de fissure
+  
+  edgesPeau = geompy.ExtractShapes(facePeau, geompy.ShapeType["EDGE"], False)
+  edges = substractSubShapes(facePeau, edgesPeau, edgesListees)
+  edgesFissurePeau = []
+  if len(verticesPipePeau) > 0: # --- au moins une extrémité du pipe sur cette face de peau
+    edgesFissurePeau = [None for i in range(len(verticesCircPeau))] # edges associés aux extrémités du pipe, en premier
+    for edge in edges:
+      for i, grpVert in enumerate(verticesCircPeau):
+        if (geompy.MinDistance(grpVert, edge) < 1.e-3) and (edge not in edgesFissurePeau):
+          edgesFissurePeau[i] = edge
+          name = "edgeFissurePeau%d"%i
+          geompy.addToStudyInFather(facePeau,  edge, name)
+    for edge in edges: # on ajoute après les edges manquantes
+      if edge not in edgesFissurePeau:
+        edgesFissurePeau.append(edge)
+  else:
+    for i, edge in enumerate(edges):
+      edgesFissurePeau.append(edge)
+      name = "edgeFissurePeau%d"%i
+      geompy.addToStudyInFather(facePeau,  edge, name)
+      
+  return (endsEdgeFond, facesPipePeau, edgeRadFacePipePeau,
+          edgesCircPeau, verticesCircPeau, groupEdgesBordPeau,
+          bordsVifs, edgesFissurePeau)

src/Tools/blocFissure/gmu/identifieElementsDebouchants.py

@@ -0,0 +1,148 @@
+# -*- coding: utf-8 -*-
+
+import logging
+import math
+
+from geomsmesh import geompy
+
+from produitMixte import produitMixte
+from whichSide import whichSide
+  
+def identifieElementsDebouchants(ifil, facesDefaut, partitionPeauFissFond,
+                                edgesFondIn, edgesFondFiss, wireFondFiss,
+                                aretesVivesC, fillingFaceExterne,
+                                edgesPipeIn, verticesPipePeau, rayonPipe,
+                                facesInside, facesOnside):
+  """
+  elements débouchants (intersection pipe et peau), indexés selon les edges du fond de fissure (edgesFondIn)
+  """
+  
+  logging.info('start')
+ 
+  verticesEdgesFondIn = [] # les points du fond de fissure au débouché du pipe sur la peau (indice de edgesFondIn)
+  pipexts = []             # les segments de pipe associés au points de fond de fissure débouchants (même indice)
+  cercles = []             # les cercles de generation des pipes débouchant (même indice)
+  facesFissExt = []        # les faces de la fissure externe associés au points de fond de fissure débouchants (même indice)
+  edgesFissExtPeau = []    # edges des faces de fissure externe sur la peau (même indice)
+  edgesFissExtPipe = []    # edges des faces de fissure externe sur le pipe (même indice)
+
+  #logging.debug("edgesFondIn %s", edgesFondIn)
+  for iedf, edge in enumerate(edgesFondIn):
+    name = "edgeFondIn%d"%iedf
+    geompy.addToStudyInFather(partitionPeauFissFond, edge, name)
+    dist = [ geompy.MinDistance(pt, edge) for pt in verticesPipePeau]
+    ptPeau = verticesPipePeau[dist.index(min(dist))] # le point de verticesPipePeau a distance minimale de l'edge
+    [u, PointOnEdge, EdgeInWireIndex]  = geompy.MakeProjectionOnWire(ptPeau, wireFondFiss)
+    logging.debug("u:%s, EdgeInWireIndex: %s, len(edgesFondFiss): %s", u, EdgeInWireIndex, len(edgesFondFiss))
+    localEdgeInFondFiss = edgesFondFiss[EdgeInWireIndex]
+    centre = PointOnEdge
+    centre2 = geompy.MakeVertexOnCurve(localEdgeInFondFiss, u)
+    geompy.addToStudyInFather(partitionPeauFissFond, centre2, "centre2_%d"%iedf)
+    verticesEdgesFondIn.append(centre)
+    name = "verticeEdgesFondIn%d"%iedf
+    geompy.addToStudyInFather(partitionPeauFissFond, centre, name)
+    norm = geompy.MakeTangentOnCurve(localEdgeInFondFiss, u)
+    geompy.addToStudyInFather(partitionPeauFissFond, centre, "norm%d"%iedf)
+    cercle = geompy.MakeCircle(centre, norm, rayonPipe)
+    geompy.addToStudyInFather(partitionPeauFissFond, cercle, "cerclorig%d"%iedf)
+    [vertex] = geompy.ExtractShapes(cercle, geompy.ShapeType["VERTEX"], False)
+    vec1 = geompy.MakeVector(centre, vertex)
+    vec2 = geompy.MakeVector(centre, ptPeau)
+    angle = geompy.GetAngleRadians(vec1, vec2)
+    # cas général : on reconstitue une portion de pipe, avec l'arête de couture qui coincide
+    #   avec la face de fissure, au niveau du débouché sur la face externe
+    # cas dégénéré : le pipe débouche perpendiculairement à une surface plane à l'origine.
+    #   La partition filling / pipe reconstruit échoue.
+    #   - Si on partitionne le filling avec un simple pipe obtenu par extrusion droite du cercle,
+    #     cela donne un point en trop sur le cercle.
+    #   - Si on prend une vraie surface plane (pas un filling), on peut faire la partition avec 
+    #     les pipes reconstruits              
+    logging.debug("angle=%s", angle)
+    #if abs(angle) > 1.e-7:
+    sommetAxe = geompy.MakeTranslationVector(centre, norm)
+    pm = produitMixte(centre, vertex, ptPeau, sommetAxe)
+    if pm > 0:  # ajout de pi a (-)angle pour éviter des points confondus (partition échoue) dans les cas dégénérés
+      cercle = geompy.MakeRotation(cercle, norm, angle + math.pi)
+    else:
+      cercle = geompy.MakeRotation(cercle, norm, -angle + math.pi)
+    name = "cercle%d"%iedf
+    geompy.addToStudyInFather(partitionPeauFissFond, cercle, name)
+    cercles.append(cercle)
+
+    # --- estimation de la longueur du pipe necessaire de part et d'autre du point de sortie
+    if aretesVivesC is None:
+      faceTestPeau = fillingFaceExterne
+    else:
+      faceTestPeau = facesDefaut[ifil]
+    sideCentre = whichSide(faceTestPeau, centre)
+    locPt0 = geompy.MakeVertexOnCurve(localEdgeInFondFiss, 0.0)
+    locPt1 = geompy.MakeVertexOnCurve(localEdgeInFondFiss, 1.0)
+    sidePt0 = whichSide(faceTestPeau, locPt0)
+    sidePt1 = whichSide(faceTestPeau, locPt1)
+    logging.debug("position centre cercle: %s, extremité edge u0: %s, u1: %s", sideCentre, sidePt0, sidePt1) 
+    normFace = geompy.GetNormal(faceTestPeau, ptPeau)
+    inclPipe = abs(geompy.GetAngleRadians(norm, normFace))
+    lgp = max(rayonPipe/2., abs(3*rayonPipe*math.tan(inclPipe)))
+    logging.debug("angle inclinaison Pipe en sortie: %s degres, lgp: %s", inclPipe*180/math.pi, lgp)
+    
+    # --- position des points extremite du pipe sur l'edge debouchante
+    #     il faut la distance curviligne ofp du point central par rapport à une extrémité de l'edge débouchante
+    locEdgePart = geompy.MakePartition([localEdgeInFondFiss],[centre], [], [], geompy.ShapeType["EDGE"], 0, [], 0)
+    edgesLoc = geompy.ExtractShapes(locEdgePart, geompy.ShapeType["EDGE"], False)
+    edgesLocSorted =[(geompy.MinDistance(edge, locPt0), kk, edge) for kk, edge in enumerate(edgesLoc)]
+    edgesLocSorted.sort()
+    ofp = geompy.BasicProperties(edgesLocSorted[0][2])[0] # distance curviligne centre locPt0
+    logging.debug("distance curviligne centre extremite0: %s", ofp)
+    p1 = geompy.MakeVertexOnCurveByLength(localEdgeInFondFiss, ofp +lgp, locPt0)
+    p2 = geompy.MakeVertexOnCurveByLength(localEdgeInFondFiss, ofp -lgp, locPt0)
+    geompy.addToStudyInFather(wireFondFiss, p1, "p1_%d"%iedf)
+    geompy.addToStudyInFather(wireFondFiss, p2, "p2_%d"%iedf)
+
+    edgePart = geompy.MakePartition([localEdgeInFondFiss], [p1,p2], [], [], geompy.ShapeType["EDGE"], 0, [], 0)
+    edps = geompy.ExtractShapes(edgePart, geompy.ShapeType["EDGE"], True)
+    for edp in edps:
+      if geompy.MinDistance(centre, edp) < 1.e-3:
+        pipext = geompy.MakePipe(cercle, edp)
+        name = "pipeExt%d"%iedf
+        geompy.addToStudyInFather(partitionPeauFissFond, pipext, name)
+        pipexts.append(pipext)
+
+    for ifa, face in enumerate(facesInside):
+      logging.debug("recherche edges communes entre une face inside et (faces onside, edges pipe et fond débouchante)")
+      edgesPeauFis = []
+      edgesPipeFis = []
+      edgesPipeFnd = []
+      try:
+        edgesPeauFis = geompy.GetSharedShapesMulti([geompy.MakeCompound(facesOnside), face], geompy.ShapeType["EDGE"])
+        logging.debug("    faces onside %s",edgesPeauFis)
+        edgesPipeFis = geompy.GetSharedShapesMulti([geompy.MakeCompound(edgesPipeIn), face], geompy.ShapeType["EDGE"])
+        logging.debug("    edgesPipeIn %s", edgesPipeFis)
+        edgesPipeFnd = geompy.GetSharedShapesMulti([geompy.MakeCompound(edgesFondIn), face], geompy.ShapeType["EDGE"])
+        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 dist < 1.e-3: # c'est la face de fissure externe associée
+          logging.debug("    face %s inside ajoutée", ifa)
+          facesFissExt.append(face)
+          name="faceFissExt%d"%iedf
+          geompy.addToStudyInFather(partitionPeauFissFond, face, name)
+          dist = 1.
+          for ipe, edpe in enumerate(edgesPeauFis):
+            for ipi, edpi in enumerate(edgesPipeFis):
+              dist = geompy.MinDistance(edpe, edpi)
+              if dist < 1.e-3:
+                edgesFissExtPeau.append(edpe)
+                name="edgesFissExtPeau%d"%iedf
+                geompy.addToStudyInFather(partitionPeauFissFond, edpe, name)
+                edgesFissExtPipe.append(edpi)
+                name="edgesFissExtPipe%d"%iedf
+                geompy.addToStudyInFather(partitionPeauFissFond, edpi, name)
+                break
+            if dist < 1.e-3:
+              break
+
+  return (verticesEdgesFondIn, pipexts, cercles, facesFissExt, edgesFissExtPeau, edgesFissExtPipe)

src/Tools/blocFissure/gmu/identifieElementsFissure.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+
+import logging
+
+from geomsmesh import geompy
+from extractionOrientee import extractionOrientee
+from extractionOrienteeMulti import extractionOrienteeMulti
+ 
+def identifieElementsFissure(ifil, facesDefaut, partitionPeauFissFond,
+                             edgesPipeFiss, edgesFondFiss, aretesVivesC,
+                             fillingFaceExterne, centreFondFiss):
+  """
+  # -----------------------------------------------------------------------
+  # --- identification edges fond de fissure, edges pipe sur la face de fissure,
+  #     edges prolongées
+  #     edges internes communes pipe et fissure, points communs edges fissure peau et edges circulaires
+  """
+
+  logging.info('start')
+
+  edgesPipeC = geompy.GetInPlace(partitionPeauFissFond, geompy.MakeCompound(edgesPipeFiss))
+  geompy.addToStudyInFather(partitionPeauFissFond, edgesPipeC, "edgesPipeFiss")
+  edgesFondC = geompy.GetInPlace(partitionPeauFissFond, geompy.MakeCompound(edgesFondFiss))
+  geompy.addToStudyInFather(partitionPeauFissFond, edgesFondC, "edgesFondFiss")
+  
+  if aretesVivesC is None:
+    [edgesInside, edgesOutside, edgesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "EDGE", 1.e-3)
+    [facesInside, facesOutside, facesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "FACE", 1.e-3)
+  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)
+    
+  edgesPipeIn = geompy.GetSharedShapesMulti([edgesPipeC, geompy.MakeCompound(edgesInside)], geompy.ShapeType["EDGE"])
+  verticesPipePeau = []
+
+  for i, edge in enumerate(edgesPipeIn):
+    try:
+      vertices = geompy.GetSharedShapesMulti([edge, geompy.MakeCompound(facesOnside)], geompy.ShapeType["VERTEX"])
+      verticesPipePeau.append(vertices[0])
+      name = "edgePipeIn%d"%i
+      geompy.addToStudyInFather(partitionPeauFissFond, edge, name)
+      name = "verticePipePeau%d"%i
+      geompy.addToStudyInFather(partitionPeauFissFond, vertices[0], name)
+      logging.debug("edgePipeIn%s coupe les faces OnSide", i)
+    except:
+      logging.debug("edgePipeIn%s ne coupe pas les faces OnSide", i)
+
+  edgesFondIn =[]
+  if len(verticesPipePeau) > 0: # au moins une extrémité du pipe sur cette face de peau  
+    #tmp = geompy.GetSharedShapesMulti([edgesFondC, geompy.MakeCompound(edgesOutside)], geompy.ShapeType["EDGE"])
+    #edgesFondOut = [ ed for ed in tmp if geompy.MinDistance(ed, geompy.MakeCompound(facesOnside)) < 1.e-3] 
+    tmp = geompy.GetSharedShapesMulti([edgesFondC, geompy.MakeCompound(edgesInside)], geompy.ShapeType["EDGE"])
+    edgesFondIn = [ ed for ed in tmp if geompy.MinDistance(ed, geompy.MakeCompound(facesOnside)) < 1.e-3]
+
+  return (edgesPipeIn, verticesPipePeau, edgesFondIn, facesInside, facesOnside) 

src/Tools/blocFissure/gmu/identifieElementsGeometriquesPeau.py

@@ -0,0 +1,82 @@
+# -*- coding: utf-8 -*-
+
+import logging
+import math
+
+from geomsmesh import geompy
+
+from extractionOrientee import extractionOrientee
+from extractionOrienteeMulti import extractionOrienteeMulti
+from orderEdgesFromWire import orderEdgesFromWire
+from produitMixte import produitMixte
+from whichSide import whichSide
+from sortFaces import sortFaces
+from substractSubShapes import substractSubShapes
+from identifieElementsFissure import identifieElementsFissure
+from identifieElementsDebouchants import identifieElementsDebouchants
+from trouveEdgesFissPeau import trouveEdgesFissPeau
+from identifieFacesPeau import identifieFacesPeau
+from identifieEdgesPeau import identifieEdgesPeau
+
+def identifieElementsGeometriquesPeau(ifil, partitionPeauFissFond, edgesPipeFiss,
+                                      edgesFondFiss, wireFondFiss, aretesVivesC,
+                                      facesDefaut, centreFondFiss, rayonPipe,
+                                      aretesVivesCoupees):
+  """
+  """
+  logging.info('start')
+  fillingFaceExterne = facesDefaut[ifil]
+
+  logging.debug("traitement partitionPeauFissFond %s", ifil)
+  
+  # --- identification edges fond de fissure, edges pipe sur la face de fissure, edges prolongées
+  #     edges internes communes pipe et fissure, points communs edges fissure peau et edges circulaires
+  
+  (edgesPipeIn, verticesPipePeau, edgesFondIn, facesInside, facesOnside) = identifieElementsFissure(ifil, facesDefaut, partitionPeauFissFond,
+                                                                                                    edgesPipeFiss, edgesFondFiss, aretesVivesC,
+                                                                                                    fillingFaceExterne, centreFondFiss)
+  
+  # --- elements débouchants (intersection pipe et peau), indexés selon les edges du fond de fissure (edgesFondIn)
+  
+  (verticesEdgesFondIn, pipexts, cercles,
+   facesFissExt, edgesFissExtPeau, edgesFissExtPipe) = identifieElementsDebouchants(ifil, facesDefaut, partitionPeauFissFond,
+                                                                                    edgesFondIn, edgesFondFiss, wireFondFiss,
+                                                                                    aretesVivesC, fillingFaceExterne,
+                                                                                    edgesPipeIn, verticesPipePeau, rayonPipe,
+                                                                                    facesInside, facesOnside)
+
+  # --- pour les faces de peau sans extremité débouchante de fissure, il faut recenser les edges de fissure sur la face de peau
+
+  if len(verticesPipePeau) == 0: # aucune extrémité du pipe sur cette face de peau
+    edgesFissExtPeau = trouveEdgesFissPeau(facesInside, facesOnside, edgesPipeIn, edgesFondIn, partitionPeauFissFond, edgesFissExtPeau)
+    
+  # --- inventaire des faces de peau : face de peau percée du pipe, extrémités du pipe
+  
+  (facePeau, facesPeauSorted, edgesPeauFondIn) = identifieFacesPeau(ifil, verticesPipePeau, facesOnside, wireFondFiss,
+                                                                    verticesEdgesFondIn, pipexts, cercles,
+                                                                    fillingFaceExterne, centreFondFiss)
+  
+  # --- identification précise des edges et disques des faces de peau selon index extremité fissure
+  
+  (endsEdgeFond, facesPipePeau, edgeRadFacePipePeau,
+   edgesCircPeau, verticesCircPeau, groupEdgesBordPeau,
+   bordsVifs, edgesFissurePeau) = identifieEdgesPeau(edgesFissExtPipe, verticesPipePeau, facePeau, facesPeauSorted,
+                                                     edgesPeauFondIn, fillingFaceExterne, aretesVivesC, aretesVivesCoupees)
+  
+  dataPPFF = dict(endsEdgeFond        = endsEdgeFond,        # pour chaque face [points edge fond de fissure aux débouchés du pipe]
+                  facesPipePeau       = facesPipePeau,       # pour chaque face [face
+                  edgeRadFacePipePeau = edgeRadFacePipePeau, # pour chaque face [edge radiale des faces du pipe débouchantes ]
+                  facesFissExt        = facesFissExt,        # pour chaque face [faces de fissure externes au pipe]
+                  edgesFissExtPeau    = edgesFissExtPeau,    # pour chaque face [edge en peau des faces de fissure externes (pas subshape facePeau)]
+                  edgesFissExtPipe    = edgesFissExtPipe,    # pour chaque face [edge commun au pipe des faces de fissure externes]
+                  facePeau            = facePeau,            # pour chaque face : la face de peau finale a mailler (percee des faces débouchantes)
+                  edgesCircPeau       = edgesCircPeau,       # pour chaque face de peau : [groupe subshapes edges circulaires aux débouchés du pipe]
+                  verticesCircPeau    = verticesCircPeau,    # pour chaque face de peau : [groupe subshapes points sur edges circulaires aux débouchés du pipe]
+                  groupEdgesBordPeau  = groupEdgesBordPeau,  # pour chaque face de peau : groupe subshape des edges aux bords liés à la partie saine
+                  bordsVifs           = bordsVifs,           # pour chaque face de peau : groupe subshape des edges aux bords correspondant à des arêtes vives
+                  edgesFissurePeau    = edgesFissurePeau,    # pour chaque face de peau : [subshape edge en peau des faces de fissure externes]
+                  verticesPipePeau    = verticesPipePeau     # pour chaque face de peau : [point commun edFissPeau edCircPeau]
+                  )  
+
+  return dataPPFF, aretesVivesCoupees
+  

src/Tools/blocFissure/gmu/identifieFacesPeau.py

@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+
+import logging
+
+from geomsmesh import geompy
+
+from sortFaces import sortFaces
+from extractionOrientee import extractionOrientee
+
+def identifieFacesPeau(ifil, verticesPipePeau, facesOnside, wireFondFiss,
+                       verticesEdgesFondIn, pipexts, cercles,
+                       fillingFaceExterne, centreFondFiss):
+  """
+  inventaire des faces de peau : face de peau percée du pipe, extrémités du pipe
+  La partition avec le pipe peut créer un vertex (et un edge) de trop sur le cercle projeté,
+  quand le cercle est très proche de la face.
+  dans ce cas, la projection du cercle sur la face suivie d'une partition permet
+  d'éviter le point en trop
+  """
+  logging.info('start')
+   
+  facesAndFond = facesOnside
+  facesAndFond.append(wireFondFiss)
+  try:
+    partitionPeauByPipe = geompy.MakePartition(facesAndFond, pipexts, [], [], geompy.ShapeType["FACE"], 0, [], 1)
+  except:
+    logging.debug("probleme partition face pipe, contournement avec MakeSection")
+    sections = []
+    for pipext in pipexts:
+      sections.append(geompy.MakeSection(facesOnside[0], pipext))
+    partitionPeauByPipe = geompy.MakePartition(facesAndFond, sections, [], [], geompy.ShapeType["FACE"], 0, [], 1)
+    
+  # contrôle edge en trop sur edges circulaires
+  if len(verticesPipePeau) > 0: # --- au moins une extrémité du pipe sur cette face de peau
+    edgeEnTrop = []
+    outilPart = pipexts
+    facesPeau = geompy.ExtractShapes(partitionPeauByPipe, geompy.ShapeType["FACE"], False)
+    facesPeauSorted, minsur, maxsurf = 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)
+      if nbv > 3:
+        edgeEnTrop.append(True) # TODO : distinguer les cas avec deux faces circulaires dont l'une est correcte
+      else:
+        edgeEnTrop.append(False)
+    refaire = sum(edgeEnTrop)
+    if refaire > 0:
+      dc = [(geompy.MinDistance(verticesEdgesFondIn[0], fac), i)  for i, fac in enumerate(facesPeauSorted[:-1])]
+      dc.sort()
+      logging.debug("dc sorted: %s", dc)
+      i0 = dc[0][1] # indice de facesPeauSorted qui correspond à verticesEdgesFondIn[0], donc 0 pour cercles
+      direct = (i0 == 0)
+      for i, bad in enumerate(edgeEnTrop):
+        if direct:
+          j = i
+        else:
+          j = 1-i
+        if bad:
+          outilPart[j] = geompy.MakeProjection(cercles[j],facesOnside[0])
+        pass
+      partitionPeauByPipe = geompy.MakePartition(facesAndFond, outilPart, [], [], geompy.ShapeType["FACE"], 0, [], 1)
+      pass
+      
+  name="partitionPeauByPipe%d"%ifil
+  geompy.addToStudy(partitionPeauByPipe, name)
+  [edgesPeauFondIn, edgesPeauFondOut, edgesPeauFondOn] = extractionOrientee(fillingFaceExterne, partitionPeauByPipe, centreFondFiss, "EDGE", 1.e-3)
+  [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)
+    facePeau = facesPeauSorted[-1] # la plus grande face
+  else:
+    facePeau =geompy.MakePartition(facesPeauFondOn, [], [], [], geompy.ShapeType["FACE"], 0, [], 1)
+    facesPeauSorted = [facePeau]
+  name="facePeau%d"%ifil
+  geompy.addToStudy(facePeau, name)
+
+  return (facePeau, facesPeauSorted, edgesPeauFondIn)

src/Tools/blocFissure/gmu/insereFissureGenerale.py

@@ -115,7 +115,7 @@ def insereFissureGenerale(maillagesSains,
   else:
     facesPartShapeDefautSorted, minSurf, maxSurf = sortFaces(facesPartShapeDefaut) # la face de fissure dans le volume doit être la plus grande
     logging.debug("surfaces faces fissure étendue, min %s, max %s", minSurf, maxSurf)
-    facesPortFissure = facesPartShapeDefautSorted[-1]
+    facesPortFissure = facesPartShapeDefautSorted[-1] #= global
   
   geompy.addToStudy(facesPortFissure, "facesPortFissure")
 
@@ -127,10 +127,10 @@ def insereFissureGenerale(maillagesSains,
   
   if geompy.NumberOfFaces(shapeDefaut) == 1:
     plan = geompy.MakePlane(centreFondFiss, tgtCentre, 10000)
-    shapeDefaut = geompy.MakePartition([shapeDefaut], [plan], [], [], geompy.ShapeType["FACE"], 0, [], 0)
+    shapeDefaut = geompy.MakePartition([shapeDefaut], [plan], [], [], geompy.ShapeType["FACE"], 0, [], 0) #= local
-    fondFissCoupe = geompy.GetInPlaceByHistory(shapeDefaut, fondFiss)
+    #fondFissCoupe = geompy.GetInPlaceByHistory(shapeDefaut, fondFiss) #= inutile
     geompy.addToStudy(shapeDefaut, 'shapeDefaut_coupe')
-    geompy.addToStudyInFather(shapeDefaut, fondFissCoupe, 'fondFiss_coupe')
+    #geompy.addToStudyInFather(shapeDefaut, fondFissCoupe, 'fondFiss_coupe')
   
   extrem, norms = findWireEndVertices(fondFiss, True)
   logging.debug("extrem: %s, norm: %s",extrem, norms)
@@ -142,17 +142,17 @@ def insereFissureGenerale(maillagesSains,
   geompy.addToStudy(pipeFiss, 'pipeFiss')
   partFissPipe = geompy.MakePartition([shapeDefaut, pipeFiss], [], [], [], geompy.ShapeType["FACE"], 0, [], 1)
   geompy.addToStudy(partFissPipe, 'partFissPipe')
-  fissPipe = geompy.GetInPlaceByHistory(partFissPipe, shapeDefaut)
+  fissPipe = geompy.GetInPlaceByHistory(partFissPipe, shapeDefaut) #= global
   geompy.addToStudy(fissPipe, 'fissPipe')
-  partPipe = geompy.GetInPlaceByHistory(partFissPipe, pipeFiss)
+  partPipe = geompy.GetInPlaceByHistory(partFissPipe, pipeFiss) #= local
   geompy.addToStudy(partPipe, 'partPipe')
   
-  edgesPipeFiss = geompy.GetSharedShapesMulti([fissPipe, partPipe], geompy.ShapeType["EDGE"])
+  edgesPipeFiss = geompy.GetSharedShapesMulti([fissPipe, partPipe], geompy.ShapeType["EDGE"]) #= global
   for i, edge in enumerate(edgesPipeFiss):
     name = "edgePipe%d"%i
     geompy.addToStudyInFather(fissPipe, edge, name)
   try:
-    wirePipeFiss = geompy.MakeWire(edgesPipeFiss)
+    wirePipeFiss = geompy.MakeWire(edgesPipeFiss) #= global
   except:
     wirePipeFiss = geompy.MakeCompound(edgesPipeFiss)
     logging.debug("wirePipeFiss construit sous forme de compound")
@@ -163,7 +163,7 @@ def insereFissureGenerale(maillagesSains,
   for i, edge in enumerate(edgesFondFiss):
     name = "edgeFondFiss%d"%i
     geompy.addToStudyInFather(fissPipe, edge, name)
-  wireFondFiss = geompy.MakeWire(edgesFondFiss)
+  wireFondFiss = geompy.MakeWire(edgesFondFiss) #= global
   geompy.addToStudy(wireFondFiss,"wireFondFiss")  
 
   # -----------------------------------------------------------------------------
@@ -174,7 +174,7 @@ def insereFissureGenerale(maillagesSains,
   #     liste de faces externes : facesDefaut
   #     liste de partitions face externe - fissure : partitionPeauFissFond (None quand pas d'intersection)
 
-  partitionsPeauFissFond = []
+  partitionsPeauFissFond = [] #= global
   ipart = 0
   for filling in facesDefaut: 
     part = geompy.MakePartition([fissPipe, filling], [], [], [], geompy.ShapeType["FACE"], 0, [], 0)
@@ -197,7 +197,7 @@ def insereFissureGenerale(maillagesSains,
   #                             et quadranglesToShapeWithCorner)
   
   aretesVives = []
-  aretesVivesCoupees = []
+  aretesVivesCoupees = []  #= global
   ia = 0
   for a in bordsPartages:
     if not isinstance(a, list):
@@ -212,7 +212,7 @@ def insereFissureGenerale(maillagesSains,
             geompy.addToStudy(a[0], name)
             ia += 1
 
-  aretesVivesC = None
+  aretesVivesC = None #= global
   if len(aretesVives) > 0:
     aretesVivesC =geompy.MakeCompound(aretesVives)
     
@@ -237,28 +237,28 @@ def insereFissureGenerale(maillagesSains,
   ptFisExtPi = [ []  for i in range(nbFacesFilling)] # pour chaque face de peau : [point commun edFissPeau edCircPeau]
   
   for ifil, partitionPeauFissFond in enumerate(partitionsPeauFissFond):
-    fillingFaceExterne = facesDefaut[ifil]
-    #fillingSansDecoupe = fillconts[idFilToCont[ifil]]
     if partitionPeauFissFond is not None:
+      fillingFaceExterne = facesDefaut[ifil]
+      #fillingSansDecoupe = fillconts[idFilToCont[ifil]]
       logging.debug("traitement partitionPeauFissFond %s", ifil)
       # -----------------------------------------------------------------------
       # --- identification edges fond de fissure, edges pipe sur la face de fissure,
       #     edges prolongées
       
-      edgesPipeC = geompy.GetInPlace(partitionPeauFissFond, geompy.MakeCompound(edgesPipeFiss))
+      edgesPipeC = geompy.GetInPlace(partitionPeauFissFond, geompy.MakeCompound(edgesPipeFiss)) #= local
       geompy.addToStudyInFather(partitionPeauFissFond, edgesPipeC, "edgesPipeFiss")
-      edgesFondC = geompy.GetInPlace(partitionPeauFissFond, geompy.MakeCompound(edgesFondFiss))
+      edgesFondC = geompy.GetInPlace(partitionPeauFissFond, geompy.MakeCompound(edgesFondFiss)) #= local
       geompy.addToStudyInFather(partitionPeauFissFond, edgesFondC, "edgesFondFiss")
       
-      if aretesVivesC is None:
+      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)
       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)
         
-      edgesPipeIn = geompy.GetSharedShapesMulti([edgesPipeC, geompy.MakeCompound(edgesInside)], geompy.ShapeType["EDGE"])
+      edgesPipeIn = geompy.GetSharedShapesMulti([edgesPipeC, geompy.MakeCompound(edgesInside)], geompy.ShapeType["EDGE"]) #= global
-      verticesPipePeau = []
+      verticesPipePeau = [] #= global
 
       for i, edge in enumerate(edgesPipeIn):
         try:
@@ -271,13 +271,14 @@ def insereFissureGenerale(maillagesSains,
           logging.debug("edgePipeIn%s coupe les faces OnSide", i)
         except:
           logging.debug("edgePipeIn%s ne coupe pas les faces OnSide", i)
-      edgesFondOut = []
+      #edgesFondOut = []     #= inutile
-      edgesFondIn =[]
+      edgesFondIn =[] #= global
       if len(verticesPipePeau) > 0: # au moins une extrémité du pipe sur cette face de peau  
-        tmp = geompy.GetSharedShapesMulti([edgesFondC, geompy.MakeCompound(edgesOutside)], geompy.ShapeType["EDGE"])
+        #tmp = geompy.GetSharedShapesMulti([edgesFondC, geompy.MakeCompound(edgesOutside)], geompy.ShapeType["EDGE"])
-        edgesFondOut = [ ed for ed in tmp if geompy.MinDistance(ed, geompy.MakeCompound(facesOnside)) < 1.e-3]
+        #edgesFondOut = [ ed for ed in tmp if geompy.MinDistance(ed, geompy.MakeCompound(facesOnside)) < 1.e-3] 
         tmp = geompy.GetSharedShapesMulti([edgesFondC, geompy.MakeCompound(edgesInside)], geompy.ShapeType["EDGE"])
         edgesFondIn = [ ed for ed in tmp if geompy.MinDistance(ed, geompy.MakeCompound(facesOnside)) < 1.e-3]
+
       verticesEdgesFondIn = [] # les points du fond de fissure au débouché du pipe sur la peau (indice de edgesFondIn)
       pipexts = []             # les segments de pipe associés au points de fond de fissure débouchants (même indice)
       cercles = []             # les cercles de generation des pipes débouchant (même indice)

src/Tools/blocFissure/gmu/partitionneFissureParPipe.py

@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*-
+
+import math
+import logging
+from geomsmesh import geompy
+from findWireEndVertices import findWireEndVertices
+from prolongeWire import prolongeWire
+
+def partitionneFissureParPipe(shapesFissure, elementsDefaut, rayonPipe):
+  """
+  pipe de fond de fissure, prolongé, partition face fissure par pipe
+  identification des edges communes pipe et face fissure
+  """
+  logging.info('start')
+  shapeDefaut       = shapesFissure[0] # faces de fissure, débordant
+  fondFiss          = shapesFissure[4] # groupe d'edges de fond de fissure
+  centreFondFiss    = elementsDefaut[15]
+  tgtCentre         = elementsDefaut[16]
+
+  if geompy.NumberOfFaces(shapeDefaut) == 1:
+    plan = geompy.MakePlane(centreFondFiss, tgtCentre, 10000)
+    shapeDefaut = geompy.MakePartition([shapeDefaut], [plan], [], [], geompy.ShapeType["FACE"], 0, [], 0)
+    #fondFissCoupe = geompy.GetInPlaceByHistory(shapeDefaut, fondFiss) #= inutile
+    geompy.addToStudy(shapeDefaut, 'shapeDefaut_coupe')
+    #geompy.addToStudyInFather(shapeDefaut, fondFissCoupe, 'fondFiss_coupe')
+  
+  extrem, norms = findWireEndVertices(fondFiss, True)
+  logging.debug("extrem: %s, norm: %s",extrem, norms)
+  cercle = geompy.MakeCircle(extrem[0], norms[0], rayonPipe)
+  cercle = geompy.MakeRotation(cercle, norms[0], math.pi/3.0 ) # éviter d'avoir l'arête de couture du pipe presque confondue avec la face fissure
+  geompy.addToStudy(cercle, 'cercle')
+  fondFissProlonge = prolongeWire(fondFiss, extrem, norms, 2*rayonPipe)
+  pipeFiss = geompy.MakePipe(cercle, fondFissProlonge)
+  geompy.addToStudy(pipeFiss, 'pipeFiss')
+  partFissPipe = geompy.MakePartition([shapeDefaut, pipeFiss], [], [], [], geompy.ShapeType["FACE"], 0, [], 1)
+  geompy.addToStudy(partFissPipe, 'partFissPipe')
+  fissPipe = geompy.GetInPlaceByHistory(partFissPipe, shapeDefaut)
+  geompy.addToStudy(fissPipe, 'fissPipe')
+  partPipe = geompy.GetInPlaceByHistory(partFissPipe, pipeFiss)
+  geompy.addToStudy(partPipe, 'partPipe')
+  
+  edgesPipeFiss = geompy.GetSharedShapesMulti([fissPipe, partPipe], geompy.ShapeType["EDGE"])
+  for i, edge in enumerate(edgesPipeFiss):
+    name = "edgePipe%d"%i
+    geompy.addToStudyInFather(fissPipe, edge, name)
+  try:
+    wirePipeFiss = geompy.MakeWire(edgesPipeFiss)
+  except:
+    wirePipeFiss = geompy.MakeCompound(edgesPipeFiss)
+    logging.debug("wirePipeFiss construit sous forme de compound")
+  geompy.addToStudy(wirePipeFiss, "wirePipeFiss")
+  
+  wireFondFiss = geompy.GetInPlace(partFissPipe,fondFiss)
+  edgesFondFiss = geompy.GetSharedShapesMulti([fissPipe, wireFondFiss], geompy.ShapeType["EDGE"])
+  for i, edge in enumerate(edgesFondFiss):
+    name = "edgeFondFiss%d"%i
+    geompy.addToStudyInFather(fissPipe, edge, name)
+  wireFondFiss = geompy.MakeWire(edgesFondFiss)
+  geompy.addToStudy(wireFondFiss,"wireFondFiss")  
+
+  return (fissPipe, edgesPipeFiss, edgesFondFiss, wirePipeFiss, wireFondFiss)

src/Tools/blocFissure/gmu/restreintFaceFissure.py

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+
+import logging
+from geomsmesh import geompy
+from sortFaces import sortFaces
+
+def restreintFaceFissure(shapeDefaut, facesDefaut, pointInterne):
+  """
+  restriction de la face de fissure au domaine solide
+  partition face fissure étendue par fillings
+  """
+  logging.info('start')
+  partShapeDefaut = geompy.MakePartition([shapeDefaut], facesDefaut, [], [], geompy.ShapeType["FACE"], 0, [], 0)
+  geompy.addToStudy(partShapeDefaut, 'partShapeDefaut')
+  facesPartShapeDefaut = geompy.ExtractShapes(partShapeDefaut, geompy.ShapeType["FACE"], False)
+  if pointInterne is not None:
+    distfaces = [(geompy.MinDistance(face,pointInterne), i, face) for i, face in enumerate(facesPartShapeDefaut)]
+    distfaces.sort()
+    logging.debug("selection de la face la plus proche du point interne, distance=%s",distfaces[0][0])
+    facesPortFissure = distfaces[0][2]
+  else:
+    facesPartShapeDefautSorted, minSurf, maxSurf = sortFaces(facesPartShapeDefaut) # la face de fissure dans le volume doit être la plus grande
+    logging.debug("surfaces faces fissure étendue, min %s, max %s", minSurf, maxSurf)
+    facesPortFissure = facesPartShapeDefautSorted[-1]
+  
+  geompy.addToStudy(facesPortFissure, "facesPortFissure")
+  return facesPortFissure

src/Tools/blocFissure/gmu/trouveEdgesFissPeau.py

@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*-
+
+import logging
+
+from geomsmesh import geompy
+
+def trouveEdgesFissPeau(facesInside, facesOnside, edgesPipeIn, edgesFondIn, partitionPeauFissFond, edgesFissExtPeau):
+  """
+  pour les faces de peau sans extremité débouchante de fissure, il faut recenser les edges de fissure sur la face de peau
+  """
+  logging.info('start')
+  
+  j = 0
+  for face in facesInside:
+    edgesPeauFis = []
+    edgesPipeFis = []
+    edgesPipeFnd = []
+    try:
+      edgesPeauFis = geompy.GetSharedShapesMulti([geompy.MakeCompound(facesOnside), face], geompy.ShapeType["EDGE"])
+      edgesPipeFis = geompy.GetSharedShapesMulti([geompy.MakeCompound(edgesPipeIn), face], geompy.ShapeType["EDGE"])
+      edgesPipeFnd = geompy.GetSharedShapesMulti([geompy.MakeCompound(edgesFondIn), face], geompy.ShapeType["EDGE"])
+    except:
+      pass
+    if (len(edgesPeauFis) > 0) and (len(edgesPipeFis) > 0) and (len(edgesPipeFnd) == 0):
+      edgesFissExtPeau.append(edgesPeauFis[0])
+      name="edgesFissExtPeau%d"%j
+      geompy.addToStudyInFather(partitionPeauFissFond, edgesPeauFis[0], name)
+      j += 1
+  return edgesFissExtPeau