Salome HOME
Merge branch 'master' into gni/evolution
authorGERALD NICOLAS <D68518@dsp0864451.atlas.edf.fr>
Thu, 11 Mar 2021 11:21:11 +0000 (12:21 +0100)
committerGERALD NICOLAS <D68518@dsp0864451.atlas.edf.fr>
Thu, 11 Mar 2021 11:21:11 +0000 (12:21 +0100)
99 files changed:
src/Tools/blocFissure/AREextradosLauncher.py
src/Tools/blocFissure/AREintradosLauncher.py
src/Tools/blocFissure/CasTests/CMakeLists.txt
src/Tools/blocFissure/CasTests/cubeAngle.py
src/Tools/blocFissure/CasTests/cubeAngle2.py
src/Tools/blocFissure/CasTests/cubeCoin.py
src/Tools/blocFissure/CasTests/cubeMilieu.py
src/Tools/blocFissure/CasTests/cubeTransverse.py
src/Tools/blocFissure/CasTests/cylindre.py
src/Tools/blocFissure/CasTests/cylindre_2.py
src/Tools/blocFissure/CasTests/disquePerce.py
src/Tools/blocFissure/CasTests/ellipse_1.py
src/Tools/blocFissure/CasTests/ellipse_2.py
src/Tools/blocFissure/CasTests/eprouvetteCourbe.py
src/Tools/blocFissure/CasTests/eprouvetteDroite.py
src/Tools/blocFissure/CasTests/eprouvetteDroite_2.py
src/Tools/blocFissure/CasTests/execution_Cas.py
src/Tools/blocFissure/CasTests/faceGauche.py
src/Tools/blocFissure/CasTests/faceGauche_2.py
src/Tools/blocFissure/CasTests/fissureCoude_1.py
src/Tools/blocFissure/CasTests/fissureCoude_10.py
src/Tools/blocFissure/CasTests/fissureCoude_2.py
src/Tools/blocFissure/CasTests/fissureCoude_3.py
src/Tools/blocFissure/CasTests/fissureCoude_4.py
src/Tools/blocFissure/CasTests/fissureCoude_5.py
src/Tools/blocFissure/CasTests/fissureCoude_6.py
src/Tools/blocFissure/CasTests/fissureCoude_7.py
src/Tools/blocFissure/CasTests/fissureCoude_8.py
src/Tools/blocFissure/CasTests/fissureCoude_9.py
src/Tools/blocFissure/CasTests/fissure_Coude.py
src/Tools/blocFissure/CasTests/fissure_Coude_4.py
src/Tools/blocFissure/CasTests/tube.py [new file with mode: 0644]
src/Tools/blocFissure/CasTests/vis_1.py
src/Tools/blocFissure/doc/gui.rst
src/Tools/blocFissure/doc/images/BF_GUI_capture.png
src/Tools/blocFissure/doc/pipes.rst
src/Tools/blocFissure/doc/principles.rst
src/Tools/blocFissure/doc/scripts.rst
src/Tools/blocFissure/doc/testcases.rst
src/Tools/blocFissure/exemple.py
src/Tools/blocFissure/exemple2.py
src/Tools/blocFissure/fissureLauncher.py
src/Tools/blocFissure/gmu/CMakeLists.txt
src/Tools/blocFissure/gmu/calculePointsAxiauxPipe.py
src/Tools/blocFissure/gmu/casStandard.py
src/Tools/blocFissure/gmu/compoundFromList.py
src/Tools/blocFissure/gmu/construitEdgesRadialesDebouchantes.py
src/Tools/blocFissure/gmu/construitFissureGenerale.py
src/Tools/blocFissure/gmu/construitMaillagePipe.py
src/Tools/blocFissure/gmu/construitPartitionsPeauFissure.py
src/Tools/blocFissure/gmu/creeZoneDefautDansObjetSain.py
src/Tools/blocFissure/gmu/creeZoneDefautMaillage.py
src/Tools/blocFissure/gmu/fissureCoude.py
src/Tools/blocFissure/gmu/fissureGenerique.py
src/Tools/blocFissure/gmu/genereMeshCalculZoneDefaut.py
src/Tools/blocFissure/gmu/getStatsMaillageFissure.py
src/Tools/blocFissure/gmu/identifieElementsDebouchants.py
src/Tools/blocFissure/gmu/identifieElementsGeometriquesPeau.py
src/Tools/blocFissure/gmu/identifieFacesEdgesFissureExterne.py
src/Tools/blocFissure/gmu/insereFissureElliptique.py
src/Tools/blocFissure/gmu/insereFissureGenerale.py
src/Tools/blocFissure/gmu/insereFissureLongue.py
src/Tools/blocFissure/gmu/insereFissureLongue_a.py [new file with mode: 0644]
src/Tools/blocFissure/gmu/insereFissureLongue_b.py [new file with mode: 0644]
src/Tools/blocFissure/gmu/insereFissureLongue_c.py [new file with mode: 0644]
src/Tools/blocFissure/gmu/insereFissureLongue_d.py [new file with mode: 0644]
src/Tools/blocFissure/gmu/mailleAretesEtJonction.py
src/Tools/blocFissure/gmu/mailleFacesFissure.py
src/Tools/blocFissure/gmu/mailleFacesPeau.py
src/Tools/blocFissure/gmu/meshBlocPart.py
src/Tools/blocFissure/gmu/orderEdgesFromWire.py
src/Tools/blocFissure/gmu/peauInterne.py
src/Tools/blocFissure/gmu/quadranglesToShapeWithCorner.py
src/Tools/blocFissure/gmu/regroupeSainEtDefaut.py
src/Tools/blocFissure/gmu/restreintFaceFissure.py
src/Tools/blocFissure/gmu/sortEdges.py
src/Tools/blocFissure/gmu/sortFaces.py
src/Tools/blocFissure/ihm/fissureCoude_ihm.py
src/Tools/blocFissure/ihm/fissureCoude_plugin.py
src/Tools/blocFissure/ihm/fissureGenerale.ui
src/Tools/blocFissure/ihm/fissureGenerale_plugin.py
src/Tools/blocFissure/lanceurSoudureArrondieTest.py
src/Tools/blocFissure/lanceurSoudureViveTest.py
src/Tools/blocFissure/lanceurTestAubry.py
src/Tools/blocFissure/materielCasTests/CMakeLists.txt
src/Tools/blocFissure/materielCasTests/cubeAngle.py
src/Tools/blocFissure/materielCasTests/cubeFin.py
src/Tools/blocFissure/materielCasTests/decoupeCylindre.py
src/Tools/blocFissure/materielCasTests/disque_perce.py
src/Tools/blocFissure/materielCasTests/ellipse.py
src/Tools/blocFissure/materielCasTests/ellipse_disque.py
src/Tools/blocFissure/materielCasTests/ellipse_probleme.py
src/Tools/blocFissure/materielCasTests/eprouvetteCourbe.py
src/Tools/blocFissure/materielCasTests/eprouvetteDroite.py
src/Tools/blocFissure/materielCasTests/fissureGauche.py
src/Tools/blocFissure/materielCasTests/fissureGauche2.py
src/Tools/blocFissure/materielCasTests/genereMateriel.py
src/Tools/blocFissure/materielCasTests/tube.py [new file with mode: 0755]
src/Tools/blocFissure/materielCasTests/vis.py

index 690af3c..ffe9de4 100644 (file)
@@ -38,8 +38,8 @@ crack = 'fissureExtrados.brep'
 
 dicoParams = dict(nomCas            = 'fissTuyau',
                   maillageSain      = '/local00/home/I48174/Documents/soudure/essaiFissure/{0}'.format(mesh),
-                  brepFaceFissure   = '/local00/home/I48174/Documents/soudure/essaiFissure/{0}'.format(crack),
-                  edgeFissIds       = [4],
+                  CAOFaceFissure    = '/local00/home/I48174/Documents/soudure/essaiFissure/{0}'.format(crack),
+                  edgeFiss          = [4],
                   lgInfluence       = 12,
                   meshBrep          = (0.05, 2.0),
                   rayonPipe         = 1.0,
index 9ce8fc0..24f861e 100644 (file)
@@ -38,8 +38,8 @@ crack = 'fissureIntrados.brep'
 
 dicoParams = dict(nomCas            = 'fissTuyau',
                   maillageSain      = '/local00/home/I48174/Documents/soudure/essaiFissure/{0}'.format(mesh),
-                  brepFaceFissure   = '/local00/home/I48174/Documents/soudure/essaiFissure/{0}'.format(crack),
-                  edgeFissIds       = [4],
+                  CAOFaceFissure    = '/local00/home/I48174/Documents/soudure/essaiFissure/{0}'.format(crack),
+                  edgeFiss          = [4],
                   lgInfluence       = 14,
                   meshBrep          = (0.05, 2.0),
                   rayonPipe         = 1.0,
index e6bcd67..d3ac131 100644 (file)
@@ -51,6 +51,7 @@ SET(plugin_SCRIPTS
   fissureCoude_9.py
   fissure_Coude.py
   vis_1.py
+  tube.py
 )
 
 # --- rules ---
index dd2559d..9ed946f 100644 (file)
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
-import os
-from blocFissure import gmu
-from blocFissure.gmu.geomsmesh import geompy, smesh
+"""problème de fissure plane coupant 2 faces (angle), débouches normaux, objet plan"""
 
-import math
-import GEOM
-import SALOMEDS
-import SMESH
-#import StdMeshers
-#import GHS3DPlugin
-#import NETGENPlugin
+import os
 import logging
 
+from blocFissure import gmu
+from blocFissure.gmu.geomsmesh import geompy, smesh
 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.construitFissureGenerale import construitFissureGenerale
 
-O, OX, OY, OZ = triedreBase()
+import GEOM
+import SALOMEDS
+import SMESH
 
 class cubeAngle(fissureGenerique):
-  """
-  problème de fissure plane coupant 2 faces (angle), débouches normaux, objet plan
-  """
+  """problème de fissure plane coupant 2 faces (angle), débouches normaux, objet plan"""
 
   nomProbleme = "cubeAngle"
 
   # ---------------------------------------------------------------------------
   def genereMaillageSain(self, geometriesSaines, meshParams):
-    logging.info("genereMaillageSain %s", self.nomCas)
+    texte = "genereMaillageSain pour '{}'".format(self.nomCas)
+    logging.info(texte)
 
-    ([objetSain], status) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, 'materielCasTests/CubeAngle.med'))
-    smesh.SetName(objetSain.GetMesh(), 'objetSain')
+    ([objetSain], _) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests", "CubeAngle.med"))
+    smesh.SetName(objetSain.GetMesh(), "{}_objetSain".format(self.nomProbleme))
 
     return [objetSain, True] # True : maillage hexa
 
@@ -63,17 +56,20 @@ class cubeAngle(fissureGenerique):
     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
     """
-    logging.info("setParamShapeFissure %s", self.nomCas)
+    texte = "genereMaillageSain pour '{}'".format(self.nomCas)
+    logging.info(texte)
     self.shapeFissureParams = dict(lgInfluence = 20,
                                    rayonPipe   = 10)
 
   # ---------------------------------------------------------------------------
   def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams):
-    logging.info("genereShapeFissure %s", self.nomCas)
+    """Importe la géométrie de la fissure"""
+    texte = "genereShapeFissure pour '{}'".format(self.nomCas)
+    logging.info(texte)
 
     lgInfluence = shapeFissureParams['lgInfluence']
 
-    shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests/CubeAngleFiss.brep"))
+    shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests", "CubeAngleFiss.brep"))
     fondFiss = geompy.CreateGroup(shellFiss, geompy.ShapeType["EDGE"])
     geompy.UnionIDs(fondFiss, [3])
     geompy.addToStudy( shellFiss, 'shellFiss' )
@@ -83,13 +79,16 @@ class cubeAngle(fissureGenerique):
     coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,10)
 
     centre = None
+
     return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss]
 
   # ---------------------------------------------------------------------------
   def setParamMaillageFissure(self):
-    self.maillageFissureParams = dict(nomRep           = '.',
+    texte = "setParamMaillageFissure pour '{}'".format(self.nomCas)
+    logging.info(texte)
+    self.maillageFissureParams = dict(nomRep           = os.curdir,
                                       nomFicSain       = self.nomCas,
-                                      nomFicFissure    = 'fissure_' + self.nomCas,
+                                      nomFicFissure    = self.nomCas + "_fissure",
                                       nbsegRad         = 5,
                                       nbsegCercle      = 8,
                                       areteFaceFissure = 10)
@@ -103,6 +102,8 @@ class cubeAngle(fissureGenerique):
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                             shapesFissure, shapeFissureParams,
                             maillageFissureParams, elementsDefaut, step):
+    texte = "genereMaillageFissure pour '{}'".format(self.nomCas)
+    logging.info(texte)
     maillageFissure = construitFissureGenerale(maillagesSains,
                                                shapesFissure, shapeFissureParams,
                                                maillageFissureParams, elementsDefaut, step)
@@ -110,12 +111,13 @@ class cubeAngle(fissureGenerique):
 
   # ---------------------------------------------------------------------------
   def setReferencesMaillageFissure(self):
-    self.referencesMaillageFissure = dict(Entity_Quad_Pyramid    = 204,
-                                          Entity_Quad_Triangle   = 336,
-                                          Entity_Quad_Edge       = 278,
-                                          Entity_Quad_Penta      = 96,
-                                          Entity_Quad_Hexa       = 3651,
-                                          Entity_Node            = 20490,
-                                          Entity_Quad_Tetra      = 1877,
-                                          Entity_Quad_Quadrangle = 1702)
-
+    self.referencesMaillageFissure = dict( \
+                                          Entity_Quad_Quadrangle = 1630, \
+                                          Entity_Quad_Hexa = 3523, \
+                                          Entity_Node = 18874, \
+                                          Entity_Quad_Edge = 261, \
+                                          Entity_Quad_Triangle = 190, \
+                                          Entity_Quad_Tetra = 1322, \
+                                          Entity_Quad_Pyramid = 172, \
+                                          Entity_Quad_Penta = 64 \
+                                         )
index 1e65d9d..21c3375 100644 (file)
 #
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
+"""problème de fissure plane coupant 2 faces (angle)"""
+
+import os
 
 from .cubeAngle import cubeAngle
 
 class cubeAngle2(cubeAngle):
-  """
-  problème de fissure plane coupant 2 faces (angle), débouches normaux, objet plan
-  detection d'un probleme de tolerance sur les edges de jonction pipe et face fissure externe 
+  """problème de fissure plane coupant 2 faces (angle), débouches normaux, objet plan
+
+  detection d'un probleme de tolerance sur les edges de jonction pipe et face fissure externe
   """
 
   nomProbleme = "cubeAngle2"
 
   # ---------------------------------------------------------------------------
   def setParamShapeFissure(self):
-    """
-    paramètres de la fissure pour méthode construitFissureGenerale
+    """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
     """
@@ -40,21 +43,22 @@ class cubeAngle2(cubeAngle):
 
   # ---------------------------------------------------------------------------
   def setParamMaillageFissure(self):
-    self.maillageFissureParams = dict(nomRep           = '.',
+    self.maillageFissureParams = dict(nomRep           = os.curdir,
                                       nomFicSain       = self.nomCas,
-                                      nomFicFissure    = 'fissure_' + self.nomCas,
+                                      nomFicFissure    = self.nomCas + "_fissure",
                                       nbsegRad         = 5,
                                       nbsegCercle      = 32,
                                       areteFaceFissure = 5)
 
   # ---------------------------------------------------------------------------
   def setReferencesMaillageFissure(self):
-    self.referencesMaillageFissure = dict(Entity_Quad_Pyramid    = 748,
-                                          Entity_Quad_Triangle   = 1228,
-                                          Entity_Quad_Edge       = 351,
-                                          Entity_Quad_Penta      = 640,
-                                          Entity_Quad_Hexa       = 5827,
-                                          Entity_Node            = 42865,
-                                          Entity_Quad_Tetra      = 9216,
-                                          Entity_Quad_Quadrangle = 2518)
-
+    self.referencesMaillageFissure = dict( \
+                                          Entity_Quad_Quadrangle = 2350, \
+                                          Entity_Quad_Hexa = 5315, \
+                                          Entity_Node = 38196, \
+                                          Entity_Quad_Edge = 345, \
+                                          Entity_Quad_Triangle = 1214, \
+                                          Entity_Quad_Tetra = 7772, \
+                                          Entity_Quad_Pyramid = 620, \
+                                          Entity_Quad_Penta = 512 \
+                                         )
index deed87e..5699196 100644 (file)
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
+"""problème de fissure plane coupant le cube dans un coin"""
+
 import os
 from blocFissure import gmu
 
-dicoParams = dict(nomCas            = 'cubeCoin',
-                  maillageSain      = os.path.join(gmu.pathBloc, 'materielCasTests/cubeFin.med'),
-                  brepFaceFissure   = os.path.join(gmu.pathBloc, "materielCasTests/cubeFin_Coin.brep"),
-                  edgeFissIds       = [6],
+dicoParams = dict(nomCas            = "cubeCoin",
+                  maillageSain      = os.path.join(gmu.pathBloc, "materielCasTests", "cubeFin.med"),
+                  CAOFaceFissure    = os.path.join(gmu.pathBloc, "materielCasTests", "cubeFin_Coin.brep"),
+                  edgeFiss          = [3],
                   lgInfluence       = 50,
                   meshBrep          = (5,10),
                   rayonPipe         = 10,
@@ -35,12 +37,13 @@ dicoParams = dict(nomCas            = 'cubeCoin',
 
   # ---------------------------------------------------------------------------
 
-referencesMaillageFissure = dict(Entity_Quad_Pyramid    = 0,
-                                 Entity_Quad_Triangle   = 0,
-                                 Entity_Quad_Edge       = 0,
-                                 Entity_Quad_Penta      = 0,
-                                 Entity_Quad_Hexa       = 0,
-                                 Entity_Node            = 0,
-                                 Entity_Quad_Tetra      = 0,
-                                 Entity_Quad_Quadrangle = 0)
-
+referencesMaillageFissure = dict( \
+                                Entity_Quad_Quadrangle = 2740, \
+                                Entity_Quad_Hexa = 7420, \
+                                Entity_Node = 46394, \
+                                Entity_Quad_Edge = 323, \
+                                Entity_Quad_Triangle = 486, \
+                                Entity_Quad_Tetra = 8512, \
+                                Entity_Quad_Pyramid = 460, \
+                                Entity_Quad_Penta = 80 \
+                                )
index f615c88..b5485fe 100644 (file)
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
+"""problème de fissure plane coupant le cube au milieu"""
+
 import os
 from blocFissure import gmu
 
-dicoParams = dict(nomCas            = 'cubeMilieu',
-                  maillageSain      = os.path.join(gmu.pathBloc, 'materielCasTests/cubeFin.med'),
-                  brepFaceFissure   = os.path.join(gmu.pathBloc, "materielCasTests/cubeFin_Milieu.brep"),
-                  edgeFissIds       = [6],
+dicoParams = dict(nomCas            = "cubeMilieu",
+                  maillageSain      = os.path.join(gmu.pathBloc, "materielCasTests", "cubeFin.med"),
+                  CAOFaceFissure    = os.path.join(gmu.pathBloc, "materielCasTests", "cubeFin_Milieu.brep"),
+                  edgeFiss          = [3],
                   lgInfluence       = 50,
                   meshBrep          = (5,10),
                   rayonPipe         = 10,
@@ -35,12 +37,13 @@ dicoParams = dict(nomCas            = 'cubeMilieu',
 
 # ---------------------------------------------------------------------------
 
-referencesMaillageFissure = dict(Entity_Quad_Pyramid    = 0,
-                                 Entity_Quad_Triangle   = 0,
-                                 Entity_Quad_Edge       = 0,
-                                 Entity_Quad_Penta      = 0,
-                                 Entity_Quad_Hexa       = 0,
-                                 Entity_Node            = 0,
-                                 Entity_Quad_Tetra      = 0,
-                                 Entity_Quad_Quadrangle = 0)
-
+referencesMaillageFissure = dict( \
+                                Entity_Quad_Quadrangle = 3140, \
+                                Entity_Quad_Hexa = 7120, \
+                                Entity_Node = 61414, \
+                                Entity_Quad_Edge = 346, \
+                                Entity_Quad_Triangle = 818, \
+                                Entity_Quad_Tetra = 19117, \
+                                Entity_Quad_Pyramid = 990, \
+                                Entity_Quad_Penta = 230 \
+                                )
index 268cc50..570e732 100644 (file)
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
+"""problème de fissure plane coupant le cube au milieu"""
+
 import os
 from blocFissure import gmu
 
-dicoParams = dict(nomCas            = 'cubeTransverse',
-                  maillageSain      = os.path.join(gmu.pathBloc, 'materielCasTests/cubeFin.med'),
-                  brepFaceFissure   = os.path.join(gmu.pathBloc, "materielCasTests/cubeFin_Transverse.brep"),
-                  edgeFissIds       = [6],
+dicoParams = dict(nomCas            = "cubeTransverse",
+                  maillageSain      = os.path.join(gmu.pathBloc, "materielCasTests", "cubeFin.med"),
+                  CAOFaceFissure    = os.path.join(gmu.pathBloc, "materielCasTests", "cubeFin_Transverse.brep"),
+                  edgeFiss          = [6],
                   lgInfluence       = 50,
                   meshBrep          = (5,10),
                   rayonPipe         = 10,
@@ -35,12 +37,13 @@ dicoParams = dict(nomCas            = 'cubeTransverse',
 
 # ---------------------------------------------------------------------------
 
-referencesMaillageFissure = dict(Entity_Quad_Pyramid    = 0,
-                                 Entity_Quad_Triangle   = 0,
-                                 Entity_Quad_Edge       = 0,
-                                 Entity_Quad_Penta      = 0,
-                                 Entity_Quad_Hexa       = 0,
-                                 Entity_Node            = 0,
-                                 Entity_Quad_Tetra      = 0,
-                                 Entity_Quad_Quadrangle = 0)
-
+referencesMaillageFissure = dict( \
+                                          Entity_Quad_Quadrangle = 2900, \
+                                          Entity_Quad_Hexa = 7000, \
+                                          Entity_Node = 58430, \
+                                          Entity_Quad_Edge = 390, \
+                                          Entity_Quad_Triangle = 1228, \
+                                          Entity_Quad_Tetra = 17567, \
+                                          Entity_Quad_Pyramid = 780, \
+                                          Entity_Quad_Penta = 200 \
+                                )
index 90b45fd..9e29286 100644 (file)
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
-import os
-from blocFissure import gmu
-from blocFissure.gmu.geomsmesh import geompy, smesh
+"""problème de fissure plane sur cylindre, grand fond de fissure en arc de cercle"""
 
-import math
-import GEOM
-import SALOMEDS
-import SMESH
-#import StdMeshers
-#import GHS3DPlugin
-#import NETGENPlugin
+import os
 import logging
 
+from blocFissure import gmu
+from blocFissure.gmu.geomsmesh import geompy, smesh
 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.construitFissureGenerale import construitFissureGenerale
 
-O, OX, OY, OZ = triedreBase()
+import GEOM
+import SALOMEDS
+import SMESH
 
 class cylindre(fissureGenerique):
-  """
-  problème de fissure plane sur cylindre, grand fond de fissure en arc de cercle
-  """
+  """problème de fissure plane sur cylindre, grand fond de fissure en arc de cercle"""
 
   nomProbleme = "cylindre"
 
@@ -55,7 +47,7 @@ class cylindre(fissureGenerique):
     """
     logging.info("genereMaillageSain %s", self.nomCas)
 
-    ([objetSain], status) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests/CylindreSain.med"))
+    ([objetSain], _) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests", "CylindreSain.med"))
     smesh.SetName(objetSain.GetMesh(), 'objetSain')
 
     return [objetSain, True] # True : maillage hexa
@@ -77,7 +69,7 @@ class cylindre(fissureGenerique):
 
     lgInfluence = shapeFissureParams['lgInfluence']
 
-    shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests/FissInCylindre2.brep"))
+    shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests", "FissInCylindre2.brep"))
     fondFiss = geompy.CreateGroup(shellFiss, geompy.ShapeType["EDGE"])
     geompy.UnionIDs(fondFiss, [6])
     geompy.addToStudy( shellFiss, 'shellFiss' )
@@ -91,9 +83,9 @@ class cylindre(fissureGenerique):
 
   # ---------------------------------------------------------------------------
   def setParamMaillageFissure(self):
-    self.maillageFissureParams = dict(nomRep           = '.',
+    self.maillageFissureParams = dict(nomRep           = os.curdir,
                                       nomFicSain       = self.nomCas,
-                                      nomFicFissure    = 'fissure_' + self.nomCas,
+                                      nomFicFissure    = self.nomCas + "_fissure",
                                       nbsegRad         = 5,
                                       nbsegCercle      = 8,
                                       areteFaceFissure = 20)
@@ -114,12 +106,13 @@ class cylindre(fissureGenerique):
 
   # ---------------------------------------------------------------------------
   def setReferencesMaillageFissure(self):
-    self.referencesMaillageFissure = dict(Entity_Quad_Pyramid    = 1270,
-                                          Entity_Quad_Triangle   = 1260,
-                                          Entity_Quad_Edge       = 758,
-                                          Entity_Quad_Penta      = 496,
-                                          Entity_Quad_Hexa       = 18814,
-                                          Entity_Node            = 113313,
-                                          Entity_Quad_Tetra      = 20469,
-                                          Entity_Quad_Quadrangle = 7280)
-
+    self.referencesMaillageFissure = dict( \
+                                          Entity_Quad_Quadrangle = 6920, \
+                                          Entity_Quad_Hexa = 18174, \
+                                          Entity_Node = 104349, \
+                                          Entity_Quad_Edge = 718, \
+                                          Entity_Quad_Triangle = 952, \
+                                          Entity_Quad_Tetra = 16691, \
+                                          Entity_Quad_Pyramid = 1110, \
+                                          Entity_Quad_Penta = 336 \
+                                         )
index 858f80d..6b17ff3 100644 (file)
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
+"""problème de fissure plane sur cylindre hexa, fond de fissure complexe : polyline"""
+
 import os
+import logging
+
 from blocFissure import gmu
 from blocFissure.gmu.geomsmesh import geompy, smesh
+from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
 
-import math
 import GEOM
 import SALOMEDS
 import SMESH
-import logging
 
 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.construitFissureGenerale import construitFissureGenerale
-
-O, OX, OY, OZ = triedreBase()
-
 class cylindre_2(cylindre):
-  """
-  problème de fissure plane sur cylindre hexa, fond de fissure complexe : polyline
-  """
+  """problème de fissure plane sur cylindre hexa, fond de fissure complexe : polyline"""
+
   nomProbleme = "cylindre2"
 
   # ---------------------------------------------------------------------------
@@ -49,9 +44,9 @@ class cylindre_2(cylindre):
 
     lgInfluence = shapeFissureParams['lgInfluence']
 
-    shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests/FissInCylindre.brep"))
+    shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests", "FissInCylindre.brep"))
     fondFiss = geompy.CreateGroup(shellFiss, geompy.ShapeType["EDGE"])
-    geompy.UnionIDs(fondFiss, [3])
+    geompy.UnionIDs(fondFiss, [6])
     geompy.addToStudy( shellFiss, 'shellFiss' )
     geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' )
 
@@ -63,12 +58,13 @@ class cylindre_2(cylindre):
 
   # ---------------------------------------------------------------------------
   def setReferencesMaillageFissure(self):
-    self.referencesMaillageFissure = dict(Entity_Quad_Pyramid    = 1334,
-                                          Entity_Quad_Triangle   = 1432,
-                                          Entity_Quad_Edge       = 785,
-                                          Entity_Quad_Penta      = 560,
-                                          Entity_Quad_Hexa       = 19070,
-                                          Entity_Node            = 114290,
-                                          Entity_Quad_Tetra      = 19978,
-                                          Entity_Quad_Quadrangle = 7424)
-
+    self.referencesMaillageFissure = dict( \
+                                          Entity_Quad_Quadrangle = 7028, \
+                                          Entity_Quad_Hexa = 18366, \
+                                          Entity_Node = 105035, \
+                                          Entity_Quad_Edge = 735, \
+                                          Entity_Quad_Triangle = 1056, \
+                                          Entity_Quad_Tetra = 16305, \
+                                          Entity_Quad_Pyramid = 1158, \
+                                          Entity_Quad_Penta = 384 \
+                                          )
index b0ceb99..3807946 100644 (file)
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
+"""disque percé"""
+
 import os
 from blocFissure import gmu
 
 dicoParams = dict(nomCas            = 'disque',
-                  maillageSain      = os.path.join(gmu.pathBloc, 'materielCasTests/disque.med'),
-                  brepFaceFissure   = os.path.join(gmu.pathBloc, "materielCasTests/ellipse_disque.brep"),
-                  edgeFissIds       = [3],
+                  maillageSain      = os.path.join(gmu.pathBloc, "materielCasTests", "disque.med"),
+                  CAOFaceFissure    = os.path.join(gmu.pathBloc, "materielCasTests", "ellipse_disque.brep"),
+                  edgeFiss          = [3],
                   lgInfluence       = 10,
                   meshBrep          = (0.5,2.5),
                   rayonPipe         = 1.0,
@@ -35,12 +37,13 @@ dicoParams = dict(nomCas            = 'disque',
 
   # ---------------------------------------------------------------------------
 
-referencesMaillageFissure = dict(Entity_Quad_Pyramid    = 610,
-                                 Entity_Quad_Triangle   = 1284,
-                                 Entity_Quad_Edge       = 393,
-                                 Entity_Quad_Penta      = 592,
-                                 Entity_Quad_Hexa       = 6952,
-                                 Entity_Node            = 51119,
-                                 Entity_Quad_Tetra      = 11672,
-                                 Entity_Quad_Quadrangle = 3000)
-
+referencesMaillageFissure = dict ( \
+                                  Entity_Quad_Quadrangle = 2748, \
+                                  Entity_Quad_Hexa = 6232, \
+                                  Entity_Node = 43889, \
+                                  Entity_Quad_Edge = 376, \
+                                  Entity_Quad_Triangle = 1366, \
+                                  Entity_Quad_Tetra = 9112, \
+                                  Entity_Quad_Pyramid = 466, \
+                                  Entity_Quad_Penta = 448 \
+                                )
index 94e8f0b..80811a5 100644 (file)
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
-import os
-from blocFissure import gmu
-from blocFissure.gmu.geomsmesh import geompy, smesh
+"""problème de fissure non plane, débouchante non normale"""
 
-import math
-import GEOM
-import SALOMEDS
-import SMESH
-#import StdMeshers
-#import GHS3DPlugin
-#import NETGENPlugin
+import os
 import logging
 
+from blocFissure import gmu
+from blocFissure.gmu.geomsmesh import geompy, smesh
 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.construitFissureGenerale import construitFissureGenerale
 
-O, OX, OY, OZ = triedreBase()
+import GEOM
+import SALOMEDS
+import SMESH
 
 class ellipse_1(fissureGenerique):
-  """
-  problème de fissure non plane, débouchante non normale
-  """
+  """problème de fissure non plane, débouchante non normale"""
 
   nomProbleme = "ellipse1"
 
@@ -55,10 +47,11 @@ class ellipse_1(fissureGenerique):
 
   # ---------------------------------------------------------------------------
   def genereMaillageSain(self, geometriesSaines, meshParams):
-    logging.info("genereMaillageSain %s", self.nomCas)
+    texte = "genereMaillageSain pour '{}'".format(self.nomCas)
+    logging.info(texte)
 
-    ([objetSain], status) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests/boiteSaine.med"))
-    smesh.SetName(objetSain.GetMesh(), 'objetSain')
+    ([objetSain], _) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests", "boiteSaine.med"))
+    smesh.SetName(objetSain.GetMesh(), "{}_objetSain".format(self.nomProbleme))
 
     return [objetSain, True] # True : maillage hexa
 
@@ -71,33 +64,38 @@ class ellipse_1(fissureGenerique):
     convexe     : optionnel, True : la face est convexe (vue de l'exterieur) sert si on ne donne pas de point interne
     pointIn_x   : optionnel, coordonnée x d'un point dans le solide sain (pour orienter la face)
     """
-    logging.info("setParamShapeFissure %s", self.nomCas)
+    texte = "genereMaillageSain pour '{}'".format(self.nomCas)
+    logging.info(texte)
     self.shapeFissureParams = dict(lgInfluence = 50,
                                    rayonPipe   = 20)
 
   # ---------------------------------------------------------------------------
   def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams):
-    logging.info("genereShapeFissure %s", self.nomCas)
+    """Importe la géométrie de la fissure"""
+    texte = "genereShapeFissure pour '{}'".format(self.nomCas)
+    logging.info(texte)
 
     lgInfluence = shapeFissureParams['lgInfluence']
 
-    shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests/ellipse1.brep"))
+    shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests", "ellipse1.brep"))
     fondFiss = geompy.CreateGroup(shellFiss, geompy.ShapeType["EDGE"])
     geompy.UnionIDs(fondFiss, [3])
     geompy.addToStudy( shellFiss, 'shellFiss' )
     geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' )
 
-
     coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,25)
 
     centre = None
+
     return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss]
 
   # ---------------------------------------------------------------------------
   def setParamMaillageFissure(self):
-    self.maillageFissureParams = dict(nomRep           = '.',
+    texte = "setParamMaillageFissure pour '{}'".format(self.nomCas)
+    logging.info(texte)
+    self.maillageFissureParams = dict(nomRep           = os.curdir,
                                       nomFicSain       = self.nomCas,
-                                      nomFicFissure    = 'fissure_' + self.nomCas,
+                                      nomFicFissure    = self.nomCas + "_fissure",
                                       nbsegRad         = 5,
                                       nbsegCercle      = 8,
                                       areteFaceFissure = 1000)
@@ -111,6 +109,8 @@ class ellipse_1(fissureGenerique):
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                             shapesFissure, shapeFissureParams,
                             maillageFissureParams, elementsDefaut, step):
+    texte = "genereMaillageFissure pour '{}'".format(self.nomCas)
+    logging.info(texte)
     maillageFissure = construitFissureGenerale(maillagesSains,
                                                shapesFissure, shapeFissureParams,
                                                maillageFissureParams, elementsDefaut, step)
@@ -118,12 +118,13 @@ class ellipse_1(fissureGenerique):
 
   # ---------------------------------------------------------------------------
   def setReferencesMaillageFissure(self):
-    self.referencesMaillageFissure = dict(Entity_Quad_Pyramid    = 175,
-                                          Entity_Quad_Triangle   = 298,
-                                          Entity_Quad_Edge       = 248,
-                                          Entity_Quad_Penta      = 96,
-                                          Entity_Quad_Hexa       = 3699,
-                                          Entity_Node            = 20741,
-                                          Entity_Quad_Tetra      = 1979,
-                                          Entity_Quad_Quadrangle = 1694)
-
+    self.referencesMaillageFissure = dict( \
+                                          Entity_Quad_Quadrangle = 1748, \
+                                          Entity_Quad_Hexa = 3795, \
+                                          Entity_Node = 21939, \
+                                          Entity_Quad_Edge = 256, \
+                                          Entity_Quad_Triangle = 360, \
+                                          Entity_Quad_Tetra = 2425, \
+                                          Entity_Quad_Pyramid = 199, \
+                                          Entity_Quad_Penta = 120 \
+                                         )
index 4947fbb..9fbef92 100644 (file)
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
+"""problème de fissure non plane, débouchante non normale"""
+
 import os
+import logging
+
 from blocFissure import gmu
 from blocFissure.gmu.geomsmesh import geompy, smesh
+from blocFissure.gmu.fissureGenerique import fissureGenerique
+from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
+from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
+from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale
 
-import math
 import GEOM
 import SALOMEDS
 import SMESH
-#import StdMeshers
-#import GHS3DPlugin
-#import NETGENPlugin
-import logging
 
 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.construitFissureGenerale import construitFissureGenerale
-
-O, OX, OY, OZ = triedreBase()
-
 class ellipse_2(ellipse_1):
-  """
-  problème de fissure non plane, débouchante non normale
-  """
+  """problème de fissure non plane, débouchante non normale"""
 
   nomProbleme = "ellipse2"
 
   # ---------------------------------------------------------------------------
   def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams):
-    logging.info("genereShapeFissure %s", self.nomCas)
+    """Importe la géométrie de la fissure"""
+    texte = "genereShapeFissure pour '{}'".format(self.nomCas)
+    logging.info(texte)
 
     lgInfluence = shapeFissureParams['lgInfluence']
 
-    shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests/ellipse1_pb.brep"))
+    shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests", "ellipse1_pb.brep"))
     fondFiss = geompy.CreateGroup(shellFiss, geompy.ShapeType["EDGE"])
     geompy.UnionIDs(fondFiss, [3])
     geompy.addToStudy( shellFiss, 'shellFiss' )
     geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' )
 
-
     coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,25)
 
     centre = None
+
     return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss]
 
   # ---------------------------------------------------------------------------
   def setReferencesMaillageFissure(self):
-    self.referencesMaillageFissure = dict(Entity_Quad_Pyramid    = 159,
-                                          Entity_Quad_Triangle   = 438,
-                                          Entity_Quad_Edge       = 249,
-                                          Entity_Quad_Penta      = 80,
-                                          Entity_Quad_Hexa       = 3635,
-                                          Entity_Node            = 20519,
-                                          Entity_Quad_Tetra      = 1973,
-                                          Entity_Quad_Quadrangle = 1658)
+    self.referencesMaillageFissure = dict( \
+                                          Entity_Quad_Quadrangle = 1748, \
+                                          Entity_Quad_Hexa = 3795, \
+                                          Entity_Node = 22219, \
+                                          Entity_Quad_Edge = 258, \
+                                          Entity_Quad_Triangle = 434, \
+                                          Entity_Quad_Tetra = 2574, \
+                                          Entity_Quad_Pyramid = 199, \
+                                          Entity_Quad_Penta = 120 \
+                                         )
index 5ed3647..ddfb857 100644 (file)
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
-import os
-from blocFissure import gmu
-from blocFissure.gmu.geomsmesh import geompy, smesh
+"""problème de fissure plane coupant 3 faces (éprouvette), faces au débouché non planes, incidence presque normale"""
 
-import math
-import GEOM
-import SALOMEDS
-import SMESH
-#import StdMeshers
-#import GHS3DPlugin
-#import NETGENPlugin
+import os
 import logging
 
+from blocFissure import gmu
+from blocFissure.gmu.geomsmesh import geompy, smesh
 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.construitFissureGenerale import construitFissureGenerale
 
-O, OX, OY, OZ = triedreBase()
+import GEOM
+import SALOMEDS
+import SMESH
 
 class eprouvetteCourbe(fissureGenerique):
-  """
-  problème de fissure plane coupant 3 faces (éprouvette), faces au débouché non planes, incidence presque normale
-  """
+  """problème de fissure plane coupant 3 faces (éprouvette), faces au débouché non planes, incidence presque normale"""
 
   nomProbleme = "eprouvetteCourbe"
 
   # ---------------------------------------------------------------------------
   def genereMaillageSain(self, geometriesSaines, meshParams):
-    logging.info("genereMaillageSain %s", self.nomCas)
+    texte = "genereMaillageSain pour '{}'".format(self.nomCas)
+    logging.info(texte)
 
-    ([objetSain], status) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests/EprouvetteCourbe.med"))
+    ([objetSain], _) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests", "EprouvetteCourbe.med"))
     smesh.SetName(objetSain.GetMesh(), 'objetSain')
 
     return [objetSain, True] # True : maillage hexa
@@ -65,33 +58,38 @@ class eprouvetteCourbe(fissureGenerique):
     convexe     : optionnel True : la face est convexe (vue de l'exterieur) sert si on ne donne pas de point interne
     pointIn_x   : optionnel coordonnée x d'un point dans le solide sain (pour orienter la face)
     """
-    logging.info("setParamShapeFissure %s", self.nomCas)
+    texte = "genereMaillageSain pour '{}'".format(self.nomCas)
+    logging.info(texte)
     self.shapeFissureParams = dict(lgInfluence = 30,
                                    rayonPipe   = 10)
 
   # ---------------------------------------------------------------------------
   def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams):
-    logging.info("genereShapeFissure %s", self.nomCas)
+    """Importe la géométrie de la fissure"""
+    texte = "genereShapeFissure pour '{}'".format(self.nomCas)
+    logging.info(texte)
 
     lgInfluence = shapeFissureParams['lgInfluence']
 
-    shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests/EprouvetteCourbeFiss.brep"))
+    shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests", "EprouvetteCourbeFiss.brep"))
     fondFiss = geompy.CreateGroup(shellFiss, geompy.ShapeType["EDGE"])
     geompy.UnionIDs(fondFiss, [8])
     geompy.addToStudy( shellFiss, 'shellFiss' )
     geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' )
 
-
     coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,10)
 
     centre = None
+
     return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss]
 
   # ---------------------------------------------------------------------------
   def setParamMaillageFissure(self):
-    self.maillageFissureParams = dict(nomRep           = '.',
+    texte = "setParamMaillageFissure pour '{}'".format(self.nomCas)
+    logging.info(texte)
+    self.maillageFissureParams = dict(nomRep           = os.curdir,
                                       nomFicSain       = self.nomCas,
-                                      nomFicFissure    = 'fissure_' + self.nomCas,
+                                      nomFicFissure    = self.nomCas + "_fissure",
                                       nbsegRad         = 5,
                                       nbsegCercle      = 8,
                                       areteFaceFissure = 15)
@@ -105,6 +103,8 @@ class eprouvetteCourbe(fissureGenerique):
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                             shapesFissure, shapeFissureParams,
                             maillageFissureParams, elementsDefaut, step):
+    texte = "genereMaillageFissure pour '{}'".format(self.nomCas)
+    logging.info(texte)
     maillageFissure = construitFissureGenerale(maillagesSains,
                                                shapesFissure, shapeFissureParams,
                                                maillageFissureParams, elementsDefaut, step)
@@ -112,12 +112,13 @@ class eprouvetteCourbe(fissureGenerique):
 
   # ---------------------------------------------------------------------------
   def setReferencesMaillageFissure(self):
-    self.referencesMaillageFissure = dict(Entity_Quad_Pyramid    = 618,
-                                          Entity_Quad_Triangle   = 1224,
-                                          Entity_Quad_Edge       = 578,
-                                          Entity_Quad_Penta      = 168,
-                                          Entity_Quad_Hexa       = 18342,
-                                          Entity_Node            = 98170,
-                                          Entity_Quad_Tetra      = 10809,
-                                          Entity_Quad_Quadrangle = 5408)
-
+    self.referencesMaillageFissure = dict( \
+                                          Entity_Quad_Quadrangle = 5318, \
+                                          Entity_Quad_Hexa = 18182, \
+                                          Entity_Node = 94472, \
+                                          Entity_Quad_Edge = 539, \
+                                          Entity_Quad_Triangle = 828, \
+                                          Entity_Quad_Tetra = 9024, \
+                                          Entity_Quad_Pyramid = 578, \
+                                          Entity_Quad_Penta = 128 \
+                                         )
index b33da9e..9b4d131 100644 (file)
@@ -52,7 +52,7 @@ class eprouvetteDroite(fissureGenerique):
   def genereMaillageSain(self, geometriesSaines, meshParams):
     logging.info("genereMaillageSain %s", self.nomCas)
 
-    ([objetSain], status) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests/eprouvetteDroite.med"))
+    ([objetSain], status) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests", "eprouvetteDroite.med"))
     smesh.SetName(objetSain.GetMesh(), 'objetSain')
 
     return [objetSain, True] # True : maillage hexa
@@ -77,7 +77,7 @@ class eprouvetteDroite(fissureGenerique):
 
     lgInfluence = shapeFissureParams['lgInfluence']
 
-    shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests/EprouvetteDroiteFiss_1.brep"))
+    shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests", "EprouvetteDroiteFiss_1.brep"))
     fondFiss = geompy.CreateGroup(shellFiss, geompy.ShapeType["EDGE"])
     geompy.UnionIDs(fondFiss, [8])
     geompy.addToStudy( shellFiss, 'shellFiss' )
@@ -91,9 +91,9 @@ class eprouvetteDroite(fissureGenerique):
 
   # ---------------------------------------------------------------------------
   def setParamMaillageFissure(self):
-    self.maillageFissureParams = dict(nomRep           = '.',
+    self.maillageFissureParams = dict(nomRep           = os.curdir,
                                       nomFicSain       = self.nomCas,
-                                      nomFicFissure    = 'fissure_' + self.nomCas,
+                                      nomFicFissure    = self.nomCas + "_fissure",
                                       nbsegRad         = 5,
                                       nbsegCercle      = 8,
                                       areteFaceFissure = 15)
@@ -114,12 +114,14 @@ class eprouvetteDroite(fissureGenerique):
 
   # ---------------------------------------------------------------------------
   def setReferencesMaillageFissure(self):
-    self.referencesMaillageFissure = dict(Entity_Quad_Pyramid    = 368,
-                                          Entity_Quad_Triangle   = 798,
-                                          Entity_Quad_Edge       = 491,
-                                          Entity_Quad_Penta      = 88,
-                                          Entity_Quad_Hexa       = 9692,
-                                          Entity_Node            = 52652,
-                                          Entity_Quad_Tetra      = 5093,
-                                          Entity_Quad_Quadrangle = 3750)
+    self.referencesMaillageFissure = dict( \
+                                          Entity_Quad_Quadrangle = 3768, \
+                                          Entity_Quad_Hexa = 9724, \
+                                          Entity_Node = 52337, \
+                                          Entity_Quad_Edge = 457, \
+                                          Entity_Quad_Triangle = 570, \
+                                          Entity_Quad_Tetra = 4919, \
+                                          Entity_Quad_Pyramid = 376, \
+                                          Entity_Quad_Penta = 96 \
+                                         )
 
index 3ab9196..1db76fc 100644 (file)
@@ -41,11 +41,9 @@ from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale
 O, OX, OY, OZ = triedreBase()
 
 class eprouvetteDroite_2(eprouvetteDroite):
-  """
-  problème de fissure plane coupant 3 faces (éprouvette), débouches non normaux, objet plan
-  """
+  """problème de fissure plane coupant 3 faces (éprouvette), débouches non normaux, objet plan"""
 
-  nomProbleme = "eprouvetteDroite2"
+  nomProbleme = "eprouvetteDroite_2"
 
   # ---------------------------------------------------------------------------
   def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams):
@@ -53,7 +51,7 @@ class eprouvetteDroite_2(eprouvetteDroite):
 
     lgInfluence = shapeFissureParams['lgInfluence']
 
-    shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests/EprouvetteDroiteFiss_2.brep"))
+    shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests", "EprouvetteDroiteFiss_2.brep"))
     fondFiss = geompy.CreateGroup(shellFiss, geompy.ShapeType["EDGE"])
     geompy.UnionIDs(fondFiss, [10])
     geompy.addToStudy( shellFiss, 'shellFiss' )
@@ -67,12 +65,14 @@ class eprouvetteDroite_2(eprouvetteDroite):
 
   # ---------------------------------------------------------------------------
   def setReferencesMaillageFissure(self):
-    self.referencesMaillageFissure = dict(Entity_Quad_Pyramid    = 396,
-                                          Entity_Quad_Triangle   = 1084,
-                                          Entity_Quad_Edge       = 510,
-                                          Entity_Quad_Penta      = 96,
-                                          Entity_Quad_Hexa       = 9504,
-                                          Entity_Node            = 55482,
-                                          Entity_Quad_Tetra      = 7545,
-                                          Entity_Quad_Quadrangle = 3724)
+    self.referencesMaillageFissure = dict( \
+                                          Entity_Quad_Quadrangle = 3724, \
+                                          Entity_Quad_Hexa = 9504, \
+                                          Entity_Node = 54049, \
+                                          Entity_Quad_Edge = 478, \
+                                          Entity_Quad_Triangle = 724, \
+                                          Entity_Quad_Tetra = 6766, \
+                                          Entity_Quad_Pyramid = 396, \
+                                          Entity_Quad_Penta = 96 \
+                                         )
 
index 79b1f5a..1cc38ba 100644 (file)
@@ -25,144 +25,244 @@ from blocFissure.gmu import initLog
 
 # -----------------------------------------------------------------------------------------------
 #initLog.setDebug()
-initLog.setVerbose()
+#initLog.setVerbose()
 #initLog.setRelease()
 #initLog.setPerfTests()
 
-# ---tous les cas en sequence, ou les cas selectionnés ...
+# ---tous les cas en séquence, ou les cas sélectionnés ...
+torunOK = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0] # OK
+#           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,28
+runall = False
 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, 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,28,29
-  torun = [ 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+  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, 1]
+#             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,28
+else:
+  torunPB = list()
+  for iaux in torunOK:
+    torunPB.append((iaux+1)%2)
+  print ("torun = {} # OK".format(torunOK))
+  print ("torun = {} # PB".format(torunPB))
+  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, 0, 0]
+#           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,28
 # -----------------------------------------------------------------------------------------------
 
 from blocFissure.gmu import geomsmesh
 from blocFissure.gmu.casStandard import casStandard
 
+d_aux = dict()
 problemes = list()
 
-cas=0
+n_cas = 0
+# matériel : cubeAngle
 from blocFissure.CasTests.cubeAngle import cubeAngle
-problemes.append(cubeAngle(cas))
+problemes.append(cubeAngle(n_cas))
 
-cas+=1
+n_cas = 1
+# matériel : cubeAngle
 from blocFissure.CasTests.cubeAngle2 import cubeAngle2
-problemes.append(cubeAngle2(cas))
+problemes.append(cubeAngle2(n_cas))
 
-cas+=1
+n_cas = 2
+# matériel : cubeFin
 from blocFissure.CasTests import cubeCoin
-problemes.append(casStandard(cubeCoin.dicoParams, cubeCoin.referencesMaillageFissure, cas))
+problemes.append(casStandard(cubeCoin.dicoParams, cubeCoin.referencesMaillageFissure, n_cas))
+d_aux[n_cas] = "cubeCoin"
 
-cas+=1
+n_cas = 3
+# matériel : cubeFin
 from blocFissure.CasTests import cubeMilieu
-problemes.append(casStandard(cubeMilieu.dicoParams, cubeMilieu.referencesMaillageFissure, cas))
+problemes.append(casStandard(cubeMilieu.dicoParams, cubeMilieu.referencesMaillageFissure, n_cas))
+d_aux[n_cas] = "cubeMilieu"
 
-cas+=1
+n_cas = 4
+# matériel : cubeFin
 from blocFissure.CasTests import cubeTransverse
-problemes.append(casStandard(cubeTransverse.dicoParams, cubeTransverse.referencesMaillageFissure, cas))
+problemes.append(casStandard(cubeTransverse.dicoParams, cubeTransverse.referencesMaillageFissure, n_cas))
+d_aux[n_cas] = "cubeTransverse"
 
-cas+=1
+n_cas = 5
+# matériel : decoupeCylindre
 from blocFissure.CasTests.cylindre import cylindre
-problemes.append(cylindre(cas))
+problemes.append(cylindre(n_cas))
 
-cas+=1
+n_cas = 6
+# matériel : decoupeCylindre
 from blocFissure.CasTests.cylindre_2 import cylindre_2
-problemes.append(cylindre_2(cas))
+problemes.append(cylindre_2(n_cas))
 
-cas+=1
+n_cas = 7
+# matériel : disque_perce
+# matériel : ellipse_disque
 from blocFissure.CasTests import disquePerce
-problemes.append(casStandard(disquePerce.dicoParams, disquePerce.referencesMaillageFissure, cas))
+problemes.append(casStandard(disquePerce.dicoParams, disquePerce.referencesMaillageFissure, n_cas))
+d_aux[n_cas] = "disquePerce"
 
-cas+=1
+n_cas = 8
 from blocFissure.CasTests.ellipse_1 import ellipse_1
-problemes.append(ellipse_1(cas))
+problemes.append(ellipse_1(n_cas))
 
-cas+=1
+n_cas = 9
 from blocFissure.CasTests.ellipse_2 import ellipse_2
-problemes.append(ellipse_2(cas))
+problemes.append(ellipse_2(n_cas))
 
-cas+=1
+n_cas = 10
 from blocFissure.CasTests.eprouvetteCourbe import eprouvetteCourbe
-problemes.append(eprouvetteCourbe(cas))
+problemes.append(eprouvetteCourbe(n_cas))
 
-cas+=1
+n_cas = 11
 from blocFissure.CasTests.eprouvetteDroite import eprouvetteDroite
-problemes.append(eprouvetteDroite(cas))
+problemes.append(eprouvetteDroite(n_cas))
 
-cas+=1
+n_cas = 12
 from blocFissure.CasTests.eprouvetteDroite_2 import eprouvetteDroite_2
-problemes.append(eprouvetteDroite_2(cas))
+problemes.append(eprouvetteDroite_2(n_cas))
 
-cas+=1
+n_cas = 13
 from blocFissure.CasTests.faceGauche import faceGauche
-problemes.append(faceGauche(cas))
+problemes.append(faceGauche(n_cas))
 
-cas+=1
+n_cas = 14
+# matériel : fissureGauche2
 from blocFissure.CasTests.faceGauche_2 import faceGauche_2
-problemes.append(faceGauche_2(cas))
-
-cas+=1
-from blocFissure.CasTests.fissure_Coude import fissure_Coude
-problemes.append(fissure_Coude(cas))
-
-cas+=1
-from blocFissure.CasTests.fissure_Coude_4 import fissure_Coude_4
-problemes.append(fissure_Coude_4(cas))
-
-cas+=1
+problemes.append(faceGauche_2(n_cas))
+#"boiteDefaut" has not been computed:
+#-  "algo3d_boiteDefaut" failed. Error: Algorithm failed. Presumably, the surface mesh is not compatible with the domain being processed (warning).
+#An edge is unique (i.e., bounds a hole in the surface).
+#The surface mesh includes at least one hole. The domain is not well defined.
+#See /tmp/GHS3D_18605_10269264.log for more information
+#Traceback (most recent call last):
+  #File "/home/D68518/salome-dev/DEV_package/appli_DEV_package/lib/python3.6/site-packages/salome/blocFissure/CasTests/execution_Cas.py", line 222, in <module>
+    #ok_maillage = cas.executeProbleme()
+  #File "/home/D68518/salome-dev/DEV_package/appli_DEV_package/lib/python3.6/site-packages/salome/blocFissure/gmu/fissureGenerique.py", line 122, in executeProbleme
+    #self.maillageFissureParams, elementsDefaut, step)
+  #File "/home/D68518/salome-dev/DEV_package/appli_DEV_package/lib/python3.6/site-packages/salome/blocFissure/CasTests/faceGauche_2.py", line 108, in genereMaillageFissure
+    #maillageFissureParams, elementsDefaut, step)
+  #File "/home/D68518/salome-dev/DEV_package/appli_DEV_package/lib/python3.6/site-packages/salome/blocFissure/gmu/construitFissureGenerale.py", line 330, in construitFissureGenerale
+    #raise Exception(text)
+#Exception: Erreur au calcul du maillage.
+
+n_cas = 15
 from blocFissure.CasTests.fissureCoude_1 import fissureCoude_1
-problemes.append(fissureCoude_1(cas))
+problemes.append(fissureCoude_1(n_cas))
+
+n_cas = 16
+from blocFissure.CasTests.fissureCoude_10 import fissureCoude_10
+problemes.append(fissureCoude_10(n_cas))
 
-cas+=1
+n_cas = 17
 from blocFissure.CasTests.fissureCoude_2 import fissureCoude_2
-problemes.append(fissureCoude_2(cas))
+problemes.append(fissureCoude_2(n_cas))
 
-cas+=1
+n_cas = 18
 from blocFissure.CasTests.fissureCoude_3 import fissureCoude_3
-problemes.append(fissureCoude_3(cas))
+problemes.append(fissureCoude_3(n_cas))
 
-cas+=1
-from blocFissure.CasTests.fissure_Coude_4 import fissure_Coude_4
-problemes.append(fissure_Coude_4(cas))
-
-cas+=1
+n_cas = 19
 from blocFissure.CasTests.fissureCoude_4 import fissureCoude_4
-problemes.append(fissureCoude_4(cas))
+problemes.append(fissureCoude_4(n_cas))
 
-cas+=1
+n_cas = 20
 from blocFissure.CasTests.fissureCoude_5 import fissureCoude_5
-problemes.append(fissureCoude_5(cas))
+problemes.append(fissureCoude_5(n_cas))
 
-cas+=1
+n_cas = 21
 from blocFissure.CasTests.fissureCoude_6 import fissureCoude_6
-problemes.append(fissureCoude_6(cas))
+problemes.append(fissureCoude_6(n_cas))
 
-cas+=1
+n_cas = 22
 from blocFissure.CasTests.fissureCoude_7 import fissureCoude_7
-problemes.append(fissureCoude_7(cas))
+problemes.append(fissureCoude_7(n_cas))
 
-cas+=1
+n_cas = 23
+# matériel : fissureGauche2
 from blocFissure.CasTests.fissureCoude_8 import fissureCoude_8
-problemes.append(fissureCoude_8(cas))
+problemes.append(fissureCoude_8(n_cas))
 
-cas+=1
+n_cas = 24
 from blocFissure.CasTests.fissureCoude_9 import fissureCoude_9
-problemes.append(fissureCoude_9(cas))
+problemes.append(fissureCoude_9(n_cas))
 
-cas+=1
-from blocFissure.CasTests.fissureCoude_10 import fissureCoude_10
-problemes.append(fissureCoude_10(cas))
+n_cas = 25
+from blocFissure.CasTests.fissure_Coude import fissure_Coude
+problemes.append(fissure_Coude(n_cas))
 
-cas+=1
+n_cas = 26
+from blocFissure.CasTests.fissure_Coude_4 import fissure_Coude_4
+problemes.append(fissure_Coude_4(n_cas))
+
+n_cas = 27
 from blocFissure.CasTests.vis_1 import vis_1
-problemes.append(vis_1(cas))
-
-for iaux, cas in enumerate(problemes):
-  if torun[iaux]:
-    logging.critical("=== Execution cas {}".format(iaux))
-    try:
-      cas.executeProbleme()
-    except:
-      traceback.print_exc()
-    print("---------------------------------------------------------------------")
+problemes.append(vis_1(n_cas))
+#"Mesh_22" has not been computed:
+#-  "algo2d_faceFiss" failed on FACE #2. Error: Algorithm failed. NgException at Surface meshing: Problem in Surface mesh generation
+#-  "algo1d_edgeFissPeau" failed on EDGE #9. Error: Algorithm failed. Source elements don't cover totally the geometrical edge
+#Traceback (most recent call last):
+  #File "/home/D68518/salome-dev/DEV_package/appli_DEV_package/lib/python3.6/site-packages/salome/blocFissure/CasTests/execution_Cas.py", line 233, in <module>
+    #ok_maillage = cas.executeProbleme()
+  #File "/home/D68518/salome-dev/DEV_package/appli_DEV_package/lib/python3.6/site-packages/salome/blocFissure/gmu/fissureGenerique.py", line 122, in executeProbleme
+    #self.maillageFissureParams, elementsDefaut, step)
+  #File "/home/D68518/salome-dev/DEV_package/appli_DEV_package/lib/python3.6/site-packages/salome/blocFissure/CasTests/vis_1.py", line 116, in genereMaillageFissure
+    #maillageFissureParams, elementsDefaut, step)
+  #File "/home/D68518/salome-dev/DEV_package/appli_DEV_package/lib/python3.6/site-packages/salome/blocFissure/gmu/construitFissureGenerale.py", line 282, in construitFissureGenerale
+    #meshPipeGroups, areteFaceFissure, rayonPipe, nbsegRad)
+  #File "/home/D68518/salome-dev/DEV_package/appli_DEV_package/lib/python3.6/site-packages/salome/blocFissure/gmu/mailleFacesFissure.py", line 69, in mailleFacesFissure
+    #raise Exception(text)
+#Exception: Erreur au calcul du maillage.
+
+n_cas = 28
+from blocFissure.CasTests.tube import tube
+problemes.append(tube(n_cas))
+#"Mesh_13" has not been computed:
+#-  "algo2d_facePeau_0" failed on "FACE_12 to mesh". Error: Algorithm failed. NgException at Surface meshing: Problem in Surface mesh generation
+#-  "algo1d_cercle1_0" failed on EDGE #20. Error: Algorithm failed. Source elements don't cover totally the geometrical edge
+#-  "algo1d_cercle1_0" failed on EDGE #17. Error: Algorithm failed. Source elements don't cover totally the geometrical edge
+#-  "algo1d_cercle1_0" failed on EDGE #15. Error: Algorithm failed. Source elements don't cover totally the geometrical edge
+#-  "algo1d_cercle1_0" failed on EDGE #12. Error: Algorithm failed. Source elements don't cover totally the geometrical edge
+
+#=============================================================
+while True:
+
+  if ( len(problemes) != len(torun) ):
+    texte  = "\nNombre de problèmes définis  : {}\n".format(len(problemes))
+    texte += "Longueur de la liste 'torun' : {}\n".format(len(torun))
+    texte += "\t==> Incohérence de programmation à corriger."
+    print (texte)
+    break
+
+  ligne = "---------------------------------------------------------------------"
+  texte = ""
+  nb_cas_ok = 0
+  nb_cas_nook = 0
+  for n_cas, cas in enumerate(problemes):
+    #print ("Cas n° {}, '{}'".format(n_cas,cas.nomProbleme))
+    if torun[n_cas]:
+      if n_cas in d_aux:
+        nom = d_aux[n_cas]
+      else:
+        nom = cas.nomProbleme
+      texte_a = "\n=== Exécution du cas n° {}, '{}'".format(n_cas,nom)
+      logging.critical(ligne+texte_a)
+      try:
+        ok_maillage = cas.executeProbleme()
+      except:
+        traceback.print_exc()
+        texte += "Problème avec le cas n° {}, '{}'\n".format(n_cas,nom)
+        ok_maillage = False
+      if ok_maillage:
+        nb_cas_ok += 1
+      else:
+        nb_cas_nook += 1
+      print(ligne)
+
+  nb_cas = nb_cas_nook + nb_cas_ok
+  if ( nb_cas > 1):
+    if nb_cas_nook:
+      texte += ". Nombre de cas_tests OK   : {}\n".format(nb_cas_ok)
+      texte += ". Nombre de cas_tests NOOK : {}\n".format(nb_cas_nook)
+    else:
+      texte += "Les {} tests se sont bien passés.\n".format(nb_cas)
+  print (texte+ligne)
+
+  break
+
index c3fecb9..1a55473 100644 (file)
@@ -41,9 +41,7 @@ from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale
 O, OX, OY, OZ = triedreBase()
 
 class faceGauche(fissureGenerique):
-  """
-  problème de fissure non plane, débouchante non normale
-  """
+  """problème de fissure non plane, débouchante non normale"""
 
   nomProbleme = "faceGauche"
 
@@ -51,7 +49,7 @@ class faceGauche(fissureGenerique):
   def genereMaillageSain(self, geometriesSaines, meshParams):
     logging.info("genereMaillageSain %s", self.nomCas)
 
-    ([objetSain], status) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests/faceGaucheSain.med"))
+    ([objetSain], status) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests", "faceGaucheSain.med"))
     smesh.SetName(objetSain.GetMesh(), 'objetSain')
 
     return [objetSain, True] # True : maillage hexa
@@ -75,7 +73,7 @@ class faceGauche(fissureGenerique):
 
     lgInfluence = shapeFissureParams['lgInfluence']
 
-    shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests/faceGaucheFiss.brep"))
+    shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests", "faceGaucheFiss.brep"))
     fondFiss = geompy.CreateGroup(shellFiss, geompy.ShapeType["EDGE"])
     geompy.UnionIDs(fondFiss, [6])
     geompy.addToStudy( shellFiss, 'shellFiss' )
@@ -89,9 +87,9 @@ class faceGauche(fissureGenerique):
 
   # ---------------------------------------------------------------------------
   def setParamMaillageFissure(self):
-    self.maillageFissureParams = dict(nomRep           = '.',
+    self.maillageFissureParams = dict(nomRep           = os.curdir,
                                       nomFicSain       = self.nomCas,
-                                      nomFicFissure    = 'fissure_' + self.nomCas,
+                                      nomFicFissure    = self.nomCas + "_fissure",
                                       nbsegRad         = 5,
                                       nbsegCercle      = 8,
                                       areteFaceFissure = 1000)
@@ -112,12 +110,14 @@ class faceGauche(fissureGenerique):
 
   # ---------------------------------------------------------------------------
   def setReferencesMaillageFissure(self):
-    self.referencesMaillageFissure = dict(Entity_Quad_Pyramid    = 1284,
-                                          Entity_Quad_Triangle   = 2336,
-                                          Entity_Quad_Edge       = 758,
-                                          Entity_Quad_Penta      = 984,
-                                          Entity_Quad_Hexa       = 6416,
-                                          Entity_Node            = 85673,
-                                          Entity_Quad_Tetra      = 35990,
-                                          Entity_Quad_Quadrangle = 4285)
+    self.referencesMaillageFissure = dict( \
+                                          Entity_Quad_Quadrangle = 3997, \
+                                          Entity_Quad_Hexa = 5904, \
+                                          Entity_Node = 77735, \
+                                          Entity_Quad_Edge = 725, \
+                                          Entity_Quad_Triangle = 2176, \
+                                          Entity_Quad_Tetra = 32320, \
+                                          Entity_Quad_Pyramid = 1156, \
+                                          Entity_Quad_Penta = 856 \
+                                         )
 
index f12066e..e9271d2 100644 (file)
@@ -42,25 +42,23 @@ from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale
 O, OX, OY, OZ = triedreBase()
 
 class faceGauche_2(fissureGenerique):
-  """
-  problème de fissure non plane, débouchante non normale
-  """
+  """problème de fissure non plane, débouchante non normale"""
 
-  nomProbleme = "faceGauche2"
+  nomProbleme = "faceGauche_2"
 
   # ---------------------------------------------------------------------------
   def genereMaillageSain(self, geometriesSaines, meshParams):
     logging.info("genereMaillageSain %s", self.nomCas)
 
-    ([objetSain], status) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests/boiteSaine.med"))
+    ([objetSain], status) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests", "boiteSaine.med"))
     smesh.SetName(objetSain.GetMesh(), 'objetSain')
 
     return [objetSain, True] # True : maillage hexa
 
   # ---------------------------------------------------------------------------
   def setParamShapeFissure(self):
-    """
-    paramètres de la fissure pour méthode construitFissureGenerale
+    """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
@@ -76,13 +74,12 @@ class faceGauche_2(fissureGenerique):
 
     lgInfluence = shapeFissureParams['lgInfluence']
 
-    shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests/faceGauche2FissCoupe.brep"))
+    shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests", "faceGauche2FissCoupe.brep"))
     fondFiss = geompy.CreateGroup(shellFiss, geompy.ShapeType["EDGE"])
-    geompy.UnionIDs(fondFiss, [14, 9])
+    geompy.UnionIDs(fondFiss, [4, 12])
     geompy.addToStudy( shellFiss, 'shellFiss' )
     geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' )
 
-
     coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,25)
 
     centre = None
@@ -90,9 +87,9 @@ class faceGauche_2(fissureGenerique):
 
   # ---------------------------------------------------------------------------
   def setParamMaillageFissure(self):
-    self.maillageFissureParams = dict(nomRep           = '.',
+    self.maillageFissureParams = dict(nomRep           = os.curdir,
                                       nomFicSain       = self.nomCas,
-                                      nomFicFissure    = 'fissure_' + self.nomCas,
+                                      nomFicFissure    = self.nomCas + "_fissure",
                                       nbsegRad         = 5,
                                       nbsegCercle      = 8,
                                       areteFaceFissure = 1000)
@@ -113,12 +110,14 @@ class faceGauche_2(fissureGenerique):
 
   # ---------------------------------------------------------------------------
   def setReferencesMaillageFissure(self):
-    self.referencesMaillageFissure = dict(Entity_Quad_Pyramid    = 859,
-                                          Entity_Quad_Triangle   = 634,
-                                          Entity_Quad_Edge       = 323,
-                                          Entity_Quad_Penta      = 288,
-                                          Entity_Quad_Hexa       = 3435,
-                                          Entity_Node            = 44095,
-                                          Entity_Quad_Tetra      = 18400,
-                                          Entity_Quad_Quadrangle = 2542)
+    self.referencesMaillageFissure = dict( \
+                                          Entity_Quad_Quadrangle = 2542, \
+                                          Entity_Quad_Hexa = 3435, \
+                                          Entity_Node = 44095, \
+                                          Entity_Quad_Edge = 323, \
+                                          Entity_Quad_Triangle = 634, \
+                                          Entity_Quad_Tetra = 18400, \
+                                          Entity_Quad_Pyramid = 859, \
+                                          Entity_Quad_Penta = 288 \
+                                         )
 
index 680da79..678bd10 100644 (file)
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
+import os
+
 from blocFissure.gmu.fissureCoude  import fissureCoude
 
 class fissureCoude_1(fissureCoude):
-  """
-  problème de fissure du Coude :
-  adaptation maillage
-  """
+  """problème de fissure du Coude : adaptation maillage"""
+
+  nomProbleme = "fissureCoude_1"
 
 # ---------------------------------------------------------------------------
   def setParamGeometrieSaine(self):
@@ -89,21 +90,23 @@ class fissureCoude_1(fissureCoude):
     nbSegCercle = nombre de secteurs
     areteFaceFissure = taille cible de l'arête des triangles en face de fissure.
     """
-    self.maillageFissureParams = dict(nomRep        = '.',
+    self.maillageFissureParams = dict(nomRep        = os.curdir,
                                       nomFicSain    = self.nomCas,
-                                      nomFicFissure = 'fissure_' + self.nomCas,
+                                      nomFicFissure = self.nomCas + "_fissure",
                                       nbsegRad      = 5,
                                       nbsegCercle   = 6,
                                       areteFaceFissure = 5)
 
   # ---------------------------------------------------------------------------
   def setReferencesMaillageFissure(self):
-    self.referencesMaillageFissure = dict(Entity_Node            = 77917,
-                                          Entity_Quad_Edge       = 975,
-                                          Entity_Quad_Triangle   = 2182,
-                                          Entity_Quad_Quadrangle = 6842,
-                                          Entity_Quad_Tetra      = 20135,
-                                          Entity_Quad_Hexa       = 8994,
-                                          Entity_Quad_Penta      = 972,
-                                          Entity_Quad_Pyramid    = 1038)
+    self.referencesMaillageFissure = dict( \
+                                          Entity_Quad_Quadrangle = 6042, \
+                                          Entity_Quad_Hexa = 7794, \
+                                          Entity_Node = 65337, \
+                                          Entity_Quad_Edge = 874, \
+                                          Entity_Quad_Triangle = 2058, \
+                                          Entity_Quad_Tetra = 16037, \
+                                          Entity_Quad_Pyramid = 738, \
+                                          Entity_Quad_Penta = 672 \
+                                         )
 
index cfd4626..08893f0 100644 (file)
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
+import os
+
 from blocFissure.gmu.fissureCoude  import fissureCoude
 
 class fissureCoude_10(fissureCoude):
   # cas test ASCOU17
 
+  nomProbleme = "fissureCoude_10"
 
 # ---------------------------------------------------------------------------
   def setParamGeometrieSaine(self):
@@ -80,7 +83,7 @@ class fissureCoude_10(fissureCoude):
                                    externe     = False)
 
   # ---------------------------------------------------------------------------
-                                   
+
   def setParamMaillageFissure(self):
     """
     Paramètres du maillage de la fissure pour le tuyau coudé
@@ -89,21 +92,23 @@ class fissureCoude_10(fissureCoude):
     nbSegCercle = nombre de secteurs
     areteFaceFissure = taille cible de l'arête des triangles en face de fissure.
     """
-    self.maillageFissureParams = dict(nomRep        = '.',
+    self.maillageFissureParams = dict(nomRep        = os.curdir,
                                       nomFicSain    = self.nomCas,
-                                      nomFicFissure = 'fissure_' + self.nomCas,
+                                      nomFicFissure = self.nomCas + "_fissure",
                                       nbsegRad      = 3,
                                       nbsegCercle   = 8,
                                       areteFaceFissure = 2.5)
-    
+
   # ---------------------------------------------------------------------------
   def setReferencesMaillageFissure(self):
-    self.referencesMaillageFissure = dict(Entity_Node            = 93352,
-                                          Entity_Quad_Edge       = 1456,
-                                          Entity_Quad_Triangle   = 8934,
-                                          Entity_Quad_Quadrangle = 6978,
-                                          Entity_Quad_Tetra      = 31147,
-                                          Entity_Quad_Hexa       = 6972,
-                                          Entity_Quad_Penta      = 1600,
-                                          Entity_Quad_Pyramid    = 1696)
+    self.referencesMaillageFissure = dict ( \
+                                            Entity_Quad_Quadrangle = 6160, \
+                                            Entity_Quad_Hexa = 5864, \
+                                            Entity_Node = 78012, \
+                                            Entity_Quad_Edge = 1346, \
+                                            Entity_Quad_Triangle = 9022, \
+                                            Entity_Quad_Tetra = 24341, \
+                                            Entity_Quad_Pyramid = 1232, \
+                                            Entity_Quad_Penta = 1136 \
+                                          )
 
index e370558..c66531a 100644 (file)
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
+import os
+
 from blocFissure.gmu.fissureCoude  import fissureCoude
 
 class fissureCoude_2(fissureCoude):
-  """
-  problème de fissure du Coude :
-  adaptation maillage
+  """problème de fissure du Coude : adaptation maillage
   """
 
+  nomProbleme = "fissureCoude_2"
+
 # ---------------------------------------------------------------------------
   def setParamGeometrieSaine(self):
     """
@@ -89,21 +91,24 @@ class fissureCoude_2(fissureCoude):
     nbSegCercle = nombre de secteurs
     areteFaceFissure = taille cible de l'arête des triangles en face de fissure.
     """
-    self.maillageFissureParams = dict(nomRep        = '.',
+    self.maillageFissureParams = dict(nomRep        = os.curdir,
                                       nomFicSain    = self.nomCas,
-                                      nomFicFissure = 'fissure_' + self.nomCas,
+                                      nomFicFissure = self.nomCas + "_fissure",
                                       nbsegRad      = 5,
                                       nbsegCercle   = 6,
                                       areteFaceFissure = 5)
 
   # ---------------------------------------------------------------------------
   def setReferencesMaillageFissure(self):
-    self.referencesMaillageFissure = dict(Entity_Node            = 132120,
-                                          Entity_Quad_Edge       = 1411,
-                                          Entity_Quad_Triangle   = 5342,
-                                          Entity_Quad_Quadrangle = 9524,
-                                          Entity_Quad_Tetra      = 40902,
-                                          Entity_Quad_Hexa       = 12981,
-                                          Entity_Quad_Penta      = 1980,
-                                          Entity_Quad_Pyramid    = 2064)
+    self.referencesMaillageFissure = dict( \
+                                          Entity_Quad_Quadrangle = 7828, \
+                                          Entity_Quad_Hexa = 10437, \
+                                          Entity_Node = 101695, \
+                                          Entity_Quad_Edge = 1199, \
+                                          Entity_Quad_Triangle = 4230, \
+                                          Entity_Quad_Tetra = 30013, \
+                                          Entity_Quad_Pyramid = 1428, \
+                                          Entity_Quad_Penta = 1344 \
+                                         )
+
 
index 5c91f60..0f0617a 100644 (file)
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
+import os
+
 from blocFissure.gmu.fissureCoude  import fissureCoude
 
 class fissureCoude_3(fissureCoude):
-  """
-  problème de fissure du Coude
-  adaptation maillage
-  """
+  """problème de fissure du Coude - adaptation maillage"""
+
+  nomProbleme = "fissureCoude_3"
 
 # ---------------------------------------------------------------------------
   def setParamGeometrieSaine(self):
@@ -89,21 +90,23 @@ class fissureCoude_3(fissureCoude):
     nbSegCercle = nombre de secteurs
     areteFaceFissure = taille cible de l'arête des triangles en face de fissure.
     """
-    self.maillageFissureParams = dict(nomRep        = '.',
+    self.maillageFissureParams = dict(nomRep        = os.curdir,
                                       nomFicSain    = self.nomCas,
-                                      nomFicFissure = 'fissure_' + self.nomCas,
+                                      nomFicFissure = self.nomCas + "_fissure",
                                       nbsegRad      = 5,
                                       nbsegCercle   = 6,
                                       areteFaceFissure = 5)
 
   # ---------------------------------------------------------------------------
   def setReferencesMaillageFissure(self):
-    self.referencesMaillageFissure = dict(Entity_Node            = 98643,
-                                          Entity_Quad_Edge       = 1130,
-                                          Entity_Quad_Triangle   = 1476,
-                                          Entity_Quad_Quadrangle = 11100,
-                                          Entity_Quad_Tetra      = 15993,
-                                          Entity_Quad_Hexa       = 14508,
-                                          Entity_Quad_Penta      = 624,
-                                          Entity_Quad_Pyramid    = 788)
+    self.referencesMaillageFissure = dict( \
+                                          Entity_Quad_Quadrangle = 10604, \
+                                          Entity_Quad_Hexa = 13764, \
+                                          Entity_Node = 89087, \
+                                          Entity_Quad_Edge = 1065, \
+                                          Entity_Quad_Triangle = 1326, \
+                                          Entity_Quad_Tetra = 12185, \
+                                          Entity_Quad_Pyramid = 602, \
+                                          Entity_Quad_Penta = 438 \
+                                         )
 
index ba0f7c0..fa2d196 100644 (file)
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
+import os
+
 from blocFissure.gmu.fissureCoude  import fissureCoude
 
 class fissureCoude_4(fissureCoude):
-  """
-  problème de fissure du Coude : ASCOU09A
-  adaptation maillage
-  """
+  """problème de fissure du Coude : ASCOU09A - adaptation maillage"""
+
+  nomProbleme = "fissureCoude_4"
 
 # ---------------------------------------------------------------------------
   def setParamGeometrieSaine(self):
@@ -89,21 +90,23 @@ class fissureCoude_4(fissureCoude):
     nbSegCercle = nombre de secteurs
     areteFaceFissure = taille cible de l'arête des triangles en face de fissure.
     """
-    self.maillageFissureParams = dict(nomRep        = '.',
+    self.maillageFissureParams = dict(nomRep        = os.curdir,
                                       nomFicSain    = self.nomCas,
-                                      nomFicFissure = 'fissure_' + self.nomCas,
+                                      nomFicFissure = self.nomCas + "_fissure",
                                       nbsegRad      = 5,
                                       nbsegCercle   = 6,
                                       areteFaceFissure = 5)
 
   # ---------------------------------------------------------------------------
   def setReferencesMaillageFissure(self):
-    self.referencesMaillageFissure = dict(Entity_Node            = 133832,
-                                          Entity_Quad_Edge       = 1133,
-                                          Entity_Quad_Triangle   = 1498,
-                                          Entity_Quad_Quadrangle = 11892,
-                                          Entity_Quad_Tetra      = 18401,
-                                          Entity_Quad_Hexa       = 22412,
-                                          Entity_Quad_Penta      = 600,
-                                          Entity_Quad_Pyramid    = 816)
+    self.referencesMaillageFissure = dict( \
+                                          Entity_Quad_Quadrangle = 11428, \
+                                          Entity_Quad_Hexa = 21716, \
+                                          Entity_Node = 124663, \
+                                          Entity_Quad_Edge = 1073, \
+                                          Entity_Quad_Triangle = 1330, \
+                                          Entity_Quad_Tetra = 14665, \
+                                          Entity_Quad_Pyramid = 642, \
+                                          Entity_Quad_Penta = 426 \
+                                         )
 
index 404978e..b8802d5 100644 (file)
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
+import os
+
 from blocFissure.gmu.fissureCoude  import fissureCoude
 
 class fissureCoude_5(fissureCoude):
-  """
-  problème de fissure du Coude :
-  adaptation maillage
-  """
+  """problème de fissure du Coude : - adaptation maillage"""
+
+  nomProbleme = "fissureCoude_5"
 
 # ---------------------------------------------------------------------------
   def setParamGeometrieSaine(self):
@@ -89,21 +90,23 @@ class fissureCoude_5(fissureCoude):
     nbSegCercle = nombre de secteurs
     areteFaceFissure = taille cible de l'arête des triangles en face de fissure.
     """
-    self.maillageFissureParams = dict(nomRep        = '.',
+    self.maillageFissureParams = dict(nomRep        = os.curdir,
                                       nomFicSain    = self.nomCas,
-                                      nomFicFissure = 'fissure_' + self.nomCas,
+                                      nomFicFissure = self.nomCas + "_fissure",
                                       nbsegRad      = 5,
                                       nbsegCercle   = 8,
                                       areteFaceFissure = 5)
 
   # ---------------------------------------------------------------------------
   def setReferencesMaillageFissure(self):
-    self.referencesMaillageFissure = dict(Entity_Node            = 55217,
-                                          Entity_Quad_Edge       = 762,
-                                          Entity_Quad_Triangle   = 1586,
-                                          Entity_Quad_Quadrangle = 5610,
-                                          Entity_Quad_Tetra      = 11468,
-                                          Entity_Quad_Hexa       = 7200,
-                                          Entity_Quad_Penta      = 516,
-                                          Entity_Quad_Pyramid    = 552)
+    self.referencesMaillageFissure = dict( \
+                                          Entity_Quad_Quadrangle = 5366, \
+                                          Entity_Quad_Hexa = 7120, \
+                                          Entity_Node = 54832, \
+                                          Entity_Quad_Edge = 722, \
+                                          Entity_Quad_Triangle = 1570, \
+                                          Entity_Quad_Tetra = 11747, \
+                                          Entity_Quad_Pyramid = 532, \
+                                          Entity_Quad_Penta = 496 \
+                                         )
 
index e79483d..c002de4 100644 (file)
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
+import os
+
 from blocFissure.gmu.fissureCoude  import fissureCoude
 
 class fissureCoude_6(fissureCoude):
-# --- cas ASCOU08
+  """ASCOU08"""
+
+  nomProbleme = "fissureCoude_6"
 
 # ---------------------------------------------------------------------------
   def setParamGeometrieSaine(self):
@@ -87,22 +91,23 @@ class fissureCoude_6(fissureCoude):
     nbSegCercle = nombre de secteurs
     areteFaceFissure = taille cible de l'arête des triangles en face de fissure.
     """
-    self.maillageFissureParams = dict(nomRep        = '.',
+    self.maillageFissureParams = dict(nomRep        = os.curdir,
                                       nomFicSain    = self.nomCas,
-                                      nomFicFissure = 'fissure_' + self.nomCas,
+                                      nomFicFissure = self.nomCas + "_fissure",
                                       nbsegRad      = 5,
                                       nbsegCercle   = 12,
                                       areteFaceFissure = 5)                                   
 
   # ---------------------------------------------------------------------------
   def setReferencesMaillageFissure(self):
-    self.referencesMaillageFissure = dict(Entity_Node            = 63783,
-                                          Entity_Quad_Edge       = 831,
-                                          Entity_Quad_Triangle   = 742,
-                                          Entity_Quad_Quadrangle = 7480,
-                                          Entity_Quad_Tetra      = 8084,
-                                          Entity_Quad_Hexa       = 10080,
-                                          Entity_Quad_Penta      = 456,
-                                          Entity_Quad_Pyramid    = 500)
-
+    self.referencesMaillageFissure = dict( \
+                                          Entity_Quad_Quadrangle = 7392, \
+                                          Entity_Quad_Hexa = 9888, \
+                                          Entity_Node = 62571, \
+                                          Entity_Quad_Edge = 833, \
+                                          Entity_Quad_Triangle = 1048, \
+                                          Entity_Quad_Tetra = 7723, \
+                                          Entity_Quad_Pyramid = 452, \
+                                          Entity_Quad_Penta = 408 \
+                                         )
 
index b864951..e86736a 100644 (file)
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
+import os
+
 from blocFissure.gmu.fissureCoude  import fissureCoude
 
 class fissureCoude_7(fissureCoude):
+  """fissureCoude_7"""
 
+  nomProbleme = "fissureCoude_7"
 
 # ---------------------------------------------------------------------------
   def setParamGeometrieSaine(self):
@@ -88,21 +92,23 @@ class fissureCoude_7(fissureCoude):
     nbSegCercle = nombre de secteurs
     areteFaceFissure = taille cible de l'arête des triangles en face de fissure.
     """
-    self.maillageFissureParams = dict(nomRep        = '.',
+    self.maillageFissureParams = dict(nomRep        = os.curdir,
                                       nomFicSain    = self.nomCas,
-                                      nomFicFissure = 'fissure_' + self.nomCas,
+                                      nomFicFissure = self.nomCas + "_fissure",
                                       nbsegRad      = 5,
                                       nbsegCercle   = 12,
                                       areteFaceFissure = 5)                                   
 
   # ---------------------------------------------------------------------------
   def setReferencesMaillageFissure(self):
-    self.referencesMaillageFissure = dict(Entity_Node            = 75580,
-                                          Entity_Quad_Edge       = 899,
-                                          Entity_Quad_Triangle   = 1158,
-                                          Entity_Quad_Quadrangle = 8022,
-                                          Entity_Quad_Tetra      = 13162,
-                                          Entity_Quad_Hexa       = 11272,
-                                          Entity_Quad_Penta      = 756,
-                                          Entity_Quad_Pyramid    = 812)
+    self.referencesMaillageFissure = dict( \
+                                          Entity_Quad_Quadrangle = 7758, \
+                                          Entity_Quad_Hexa = 10696, \
+                                          Entity_Node = 71535, \
+                                          Entity_Quad_Edge = 882, \
+                                          Entity_Quad_Triangle = 1378, \
+                                          Entity_Quad_Tetra = 10847, \
+                                          Entity_Quad_Pyramid = 668, \
+                                          Entity_Quad_Penta = 612 \
+                                         )
 
index 05b51fb..2151fc1 100644 (file)
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
+import os
+
 from blocFissure.gmu.fissureCoude  import fissureCoude
 
 class fissureCoude_8(fissureCoude):
-  # cas test ASCOU15
+  """cas test ASCOU16"""
 
+  nomProbleme = "fissureCoude_8"
 
 # ---------------------------------------------------------------------------
   def setParamGeometrieSaine(self):
@@ -80,7 +83,7 @@ class fissureCoude_8(fissureCoude):
                                    externe     = False)
 
   # ---------------------------------------------------------------------------
-                                   
+
   def setParamMaillageFissure(self):
     """
     Paramètres du maillage de la fissure pour le tuyau coudé
@@ -89,21 +92,22 @@ class fissureCoude_8(fissureCoude):
     nbSegCercle = nombre de secteurs
     areteFaceFissure = taille cible de l'arête des triangles en face de fissure.
     """
-    self.maillageFissureParams = dict(nomRep        = '.',
+    self.maillageFissureParams = dict(nomRep        = os.curdir,
                                       nomFicSain    = self.nomCas,
-                                      nomFicFissure = 'fissure_' + self.nomCas,
+                                      nomFicFissure = self.nomCas + "_fissure",
                                       nbsegRad      = 4,
                                       nbsegCercle   = 16,
                                       areteFaceFissure = 5)
-    
+
   # ---------------------------------------------------------------------------
   def setReferencesMaillageFissure(self):
-    self.referencesMaillageFissure = dict(Entity_Node            = 50627,
-                                          Entity_Quad_Edge       = 666,
-                                          Entity_Quad_Triangle   = 1498,
-                                          Entity_Quad_Quadrangle = 4747,
-                                          Entity_Quad_Tetra      = 13225,
-                                          Entity_Quad_Hexa       = 5464,
-                                          Entity_Quad_Penta      = 864,
-                                          Entity_Quad_Pyramid    = 880)
-
+    self.referencesMaillageFissure = dict( \
+                                          Entity_Quad_Quadrangle = 4572, \
+                                          Entity_Quad_Hexa = 5128, \
+                                          Entity_Node = 45641, \
+                                          Entity_Quad_Edge = 648, \
+                                          Entity_Quad_Triangle = 1282, \
+                                          Entity_Quad_Tetra = 11122, \
+                                          Entity_Quad_Pyramid = 768, \
+                                          Entity_Quad_Penta = 752 \
+                                         )
index 10701d1..dae917f 100644 (file)
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
+import os
+
 from blocFissure.gmu.fissureCoude  import fissureCoude
 
 class fissureCoude_9(fissureCoude):
-  # cas test ASCOU19
+  """cas test ASCOU19"""
 
+  nomProbleme = "fissureCoude_9"
 
 # ---------------------------------------------------------------------------
   def setParamGeometrieSaine(self):
@@ -87,21 +90,22 @@ class fissureCoude_9(fissureCoude):
     nbSegCercle = nombre de secteurs
     areteFaceFissure = taille cible de l'arête des triangles en face de fissure.
     """
-    self.maillageFissureParams = dict(nomRep        = '.',
+    self.maillageFissureParams = dict(nomRep        = os.curdir,
                                       nomFicSain    = self.nomCas,
-                                      nomFicFissure = 'fissure_' + self.nomCas,
+                                      nomFicFissure = self.nomCas + "_fissure",
                                       nbsegRad      = 6,
                                       nbsegCercle   = 20,
                                       areteFaceFissure = 2.5)
 
   # ---------------------------------------------------------------------------
   def setReferencesMaillageFissure(self):
-    self.referencesMaillageFissure = dict(Entity_Node            = 162936,
-                                          Entity_Quad_Edge       = 1254,
-                                          Entity_Quad_Triangle   = 3238,
-                                          Entity_Quad_Quadrangle = 15088,
-                                          Entity_Quad_Tetra      = 19305,
-                                          Entity_Quad_Hexa       = 27472,
-                                          Entity_Quad_Penta      = 920,
-                                          Entity_Quad_Pyramid    = 1056)
-
+    self.referencesMaillageFissure = dict( \
+                                          Entity_Quad_Quadrangle = 14864, \
+                                          Entity_Quad_Hexa = 26772, \
+                                          Entity_Node = 156163, \
+                                          Entity_Quad_Edge = 1237, \
+                                          Entity_Quad_Triangle = 3178, \
+                                          Entity_Quad_Tetra = 16952, \
+                                          Entity_Quad_Pyramid = 916, \
+                                          Entity_Quad_Penta = 780 \
+                                         )
index f510d2a..861a921 100644 (file)
@@ -18,6 +18,8 @@
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
+import os
+
 from blocFissure import gmu
 from blocFissure.gmu.geomsmesh import geompy, smesh
 
@@ -40,12 +42,12 @@ from blocFissure.gmu.insereFissureLongue import insereFissureLongue
 O, OX, OY, OZ = triedreBase()
 
 class fissure_Coude(fissureGenerique):
-  """
-  problème de fissure du Coude : version de base
+  """problème de fissure du Coude : version de base
+
   maillage hexa
   """
 
-  nomProbleme = "tuyau_Coude"
+  nomProbleme = "fissure_Coude"
 
   # ---------------------------------------------------------------------------
   def setParamGeometrieSaine(self):
@@ -256,8 +258,6 @@ class fissure_Coude(fissureGenerique):
     smesh.SetName(algo1d_long_p2, "algo1d_long_p2")
     smesh.SetName(hypo1d_long_p2, "hypo1d_long_p2")
 
-    isDone = maillageSain.Compute()
-
     mp1 = maillageSain.GroupOnGeom(P1,'P1',SMESH.NODE)
     mp2 = maillageSain.GroupOnGeom(P2,'P2',SMESH.NODE)
     ext = maillageSain.GroupOnGeom(EXTUBE,'EXTUBE',SMESH.FACE)
@@ -267,6 +267,8 @@ class fissure_Coude(fissureGenerique):
     pex = maillageSain.GroupOnGeom(PEAUEXT,'PEAUEXT',SMESH.FACE)
     cou = maillageSain.GroupOnGeom(COUDE,'COUDSAIN',SMESH.VOLUME)
 
+    isDone = maillageSain.Compute()
+
     return [maillageSain, True] # True : maillage hexa
 
   # ---------------------------------------------------------------------------
@@ -477,9 +479,9 @@ class fissure_Coude(fissureGenerique):
 
   # ---------------------------------------------------------------------------
   def setParamMaillageFissure(self):
-    self.maillageFissureParams = dict(nomRep        = '.',
+    self.maillageFissureParams = dict(nomRep        = os.curdir,
                                       nomFicSain    = self.nomCas,
-                                      nomFicFissure = 'fissure_' + self.nomCas,
+                                      nomFicFissure = self.nomCas + "_fissure",
                                       nbsegExt      = 5,
                                       nbsegGen      = 25,
                                       nbsegRad      = 5,
@@ -504,12 +506,14 @@ class fissure_Coude(fissureGenerique):
 
   # ---------------------------------------------------------------------------
   def setReferencesMaillageFissure(self):
-    self.referencesMaillageFissure = dict(Entity_Node            = 77491,
-                                          Entity_Quad_Edge       = 1006,
-                                          Entity_Quad_Triangle   = 2412,
-                                          Entity_Quad_Quadrangle = 6710,
-                                          Entity_Quad_Tetra      = 20853,
-                                          Entity_Quad_Hexa       = 8656,
-                                          Entity_Quad_Penta      = 1176,
-                                          Entity_Quad_Pyramid    = 1232)
+    self.referencesMaillageFissure = dict( \
+                                          Entity_Quad_Quadrangle = 6710, \
+                                          Entity_Quad_Hexa = 8656, \
+                                          Entity_Node = 76807, \
+                                          Entity_Quad_Edge = 1006, \
+                                          Entity_Quad_Triangle = 2342, \
+                                          Entity_Quad_Tetra = 20392, \
+                                          Entity_Quad_Pyramid = 1232, \
+                                          Entity_Quad_Penta = 1176 \
+                                         )
 
index 482b527..2df1c7a 100644 (file)
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
+import os
+
 from .fissure_Coude  import fissure_Coude
 
 class fissure_Coude_4(fissure_Coude):
-  """
-  probleme de fissure du Coude : ASCOU09A
+  """probleme de fissure du Coude : ASCOU09A
+
   adaptation maillage
   """
 
+  nomProbleme = "fissure_Coude_4"
+
 # ---------------------------------------------------------------------------
   def setParamGeometrieSaine(self):
     """
@@ -65,9 +69,9 @@ class fissure_Coude_4(fissure_Coude):
     externe     : True : fissure face externe, False : fissure face interne
     """
     print("setParamShapeFissure", self.nomCas)
-    self.shapeFissureParams = dict(nomRep        = '.',
+    self.shapeFissureParams = dict(nomRep        = os.curdir,
                                    nomFicSain    = self.nomCas,
-                                   nomFicFissure = 'fissure_' + self.nomCas,
+                                   nomFicFissure = self.nomCas + "_fissure",
                                    profondeur  = 10,
                                    azimut      = 90,
                                    alpha       = 20,
diff --git a/src/Tools/blocFissure/CasTests/tube.py b/src/Tools/blocFissure/CasTests/tube.py
new file mode 100644 (file)
index 0000000..880df4c
--- /dev/null
@@ -0,0 +1,126 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2014-2020  EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+"""problème de fissure plane dans un tube"""
+
+import os
+import logging
+
+from blocFissure import gmu
+from blocFissure.gmu.geomsmesh import geompy, smesh
+from blocFissure.gmu.fissureGenerique import fissureGenerique
+from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
+from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
+from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale
+
+import GEOM
+import SALOMEDS
+import SMESH
+
+class tube(fissureGenerique):
+  """problème de fissure plane dans un tube"""
+
+  nomProbleme = "tube"
+
+  # ---------------------------------------------------------------------------
+  def genereMaillageSain(self, geometriesSaines, meshParams):
+    texte = "genereMaillageSain pour '{}'".format(self.nomCas)
+    logging.info(texte)
+
+    ([objetSain], _) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests", "Tube.med"))
+    smesh.SetName(objetSain.GetMesh(), "{}_objetSain".format(self.nomProbleme))
+
+    return [objetSain, True] # True : maillage hexa
+
+  # ---------------------------------------------------------------------------
+  def setParamShapeFissure(self):
+    """
+    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
+    """
+    texte = "genereMaillageSain pour '{}'".format(self.nomCas)
+    logging.info(texte)
+    self.shapeFissureParams = dict(lgInfluence = 0.4,
+                                   rayonPipe   = 0.05)
+
+  # ---------------------------------------------------------------------------
+  def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams):
+    """Importe la géométrie de la fissure"""
+    texte = "genereShapeFissure pour '{}'".format(self.nomCas)
+    logging.info(texte)
+
+    lgInfluence = shapeFissureParams['lgInfluence']
+
+    (_, shellFiss, _, l_groups, _) = geompy.ImportXAO(os.path.join(gmu.pathBloc, "materielCasTests", "TubeFiss.xao"))
+    l_aux = list()
+    for group in l_groups:
+      if ( group.GetName() in ("Group_1","Group_2","Group_3") ):
+        l_aux.append(group)
+    fondFiss = geompy.CreateGroup(shellFiss, geompy.ShapeType["EDGE"])
+    geompy.UnionList(fondFiss, l_aux )
+    geompy.addToStudy( shellFiss, 'shellFiss' )
+    geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' )
+
+    coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 0.025, 0.1)
+
+    centre = None
+
+    return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss]
+
+  # ---------------------------------------------------------------------------
+  def setParamMaillageFissure(self):
+    texte = "setParamMaillageFissure pour '{}'".format(self.nomCas)
+    logging.info(texte)
+    self.maillageFissureParams = dict(nomRep           = os.curdir,
+                                      nomFicSain       = self.nomCas,
+                                      nomFicFissure    = self.nomCas + "_fissure",
+                                      nbsegRad         = 5,
+                                      nbsegCercle      = 8,
+                                      areteFaceFissure = 0.5)
+
+  # ---------------------------------------------------------------------------
+  def genereZoneDefaut(self, geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams):
+    elementsDefaut = creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams)
+    return elementsDefaut
+
+  # ---------------------------------------------------------------------------
+  def genereMaillageFissure(self, geometriesSaines, maillagesSains,
+                            shapesFissure, shapeFissureParams,
+                            maillageFissureParams, elementsDefaut, step):
+    texte = "genereMaillageFissure pour '{}'".format(self.nomCas)
+    logging.info(texte)
+    maillageFissure = construitFissureGenerale(maillagesSains,
+                                               shapesFissure, shapeFissureParams,
+                                               maillageFissureParams, elementsDefaut, step)
+    return maillageFissure
+
+  # ---------------------------------------------------------------------------
+  def setReferencesMaillageFissure(self):
+    self.referencesMaillageFissure = dict( \
+                                          Entity_Quad_Quadrangle = 1630, \
+                                          Entity_Quad_Hexa = 3523, \
+                                          Entity_Node = 18874, \
+                                          Entity_Quad_Edge = 261, \
+                                          Entity_Quad_Triangle = 190, \
+                                          Entity_Quad_Tetra = 1322, \
+                                          Entity_Quad_Pyramid = 172, \
+                                          Entity_Quad_Penta = 64 \
+                                         )
index 65dcede..9963dd1 100644 (file)
@@ -41,57 +41,61 @@ from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale
 O, OX, OY, OZ = triedreBase()
 
 class vis_1(fissureGenerique):
-  """
-  problème de fissure non plane, débouchante non normale
-  """
+  """problème de fissure non plane, débouchante non normale"""
 
   nomProbleme = "vis_1"
 
   # ---------------------------------------------------------------------------
   def genereMaillageSain(self, geometriesSaines, meshParams):
-    logging.info("genereMaillageSain %s", self.nomCas)
+    texte = "genereMaillageSain pour '{}'".format(self.nomCas)
+    logging.info(texte)
 
-    ([objetSain], status) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests/visSain.med"))
-    smesh.SetName(objetSain.GetMesh(), 'objetSain')
+    ([objetSain], _) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests", "visSain.med"))
+    smesh.SetName(objetSain.GetMesh(), "{}_objetSain".format(self.nomProbleme))
 
     return [objetSain, True] # True : maillage hexa
 
   # ---------------------------------------------------------------------------
   def setParamShapeFissure(self):
-    """
-    paramètres de la fissure pour méthode construitFissureGenerale
+    """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
     pointIn_x   : optionnel coordonnée x d'un point dans le solide sain (pour orienter la face)
     """
-    logging.info("setParamShapeFissure %s", self.nomCas)
+    texte = "setParamShapeFissure pour '{}'".format(self.nomCas)
+    logging.info(texte)
     self.shapeFissureParams = dict(lgInfluence = 0.6,
                                    rayonPipe   = 0.1)
 
   # ---------------------------------------------------------------------------
   def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams):
-    logging.info("genereShapeFissure %s", self.nomCas)
+    """Importe la géométrie de la fissure et crée le groupe du fond de la fissure"""
+    texte = "genereShapeFissure pour '{}'".format(self.nomCas)
+    logging.info(texte)
 
     lgInfluence = shapeFissureParams['lgInfluence']
 
-    shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests/visFiss.brep"))
+    shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests", "visFiss.brep"))
     fondFiss = geompy.CreateGroup(shellFiss, geompy.ShapeType["EDGE"])
-    geompy.UnionIDs(fondFiss, [6, 8])
+    geompy.UnionIDs(fondFiss, [6, 8, 3])
     geompy.addToStudy( shellFiss, 'shellFiss' )
     geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' )
 
-
     coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 0.1 ,0.2)
 
     centre = None
+
     return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss]
 
   # ---------------------------------------------------------------------------
   def setParamMaillageFissure(self):
-    self.maillageFissureParams = dict(nomRep           = '.',
+    texte = "setParamMaillageFissure pour '{}'".format(self.nomCas)
+    logging.info(texte)
+    self.maillageFissureParams = dict(nomRep           = os.curdir,
                                       nomFicSain       = self.nomCas,
-                                      nomFicFissure    = 'fissure_' + self.nomCas,
+                                      nomFicFissure    = self.nomCas + "_fissure",
                                       nbsegRad         = 5,
                                       nbsegCercle      = 32,
                                       areteFaceFissure = 0.1)
@@ -105,6 +109,8 @@ class vis_1(fissureGenerique):
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                             shapesFissure, shapeFissureParams,
                             maillageFissureParams, elementsDefaut, step):
+    texte = "genereMaillageFissure pour '{}'".format(self.nomCas)
+    logging.info(texte)
     maillageFissure = construitFissureGenerale(maillagesSains,
                                                shapesFissure, shapeFissureParams,
                                                maillageFissureParams, elementsDefaut, step)
@@ -112,12 +118,14 @@ class vis_1(fissureGenerique):
 
   # ---------------------------------------------------------------------------
   def setReferencesMaillageFissure(self):
-    self.referencesMaillageFissure = dict(Entity_Quad_Pyramid    = 1284,
-                                          Entity_Quad_Triangle   = 2336,
-                                          Entity_Quad_Edge       = 758,
-                                          Entity_Quad_Penta      = 984,
-                                          Entity_Quad_Hexa       = 6416,
-                                          Entity_Node            = 85673,
-                                          Entity_Quad_Tetra      = 35990,
-                                          Entity_Quad_Quadrangle = 4285)
+    self.referencesMaillageFissure = dict( \
+                                          Entity_Quad_Quadrangle = 4285 ,\
+                                          Entity_Quad_Hexa       = 6416, \
+                                          Entity_Node            = 85673, \
+                                          Entity_Quad_Edge       = 758, \
+                                          Entity_Quad_Triangle   = 2336, \
+                                          Entity_Quad_Tetra      = 35990, \
+                                          Entity_Quad_Pyramid    = 1284, \
+                                          Entity_Quad_Penta      = 984 \
+                                         )
 
index af08150..4d63358 100644 (file)
@@ -6,23 +6,30 @@ With GUI
 To make the use of « Bloc Fissure » easier, a Graphical User Interface (GUI) was developed.\r
 Inputs are similar to those of :ref:`script mode <script>`. GUI is accessible in the SMESH extension *Add a crack in a mesh*\r
 \r
-.. figure:: images/BF_GUI_capture.png\r
-   :width: 700\r
+.. image:: images/BF_GUI_capture.png\r
+   :scale: 100\r
    :align: center\r
+   :alt: Window of the graphical interface\r
 \r
-   Windows of the graphical interface\r
+Window of the graphical interface\r
 \r
 +------------------------------------------------------------------------------------------------------------------+\r
 |       GUI parameters                                                                                             |\r
 +======================+===================================+=======================================================+\r
-| **maillageSain**     | *[string]*                        |  Relative address of the input structure 3D mesh      |\r
+| **Maillage sain**    | *[string]*                        |  Relative address of the input structure 3D mesh      |\r
 |                      | ex: mesh/maillage.med             |  in MED format (base is repertoire de travail)        |\r
 +----------------------+-----------------------------------+-------------------------------------------------------+\r
-| **FaceFissure**      | *[string]*                        |  Relative address of the input crack geometry         |\r
-|                      | ex: mesh/fissure.brep             |  in BREP format (base is repertoire de travail)       |\r
+| **Face fissure**     | *[string]*                        |  Relative address of the input crack geometry in      |\r
+|                      | ex: mesh/fissure.xao              |  BREP or XAO format (base is repertoire de travail)   |\r
 +----------------------+-----------------------------------+-------------------------------------------------------+\r
-| **index edges fond   | *[list of integers]*              |  List of edges number which define the crack front    |\r
-| fissure**            | ex: [1,2]                         |                                                       |\r
+| **Arêtes fond        | *[list of strings]*               |  Definition of the crack front:                       |\r
+| fissure**            | ex: ["F_1", "F_2"]                |  If XAO: list of the names of the edge group(s)       |\r
++----------------------+-----------------------------------+-------------------------------------------------------+\r
+|                      | *[list of integers]*              |  If BREP (or XAO): list of edges number in GEOM       |\r
+|                      | ex: [1,2]                         |                                                       |\r
++----------------------+-----------------------------------+-------------------------------------------------------+\r
+| **Distance           | *[float]*                         |  Length of influence - distance that defines the      |\r
+| d'influence**        | ex: 20.0000                       |  size of the extracted Box around the crack           |\r
 +----------------------+-----------------------------------+-------------------------------------------------------+\r
 | **min**              | *[float]*                         |  Float defining the minimum size of elements          |\r
 |                      | ex: 1.00000                       |  to mesh the crack                                    |\r
@@ -30,40 +37,40 @@ Inputs are similar to those of :ref:`script mode <script>`. GUI is accessible in
 | **max**              | *[float]*                         |  Float defining the maximum size of elements          |\r
 |                      | ex: 10.0000                       |  to mesh the crack                                    |\r
 +----------------------+-----------------------------------+-------------------------------------------------------+\r
-| **distance           | *[float]*                         |  Length of influence - distance that defines the      |\r
-| influence**          | ex: 20.0000                       |  size of the extracted Box around the crack           |\r
-+----------------------+-----------------------------------+-------------------------------------------------------+\r
-| **rayon pipe**       | *[float]*                         |  Radius of the tore around the front                  |\r
+| **Rayon pipe**       | *[float]*                         |  Radius of the tore around the front                  |\r
 |                      | ex: 5.00000                       |                                                       |\r
 +----------------------+-----------------------------------+-------------------------------------------------------+\r
-| **longueur mailles** | *[float]*                         |  Length of the segments of the tore along crack front |\r
+| **Longueur mailles** | *[float]*                         |  Length of the segments of the tore along crack front |\r
 |                      | ex: 5.00000                       |                                                       |\r
 +----------------------+-----------------------------------+-------------------------------------------------------+\r
-|  **couronnes**       | *[integer]*                       |  Number of radial segment of the tore                 |\r
+| **Couronnes**        | *[integer]*                       |  Number of radial segment of the tore                 |\r
 |                      | ex: 5                             |                                                       |\r
 +----------------------+-----------------------------------+-------------------------------------------------------+\r
-| **secteurs**         | *[integer]*                       |  Number of sectors of the tore                        |\r
+| **Secteurs**         | *[integer]*                       |  Number of sectors of the tore                        |\r
 |                      | ex: 16                            |                                                       |\r
 +----------------------+-----------------------------------+-------------------------------------------------------+\r
-| **arete face         | *[float]*                         |  Mesh size of elements for the Box remeshing          |\r
+| **Triangles face     | *[float]*                         |  Mesh size of elements for the Box remeshing          |\r
 | fissure**            | ex: 5.0000                        |                                                       |\r
 +----------------------+-----------------------------------+-------------------------------------------------------+\r
-| **repertoire de      | *[string]*                        |  Absolute address of the directory where files are    |\r
+| **pertoire de      | *[string]*                        |  Absolute address of the directory where files are    |\r
 | travail**            | ex: /home/A123456                 |  saved                                                |\r
 +----------------------+-----------------------------------+-------------------------------------------------------+\r
-| **nom résultat**     | *[string]*                        |  Name of the resulting mesh                           |\r
+| **Nom du résultat**  | *[string]*                        |  Name of the resulting mesh                           |\r
 |                      | ex: maillage_fissure              |                                                       |\r
 +----------------------+-----------------------------------+-------------------------------------------------------+\r
-| **mode**             | *[choice]*                        |  Verbose mode for Salome messages                     |\r
+| **Mode**             | *[choice]*                        |  Verbose mode for Salome messages                     |\r
 |                      | ex: verbose                       |                                                       |\r
 +----------------------+-----------------------------------+-------------------------------------------------------+\r
 \r
-.. figure:: images/parametres_GUI.png\r
+.. image:: images/parametres_GUI.png\r
    :width: 350\r
    :align: center\r
+   :alt: Tore parameters\r
+\r
+Tore parameters\r
 \r
-   Tore parameters\r
 \r
+- **Exemple**: fills the panels with a test-case\r
 \r
 - **Reset**: clears all the parameters\r
 \r
@@ -73,7 +80,7 @@ Inputs are similar to those of :ref:`script mode <script>`. GUI is accessible in
 \r
 - **Sauver**: save a .dic file with the active parameters\r
 \r
-- **Cancel**: exit GUI\r
+- **Fermer**: exit GUI\r
 \r
-- **Sauver**: Launch calculation\r
+- **OK**: Launch calculation\r
 \r
index d234f6c..c1fb0e0 100644 (file)
Binary files a/src/Tools/blocFissure/doc/images/BF_GUI_capture.png and b/src/Tools/blocFissure/doc/images/BF_GUI_capture.png differ
index adac583..2101f54 100644 (file)
@@ -6,9 +6,10 @@ For bended pipes
 Cracked bended pipes being a common encountered case, a specific module was developed with a Graphic User Interface (GUI). GUI is accessible in the SMESH extension *Meshed Pipe with a crack*. Compared to the classical use of « Bloc Fissure », this extension also generate the pipe mesh and the crack geometry from geometrical information.\r
 \r
 \r
-.. figure:: images/Capture_GUI_pipes_2.png\r
+.. image:: images/Capture_GUI_pipes_2.png\r
    :width: 800\r
    :align: center\r
+   :alt: Print screen of GUI\r
 \r
    Print screen of GUI of the extension *Meshed Pipe with a crack*\r
 \r
index ae22329..af6c7a6 100644 (file)
@@ -10,7 +10,7 @@ In order to illustrate « Bloc Fissure » principle, the simple case of a crack
 \r
 1. The first step consists in loading the structure mesh (a) as well as the crack surface geometry (b).\r
 \r
-2. The crack is then meshed (c). A length criterion defines the size of the extracted « Box ». This length is called the length of influence. Every element having a node within this zone is included in the « Box ». A second operation adds elements in the Box in order to have continuous faces (d).\r
+2. The crack is then meshed (c). A length criterion defines the size of the extracted « Box ». This length is called the length of influence. Every element of the structure mesh having a node within this zone is included in the « Box ». A second operation adds those elements in the Box in order to have continuous faces (d).\r
 \r
 3. A geometrical Box is reconstructed from the extracted Box mesh. The reconstruction is limited to faces which intersect the crack (e). A torus is created following the crack front (f).\r
 \r
@@ -63,6 +63,7 @@ The length of influence is important. It defines the size of the extracted Box.
 .. image:: images/longueur_influence.png\r
    :width: 600\r
    :align: center\r
+   :alt: The length of influence\r
 \r
 Every element having a node at a smaller distance to the crack than the length of influence is selected. Then a filling algorithm fulfill the Box with elements to get a Box. The Box is not limited to rectangular shapes. See the section on :ref:`test cases <test_cases>` to see examples.\r
 \r
@@ -90,6 +91,7 @@ For similar reasons, crack front edges must exceed from the structure mesh. The
 \r
 .. image:: images/schema_lignes1.png\r
    :scale: 80\r
+   :alt: Crack front edges\r
 \r
 5) **Loss of element groups:**\r
 \r
index 0808c48..078da25 100644 (file)
@@ -15,10 +15,12 @@ The main command of « Bloc Fissure » is the casStandard function. It has a sin
 | **maillageSain**     | *[string]*                        |  Absolute address of the input structure 3D mesh      |\r
 |                      |                                   |  in MED format                                        |\r
 +----------------------+-----------------------------------+-------------------------------------------------------+\r
-| **BrepFaceFissure**  | *[string]*                        |  Absolute address of the input crack geometry         |\r
-|                      |                                   |  in BREP format                                       |\r
+| **CAOFaceFissure**   | *[string]*                        |  Absolute address of the input crack geometry         |\r
+|                      |                                   |  in XAO or BREP format                                |\r
 +----------------------+-----------------------------------+-------------------------------------------------------+\r
-| **edgeFissIds**      | *[list of integers]*              |  List of edges number which define the crack front    |\r
+| **edgeFiss**         | *[list of strings]*               |  List of edges group which define the crack front     |\r
++----------------------+-----------------------------------+-------------------------------------------------------+\r
+|                      | *[list of integers]*              |  List of edges number which define the crack front    |\r
 +----------------------+-----------------------------------+-------------------------------------------------------+\r
 | **meshBrep**         | *[list of 2 floats]*              |  List of two floats defining respectively minimum and |\r
 |                      |                                   |  maximum size of elements of the crack mesh           |\r
@@ -47,6 +49,7 @@ Geometrical parameters of the tore are illustrated :
 .. image:: images/parametres.png\r
    :width: 350\r
    :align: center\r
+   :alt: Geometrical parameters of the tore\r
 \r
 Different levels of verbose are available. Use one of this 4 optional functions to set verbose type:\r
 \r
@@ -68,8 +71,8 @@ Different levels of verbose are available. Use one of this 4 optional functions
 \r
   dicoParams = dict(nomCas            = 'cubeFiss',\r
                     maillageSain      = "/home/A123456/BF/cube.med",\r
-                    brepFaceFissure   = "/home/A123456/BF/fiss.brep",\r
-                    edgeFissIds       = [4],\r
+                    CAOFaceFissure    = "/home/A123456/BF/fiss.xao",\r
+                    edgeFiss          = ["Fond"],\r
                     lgInfluence       = 20.,\r
                     meshBrep          = (5.,10.),\r
                     rayonPipe         = 5.,\r
index f468d66..8119c4e 100644 (file)
@@ -92,6 +92,8 @@ All 13 cases are shown Table 2. Two views show the whole cracked structure and a
 |   :width: 400                             |    :width: 400                               |\r
 |   :align: center                          |    :align: center                            |\r
 +-------------------------------------------+----------------------------------------------+\r
+| tube                                                                                     |\r
++-------------------------------------------+----------------------------------------------+\r
 \r
 .. _pipeTC:\r
 \r
@@ -146,13 +148,13 @@ There is no need to generate them again.
 \r
 2) **To execute only selected test cases**:\r
 \r
-modify the file ``execution_Cas.py`` and change::\r
+modify the file ``CasTests/execution_Cas.py`` and change::\r
 \r
     runall = False. #old : True\r
 \r
 And change from 0 to 1 of the index of the test you want to launch::\r
 \r
-    torun = [ 0, 1, 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, 0]\r
+    torun = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\r
 \r
 then launch the test cases::\r
 \r
@@ -162,17 +164,17 @@ The index of each test is the position of the test in the following table, from
 2 for cubeCoin... from top to bottom, then from left to right.\r
 \r
 +--------------------+--------------------+--------------------+-----------------+-----------------+\r
-| cubeAngle          | cylindre_2         | eprouvetteDroite_2 | fissureCoude_3  | fissureCoude_8  |\r
+| cubeAngle          | cylindre_2         | eprouvetteDroite_2 | fissureCoude_3  | fissureCoude_9  |\r
 +--------------------+--------------------+--------------------+-----------------+-----------------+\r
-| cubeAngle2         | disquePerce        | faceGauche         | fissureCoude_4  | fissureCoude_10 |\r
+| cubeAngle2         | disquePerce        | faceGauche         | fissureCoude_4  | fissure_Coude   |\r
 +--------------------+--------------------+--------------------+-----------------+-----------------+\r
-| cubeCoin           | ellipse_1          | faceGauche_2       | fissure_Coude_4 | fissureCoude_10 |\r
+| cubeCoin           | ellipse_1          | faceGauche_2       | fissureCoude_5  | fissure_Coude_4 |\r
 +--------------------+--------------------+--------------------+-----------------+-----------------+\r
-| cubeMilieu         | ellipse_2          | fissure_Coude      | fissureCoude_5  | vis_1           |\r
+| cubeMilieu         | ellipse_2          | fissureCoude_1     | fissureCoude_6  | vis_1           |\r
 +--------------------+--------------------+--------------------+-----------------+-----------------+\r
-| cubeTransverse     | eprouvetteCourbe   | fissureCoude_1     | fissureCoude_6  |                 |\r
+| cubeTransverse     | eprouvetteCourbe   | fissureCoude_10    | fissureCoude_7  | tube            |\r
 +--------------------+--------------------+--------------------+-----------------+-----------------+\r
-| cylindre           | eprouvetteDroite   | fissureCoude_2     | fissureCoude_7  |                 |\r
+| cylindre           | eprouvetteDroite   | fissureCoude_2     | fissureCoude_8  |                 |\r
 +--------------------+--------------------+--------------------+-----------------+-----------------+\r
 \r
 3) **To execute only one test case**::\r
index ba279c3..de4944c 100644 (file)
@@ -26,10 +26,10 @@ initLog.setDebug()
 
 from blocFissure.gmu.casStandard import casStandard
 
-dicoParams = dict(nomCas            = 'angleCube',
-                  maillageSain      = os.path.join(gmu.pathBloc, 'materielCasTests/CubeAngle.med'),
-                  brepFaceFissure   = os.path.join(gmu.pathBloc, "materielCasTests/CubeAngleFiss.brep"),
-                  edgeFissIds       = [4],
+dicoParams = dict(nomCas            = "angleCube",
+                  maillageSain      = os.path.join(gmu.pathBloc, "materielCasTests", "CubeAngle.med"),
+                  CAOFaceFissure    = os.path.join(gmu.pathBloc, "materielCasTests", "CubeAngleFiss.brep"),
+                  edgeFiss          = [4],
                   lgInfluence       = 20,
                   meshBrep          = (5,10),
                   rayonPipe         = 5,
index b6d3886..f464339 100644 (file)
@@ -93,8 +93,8 @@ from blocFissure.gmu.casStandard import casStandard
 
 dicoParams = dict(nomCas            = 'angleCube2',
                   maillageSain      = 'boite.med',
-                  brepFaceFissure   = "disk.brep",
-                  edgeFissIds       = [4],
+                  CAOFaceFissure    = "disk.brep",
+                  edgeFiss          = [4],
                   lgInfluence       = 50,
                   meshBrep          = (5,10),
                   rayonPipe         = 15,
index c9cb495..8e3863f 100644 (file)
@@ -38,8 +38,8 @@ crack = 'fissureQuartEllipse.brep'
 
 dicoParams = dict(nomCas            = 'fissTuyau',
                   maillageSain      = '/local00/home/I48174/Bureau/supportMaillage/{0}'.format(mesh),
-                  brepFaceFissure   = '/local00/home/I48174/Bureau/supportMaillage/{0}'.format(crack),
-                  edgeFissIds       = [9],
+                  CAOFaceFissure    = '/local00/home/I48174/Bureau/supportMaillage/{0}'.format(crack),
+                  edgeFiss          = [9],
                   lgInfluence       = 250,
                   meshBrep          = (10, 50),
                   rayonPipe         = 35,
@@ -51,4 +51,4 @@ dicoParams = dict(nomCas            = 'fissTuyau',
 execInstance = casStandard(dicoParams)
 
 if salome.sg.hasDesktop():
-    salome.sg.updateObjBrowser()
\ No newline at end of file
+    salome.sg.updateObjBrowser()
index b67fe88..d642fe5 100644 (file)
@@ -72,6 +72,10 @@ SET(plugin_SCRIPTS
   insereFissureElliptique.py
   insereFissureGenerale.py
   insereFissureLongue.py
+  insereFissureLongue_a.py
+  insereFissureLongue_b.py
+  insereFissureLongue_c.py
+  insereFissureLongue_d.py
   listOfExtraFunctions.py
   mailleAretesEtJonction.py
   mailleFacesFissure.py
index 2dd1a9f..7bd9b93 100644 (file)
@@ -23,43 +23,54 @@ import math
 
 from .geomsmesh import geompy
 from .geomsmesh import smesh
-  
-def calculePointsAxiauxPipe(edgesFondFiss, edgesIdByOrientation, facesDefaut, 
+
+def calculePointsAxiauxPipe(edgesFondFiss, edgesIdByOrientation, facesDefaut,
                             centreFondFiss, wireFondFiss, wirePipeFiss,
                             lenSegPipe, rayonPipe, nbsegCercle, nbsegRad):
-  """
-  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é)  
+  - vecteurs tangents au fond de fissure (normal au disque maillé)
   """
-  
+
   logging.info('start')
 
-  # --- option de maillage selon le rayon de courbure du fond de fissure 
+  # --- option de maillage selon le rayon de courbure du fond de fissure
   lenEdgeFondExt = 0
   for edff in edgesFondFiss:
     lenEdgeFondExt += geompy.BasicProperties(edff)[0]
-  
-  disfond = []
+
+  disfond = list()
   for filling in facesDefaut:
     disfond.append(geompy.MinDistance(centreFondFiss, filling))
   disfond.sort()
   rcourb = disfond[0]
+  texte = "rcourb: {}, lenEdgeFondExt: {}, lenSegPipe: {}".format(rcourb, lenEdgeFondExt, lenSegPipe)
+  logging.info(texte)
   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)  
+  lgmax = lenSegPipe*1.5
+  texte = "==> deflexion: {}, lgmin: {}, lgmax: {}".format(deflexion, lgmin, lgmax)
+  logging.info(texte)
 
   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
+
+  is_done = meshFondExt.Compute()
+  text = "calculePointsAxiauxPipe meshFondExt.Compute"
+  if is_done:
+    logging.info(text)
+  else:
+    text = "Erreur au calcul du maillage.\n" + text
+    logging.info(text)
+    raise Exception(text)
+
+  ptGSdic = dict() # dictionnaire [paramètre sur la courbe] --> point géométrique
   allNodeIds = meshFondExt.GetNodesId()
   for nodeId in allNodeIds:
     xyz = meshFondExt.GetNodeXYZ(nodeId)
@@ -69,19 +80,19 @@ def calculePointsAxiauxPipe(edgesFondFiss, edgesIdByOrientation, facesDefaut,
     edgeOrder = edgesIdByOrientation[EdgeInWireIndex]
     ptGSdic[(edgeOrder, EdgeInWireIndex, u)] = pt
     #logging.debug("nodeId %s, u %s", nodeId, str(u))
-  usort = sorted(ptGSdic)  
+  usort = sorted(ptGSdic)
   logging.debug("nombre de points obtenus par deflexion %s",len(usort))
-     
-  centres = []
-  origins = []
-  normals = []      
+
+  centres = list()
+  origins = list()
+  normals = list()
   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)
+    part = geompy.MakePartition([plan], [wirePipeFiss], list(), list(), geompy.ShapeType["VERTEX"], 0, list(), 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:
@@ -99,21 +110,21 @@ def calculePointsAxiauxPipe(edgesFondFiss, edgesIdByOrientation, facesDefaut,
 #      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]
+
+  gptsdisks = list() # vertices géométrie de tous les disques
+  raydisks = [list() for i in range(nbsegCercle)]
+  for i, centres_i in enumerate(centres): # boucle sur les disques
+    gptdsk = list() # 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)
@@ -122,7 +133,7 @@ def calculePointsAxiauxPipe(edgesFondFiss, edgesIdByOrientation, facesDefaut,
     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
@@ -132,7 +143,7 @@ def calculePointsAxiauxPipe(edgesFondFiss, edgesIdByOrientation, facesDefaut,
       gptdsk.append(pts)
       ray = geompy.MakeRotation(rayon, normal, angle)
       raydisks[k+1].append(ray)
-      
+
     gptsdisks.append(gptdsk)
-    
+
   return (centres, gptsdisks, raydisks)
index 7f29944..52cd105 100644 (file)
@@ -17,6 +17,7 @@
 #
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
+"""Cas standard"""
 
 import os
 from .geomsmesh import geompy, smesh
@@ -28,9 +29,6 @@ import math
 import GEOM
 import SALOMEDS
 import SMESH
-#import StdMeshers
-#import GHS3DPlugin
-#import NETGENPlugin
 import logging
 
 from .fissureGenerique import fissureGenerique
@@ -44,13 +42,14 @@ from .construitFissureGenerale import construitFissureGenerale
 O, OX, OY, OZ = triedreBase()
 
 class casStandard(fissureGenerique):
-  """
-  problème de fissure standard, défini par :
+  """problème de fissure standard, défini par :
+
   - un maillage sain (hexaèdres),
   - une face géométrique de fissure, qui doit légèrement dépasser hors du volume maillé
   - les numéros d'arêtes (edges géométriques) correspondant au fond de fissure
   - les paramètres de maillage de la fissure
   """
+  referencesMaillageFissure = None
 
   # ---------------------------------------------------------------------------
   def __init__ (self, dicoParams, references = None, numeroCas = 0):
@@ -66,7 +65,7 @@ class casStandard(fissureGenerique):
     if 'reptrav' in self.dicoParams:
       self.reptrav = self.dicoParams['reptrav']
     else:
-      self.reptrav = '.'  
+      self.reptrav = os.curdir
     self.numeroCas = numeroCas
     if self.numeroCas != 0:
       self.nomCas = self.nomProbleme +"_%d"%(self.numeroCas)
@@ -84,7 +83,7 @@ class casStandard(fissureGenerique):
       self.dicoParams['aretesVives'] = 0
     if self.numeroCas == 0: # valeur par défaut : exécution immédiate, sinon execution différée dans le cas d'une liste de problèmes
       self.executeProbleme(step)
-    
+
   # ---------------------------------------------------------------------------
   def genereMaillageSain(self, geometriesSaines, meshParams):
     logging.info("genereMaillageSain %s", self.nomCas)
@@ -122,9 +121,28 @@ class casStandard(fissureGenerique):
 
     lgInfluence = shapeFissureParams['lgInfluence']
 
-    shellFiss = geompy.ImportBREP( self.dicoParams['brepFaceFissure'])
+#   Contrôle de 'brepFaceFissure' pour les anciennes versions
+    if ( 'brepFaceFissure' in self.dicoParams ):
+      self.dicoParams['CAOFaceFissure'] = self.dicoParams['brepFaceFissure']
+    cao_file = self.dicoParams['CAOFaceFissure']
+    suffix = os.path.basename(cao_file).split(".")[-1]
+    if ( suffix.upper() == "BREP" ):
+      shellFiss = geompy.ImportBREP(cao_file)
+    elif ( suffix.upper() == "XAO" ):
+      (_, shellFiss, _, l_groups, _) = geompy.ImportXAO(cao_file)
     fondFiss = geompy.CreateGroup(shellFiss, geompy.ShapeType["EDGE"])
-    geompy.UnionIDs(fondFiss, self.dicoParams['edgeFissIds'] )
+#   Contrôle de 'edgeFissIds' pour les anciennes versions
+    if ( 'edgeFissIds' in self.dicoParams ):
+      self.dicoParams['edgeFiss'] = self.dicoParams['edgeFissIds']
+    if isinstance(self.dicoParams['edgeFiss'][0],int):
+      geompy.UnionIDs(fondFiss, self.dicoParams['edgeFiss'] )
+    else:
+      l_groups = geompy.GetGroups(shellFiss)
+      l_aux = list()
+      for group in l_groups:
+        if ( group.GetName() in self.dicoParams['edgeFiss'] ):
+          l_aux.append(group)
+      geompy.UnionList(fondFiss, l_aux )
     geomPublish(initLog.debug, shellFiss, 'shellFiss' )
     geomPublishInFather(initLog.debug, shellFiss, fondFiss, 'fondFiss' )
 
@@ -153,8 +171,8 @@ class casStandard(fissureGenerique):
   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                             shapesFissure, shapeFissureParams,
                             maillageFissureParams, elementsDefaut, step):
-    maillageFissure = construitFissureGenerale(maillagesSains,
-                                              shapesFissure, shapeFissureParams,
+    maillageFissure = construitFissureGenerale(maillagesSains, \
+                                              shapesFissure, shapeFissureParams, \
                                               maillageFissureParams, elementsDefaut, step)
     return maillageFissure
 
@@ -163,12 +181,13 @@ class casStandard(fissureGenerique):
     if self.references is not None:
       self.referencesMaillageFissure = self.references
     else:
-      self.referencesMaillageFissure = dict(Entity_Quad_Pyramid    = 0,
-                                            Entity_Quad_Triangle   = 0,
-                                            Entity_Quad_Edge       = 0,
-                                            Entity_Quad_Penta      = 0,
-                                            Entity_Quad_Hexa       = 0,
-                                            Entity_Node            = 0,
-                                            Entity_Quad_Tetra      = 0,
-                                            Entity_Quad_Quadrangle = 0)
-
+      self.referencesMaillageFissure = dict( \
+                                            Entity_Quad_Quadrangle = 0, \
+                                            Entity_Quad_Hexa = 0, \
+                                            Entity_Node = 0, \
+                                            Entity_Quad_Edge = 0, \
+                                            Entity_Quad_Triangle = 0, \
+                                            Entity_Quad_Tetra = 0, \
+                                            Entity_Quad_Pyramid = 0, \
+                                            Entity_Quad_Penta = 0 \
+                                           )
index 35c5fe2..bca8379 100644 (file)
@@ -25,12 +25,11 @@ from .geomsmesh import geomPublishInFather
 from . import initLog
 
 def compoundFromList(elements, nom=None):
-  """
-  
-  """
+  """compoundFromList"""
+
   logging.debug('start')
   
-  shapeList = []
+  shapeList = list()
   for a in elements:
     if not isinstance(a, list):
       shapeList.append(a)
index 57f6049..557c6c0 100644 (file)
 #
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
+"""Construit les arêtes débouchantes"""
 
 import logging
 
 from .geomsmesh import geompy
 from .geomsmesh import geomPublish
-from .geomsmesh import geomPublishInFather
+#from .geomsmesh import geomPublishInFather
 from . import initLog
 import GEOM
 from .sortEdges import sortEdges
 
 def construitEdgesRadialesDebouchantes(idisklim, idiskout, gptsdisks, raydisks,
                                        facesPipePeau, edgeRadFacePipePeau, nbsegCercle):
-  """
-  construction des listes d'edges radiales sur chaque extrémité débouchante
-  """
+  """construction des listes d'edges radiales sur chaque extrémité débouchante"""
   logging.info('start')
 
   # --- listes de nappes radiales en filling à chaque extrémité débouchante
@@ -95,7 +94,7 @@ def construitEdgesRadialesDebouchantes(idisklim, idiskout, gptsdisks, raydisks,
           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)
+            [edsorted, _, maxl] = sortEdges(eds)
             edge = edsorted[-1]
           else:
             maxl = geompy.BasicProperties(edge)[0]
@@ -118,7 +117,7 @@ def construitEdgesRadialesDebouchantes(idisklim, idiskout, gptsdisks, raydisks,
               logging.debug("  edges issues de la partition: %s", ednouv)
               for ii, ed in enumerate(ednouv):
                 geomPublish(initLog.debug, ed, "ednouv%d"%ii)
-              [edsorted, minl,maxl] = sortEdges(ednouv)
+              [edsorted, _, maxl] = sortEdges(ednouv)
               logging.debug("  longueur edge trouvée: %s", maxl)
               edge = edsorted[-1]
             else:
@@ -134,7 +133,7 @@ def construitEdgesRadialesDebouchantes(idisklim, idiskout, gptsdisks, raydisks,
               logging.debug("nombre vertex candidats %s", len(vxnouv))
               if len(vxnouv) >= 2:
                 eds = [geompy.MakeEdge(vxnouv[j],vxnouv[(j+1)%len(vxnouv)]) for j in range(len(vxnouv))]
-                [edsorted2, minl,maxl] = sortEdges(eds)
+                [edsorted2, _, maxl] = sortEdges(eds)
                 edge = edsorted2[-1]
                 logging.debug("lg edge: %s", maxl)
               else:
@@ -144,4 +143,4 @@ def construitEdgesRadialesDebouchantes(idisklim, idiskout, gptsdisks, raydisks,
           geomPublish(initLog.debug, edge, name)
       listEdges.append(edges)
 
-  return (listEdges, idFacesDebouchantes)
\ No newline at end of file
+  return (listEdges, idFacesDebouchantes)
index 9637bab..8dfcfa5 100644 (file)
@@ -18,6 +18,8 @@
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
+import os
+
 import logging
 import salome
 from .geomsmesh import geompy
@@ -82,7 +84,7 @@ def construitFissureGenerale(maillagesSains,
   TODO: a completer
   """
   logging.info('start')
-  
+
   shapeDefaut       = shapesFissure[0] # faces de fissure, débordant
   fondFiss          = shapesFissure[4] # groupe d'edges de fond de fissure
 
@@ -121,8 +123,7 @@ def construitFissureGenerale(maillagesSains,
   else:
     pointInterne = None
 
-  #fichierMaillageSain = nomRep + '/' + nomFicSain + '.med'
-  fichierMaillageFissure = nomRep + '/' + nomFicFissure + '.med'
+  fichierMaillageFissure = os.path.join (nomRep , '{}.med'.format(nomFicFissure))
 
   # fillings des faces en peau
   facesDefaut              = elementsDefaut[0]
@@ -143,24 +144,25 @@ def construitFissureGenerale(maillagesSains,
   centreFondFiss           = elementsDefaut[15]
   #tgtCentre                = elementsDefaut[16]
   if lgAretesVives == 0:
-     lgAretesVives = dmoyen
+    lgAretesVives = dmoyen
 
 
   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):
     geomPublishInFather(initLog.debug, 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
@@ -169,39 +171,41 @@ def construitFissureGenerale(maillagesSains,
   #     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)
-    
+
   aretesVivesC = compoundFromList(bordsPartages, "areteVive")
-  aretesVivesCoupees = []  # ensembles des arêtes vives identifiées sur les faces de peau dans l'itération sur partitionsPeauFissFond
-   
+  aretesVivesCoupees = list()  # ensembles des arêtes vives identifiées sur les faces de peau dans l'itération sur partitionsPeauFissFond
+
   # --- 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]
+  texte = "nbFacesFilling : {} ".format(nbFacesFilling)
+  logging.info(texte)
+
+  ptEdgeFond = [ list()  for i in range(nbFacesFilling)] # pour chaque face [points edge fond de fissure aux débouchés du pipe]
+  fsPipePeau = [ list()  for i in range(nbFacesFilling)] # pour chaque face [faces du pipe débouchantes]
+  edRadFPiPo = [ list()  for i in range(nbFacesFilling)] # pour chaque face [edge radiale des faces du pipe débouchantes ]
+  fsFissuExt = [ list()  for i in range(nbFacesFilling)] # pour chaque face [faces de fissure externes au pipe]
+  edFisExtPe = [ list()  for i in range(nbFacesFilling)] # pour chaque face [edge en peau des faces de fissure externes (pas subshape facePeau)]
+  edFisExtPi = [ list()  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]
+  edCircPeau = [ list()  for i in range(nbFacesFilling)] # pour chaque face de peau : [subshape edge circulaire aux débouchés du pipe]
+  ptCircPeau = [ list()  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]
-  
+  edFissPeau = [ list()  for i in range(nbFacesFilling)] # pour chaque face de peau : [subshape edge en peau des faces de fissure externes]
+  ptFisExtPi = [ list()  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)      
+                                                                      aretesVivesCoupees)
       ptEdgeFond[ifil] = dataPPFF['endsEdgeFond']
       fsPipePeau[ifil] = dataPPFF['facesPipePeau']
       edRadFPiPo[ifil] = dataPPFF['edgeRadFacePipePeau']
@@ -216,72 +220,71 @@ def construitFissureGenerale(maillagesSains,
       edFissPeau[ifil] = dataPPFF['edgesFissurePeau']
       ptFisExtPi[ifil] = dataPPFF['verticesPipePeau']
 
-  facesPipePeau = []
-  edgeRadFacePipePeau = []
+  facesPipePeau = list()
+  edgeRadFacePipePeau = list()
   for ifil in range(nbFacesFilling):
     facesPipePeau += fsPipePeau[ifil]
     edgeRadFacePipePeau += edRadFPiPo[ifil]
-  
+
   for i, avc in enumerate(aretesVivesCoupees):
     name = "areteViveCoupee%d"%i
     geomPublish(initLog.debug, avc, name)
-  
+
   # --- identification des faces et edges de fissure externe pour maillage
-  
-  (faceFissureExterne, edgesPipeFissureExterneC,
-    wirePipeFissureExterne, edgesPeauFissureExterneC) = identifieFacesEdgesFissureExterne(fsFissuExt, edFisExtPe,
-                                                                                          edFisExtPi, edgesPipeFiss)
+
+  (faceFissureExterne, edgesPipeFissureExterneC, wirePipeFissureExterne, edgesPeauFissureExterneC) = \
+      identifieFacesEdgesFissureExterne(fsFissuExt, edFisExtPe, edFisExtPi, edgesPipeFiss)
 
   # --- 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é)
-  
-  (centres, gptsdisks, raydisks) = calculePointsAxiauxPipe(edgesFondFiss, edgesIdByOrientation, facesDefaut, 
+
+  (centres, gptsdisks, raydisks) = calculePointsAxiauxPipe(edgesFondFiss, edgesIdByOrientation, facesDefaut,
                                                            centreFondFiss, wireFondFiss, wirePipeFiss,
                                                            lenSegPipe, rayonPipe, nbsegCercle, nbsegRad)
-   
+
   # --- recherche des points en trop (externes au volume à remailler)
-  #     - on associe chaque extrémité du pipe à une face filling 
+  #     - 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
-  
+
   (idFillingFromBout, idisklim, idiskout) = elimineExtremitesPipe(ptEdgeFond, facesDefaut, centres, gptsdisks, nbsegCercle)
 
   # --- construction des listes d'edges radiales sur chaque extrémité débouchante
-  
+
   (listEdges, idFacesDebouchantes) = construitEdgesRadialesDebouchantes(idisklim, idiskout, gptsdisks, raydisks,
                                                                         facesPipePeau, edgeRadFacePipePeau, nbsegCercle)
-    
+
   # --- création des points du maillage du pipe sur la face de peau
-  
+
   (gptsdisks, idisklim) = creePointsPipePeau(listEdges, idFacesDebouchantes, idFillingFromBout,
                                              ptEdgeFond, ptFisExtPi, edCircPeau, gptsdisks, idisklim, nbsegRad)
-  
+
   # --- ajustement precis des points sur edgesPipeFissureExterneC
-  
+
   gptsdisks = ajustePointsEdgePipeFissure(edgesPipeFissureExterneC, wirePipeFissureExterne, gptsdisks, idisklim)
-    
+
    # --- maillage effectif du pipe
 
   (meshPipe, meshPipeGroups, edgesCircPipeGroup) = construitMaillagePipe(gptsdisks, idisklim, nbsegCercle, nbsegRad)
-  
+
   # --- edges de bord, faces défaut à respecter
-  
+
   (internalBoundary, bordsLibres, grpAretesVives) = mailleAretesEtJonction(internalBoundary, aretesVivesCoupees, lgAretesVives)
 
   # --- maillage faces de fissure
-  
-  (meshFaceFiss, grpFaceFissureExterne, 
+
+  (meshFaceFiss, grpFaceFissureExterne,
    grpEdgesPeauFissureExterne, grpEdgesPipeFissureExterne) = mailleFacesFissure(faceFissureExterne, edgesPipeFissureExterneC, edgesPeauFissureExterneC,
                                                                                 meshPipeGroups, areteFaceFissure, rayonPipe, nbsegRad)
 
   # --- maillage faces de peau
-  
+
   meshesFacesPeau = mailleFacesPeau(partitionsPeauFissFond, idFillingFromBout, facesDefaut,
-                                    facesPeaux, edCircPeau, ptCircPeau, gpedgeBord, gpedgeVifs, edFissPeau, 
+                                    facesPeaux, edCircPeau, ptCircPeau, gpedgeBord, gpedgeVifs, edFissPeau,
                                     bordsLibres, grpEdgesPeauFissureExterne, grpAretesVives,
                                     edgesCircPipeGroup, dmoyen, rayonPipe, nbsegRad)
 
@@ -315,16 +318,24 @@ def construitFissureGenerale(maillagesSains,
     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' )
+
+  is_done = meshBoiteDefaut.Compute()
+  text = "meshBoiteDefaut.Compute"
+  if is_done:
+    logging.info(text+" OK")
+  else:
+    text = "Erreur au calcul du maillage.\n" + text
+    logging.info(text)
+    raise Exception(text)
+
+  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,
+  _, normfiss = shapeSurFissure(facesPortFissure)
+  maillageComplet = RegroupeSainEtDefaut(maillageSain, meshBoiteDefaut, \
                                          None, None, 'COMPLET', normfiss)
 
   logging.info("conversion quadratique")
@@ -354,5 +365,5 @@ def construitFissureGenerale(maillagesSains,
     salome.sg.updateObjBrowser()
 
   logging.info("maillage fissure fini")
-  
+
   return maillageComplet
index cd79654..0f5576a 100644 (file)
@@ -17,6 +17,7 @@
 #
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
+"""Maillage du pipe"""
 
 import logging
 
@@ -25,9 +26,7 @@ from .geomsmesh import smesh
 import SMESH
 
 def construitMaillagePipe(gptsdisks, idisklim, nbsegCercle, nbsegRad):
-  """
-  maillage effectif du pipe
-  """
+  """maillage effectif du pipe"""
   logging.info('start')
   meshPipe = smesh.Mesh(None, "meshPipe")
   fondFissGroup = meshPipe.CreateEmptyGroup(SMESH.EDGE, "FONDFISS")
@@ -38,26 +37,26 @@ def construitMaillagePipe(gptsdisks, idisklim, nbsegCercle, nbsegRad):
   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
+
+  mptsdisks  = list() # vertices maillage de tous les disques
+  mEdges     = list() # identifiants edges maillage fond de fissure
+  mEdgeFaces = list() # identifiants edges maillage edge face de fissure externe
+  mFaces     = list() # identifiants faces maillage fissure
+  mVols      = list() # identifiants volumes maillage pipe
+
+  mptdsk = list()
   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
+    mptdsk = list() # vertices maillage d'un disque
     for k in range(nbsegCercle):
       points = gptdsk[k]
-      mptids = []
+      mptids = list()
       for j, pt in enumerate(points):
         if j == 0 and k > 0:
           id = mptdsk[0][0]
@@ -67,37 +66,39 @@ def construitMaillagePipe(gptsdisks, idisklim, nbsegCercle, nbsegRad):
         mptids.append(id)
       mptdsk.append(mptids)
     mptsdisks.append(mptdsk)
-    
+
     # -----------------------------------------------------------------------
     # --- groupes edges cercles debouchants
-    
+
     if idisk == idisklim[0]:
-      pts = []
+      pts = list()
       for k in range(nbsegCercle):
         pts.append(mptdsk[k][-1])
-      edges = []
-      for k in range(len(pts)):
-        k1 = (k+1)%len(pts)
+      edges = list()
+      nb_pts = len(pts)
+      for k in range(nb_pts):
+        k1 = (k+1)%nb_pts
         idEdge = meshPipe.AddEdge([pts[k], pts[k1]])
         edges.append(idEdge)
       edgeCircPipe0Group.Add(edges)
-       
+
     if idisk == idisklim[1]:
-      pts = []
+      pts = list()
       for k in range(nbsegCercle):
         pts.append(mptdsk[k][-1])
-      edges = []
-      for k in range(len(pts)):
-        k1 = (k+1)%len(pts)
+      edges = list()
+      nb_pts = len(pts)
+      for k in range(nb_pts):
+        k1 = (k+1)%nb_pts
         idEdge = meshPipe.AddEdge([pts[k], pts[k1]])
         edges.append(idEdge)
       edgeCircPipe1Group.Add(edges)
-    
+
     # -----------------------------------------------------------------------
     # --- groupes faces  debouchantes
-    
+
     if idisk == idisklim[0]:
-      faces = []
+      faces = list()
       for j in range(nbsegRad):
         for k in range(nbsegCercle):
           k1 = k+1
@@ -111,7 +112,7 @@ def construitMaillagePipe(gptsdisks, idisklim, nbsegCercle, nbsegRad):
       faceCircPipe0Group.Add(faces)
 
     if idisk == idisklim[1]:
-      faces = []
+      faces = list()
       for j in range(nbsegRad):
         for k in range(nbsegCercle):
           k1 = k+1
@@ -123,10 +124,10 @@ def construitMaillagePipe(gptsdisks, idisklim, nbsegCercle, nbsegRad):
             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)
@@ -141,28 +142,28 @@ def construitMaillagePipe(gptsdisks, idisklim, nbsegCercle, nbsegRad):
       ide2 = meshPipe.AddEdge([oldmpts[0][-1], mptdsk[0][-1]])
       mEdgeFaces.append(ide2)
       edgeFaceFissGroup.Add([ide2])
-      idFaces = []
-      idVols = []
-      
+      idFaces = list()
+      idVols = list()
+
       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 = []
+
+        idVolCercle = list()
         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],
+            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],
+            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)  
-        
+        idVols.append(idVolCercle)
+
       mFaces.append(idFaces)
       mVols.append(idVols)
 
@@ -172,16 +173,20 @@ def construitMaillagePipe(gptsdisks, idisklim, nbsegCercle, nbsegRad):
   nb, new_mesh, new_group = meshPipe.MakeBoundaryElements(SMESH.BND_2DFROM3D, "pipeBoundaries")
   edgesCircPipeGroup = [edgeCircPipe0Group, edgeCircPipe1Group]
 
-  meshPipeGroups = dict(fondFissGroup = fondFissGroup,
-                        nodesFondFissGroup = nodesFondFissGroup,
-                        faceFissGroup = faceFissGroup,
-                        edgeFaceFissGroup = edgeFaceFissGroup,
-                        edgeCircPipe0Group = edgeCircPipe0Group,
-                        edgeCircPipe1Group = edgeCircPipe1Group,
-                        faceCircPipe0Group = faceCircPipe0Group,
-                        faceCircPipe1Group = faceCircPipe1Group,
-                        pipeFissGroup = pipeFissGroup,
-                        edgesCircPipeGroup = edgesCircPipeGroup
+  meshPipeGroups = dict(fondFissGroup = fondFissGroup, \
+                        nodesFondFissGroup = nodesFondFissGroup, \
+                        faceFissGroup = faceFissGroup, \
+                        edgeFaceFissGroup = edgeFaceFissGroup, \
+                        edgeCircPipe0Group = edgeCircPipe0Group, \
+                        edgeCircPipe1Group = edgeCircPipe1Group, \
+                        faceCircPipe0Group = faceCircPipe0Group, \
+                        faceCircPipe1Group = faceCircPipe1Group, \
+                        pipeFissGroup = pipeFissGroup, \
+                        edgesCircPipeGroup = edgesCircPipeGroup \
                         )
-  
-  return (meshPipe, meshPipeGroups, edgesCircPipeGroup)
\ No newline at end of file
+
+  #if meshPipe:
+    #text = "Arrêt rapide.\n"
+    #logging.info(text)
+    #raise Exception(text)
+  return (meshPipe, meshPipeGroups, edgesCircPipeGroup)
index eff8b18..9b68b81 100644 (file)
@@ -34,31 +34,31 @@ from .checkDecoupePartition import checkDecoupePartition
   #     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.
+  """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 = []
+  partitionsPeauFissFond = list()
   ipart = 0
-  for filling in facesDefaut: 
-    part = geompy.MakePartition([fissPipe, filling], [], [], [], geompy.ShapeType["FACE"], 0, [], 0)
+  for filling in facesDefaut:
+    part = geompy.MakePartition([fissPipe, filling], list(), list(), list(), geompy.ShapeType["FACE"], 0, list(), 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)
+      if otherFD:
+        fissPipePart = geompy.MakePartition([fissPipe], otherFD, list(), list(), geompy.ShapeType["FACE"], 0, list(), 0)
       else:
         fissPipePart = fissPipe
-      part = geompy.MakePartition([fissPipePart, filling], [], [], [], geompy.ShapeType["FACE"], 0, [], 0)
+      part = geompy.MakePartition([fissPipePart, filling], list(), list(), list(), geompy.ShapeType["FACE"], 0, list(), 0)
       partitionsPeauFissFond.append(part)
       geomPublish(initLog.debug, part, 'partitionPeauFissFond%d'%ipart )
     else:
       partitionsPeauFissFond.append(None)
-    ipart = ipart +1
+    ipart += 1
 
-  return partitionsPeauFissFond
\ No newline at end of file
+  return partitionsPeauFissFond
index 412516f..0e87d70 100644 (file)
@@ -18,6 +18,8 @@
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
+import os
+
 import logging
 from .geomsmesh import smesh
 import SMESH
@@ -62,7 +64,7 @@ def creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure,
   nomRep              = maillageFissureParams['nomRep']
   nomFicSain          = maillageFissureParams['nomFicSain']
 
-  fichierMaillageSain    = nomRep + '/' + nomFicSain + '.med'
+  fichierMaillageSain = os.path.join (nomRep , '{}.med'.format(nomFicSain))
   
   # --- centre de fond de fissure et tangente
   
@@ -80,10 +82,10 @@ def creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure,
   [maillageSain, internalBoundary, zoneDefaut, zoneDefaut_skin, zoneDefaut_internalFaces, zoneDefaut_internalEdges] = \
     peauInterne(fichierMaillageSain, shapeDefaut, nomZones)
 
-  facesDefaut = []
-  centresDefaut = []
-  normalsDefaut =[]
-  extrusionsDefaut = []
+  facesDefaut = list()
+  centresDefaut = list()
+  normalsDefaut = list()
+  extrusionsDefaut = list()
   isPlane = False
   if isHexa and not isPlane:
     meshQuad =  smesh.CopyMesh( zoneDefaut_skin, 'meshQuad', 0, 0)
@@ -100,7 +102,7 @@ def creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure,
   else:
     [facesDefaut, centreDefaut, normalDefaut, extrusionDefaut] = \
       creeZoneDefautGeom( geometrieSaine, shapeDefaut, origShapes, verticesShapes, dmoyen, lgExtrusion)
-    bordsPartages = []
+    bordsPartages = list()
     for face in facesDefaut:
       bordsPartages.append([None,None]) # TODO : traitement des arêtes vives ?
     fillconts = facesDefaut
index 73fa237..f0269ea 100644 (file)
@@ -30,62 +30,64 @@ from .fissError import fissError
 
 def creeZoneDefautMaillage(maillagesSains, shapeDefaut, tailleDefaut,
                            nomZones, coordsNoeudsFissure):
-  """
-  Identification de la zone à remailler, opérations sur le maillage
-  de l'objet sain.
+  """Identification de la zone à remailler, opérations sur le maillage de l'objet sain.
+
   La zone à remailler est définie à partir d'un objet géométrique
   ou à partir d'un jeu de points et d'une distance d'influence.
   @param maillagesSains : (le maillage de l'objet initial, booleen isHexa)
   @param shapeDefaut : objet géométrique représentant la fissure
-  (selon les cas, un point central, ou une shape plus complexe,
-  dont on ne garde que les vertices)
+  (selon les cas, un point central, ou une shape plus complexe, dont on ne garde que les vertices)
   @param tailleDefaut : distance d'influence définissant la zone à remailler:
   tous les éléments du maillage initial qui pénètrent dans cette zone
   sont détectés
   @param nomZones : préfixe des noms de groupes créés dans le maillage initial. S'il y a un groupe de noeuds
   @coordsNoeudsFissure : jeu de points donné par une liste (x1,y1,z1, x2,y2,z2, ...)
-  @return (origShapes, verticesShapes, dmoyen) liste id subShapes,
-  listes noeuds de bord, longueur arête moyenne bord
+  @return (origShapes, verticesShapes, dmoyen) liste id subShapes, listes noeuds de bord, longueur arête moyenne bord
   """
   logging.info("start")
-  
+  logging.debug("distance d'influence (tailleDefaut) = %f" % tailleDefaut)
+  #print ("  shapeDefaut : {}".format(shapeDefaut))
+  #print ("  nomZones : {}".format(nomZones))
+
   maillageSain = maillagesSains[0]
   isHexa = maillagesSains[1]
   lists = maillageSain.CreateHoleSkin(tailleDefaut, shapeDefaut, nomZones, coordsNoeudsFissure)
 
-  logging.debug("lists=%s", lists)
+  #print("lists = {}".format(lists))
 
   trace = True
-  origShapes = []
-  verticesShapes = []
+  origShapes = list()
+  verticesShapes = list()
 
-  cumul = 0 # somme des distances carrées entre point ordonnés (taille des arêtes)
-  nb = 0    # nombre d'arêtes évaluées
+  cumul = 0. # somme des distances carrées entre point ordonnés (taille des arêtes)
+  nb = 0     # nombre d'arêtes évaluées
 
   for aList in lists:
     aShape = aList[0]
     origShapes.append(aShape)
-    logging.debug("  shapeId %s", aShape)
-    vertices = []
-    xyz0 = None
-    for inode in range(1, len(aList)):
-      xyz = maillageSain.GetNodeXYZ(aList[inode])
-      if xyz0 is not None:
-        cumul += distance2(xyz, xyz0)
-        nb += 1
+    vertices = list()
+    xyz0 = maillageSain.GetNodeXYZ(aList[1])
+    ###vertices.append(geompy.MakeVertex(xyz0[0], xyz0[1], xyz0[2])) pourquoi pas le premier ?
+    #print ("  node 0 {} : {}".format(aList[1],xyz0))
+    #print (xyz0)
+    for node in aList[2:]:
+      xyz = maillageSain.GetNodeXYZ(node)
+      #print ("  node {} : {}".format(node,xyz))
+      cumul += distance2(xyz, xyz0)
       xyz0 = xyz
-      #logging.debug("    node %s %s", aList[inode], xyz)
+      #logging.debug("    node %s %s", node, xyz)
       vertices.append(geompy.MakeVertex(xyz[0], xyz[1], xyz[2]))
-      pass
+    nb += len(aList) - 2
     verticesShapes.append(vertices)
-    pass
+  #print ("nb = {}".format(nb))
+  #print ("cumul = {}".format(cumul))
 
-  if (nb == 0) :
+  if (nb == 0):
     texte = "La zone à remailler n'est pas détectée correctement.<br>"
     texte += "Cause possible :<ul>"
     texte += "<li>La distance d'influence est trop petite. "
     texte += "L'ordre de grandeur minimal correspond à la taille des mailles du maillage sain dans la zone à remailler.</li></ul>"
     raise fissError(traceback.extract_stack(),texte)
 
-  dmoyen = math.sqrt(cumul/nb) # ~ taille de l'arête moyenne du maillage global
+  dmoyen = math.sqrt(cumul/float(nb)) # ~ taille de l'arête moyenne du maillage global
   return origShapes, verticesShapes, dmoyen
index 95cf190..772ce40 100644 (file)
@@ -18,6 +18,8 @@
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
+import os
+
 from .geomsmesh import geompy, smesh
 from .geomsmesh import geomPublish
 from .geomsmesh import geomPublishInFather
@@ -48,7 +50,7 @@ class fissureCoude(fissureGenerique):
   maillage hexa
   """
 
-  nomProbleme = "tuyau_Coude"
+  nomProbleme = "fissureCoude"
 
   # ---------------------------------------------------------------------------
   def setParamGeometrieSaine(self):
@@ -293,7 +295,14 @@ class fissureCoude(fissureGenerique):
     smesh.SetName(algo1d_long_p2, "algo1d_long_p2")
     smesh.SetName(hypo1d_long_p2, "hypo1d_long_p2")
 
-    isDone = maillageSain.Compute()
+    is_done = maillageSain.Compute()
+    text = "maillageSain.Compute"
+    if is_done:
+      logging.info(text+" OK")
+    else:
+      text = "Erreur au calcul du maillage.\n" + text
+      logging.info(text)
+      raise Exception(text)
 
     mp1 = maillageSain.GroupOnGeom(P1,'P1',SMESH.NODE)
     mp2 = maillageSain.GroupOnGeom(P2,'P2',SMESH.NODE)
@@ -656,7 +665,7 @@ class fissureCoude(fissureGenerique):
     nbSegCercle = nombre de secteurs
     areteFaceFissure = taille cible de l'arête des triangles en face de fissure.
     """
-    self.maillageFissureParams = dict(nomRep        = '.',
+    self.maillageFissureParams = dict(nomRep        = os.curdir,
                                       nomFicSain    = self.nomCas,
                                       nomFicFissure = 'fissure_' + self.nomCas,
                                       nbsegRad      = 5,
index bbc606a..ccae1a8 100644 (file)
@@ -17,6 +17,7 @@
 #
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
+"""fissureGenerique"""
 
 import logging
 
@@ -24,15 +25,15 @@ from blocFissure import gmu
 from blocFissure.gmu.initEtude import initEtude
 from blocFissure.gmu.getStatsMaillageFissure import getStatsMaillageFissure
 
-class fissureGenerique():
-  """
-  classe générique problème fissure:
+class fissureGenerique(object):
+  """classe générique problème fissure:
+
   génération géométrie et maillage sain
   définition et positionnement d'une fissure
   génération d'un bloc défaut inséré dans le maillage sain
   """
 
-  nomProbleme = "generique"
+  nomProbleme = "fissureGenerique"
 
   def __init__(self, numeroCas):
     initEtude()
@@ -41,46 +42,58 @@ class fissureGenerique():
     self.fissureLongue = False
 
   def setParamGeometrieSaine(self):
-    self.geomParams = {}
+    """setParamGeometrieSaine"""
+    self.geomParams = dict()
 
   def genereGeometrieSaine(self, geomParams):
+    """genereGeometrieSaine"""
     geometriesSaines = [None]
     return geometriesSaines
 
   def setParamMaillageSain(self):
-    self.meshParams = {}
+    """setParamMaillageSain"""
+    self.meshParams = dict()
 
   def genereMaillageSain(self, geometriesSaines, meshParams):
+    """genereMaillageSain"""
     maillagesSains = [None]
     return maillagesSains
 
   def setParamShapeFissure(self):
-    self.shapeFissureParams = {}
+    """setParamShapeFissure"""
+    self.shapeFissureParams = dict()
 
   def genereShapeFissure(self, geometriesSaines, geomParams, shapeFissureParams):
+    """genereShapeFissure"""
     shapesFissure = [None]
     return shapesFissure
 
   def setParamMaillageFissure(self):
-    self.maillageFissureParams = {}
+    """setParamMaillageFissure"""
+    self.maillageFissureParams = dict()
 
   def genereZoneDefaut(self, geometriesSaines, maillagesSains, shapesFissure, maillageFissureParams):
+    """genereZoneDefaut"""
     elementsDefaut = [None]
     return elementsDefaut
 
   def genereMaillageFissure(self, geometriesSaines, maillagesSains, shapesFissure,
-                            maillageFissureParams, elementsDefaut, step):
+                            maillageFissureParams, elementsDefaut):
+    """genereMaillageFissure"""
     maillageFissure = None
     return maillageFissure
 
   def setReferencesMaillageFissure(self):
-    referencesMaillageFissure = {}
+    """setReferencesMaillageFissure"""
+    referencesMaillageFissure = dict()
     return referencesMaillageFissure
 
 # ---------------------------------------------------------------------------
 
   def executeProbleme(self, step=-1):
-    logging.info(" --- executeProbleme %s", self.nomCas)
+    """executeProbleme"""
+    texte = " --- fissureGenerique.executeProbleme pour '{}', step = {}".format(self.nomCas,step)
+    logging.info(texte)
     if step == 0:
       return
 
@@ -109,10 +122,5 @@ class fissureGenerique():
                                                  self.maillageFissureParams, elementsDefaut, step)
 
     self.setReferencesMaillageFissure()
-    mesures = getStatsMaillageFissure(maillageFissure, self.referencesMaillageFissure, self.maillageFissureParams)
-
-
-
-
-
-
+    ok_maillage = getStatsMaillageFissure(maillageFissure, self.referencesMaillageFissure, self.maillageFissureParams)
+    return ok_maillage
index fedf48e..9094251 100644 (file)
@@ -39,8 +39,10 @@ def genereMeshCalculZoneDefaut(facefiss, minSize, maxSize):
       -SetQuadAllowed = permission quadrangle dans maillage triangle
   -On récupère les coordonnées de chaque noeud de la fissure qu'on stocke
    dans une liste sous la forme : [X0, Y0, Z0, ..., Xn, Yn, Zn]"""
-   
+
   logging.info('start')
+  text = "Maillage de '{}'".format(facefiss.GetName())
+  logging.info(text)
 
   meshFissure = smesh.Mesh(facefiss)
   algo2d = meshFissure.Triangle(algo=smeshBuilder.NETGEN_1D2D)
@@ -51,15 +53,26 @@ def genereMeshCalculZoneDefaut(facefiss, minSize, maxSize):
   hypo2d.SetFineness( 2 )
   hypo2d.SetMinSize( minSize )
   hypo2d.SetQuadAllowed( 0 )
-  isDone = meshFissure.Compute()
   smesh.SetName(algo2d, "algo2d_zoneFiss")
   smesh.SetName(hypo2d, "hypo1d_zoneFiss")
 
-  coordsNoeudsFissure = []
+  is_done = meshFissure.Compute()
+  text = "meshFissure.Compute"
+  if is_done:
+    logging.info(text+" OK")
+  else:
+    text = "Erreur au calcul du maillage.\n" + text
+    logging.info(text)
+    raise Exception(text)
+
+  coordsNoeudsFissure = list()
   nodeIds = meshFissure.GetNodesId()
   for id in nodeIds:
     coords = meshFissure.GetNodeXYZ(id)
     coordsNoeudsFissure.append(coords[0])
     coordsNoeudsFissure.append(coords[1])
     coordsNoeudsFissure.append(coords[2])
+
+  logging.info('end')
+
   return coordsNoeudsFissure
index 4db1f82..709806b 100644 (file)
 #
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
+"""Statistiques maillage"""
 
+import os
 import logging
 import SMESH
 
-# -----------------------------------------------------------------------------
-# --- statistiques maillage
 
 def getStatsMaillageFissure(maillage, referencesMaillageFissure, maillageFissureParams):
   """
@@ -30,47 +30,62 @@ def getStatsMaillageFissure(maillage, referencesMaillageFissure, maillageFissure
   """
   logging.debug('start')
 
-  nomRep = '.'
   if 'nomRep' in maillageFissureParams:
     nomRep = maillageFissureParams['nomRep']
-  
+  else:
+    nomRep = os.path.curdir
+
   nomFicFissure     = maillageFissureParams['nomFicFissure']
-  fichierStatMaillageFissure = nomRep + '/' + nomFicFissure + '.res'
-  fichierNewRef = nomRep + '/' + nomFicFissure + '.new'
+  fichierStatMaillageFissure = os.path.join(nomRep, "{}.res".format(nomFicFissure))
+  fichierNewRef = os.path.join(nomRep, "{}.new".format(nomFicFissure))
   logging.debug("fichierStatMaillageFissure=%s", fichierStatMaillageFissure)
 
-  OK = False
+  ok_maillage = False
   if maillage is not None:
     mesures = maillage.GetMeshInfo()
-    d= {}
+    d_resu = dict()
     for key, value in mesures.items():
       logging.debug( "key: %s value: %s", key, value)
-      d[str(key)] = value
-    logging.debug("dico mesures %s", d)      
+      d_resu[str(key)] = value
+    logging.debug("dico mesures %s", d_resu)
+
+    text_2 = ""
+    ok_maillage = True
+    with open(fichierStatMaillageFissure, "w") as fic_stat :
+      for key in ('Entity_Quad_Quadrangle', 'Entity_Quad_Hexa'):
+        if d_resu[key] != referencesMaillageFissure[key]:
+          text = "Ecart"
+          ok_maillage = False
+        else:
+          text = "Valeur_OK"
+        text += ": {} reference: {} calcul: {}".format(key,referencesMaillageFissure[key],d_resu[key])
+        logging.info(text)
+        fic_stat.write(text+"\n")
+        text_2 += "                                          {} = {}, \\\n".format(key,d_resu[key])
+      tolerance = 0.05
+      for key in ('Entity_Node', 'Entity_Quad_Edge', 'Entity_Quad_Triangle', 'Entity_Quad_Tetra', 'Entity_Quad_Pyramid', 'Entity_Quad_Penta'):
+        if (d_resu[key] < (1.0 - tolerance)*referencesMaillageFissure[key]) \
+        or (d_resu[key] > (1.0 + tolerance)*referencesMaillageFissure[key]):
+          text = "Ecart"
+          ok_maillage = False
+        else:
+          text = "Valeur_OK"
+        text += ": {} reference: {} calcul: {}".format(key,referencesMaillageFissure[key],d_resu[key])
+        logging.info(text)
+        fic_stat.write(text+"\n")
+        text_2 += "                                          {} = {}, \\\n".format(key,d_resu[key])
+
+
+    if ok_maillage:
+      print ("Calcul cohérent avec la référence.")
+    else:
+#     Résultats de référence pour intégration dans le python du cas pour une mise à jour
+      with open(fichierNewRef, "w") as fic_info :
+        fic_info.write(text_2[:-4]+" \\")
+      text = "Calcul différent de la référence.\n"
+      text += "Voir le fichier {}\n".format(fichierStatMaillageFissure)
+      text += "La nouvelle référence est disponible dans le fichier :\n{}\n".format(fichierNewRef)
+      text += "Il faut l'insérer pour créer le dictionnaire 'referencesMaillageFissure' dans le paramétrage du cas."
+      print (text)
 
-    f = open(fichierStatMaillageFissure, 'w')
-    f2 = open(fichierNewRef, 'w')
-    OK = True
-    for key in ('Entity_Quad_Pyramid', 'Entity_Quad_Hexa', 'Entity_Quad_Quadrangle'):
-      if d[key] != referencesMaillageFissure[key]:
-        logging.info("Ecart: %s reference: %s calcul: %s", key, referencesMaillageFissure[key], d[key])
-        f.write("Ecart: " + key + " reference: " + str(referencesMaillageFissure[key]) + " calcul: " + str(d[key]) + '\n')
-        OK = False
-      else:
-        logging.info("Valeur_OK: %s reference: %s calcul: %s", key, referencesMaillageFissure[key], d[key])
-        f.write("Valeur_OK: " + key + " reference: " + str(referencesMaillageFissure[key]) + " calcul: " + str(d[key]) + '\n')
-      f2.write(key + " = " + str(d[key]) + ",\n")
-    tolerance = 0.05
-    for key in ('Entity_Quad_Penta', 'Entity_Quad_Tetra', 'Entity_Quad_Triangle', 'Entity_Quad_Edge', 'Entity_Node'):
-      if (d[key] < (1.0 - tolerance)*referencesMaillageFissure[key]) \
-      or (d[key] > (1.0 + tolerance)*referencesMaillageFissure[key]):
-        logging.info("Ecart: %s reference: %s calcul: %s", key, referencesMaillageFissure[key], d[key])
-        f.write("Ecart: " + key + " reference: " + str(referencesMaillageFissure[key]) + " calcul: " + str(d[key]) + '\n')
-        OK = False
-      else:
-        logging.info("Valeur_OK: %s reference: %s calcul: %s", key, referencesMaillageFissure[key], d[key])
-        f.write("Valeur_OK: " + key + " reference: " + str(referencesMaillageFissure[key]) + " calcul: " + str(d[key]) + '\n')
-      f2.write(key + " = " + str(d[key]) + ",\n")
-    f.close()
-    f2.close()
-  return OK
+  return ok_maillage
index 0d4b28e..486c550 100644 (file)
@@ -30,24 +30,22 @@ from .fissError import fissError
 
 from .produitMixte import produitMixte
 from .whichSide import whichSide
-  
-def identifieElementsDebouchants(ifil, facesDefaut, partitionPeauFissFond,
-                                edgesFondIn, edgesFondFiss, wireFondFiss,
-                                aretesVivesC, fillingFaceExterne,
-                                edgesPipeIn, verticesPipePeau, rayonPipe,
+
+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)
-  """
-  
+  """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)
+
+  verticesEdgesFondIn = list() # les points du fond de fissure au débouché du pipe sur la peau (indice de edgesFondIn)
+  pipexts = list()             # les segments de pipe associés au points de fond de fissure débouchants (même indice)
+  cercles = list()             # les cercles de generation des pipes débouchant (même indice)
+  facesFissExt = list()        # les faces de la fissure externe associés au points de fond de fissure débouchants (même indice)
+  edgesFissExtPeau = list()    # edges des faces de fissure externe sur la peau (même indice)
+  edgesFissExtPipe = list()    # edges des faces de fissure externe sur le pipe (même indice)
 
   #logging.debug("edgesFondIn %s", edgesFondIn)
   for iedf, edge in enumerate(edgesFondIn):
@@ -78,8 +76,8 @@ def identifieElementsDebouchants(ifil, facesDefaut, partitionPeauFissFond,
     #   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              
+    #   - 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)
@@ -102,15 +100,15 @@ def identifieElementsDebouchants(ifil, facesDefaut, partitionPeauFissFond,
     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) 
+    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)
+    locEdgePart = geompy.MakePartition([localEdgeInFondFiss],[centre], list(), list(), geompy.ShapeType["EDGE"], 0, list(), 0)
     edgesLoc = geompy.ExtractShapes(locEdgePart, geompy.ShapeType["EDGE"], False)
     edgesLocSorted =[(geompy.MinDistance(edge, locPt0), kk, edge) for kk, edge in enumerate(edgesLoc)]
     edgesLocSorted.sort()
@@ -127,7 +125,7 @@ def identifieElementsDebouchants(ifil, facesDefaut, partitionPeauFissFond,
     geomPublishInFather(initLog.debug, wireFondFiss, p1, "p1_%d"%iedf)
     geomPublishInFather(initLog.debug, wireFondFiss, p2, "p2_%d"%iedf)
 
-    edgePart = geompy.MakePartition([localEdgeInFondFiss], [p1,p2], [], [], geompy.ShapeType["EDGE"], 0, [], 0)
+    edgePart = geompy.MakePartition([localEdgeInFondFiss], [p1,p2], list(), list(), geompy.ShapeType["EDGE"], 0, list(), 0)
     edps = geompy.ExtractShapes(edgePart, geompy.ShapeType["EDGE"], True)
     for edp in edps:
       if geompy.MinDistance(centre, edp) < 1.e-3:
@@ -138,9 +136,9 @@ def identifieElementsDebouchants(ifil, facesDefaut, partitionPeauFissFond,
 
     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 = []
+      edgesPeauFis = list()
+      edgesPipeFis = list()
+      edgesPipeFnd = list()
       try:
         edgesPeauFis = geompy.GetSharedShapesMulti([geompy.MakeCompound(facesOnside), face], geompy.ShapeType["EDGE"])
         logging.debug("    faces onside %s",edgesPeauFis)
@@ -174,4 +172,4 @@ def identifieElementsDebouchants(ifil, facesDefaut, partitionPeauFissFond,
             if dist < 1.e-3:
               break
 
-  return (verticesEdgesFondIn, pipexts, cercles, facesFissExt, edgesFissExtPeau, edgesFissExtPipe)
\ No newline at end of file
+  return (verticesEdgesFondIn, pipexts, cercles, facesFissExt, edgesFissExtPeau, edgesFissExtPipe)
index 9c366ba..91c3577 100644 (file)
@@ -26,9 +26,9 @@ from .trouveEdgesFissPeau import trouveEdgesFissPeau
 from .identifieFacesPeau import identifieFacesPeau
 from .identifieEdgesPeau import identifieEdgesPeau
 
-def identifieElementsGeometriquesPeau(ifil, partitionPeauFissFond, edgesPipeFiss,
-                                      edgesFondFiss, wireFondFiss, aretesVivesC,
-                                      facesDefaut, centreFondFiss, rayonPipe,
+def identifieElementsGeometriquesPeau(ifil, partitionPeauFissFond, edgesPipeFiss, \
+                                      edgesFondFiss, wireFondFiss, aretesVivesC, \
+                                      facesDefaut, centreFondFiss, rayonPipe, \
                                       aretesVivesCoupees):
   """
   """
@@ -36,16 +36,16 @@ def identifieElementsGeometriquesPeau(ifil, partitionPeauFissFond, edgesPipeFiss
   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,
@@ -57,20 +57,20 @@ def identifieElementsGeometriquesPeau(ifil, partitionPeauFissFond, edgesPipeFiss
 
   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, aretesVivesCoupees) = 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 [faces du pipe débouchantes]
                   edgeRadFacePipePeau = edgeRadFacePipePeau, # pour chaque face [edge radiale des faces du pipe débouchantes ]
@@ -84,7 +84,7 @@ def identifieElementsGeometriquesPeau(ifil, partitionPeauFissFond, edgesPipeFiss
                   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
-  
+
index 287f24a..bdb6d90 100644 (file)
@@ -26,45 +26,50 @@ from .geomsmesh import geomPublishInFather
 from . import initLog
 
 def identifieFacesEdgesFissureExterne(fsFissuExt, edFisExtPe, edFisExtPi, edgesPipeFiss):
-  """
-  identification des faces et edges de fissure externe pour maillage
-  """
+  """identification des faces et edges de fissure externe pour maillage"""
   logging.info('start')
-  facesFissExt = []
-  edgesFissExtPeau = []
-  edgesFissExtPipe = []
+
+  logging.debug("---------------------------- fsFissuExt : {} ".format(fsFissuExt))
+  facesFissExt = list()
+  edgesFissExtPeau = list()
+  edgesFissExtPipe = list()
   for ifil in range(len(fsFissuExt)): # 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))
+  logging.debug("---------------------------- identification faces de fissure externes au pipe : {}".format(len(facesFissExt)))
   # regroupement des faces de fissure externes au pipe.
-  
-  if len(facesFissExt) > 1:
+
+  if not facesFissExt:
+    logging.info("---------------------------- fsFissuExt : {} ".format(fsFissuExt))
+    raise Exception("stop identifieFacesEdgesFissureExterne ; aucune face de fissure externe au pipe n'a été trouvée.")
+
+  elif 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 = []
+    edgesBordFFE = list()
     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)
+    logging.debug("edgesBordFFEid {}".format(edgesBordFFEid))
     edgesPPE = geompy.ExtractShapes(edgesPipeFissureExterneC, geompy.ShapeType["EDGE"], False)
     edgesPPEid = [ geompy.GetSubShapeID(faceFissureExterne, ed) for ed in edgesPPE]
-    logging.debug("edgesPPEid %s", edgesPPEid)
+    logging.debug("edgesPPEid {}".format(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)
+    logging.debug("edgesPFE {}".format(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))
   geomPublish(initLog.debug, faceFissureExterne, "faceFissureExterne")
   geomPublishInFather(initLog.debug, faceFissureExterne, edgesPeauFissureExterneC, "edgesPeauFissureExterne")
   geomPublishInFather(initLog.debug, faceFissureExterne, edgesPipeFissureExterneC, "edgesPipeFissureExterne")
-  
-  return (faceFissureExterne, edgesPipeFissureExterneC, wirePipeFissureExterne, edgesPeauFissureExterneC)
\ No newline at end of file
+
+  return (faceFissureExterne, edgesPipeFissureExterneC, wirePipeFissureExterne, edgesPeauFissureExterneC)
index 037e072..6b7a759 100644 (file)
@@ -17,6 +17,9 @@
 #
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
+"""Insertion d'une fissure elliptique"""
+
+import os
 
 import logging
 import salome
@@ -40,12 +43,12 @@ from .meshBlocPart import meshBlocPart
 from .enleveDefaut import enleveDefaut
 from .regroupeSainEtDefaut import RegroupeSainEtDefaut
 from .putName import putName
+
 # -----------------------------------------------------------------------------
 # --- procedure complete fissure elliptique
 
-def insereFissureElliptique(geometriesSaines, maillagesSains,
-                            shapesFissure, shapeFissureParams,
+def insereFissureElliptique(geometriesSaines, maillagesSains, \
+                            shapesFissure, shapeFissureParams, \
                             maillageFissureParams, elementsDefaut, step=-1):
   """
   TODO: a completer
@@ -81,8 +84,8 @@ def insereFissureElliptique(geometriesSaines, maillagesSains,
   nbsegFis          = maillageFissureParams['nbsegFis']      # 20
   lensegEllipsoide  = maillageFissureParams['lensegEllipso'] # 1.0
 
-  fichierMaillageSain = nomRep + '/' + nomFicSain + '.med'
-  fichierMaillageFissure = nomRep + '/' + nomFicFissure + '.med'
+  fichierMaillageSain = os.path.join(nomRep, '{}.med'.format(nomFicSain))
+  fichierMaillageFissure = os.path.join(nomRep, '{}.med'.format(nomFicFissure))
 
   facesDefaut              = elementsDefaut[0]
   centreDefaut             = elementsDefaut[1]
@@ -130,11 +133,10 @@ def insereFissureElliptique(geometriesSaines, maillagesSains,
   if step == 7:
     return None
 
-  [blocPartition, blocp, tore,
-  faceFissure, facesExternes, facesExtBloc, facesExtElli,
-  aretesInternes, ellipsoidep, sharedFaces, sharedEdges, edgesBords] = \
-    partitionBlocDefaut(extrusionDefaut, facesDefaut, gener1, pipe1,
-                        facefis1, ellipsoide1)
+  [ blocPartition, blocp, tore, \
+    faceFissure, facesExternes, facesExtBloc, facesExtElli,
+    aretesInternes, ellipsoidep, sharedFaces, sharedEdges, edgesBords] = \
+    partitionBlocDefaut(extrusionDefaut, facesDefaut, gener1, pipe1, facefis1, ellipsoide1)
   if not isHexa:
     edgesBords = None # maillage sain hexa ==> filling, et maillage edges Bords imposés du maillage sain
 
@@ -191,11 +193,11 @@ def insereFissureElliptique(geometriesSaines, maillagesSains,
     return None
 
   [bloc1, blocComplet] = \
-    meshBlocPart(blocPartition, faceFissure, tore, centres, edges, diams, circles, faces,
-                gencnt, facefissoutore, edgeext, facesExternes, facesExtBloc, facesExtElli,
-                aretesInternes, internalBoundary, ellipsoidep, sharedFaces, sharedEdges, edgesBords,
-                nbsegExt, nbsegGen, nbsegRad, scaleRad, reverses, reverext, nbsegCercle,
-                nbsegFis, dmoyen, lensegEllipsoide)
+    meshBlocPart(blocPartition, faceFissure, tore, centres, edges, diams, circles, faces, \
+                 gencnt, facefissoutore, edgeext, facesExternes, facesExtBloc, facesExtElli, \
+                 aretesInternes, internalBoundary, ellipsoidep, sharedFaces, sharedEdges, edgesBords, \
+                 nbsegExt, nbsegGen, nbsegRad, scaleRad, reverses, reverext, nbsegCercle,
+                 nbsegFis, dmoyen, lensegEllipsoide) \
 
   if step == 16:
     return None
index 8998b91..b65478d 100644 (file)
 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 #
 
+"""procédure complète fissure générale"""
+
+import os
+
 import logging
 import salome
 from .geomsmesh import geompy
@@ -56,9 +60,6 @@ from .projettePointSurCourbe import projettePointSurCourbe
 from .prolongeWire import prolongeWire
 #from getCentreFondFiss import getCentreFondFiss
 
-# -----------------------------------------------------------------------------
-# --- procédure complète fissure générale
-
 def insereFissureGenerale(maillagesSains,
                           shapesFissure, shapeFissureParams,
                           maillageFissureParams, elementsDefaut, step=-1):
@@ -66,7 +67,7 @@ def insereFissureGenerale(maillagesSains,
   TODO: a completer
   """
   logging.info('start')
-  
+
   shapeDefaut       = shapesFissure[0] # faces de fissure, débordant
   fondFiss          = shapesFissure[4] # groupe d'edges de fond de fissure
 
@@ -100,8 +101,8 @@ def insereFissureGenerale(maillagesSains,
   if isPointInterne:
     pointInterne = geompy.MakeVertex(pointIn_x, pointIn_y, pointIn_z)
 
-  #fichierMaillageSain = nomRep + '/' + nomFicSain + '.med'
-  fichierMaillageFissure = nomRep + '/' + nomFicFissure + '.med'
+  #fichierMaillageSain = os.path.join(nomRep, '{}.med'.format(nomFicSain))
+  fichierMaillageFissure = os.path.join(nomRep, '{}.med'.format(nomFicFissure))
 
   # fillings des faces en peau
   facesDefaut = elementsDefaut[0]
@@ -125,7 +126,7 @@ def insereFissureGenerale(maillagesSains,
   # --- restriction de la face de fissure au domaine solide :
   #     partition face fissure étendue par fillings, on garde la plus grande face
 
-  partShapeDefaut = geompy.MakePartition([shapeDefaut], facesDefaut, [], [], geompy.ShapeType["FACE"], 0, [], 0)
+  partShapeDefaut = geompy.MakePartition([shapeDefaut], facesDefaut, list(), list(), geompy.ShapeType["FACE"], 0, [], 0)
   geomPublish(initLog.debug, partShapeDefaut, 'partShapeDefaut')
   facesPartShapeDefaut = geompy.ExtractShapes(partShapeDefaut, geompy.ShapeType["FACE"], False)
   if isPointInterne:
@@ -137,22 +138,22 @@ def insereFissureGenerale(maillagesSains,
     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] #= global
-  
+
   geomPublish(initLog.debug, facesPortFissure, "facesPortFissure")
 
   O, OX, OY, OZ = triedreBase()
-  
+
   # -----------------------------------------------------------------------------
   # --- pipe de fond de fissure, prolongé, partition face fissure par pipe
   #     identification des edges communes pipe et face fissure
-  
+
   if geompy.NumberOfFaces(shapeDefaut) == 1:
     plan = geompy.MakePlane(centreFondFiss, tgtCentre, 10000)
     shapeDefaut = geompy.MakePartition([shapeDefaut], [plan], [], [], geompy.ShapeType["FACE"], 0, [], 0) #= local
     #fondFissCoupe = geompy.GetInPlaceByHistory(shapeDefaut, fondFiss) #= inutile
     geomPublish(initLog.debug, shapeDefaut, 'shapeDefaut_coupe')
     #geomPublishInFather(initLog.debug,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)
@@ -167,7 +168,7 @@ def insereFissureGenerale(maillagesSains,
   geomPublish(initLog.debug, fissPipe, 'fissPipe')
   partPipe = geompy.GetInPlaceByHistory(partFissPipe, pipeFiss) #= local
   geomPublish(initLog.debug, partPipe, 'partPipe')
-  
+
   edgesPipeFiss = geompy.GetSharedShapesMulti([fissPipe, partPipe], geompy.ShapeType["EDGE"]) #= global
   for i, edge in enumerate(edgesPipeFiss):
     name = "edgePipe%d"%i
@@ -178,14 +179,14 @@ def insereFissureGenerale(maillagesSains,
     wirePipeFiss = geompy.MakeCompound(edgesPipeFiss)
     logging.debug("wirePipeFiss construit sous forme de compound")
   geomPublish(initLog.debug, 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
     geomPublishInFather(initLog.debug,fissPipe, edge, name)
   wireFondFiss = geompy.MakeWire(edgesFondFiss) #= global
-  geomPublish(initLog.debug, wireFondFiss,"wireFondFiss")  
+  geomPublish(initLog.debug, wireFondFiss,"wireFondFiss")
 
   # -----------------------------------------------------------------------------
   # --- peau et face de fissure
@@ -195,68 +196,68 @@ def insereFissureGenerale(maillagesSains,
   #     liste de faces externes : facesDefaut
   #     liste de partitions face externe - fissure : partitionPeauFissFond (None quand pas d'intersection)
 
-  partitionsPeauFissFond = [] #= global
+  partitionsPeauFissFond = list() #= global
   ipart = 0
-  for filling in facesDefaut: 
-    part = geompy.MakePartition([fissPipe, filling], [], [], [], geompy.ShapeType["FACE"], 0, [], 0)
+  for filling in facesDefaut:
+    part = geompy.MakePartition([fissPipe, filling], list(), list(), list(), geompy.ShapeType["FACE"], 0, list(), 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)
+        fissPipePart = geompy.MakePartition([fissPipe], otherFD, list(), list(), geompy.ShapeType["FACE"], 0, list(), 0)
       else:
         fissPipePart = fissPipe
-      part = geompy.MakePartition([fissPipePart, filling], [], [], [], geompy.ShapeType["FACE"], 0, [], 0)
+      part = geompy.MakePartition([fissPipePart, filling], list(), list(), list(), geompy.ShapeType["FACE"], 0, list(), 0)
       partitionsPeauFissFond.append(part)
       geomPublish(initLog.debug,  part, 'partitionPeauFissFond%d'%ipart )
     else:
       partitionsPeauFissFond.append(None)
     ipart = ipart +1
-  
+
+
   # --- arêtes vives détectées (dans quadranglesToShapeNoCorner
   #                             et quadranglesToShapeWithCorner)
-  
-  aretesVives = []
-  aretesVivesCoupees = []  #= global
+
+  aretesVives = list()
+  aretesVivesCoupees = list()  #= global
   ia = 0
   for a in bordsPartages:
     if not isinstance(a, list):
-        aretesVives.append(a)
+      aretesVives.append(a)
+      name = "areteVive%d"%ia
+      geomPublish(initLog.debug, a, name)
+      ia += 1
+    else:
+      if a[0] is not None:
+        aretesVives.append(a[0])
         name = "areteVive%d"%ia
-        geomPublish(initLog.debug, a, name)
+        geomPublish(initLog.debug, a[0], name)
         ia += 1
-    else:
-        if a[0] is not None:
-            aretesVives.append(a[0])
-            name = "areteVive%d"%ia
-            geomPublish(initLog.debug, a[0], name)
-            ia += 1
 
   aretesVivesC = None #= global
   if len(aretesVives) > 0:
     aretesVivesC =geompy.MakeCompound(aretesVives)
-    
+
   # -------------------------------------------------------
   # --- 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]
+  ptEdgeFond = [ list()  for i in range(nbFacesFilling)] # pour chaque face [points edge fond de fissure aux débouchés du pipe]
+  fsPipePeau = [ list()  for i in range(nbFacesFilling)] # pour chaque face [faces du pipe débouchantes]
+  edRadFPiPo = [ list()  for i in range(nbFacesFilling)] # pour chaque face [edge radiale des faces du pipe débouchantes ]
+  fsFissuExt = [ list()  for i in range(nbFacesFilling)] # pour chaque face [faces de fissure externes au pipe]
+  edFisExtPe = [ list()  for i in range(nbFacesFilling)] # pour chaque face [edge en peau des faces de fissure externes (pas subshape facePeau)]
+  edFisExtPi = [ list()  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]
+  edCircPeau = [ list()  for i in range(nbFacesFilling)] # pour chaque face de peau : [subshape edge circulaire aux débouchés du pipe]
+  ptCircPeau = [ list()  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]
-  
+  edFissPeau = [ list()  for i in range(nbFacesFilling)] # pour chaque face de peau : [subshape edge en peau des faces de fissure externes]
+  ptFisExtPi = [ list()  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:
       fillingFaceExterne = facesDefaut[ifil]
@@ -265,21 +266,21 @@ def insereFissureGenerale(maillagesSains,
       # -----------------------------------------------------------------------
       # --- identification edges fond de fissure, edges pipe sur la face de fissure,
       #     edges prolongées
-      
+
       edgesPipeC = geompy.GetInPlace(partitionPeauFissFond, geompy.MakeCompound(edgesPipeFiss)) #= local
       geomPublishInFather(initLog.debug,partitionPeauFissFond, edgesPipeC, "edgesPipeFiss")
       edgesFondC = geompy.GetInPlace(partitionPeauFissFond, geompy.MakeCompound(edgesFondFiss)) #= local
       geomPublishInFather(initLog.debug,partitionPeauFissFond, edgesFondC, "edgesFondFiss")
-      
+
       if aretesVivesC is None: #= global facesInside facesOnside
         [edgesInside, edgesOutside, edgesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "EDGE", 1.e-3)
         [facesInside, facesOutside, facesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "FACE", 1.e-3)
       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"]) #= global
-      verticesPipePeau = [] #= global
+      verticesPipePeau = list() #= global
 
       for i, edge in enumerate(edgesPipeIn):
         try:
@@ -292,20 +293,20 @@ 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 = []     #= inutile
-      edgesFondIn =[] #= global
-      if len(verticesPipePeau) > 0: # au moins une extrémité du pipe sur cette face de peau  
+      #edgesFondOut = list()     #= inutile
+      edgesFondIn =list() #= 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"])
-        #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)
-      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)
+      verticesEdgesFondIn = list() # les points du fond de fissure au débouché du pipe sur la peau (indice de edgesFondIn)
+      pipexts = list()             # les segments de pipe associés au points de fond de fissure débouchants (même indice)
+      cercles = list()             # les cercles de generation des pipes débouchant (même indice)
+      facesFissExt = list()        # les faces de la fissure externe associés au points de fond de fissure débouchants (même indice)
+      edgesFissExtPeau = list()    # edges des faces de fissure externe sur la peau (même indice)
+      edgesFissExtPipe = list()    # edges des faces de fissure externe sur le pipe (même indice)
       #logging.debug("edgesFondIn %s", edgesFondIn)
 
       edgesFondFiss, edgesIdByOrientation = orderEdgesFromWire(wireFondFiss)
@@ -340,8 +341,8 @@ def insereFissureGenerale(maillagesSains,
         #   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              
+        #   - 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)
@@ -364,15 +365,15 @@ def insereFissureGenerale(maillagesSains,
         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) 
+        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)
+        locEdgePart = geompy.MakePartition([localEdgeInFondFiss],[centre], list(), list(), geompy.ShapeType["EDGE"], 0, list(), 0)
         edgesLoc = geompy.ExtractShapes(locEdgePart, geompy.ShapeType["EDGE"], False)
         edgesLocSorted =[(geompy.MinDistance(edge, locPt0), kk, edge) for kk, edge in enumerate(edgesLoc)]
         edgesLocSorted.sort()
@@ -383,7 +384,7 @@ def insereFissureGenerale(maillagesSains,
         geomPublishInFather(initLog.debug,wireFondFiss, p1, "p1_%d"%iedf)
         geomPublishInFather(initLog.debug,wireFondFiss, p2, "p2_%d"%iedf)
 
-        edgePart = geompy.MakePartition([localEdgeInFondFiss], [p1,p2], [], [], geompy.ShapeType["EDGE"], 0, [], 0)
+        edgePart = geompy.MakePartition([localEdgeInFondFiss], [p1,p2], list(), list(), geompy.ShapeType["EDGE"], 0, list(), 0)
         edps = geompy.ExtractShapes(edgePart, geompy.ShapeType["EDGE"], True)
         for edp in edps:
           if geompy.MinDistance(centre, edp) < 1.e-3:
@@ -394,9 +395,9 @@ def insereFissureGenerale(maillagesSains,
 
         for face in facesInside:
           logging.debug("recherche edges communes entre une face inside et (faces onside, edges pipe et fond débouchante)")
-          edgesPeauFis = []
-          edgesPipeFis = []
-          edgesPipeFnd = []
+          edgesPeauFis = list()
+          edgesPipeFis = list()
+          edgesPipeFnd = list()
           try:
             edgesPeauFis = geompy.GetSharedShapesMulti([geompy.MakeCompound(facesOnside), face], geompy.ShapeType["EDGE"])
             logging.debug("    faces onside %s",edgesPeauFis)
@@ -434,9 +435,9 @@ def insereFissureGenerale(maillagesSains,
                                      # il faut recenser les edges de fissure sur la face de peau
         j = 0
         for face in facesInside:
-          edgesPeauFis = []
-          edgesPipeFis = []
-          edgesPipeFnd = []
+          edgesPeauFis = list()
+          edgesPipeFis = list()
+          edgesPipeFnd = list()
           try:
             edgesPeauFis = geompy.GetSharedShapesMulti([geompy.MakeCompound(facesOnside), face], geompy.ShapeType["EDGE"])
             edgesPipeFis = geompy.GetSharedShapesMulti([geompy.MakeCompound(edgesPipeIn), face], geompy.ShapeType["EDGE"])
@@ -448,28 +449,28 @@ def insereFissureGenerale(maillagesSains,
             name="edgesFissExtPeau%d"%j
             geomPublishInFather(initLog.debug,partitionPeauFissFond, edgesPeauFis[0], name)
             j += 1
-     
+
       # -----------------------------------------------------------------------
       # --- identification 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
-      
+
       facesAndFond = facesOnside
       facesAndFond.append(wireFondFiss)
       try:
-        partitionPeauByPipe = geompy.MakePartition(facesAndFond, pipexts, [], [], geompy.ShapeType["FACE"], 0, [], 1)
+        partitionPeauByPipe = geompy.MakePartition(facesAndFond, pipexts, list(), list(), geompy.ShapeType["FACE"], 0, list(), 1)
       except:
         logging.debug("probleme partition face pipe, contournement avec MakeSection")
-        sections = []
+        sections = list()
         for pipext in pipexts:
           sections.append(geompy.MakeSection(facesOnside[0], pipext))
-        partitionPeauByPipe = geompy.MakePartition(facesAndFond, sections, [], [], geompy.ShapeType["FACE"], 0, [], 1)
-        
+        partitionPeauByPipe = geompy.MakePartition(facesAndFond, sections, list(), list(), geompy.ShapeType["FACE"], 0, list(), 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 = []
+        edgeEnTrop = list()
         outilPart = pipexts
         facesPeau = geompy.ExtractShapes(partitionPeauByPipe, geompy.ShapeType["FACE"], False)
         facesPeauSorted, minsur, maxsurf = sortFaces(facesPeau)
@@ -495,31 +496,31 @@ def insereFissureGenerale(maillagesSains,
             if bad:
               outilPart[j] = geompy.MakeProjection(cercles[j],facesOnside[0])
             pass
-          partitionPeauByPipe = geompy.MakePartition(facesAndFond, outilPart, [], [], geompy.ShapeType["FACE"], 0, [], 1)
+          partitionPeauByPipe = geompy.MakePartition(facesAndFond, outilPart, list(), list(), geompy.ShapeType["FACE"], 0, list(), 1)
           pass
-          
+
       name="partitionPeauByPipe%d"%ifil
       geomPublish(initLog.debug, 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)
+        facePeau =geompy.MakePartition(facesPeauFondOn, list(), list(), list(), geompy.ShapeType["FACE"], 0, list(), 1)
       name="facePeau%d"%ifil
       geomPublish(initLog.debug, facePeau, name)
-      
+
       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 = []
+
+      edgesListees = list()
+      edgesCircPeau = list()
+      verticesCircPeau = list()
       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):
@@ -528,8 +529,9 @@ def insereFissureGenerale(maillagesSains,
             if dist < 1e-3:
               for ik, edpfi in enumerate(edgesPeauFondIn):
                 if geompy.MinDistance(face, edpfi) < 1e-3:
+                  ikok = ik
                   break
-              sharedVertices = geompy.GetSharedShapesMulti([face, edgesPeauFondIn[ik]], geompy.ShapeType["VERTEX"])
+              sharedVertices = geompy.GetSharedShapesMulti([face, edgesPeauFondIn[ikok]], geompy.ShapeType["VERTEX"])
               nameFace = "facePipePeau%d"%i
               nameVert = "endEdgeFond%d"%i
               nameEdge = "edgeRadFacePipePeau%d"%i
@@ -547,11 +549,11 @@ def insereFissureGenerale(maillagesSains,
               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))]        
+        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"])
@@ -572,7 +574,7 @@ def insereFissureGenerale(maillagesSains,
       # --- edges de bord de la face de peau
 
       edgesFilling = geompy.ExtractShapes(fillingFaceExterne, geompy.ShapeType["EDGE"], False)
-      edgesBords = []
+      edgesBords = list()
       for i, edge in enumerate(edgesFilling):
         edgepeau = geompy.GetInPlace(facePeau, edge)
         name = "edgepeau%d"%i
@@ -608,12 +610,12 @@ def insereFissureGenerale(maillagesSains,
           aretesVivesCoupees += edv
       logging.debug("aretesVivesCoupees %s",aretesVivesCoupees)
       geomPublishInFather(initLog.debug,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 = []
+      edgesFissurePeau = list()
       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:
@@ -630,7 +632,6 @@ def insereFissureGenerale(maillagesSains,
           edgesFissurePeau.append(edge)
           name = "edgeFissurePeau%d"%i
           geomPublishInFather(initLog.debug,facePeau,  edge, name)
-        
 
       ptEdgeFond[ifil] = endsEdgeFond        # pour chaque face [points edge fond de fissure aux débouchés du pipe]
       fsPipePeau[ifil] = facesPipePeau       # pour chaque face [faces du pipe débouchantes]
@@ -649,30 +650,30 @@ def insereFissureGenerale(maillagesSains,
   # -----------------------------------------------------------------------
   # fin de la boucle sur les faces de filling
   # -----------------------------------------------------------------------
-  
+
   for i, avc in enumerate(aretesVivesCoupees):
     name = "areteViveCoupee%d"%i
     geomPublish(initLog.debug, avc, name)
-  
+
   # --- identification des faces et edges de fissure externe pour maillage
-  
-  facesFissExt = []
-  edgesFissExtPeau = []
-  edgesFissExtPipe = []
+
+  facesFissExt = list()
+  edgesFissExtPeau = list()
+  edgesFissExtPipe = list()
   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)
+    faceFissureExterne = geompy.MakePartition(facesFissExt, list(), list(), list(), geompy.ShapeType["FACE"], 0, list(), 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 = []
+    edgesBordFFE = list()
     for bound in closedFreeBoundaries:
       edgesBordFFE += geompy.ExtractShapes(bound, geompy.ShapeType["EDGE"], False)
     edgesBordFFEid = [ (ed,geompy.GetSubShapeID(faceFissureExterne, ed)) for ed in edgesBordFFE]
@@ -691,7 +692,7 @@ def insereFissureGenerale(maillagesSains,
   geomPublish(initLog.debug, faceFissureExterne, "faceFissureExterne")
   geomPublishInFather(initLog.debug,faceFissureExterne, edgesPeauFissureExterneC, "edgesPeauFissureExterne")
   geomPublishInFather(initLog.debug,faceFissureExterne, edgesPipeFissureExterneC, "edgesPipeFissureExterne")
-  
+
   logging.debug("---------------------------- Preparation Maillage du Pipe --------------")
   # -----------------------------------------------------------------------
   # --- preparation maillage du pipe :
@@ -700,12 +701,12 @@ def insereFissureGenerale(maillagesSains,
   #     - 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 
+  # --- option de maillage selon le rayon de courbure du fond de fissure
   lenEdgeFondExt = 0
   for edff in edgesFondFiss:
     lenEdgeFondExt += geompy.BasicProperties(edff)[0]
-  
-  disfond = []
+
+  disfond = list()
   for filling in facesDefaut:
     disfond.append(geompy.MinDistance(centreFondFiss, filling))
   disfond.sort()
@@ -714,14 +715,22 @@ def insereFissureGenerale(maillagesSains,
   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)  
+  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()
-  
+
+  is_done = meshFondExt.Compute()
+  text = "meshFondExt.Compute"
+  if is_done:
+    logging.info(text+" OK")
+  else:
+    text = "Erreur au calcul du maillage.\n" + text
+    logging.info(text)
+    raise Exception(text)
+
   ptGSdic = {} # dictionnaire [paramètre sur la courbe] --> point géométrique
   allNodeIds = meshFondExt.GetNodesId()
   for nodeId in allNodeIds:
@@ -732,19 +741,19 @@ def insereFissureGenerale(maillagesSains,
     edgeOrder = edgesIdByOrientation[EdgeInWireIndex]
     ptGSdic[(edgeOrder, EdgeInWireIndex, u)] = pt
     #logging.debug("nodeId %s, u %s", nodeId, str(u))
-  usort = sorted(ptGSdic)  
+  usort = sorted(ptGSdic)
   logging.debug("nombre de points obtenus par deflexion %s",len(usort))
-     
-  centres = []
-  origins = []
-  normals = []      
+
+  centres = list()
+  origins = list()
+  normals = list()
   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)
+    part = geompy.MakePartition([plan], [wirePipeFiss], list(), list(), geompy.ShapeType["VERTEX"], 0, list(), 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:
@@ -762,21 +771,21 @@ def insereFissureGenerale(maillagesSains,
 #      geomPublishInFather(initLog.debug,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]
+
+  gptsdisks = list() # vertices géométrie de tous les disques
+  raydisks = [list() for i in range(nbsegCercle)]
+  for i, centres_i in enumerate(centres): # boucle sur les disques
+    gptdsk = list() # 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)
@@ -785,7 +794,7 @@ def insereFissureGenerale(maillagesSains,
     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
@@ -795,17 +804,17 @@ def insereFissureGenerale(maillagesSains,
       gptdsk.append(pts)
       ray = geompy.MakeRotation(rayon, normal, angle)
       raydisks[k+1].append(ray)
-      
-    gptsdisks.append(gptdsk) 
+
+    gptsdisks.append(gptdsk)
+
   # -----------------------------------------------------------------------
   # --- recherche des points en trop (externes au volume à remailler)
-  #     - on associe chaque extrémité du pipe à une face filling 
+  #     - on associe chaque extrémité du pipe à une face filling
   #     - on part des disques aux extrémités du pipe