src/Tools/blocFissure/gmu/insereFissureLongue.py

   1 # -*- coding: utf-8 -*-
   2 # Copyright (C) 2014-2020  EDF R&D
   3 #
   4 # This library is free software; you can redistribute it and/or
   5 # modify it under the terms of the GNU Lesser General Public
   6 # License as published by the Free Software Foundation; either
   7 # version 2.1 of the License, or (at your option) any later version.
   8 #
   9 # This library is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 # Lesser General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU Lesser General Public
  15 # License along with this library; if not, write to the Free Software
  16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 #
  18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 #
  20 """procédure complète de construction d'une fissure longue"""
  21
  22 import os
  23
  24 import logging
  25 import salome
  26 from .geomsmesh import geompy
  27 from .geomsmesh import geomPublish
  28 from .geomsmesh import geomPublishInFather
  29 from . import initLog
  30 from .geomsmesh import smesh
  31 from salome.smesh import smeshBuilder
  32 import SMESH
  33 import math
  34
  35 from .extractionOrientee import extractionOrientee
  36 from .sortFaces import sortFaces
  37 from .sortEdges import sortEdges
  38 from .eliminateDoubles import eliminateDoubles
  39 from .substractSubShapes import substractSubShapes
  40 from .produitMixte import produitMixte
  41 from .findWireEndVertices import findWireEndVertices
  42 from .getSubshapeIds import getSubshapeIds
  43 from .putName import putName
  44 from .distance2 import distance2
  45 from .enleveDefaut import enleveDefaut
  46 from .shapeSurFissure import shapeSurFissure
  47 from .regroupeSainEtDefaut import RegroupeSainEtDefaut
  48 from .triedreBase import triedreBase
  49
  50 from .insereFissureLongue_a import insereFissureLongue_a
  51 from .insereFissureLongue_b import insereFissureLongue_b
  52 from .insereFissureLongue_c import insereFissureLongue_c
  53 from .insereFissureLongue_d import insereFissureLongue_d
  54
  55 # -----------------------------------------------------------------------------
  56
  57 def insereFissureLongue(geometriesSaines, \
  58                         shapesFissure, shapeFissureParams, \
  59                         maillageFissureParams, elementsDefaut, \
  60                         step=-1, mailleur="MeshGems"):
  61   """procedure complete fissure longue"""
  62   logging.info('start')
  63   logging.info("Usage du mailleur %s", mailleur)
  64
  65   #geometrieSaine    = geometriesSaines[0]
  66   shapeDefaut       = shapesFissure[0] # face de fissure, debordant
  67   #tailleDefaut      = shapesFissure[2]
  68   wiretube          = shapesFissure[4] # wire fond de fissure, debordant
  69   planfiss          = shapesFissure[7] # plan de fissure
  70   pipefiss          = shapesFissure[8] # pipe, debordant
  71
  72   profondeur  = shapeFissureParams['profondeur']
  73   rayonPipe   = profondeur/4.0
  74
  75   nomRep            = maillageFissureParams['nomRep']
  76   nomFicSain        = maillageFissureParams['nomFicSain']
  77   nomFicFissure     = maillageFissureParams['nomFicFissure']
  78
  79   #nbsegExt          = maillageFissureParams['nbsegExt']      # 5
  80   #nbsegGen          = maillageFissureParams['nbsegGen']      # 25
  81   #nbsegRad          = maillageFissureParams['nbsegRad']      # 5
  82   #scaleRad          = maillageFissureParams['scaleRad']      # 4
  83   #nbsegCercle       = maillageFissureParams['nbsegCercle']   # 6
  84   #nbsegFis          = maillageFissureParams['nbsegFis']      # 20
  85   #lensegEllipsoide  = maillageFissureParams['lensegEllipso'] # 1.0
  86
  87   #fichierMaillageSain = os.path.join(nomRep, '{}.med'.format(nomFicSain))
  88   fichierMaillageFissure = os.path.join(nomRep, '{}.med'.format(nomFicFissure))
  89
  90   facesDefaut              = elementsDefaut[0]
  91   #centreDefaut             = elementsDefaut[1]
  92   #normalDefaut             = elementsDefaut[2]
  93   #extrusionDefaut          = elementsDefaut[3]
  94   #dmoyen                   = elementsDefaut[4]
  95   #bordsPartages            = elementsDefaut[5]
  96   #fillconts                = elementsDefaut[6]
  97   #idFilToCont              = elementsDefaut[7]
  98   maillageSain             = elementsDefaut[8]
  99   internalBoundary         = elementsDefaut[9]
 100   zoneDefaut               = elementsDefaut[10]
 101   zoneDefaut_skin          = elementsDefaut[11]
 102   zoneDefaut_internalFaces = elementsDefaut[12]
 103   zoneDefaut_internalEdges = elementsDefaut[13]
 104
 105   facePorteFissure =  shapeDefaut
 106   WirePorteFondFissure = wiretube
 107   fillingFaceExterne = facesDefaut[0]
 108   logging.debug("fillingFaceExterne %s", fillingFaceExterne)
 109   geomPublish(initLog.debug, fillingFaceExterne, "fillingFaceExterne")
 110   edgesFilling = geompy.ExtractShapes(fillingFaceExterne, geompy.ShapeType["EDGE"], False)
 111
 112   O, OX, OY, OZ = triedreBase()
 113
 114   # -----------------------------------------------------------------------------
 115   # --- peau et face de fissure
 116
 117   # --- partition peau defaut - face de fissure prolongee - wire de fond de fissure prolongée
 118   partitionPeauFissFond = geompy.MakePartition([facePorteFissure, WirePorteFondFissure, fillingFaceExterne], list(), list(), list(), geompy.ShapeType["FACE"], 0, list(), 0)
 119   geomPublish(initLog.debug,  partitionPeauFissFond, 'partitionPeauFissFond' )
 120
 121   edges = geompy.ExtractShapes(WirePorteFondFissure, geompy.ShapeType["EDGE"], False)
 122
 123   lgmax = 0
 124   imax = 0
 125   for i, edge in enumerate(edges):
 126     props = geompy.BasicProperties(edge)
 127     lg = props[0]
 128     if lg > lgmax:
 129       lgmax = lg
 130       imax = i
 131   edgemax = edges[imax]
 132   geomPublish(initLog.debug, edgemax, 'edgemax')
 133   centreFondFiss = geompy.MakeVertexOnCurve(edgemax, 0.5)
 134   geomPublish(initLog.debug, centreFondFiss, 'centreFondFiss')
 135   tangentFondFiss = geompy.MakeTangentOnCurve(edgemax, 0.5)
 136   geomPublish(initLog.debug, tangentFondFiss, 'tangentFondFiss')
 137
 138   bord1FondFiss = geompy.MakeVertexOnCurve(edgemax, 0.0)
 139   geomPublish(initLog.debug, bord1FondFiss, 'bord1FondFiss')
 140   tangentBord1FondFiss = geompy.MakeTangentOnCurve(edgemax, 0.0)
 141   geomPublish(initLog.debug, tangentBord1FondFiss, 'tangentBord1FondFiss')
 142
 143   bord2FondFiss = geompy.MakeVertexOnCurve(edgemax, 1.0)
 144   geomPublish(initLog.debug, bord2FondFiss, 'bord2FondFiss')
 145   tangentBord2FondFiss = geompy.MakeTangentOnCurve(edgemax, 1.0)
 146   geomPublish(initLog.debug, tangentBord2FondFiss, 'tangentBord2FondFiss')
 147
 148   planBord1 = geompy.MakePlane(bord1FondFiss, tangentBord1FondFiss, 3*rayonPipe)
 149   planBord2 = geompy.MakePlane(bord2FondFiss, tangentBord2FondFiss, 3*rayonPipe)
 150   geomPublish(initLog.debug, planBord1, 'planBord1')
 151   geomPublish(initLog.debug, planBord2, 'planBord2')
 152
 153   [edgesInside, edgesOutside, edgesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "EDGE", 1.e-3)
 154   [facesInside, facesOutside, facesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "FACE", 1.e-3)
 155
 156   # --- partition peau -face fissure - pipe fond de fissure prolongé
 157   partitionPeauFissByPipe = geompy.MakePartition([facesInside[0], facesOnside[0]], [pipefiss], list(), list(), geompy.ShapeType["FACE"], 0, list(), 0)
 158   geomPublish(initLog.debug,  partitionPeauFissByPipe, 'partitionPeauFissByPipe' )
 159
 160   # --- identification face de peau
 161   [facesPeauFissInside, facesPeauFissOutside, facesPeauFissOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissByPipe, centreFondFiss, "FACE", 0.1, "peauFiss_bord_")
 162   facesPeauSorted, minsur, maxsurf = sortFaces(facesPeauFissOnside) # 4 demi disques, une grande face
 163   facePeau = facesPeauSorted[-1] # la plus grande face
 164   geomPublishInFather(initLog.debug,partitionPeauFissByPipe, facePeau, "facePeau")
 165
 166   # --- identification edges de bord face peau
 167   edgesBords = list()
 168   for i, edge in enumerate(edgesFilling):
 169     edgepeau = geompy.GetInPlace(facePeau, edge)
 170     edgesBords.append(edgepeau)
 171   groupEdgesBordPeau = geompy.CreateGroup(facePeau, geompy.ShapeType["EDGE"])
 172   geompy.UnionList(groupEdgesBordPeau, edgesBords)
 173   geomPublishInFather(initLog.debug,facePeau, groupEdgesBordPeau , "EdgesBords")
 174
 175   # --- identification face fissure externe au pipe et edge commune peau fissure
 176   for face in facesPeauFissInside:
 177     try:
 178       sharedEdges = geompy.GetSharedShapesMulti([facePeau, face], geompy.ShapeType["EDGE"])
 179       if sharedEdges is not None:
 180         faceFiss = face
 181         edgePeauFiss = sharedEdges[0]
 182         geomPublishInFather(initLog.debug,partitionPeauFissByPipe, faceFiss, "faceFiss")
 183         geomPublishInFather(initLog.debug,faceFiss, edgePeauFiss, "edgePeauFiss")
 184         geomPublishInFather(initLog.debug,facePeau, edgePeauFiss, "edgePeauFiss")
 185         break
 186     except:
 187       pass
 188   verticesEdgePeauFiss = geompy.ExtractShapes(edgePeauFiss, geompy.ShapeType["VERTEX"], False)
 189
 190   # --- identification edges demi cercle dans face de peau
 191   edgesFacePeau = geompy.ExtractShapes(facePeau, geompy.ShapeType["EDGE"], False)
 192   edgesFacePeauSorted, minlg, maxlg = sortEdges(edgesFacePeau)
 193   demiCerclesPeau = edgesFacePeauSorted[0:4]
 194   verticesDemiCerclesPeau = list()
 195   for i, edge in enumerate(demiCerclesPeau):
 196     name = "demiCerclePeau_%d"%i
 197     geomPublishInFather(initLog.debug,facePeau, edge, name)
 198     verticesDemiCerclesPeau += geompy.ExtractShapes(edge, geompy.ShapeType["VERTEX"], False)
 199   verticesDemiCerclesPeau = eliminateDoubles(facePeau, verticesDemiCerclesPeau)
 200   for i, vertex in enumerate(verticesDemiCerclesPeau):
 201     name = "verticesDemiCerclesPeau_%d"%i
 202     geomPublishInFather(initLog.debug,facePeau, vertex, name)
 203   verticesOutCercles = substractSubShapes(facePeau, verticesDemiCerclesPeau, verticesEdgePeauFiss)
 204   for i, vertex in enumerate(verticesOutCercles):
 205     name = "verticesOutCercles_%d"%i
 206     geomPublishInFather(initLog.debug,facePeau, vertex, name)
 207
 208   # --- demi cercles  regroupés
 209   groupsDemiCerclesPeau = list()
 210   for i, vertex in enumerate(verticesEdgePeauFiss):
 211     demis = list()
 212     for edge in demiCerclesPeau:
 213       if geompy.MinDistance(vertex, edge) < 1.e-5:
 214         demis.append(edge)
 215     group = geompy.CreateGroup(facePeau, geompy.ShapeType["EDGE"])
 216     geompy.UnionList(group, demis)
 217     name = "Cercle%d"%i
 218     geomPublishInFather(initLog.debug,facePeau, group , name)
 219     groupsDemiCerclesPeau.append(group)
 220
 221   # --- identification edges commune pipe face fissure externe au pipe
 222   edgePeauFissId = geompy.GetSubShapeID(partitionPeauFissByPipe, edgePeauFiss)
 223   edgesFaceFiss = geompy.ExtractShapes(faceFiss, geompy.ShapeType["EDGE"], False)
 224   edgesFaceFissPipe = list()
 225   for edge in edgesFaceFiss:
 226     if geompy.GetSubShapeID(partitionPeauFissByPipe, edge) != edgePeauFissId:
 227       edgesFaceFissPipe.append(edge)
 228       name = "edgeFaceFissPipe_%d"%len(edgesFaceFissPipe)
 229       geomPublishInFather(initLog.debug,faceFiss, edge, name)
 230   groupEdgesFaceFissPipe = geompy.CreateGroup(faceFiss, geompy.ShapeType["EDGE"])
 231   geompy.UnionList(groupEdgesFaceFissPipe, edgesFaceFissPipe)
 232   geomPublishInFather(initLog.debug,faceFiss, groupEdgesFaceFissPipe, "edgesFaceFissPipe")
 233
 234   # -----------------------------------------------------------------------------
 235   # --- pipe de fond de fissure
 236
 237   wireFondFiss = geompy.MakeWire(edgesInside, 1e-07)
 238
 239   disque = geompy.MakeDiskPntVecR(centreFondFiss, tangentFondFiss, rayonPipe)
 240   [vertex] = geompy.ExtractShapes(disque, geompy.ShapeType["VERTEX"], False)
 241   vertproj = geompy.MakeProjection(vertex, planfiss)
 242   vec1 = geompy.MakeVector(centreFondFiss, vertex)
 243   try:
 244     # si centreFondFiss et vertproj sont proches: exception. Angle = +- 90°
 245     vec2 = geompy.MakeVector(centreFondFiss, vertproj)
 246     angle = geompy.GetAngleRadians(vec1, vec2)
 247   except:
 248     # on utilise la projection du centre sur la peau pour avoir un vecteur non nul
 249     vertproj = geompy.MakeProjection(centreFondFiss, facePeau)
 250     vec2 = geompy.MakeVector(centreFondFiss, vertproj)
 251     angle = geompy.GetAngleRadians(vec1, vec2)
 252   sommetAxe = geompy.MakeTranslationVector(centreFondFiss, tangentFondFiss)
 253   pm = produitMixte(centreFondFiss, vertex, vertproj, sommetAxe)
 254   if pm > 0:
 255     disque = geompy.MakeRotation(disque, tangentFondFiss, angle)
 256   else:
 257     disque = geompy.MakeRotation(disque, tangentFondFiss, -angle)
 258   [vertexReference] = geompy.ExtractShapes(disque, geompy.ShapeType["VERTEX"], False)
 259
 260   pipeFondFiss = geompy.MakePipe(disque, wireFondFiss)
 261   pipeFondFiss = geompy.MakePartition([pipeFondFiss], [planfiss, wireFondFiss, planBord1, planBord2], list(), list(), geompy.ShapeType["SOLID"], 0, list(), 0)
 262   #pipe = geompy.MakePipe(disque, WirePorteFondFissure)
 263   #pipe = geompy.MakePartition([pipe],[fillingFaceExterne], list(), list(), geompy.ShapeType["SOLID"], 0, list(), 0)
 264   #pipes = geompy.ExtractShapes(pipe, geompy.ShapeType["SOLID"], False)
 265   #pipesSorted, volmin, volmax = sortSolids(pipes)
 266   #pipeFondFiss = pipesSorted[-1]
 267   #pipeFondFiss = geompy.MakePartition([pipeFondFiss], [planfiss, wireFondFiss, planBord1, planBord2], list(), list(), geompy.ShapeType["SOLID"], 0, list(), 0)
 268
 269   geomPublish(initLog.debug,  disque, 'disque')
 270   geomPublish(initLog.debug,  wireFondFiss, 'wireFondFiss')
 271   geomPublish(initLog.debug,  pipeFondFiss, 'pipeFondFiss')
 272
 273   VerticesEndFondFiss = findWireEndVertices(wireFondFiss)
 274   for i, v in enumerate(VerticesEndFondFiss):
 275     name = "vertexEndFondFiss_%d"%i
 276     geomPublishInFather(initLog.debug,wireFondFiss, v, name)
 277   VerticesEndPipeFiss = list()
 278   for v in VerticesEndFondFiss:
 279     VerticesEndPipeFiss.append(geompy.GetInPlace(pipeFondFiss, v))
 280   for i, v in enumerate(VerticesEndPipeFiss):
 281     name = "vertexEndPipeFiss_%d"%i
 282     geomPublishInFather(initLog.debug,pipeFondFiss, v, name)
 283
 284   geomPublishInFather(initLog.debug,pipeFondFiss, VerticesEndPipeFiss[0], "PFOR")
 285   geomPublishInFather(initLog.debug,pipeFondFiss, VerticesEndPipeFiss[1], "PFEX")
 286   if geompy.MinDistance(VerticesEndPipeFiss[0], verticesOutCercles[0]) > geompy.MinDistance(VerticesEndPipeFiss[0], verticesOutCercles[1]):
 287     a = verticesOutCercles[0]
 288     verticesOutCercles[0] = verticesOutCercles[1]
 289     verticesOutCercles[1] = a
 290   geomPublishInFather(initLog.debug,facePeau, verticesOutCercles[0], "THOR")
 291   geomPublishInFather(initLog.debug,facePeau, verticesOutCercles[1], "THEX")
 292
 293   [facesPipeInside, facesPipeOutside, facesPipeOnside] = extractionOrientee(fillingFaceExterne, pipeFondFiss, centreFondFiss, "FACE", 0.1, "pipe_bord_")
 294   [edgesPipeInside, edgesPipeOutside, edgesPipeOnside] = extractionOrientee(fillingFaceExterne, pipeFondFiss, centreFondFiss, "EDGE", 0.1, "pipe_bord_")
 295   disqueInt1 = geompy.GetInPlaceByHistory(pipeFondFiss, planBord1)
 296   disqueInt2 = geompy.GetInPlaceByHistory(pipeFondFiss, planBord2)
 297   disques = facesPipeOnside + [disqueInt1, disqueInt2]
 298   edgesDiskInt = geompy.ExtractShapes(disqueInt1, geompy.ShapeType["EDGE"], False)
 299   edgesDiskInt = edgesDiskInt +geompy.ExtractShapes(disqueInt2, geompy.ShapeType["EDGE"], False)
 300   edgesSorted, minlg, maxlg = sortEdges(edgesDiskInt) # 4 rayons, 2 demi cercles
 301
 302   centre = geompy.MakeVertexOnSurface(planfiss, 0.5, 0.5)
 303   refpoint = geompy.MakeTranslationVector(centre, geompy.GetNormal(planfiss,centre))
 304   geomPublish(initLog.debug, refpoint, 'refpoint')
 305   [facesPipeInplan, facesPipeOutplan, facesPipeOnplan] = extractionOrientee(planfiss, pipeFondFiss, refpoint, "FACE", 0.1, "pipe_plan_")
 306   [edgesPipeInplan, edgesPipeOutplan, edgesPipeOnplan] = extractionOrientee(planfiss, pipeFondFiss, refpoint, "EDGE", 0.1, "pipe_plan_")
 307
 308   # --- rayon disques = (edgesPipeOnside inter edgesPipeOnplan) + rayons disque internes
 309   #     demi cercles  = edgesPipeOnside moins edgesPipeOnplan + demi cercles disque internes
 310   #     generatrices  = edgesPipeOnplan moins rayon disques (3 grandes et 6 petites)
 311   edgesIdPipeOnside = getSubshapeIds(pipeFondFiss, edgesPipeOnside)
 312   edgesIdPipeOnplan = getSubshapeIds(pipeFondFiss, edgesPipeOnplan)
 313   rayons = list()
 314   demiCercles = list()
 315   for i, edgeId in enumerate(edgesIdPipeOnside):
 316     if edgeId in edgesIdPipeOnplan:
 317       rayons.append(edgesPipeOnside[i])
 318     else:
 319       demiCercles.append(edgesPipeOnside[i])
 320   demiCerclesExternes = demiCercles
 321   rayons = rayons + edgesSorted[:4]            # les 4 plus petits sont les rayons
 322   demiCercles = demiCercles  + edgesSorted[4:] # les suivants sont les arcs de cercle
 323   rayonsId = getSubshapeIds(pipeFondFiss, rayons)
 324   generatrices = list()
 325   for i, edgeId in enumerate(edgesIdPipeOnplan):
 326     if edgeId not in rayonsId:
 327       generatrices.append(edgesPipeOnplan[i])
 328
 329   # --- generatrices en contact avec la face fissure externe au pipe
 330   generFiss = list()
 331   for edge in generatrices:
 332     distance = geompy.MinDistance(vertexReference, edge)
 333     logging.debug("distance %s", distance)
 334     if distance < 1.e-5:
 335       generFiss.append(edge)
 336       break
 337   for edge in generatrices:
 338     distance = geompy.MinDistance(generFiss[0], edge)
 339     logging.debug("distance %s", distance)
 340     if distance < 1.e-5:
 341       generFiss.append(edge)
 342   groupGenerFiss = geompy.CreateGroup(pipeFondFiss, geompy.ShapeType["EDGE"])
 343   geompy.UnionList(groupGenerFiss, generFiss)
 344   geomPublishInFather(initLog.debug,pipeFondFiss, groupGenerFiss, "GenFiss")
 345
 346   # --- demi cercles externes regroupés
 347   groupsDemiCerclesPipe = list()
 348   for i, vertex in enumerate(verticesEdgePeauFiss):
 349     demis = list()
 350     for edge in demiCerclesExternes:
 351       if geompy.MinDistance(vertex, edge) < 0.1:
 352         demis.append(edge)
 353     group = geompy.CreateGroup(pipeFondFiss, geompy.ShapeType["EDGE"])
 354     geompy.UnionList(group, demis)
 355     name = "Cercle%d"%i
 356     geomPublishInFather(initLog.debug,pipeFondFiss, group , name)
 357     groupsDemiCerclesPipe.append(group)
 358
 359   # --- faces fissure dans le pipe
 360
 361   facesFissinPipe = list()
 362   generFissId = getSubshapeIds(pipeFondFiss, generFiss)
 363   logging.debug("generatrice fissure %s", generFissId)
 364   for face in facesPipeOnplan:
 365     edges =geompy.ExtractShapes(face, geompy.ShapeType["EDGE"], False)
 366     edgesId = getSubshapeIds(pipeFondFiss, edges)
 367     logging.debug("  edges %s", edgesId)
 368     for i,edgeId in enumerate(edgesId):
 369       if edgeId in generFissId:
 370         logging.debug("face found")
 371         facesFissinPipe.append(face)
 372         name = "faceFissInPipe_%d"%i
 373         geomPublishInFather(initLog.debug,pipeFondFiss, face, name)
 374         break
 375   groupFaceFissInPipe = geompy.CreateGroup(pipeFondFiss, geompy.ShapeType["FACE"])
 376   geompy.UnionList(groupFaceFissInPipe, facesFissinPipe)
 377   name = "FaceFissInPipe"
 378   geomPublishInFather(initLog.debug,pipeFondFiss, groupFaceFissInPipe , name)
 379
 380   # --- edges de fond de fissure
 381
 382   edgesFondFiss = list()
 383   for i, edge in enumerate(edgesInside):
 384     anEdge = geompy.GetInPlace(pipeFondFiss, edge)
 385     logging.debug("  edge %s ", anEdge)
 386     edgesFondFiss.append(anEdge)
 387     name ="edgeFondFissure_%d"%i
 388     geomPublishInFather(initLog.debug,pipeFondFiss, anEdge, name)
 389   groupEdgeFondFiss = geompy.CreateGroup(pipeFondFiss, geompy.ShapeType["EDGE"])
 390   geompy.UnionList(groupEdgeFondFiss, edgesFondFiss)
 391   name = "FONDFISS"
 392   geomPublishInFather(initLog.debug,pipeFondFiss, groupEdgeFondFiss , name)
 393
 394   # -------------------------------------------------------------------------
 395   # --- maillage
 396
 397   # --- edges de bord face defaut à respecter
 398
 399   aFilterManager = smesh.CreateFilterManager()
 400   nbAdded, internalBoundary, _NoneGroup = internalBoundary.MakeBoundaryElements( SMESH.BND_1DFROM2D, '', '', 0, [  ])
 401   criteres = list()
 402   unCritere = smesh.GetCriterion(SMESH.EDGE,SMESH.FT_FreeBorders,SMESH.FT_Undefined,0)
 403   criteres.append(unCritere)
 404   filtre = smesh.GetFilterFromCriteria(criteres)
 405   bordsLibres = internalBoundary.MakeGroupByFilter( 'bords', filtre )
 406   smesh.SetName(bordsLibres, 'bordsLibres')
 407
 408   # --- pour aider l'algo hexa-tetra a ne pas mettre de pyramides a l'exterieur des volumes replies sur eux-memes
 409   #     on designe les faces de peau en quadrangles par le groupe "skinFaces"
 410
 411   skinFaces = internalBoundary.CreateEmptyGroup( SMESH.FACE, 'skinFaces' )
 412   nbAdd = skinFaces.AddFrom( internalBoundary.GetMesh() )
 413
 414   # --- maillage pipe fond fissure
 415
 416   meshFondFiss, groups_demiCercles, group_generFiss, nbSegGenLong, nbSegGenBout = \
 417             insereFissureLongue_a (pipeFondFiss, disques, rayons, demiCercles, demiCerclesPeau, generatrices, \
 418             VerticesEndPipeFiss, verticesEdgePeauFiss, \
 419             groupFaceFissInPipe, groupEdgeFondFiss, groupsDemiCerclesPipe, groupGenerFiss, \
 420             profondeur, rayonPipe, distance2)
 421
 422   # --- maillage face de peau
 423
 424   meshFacePeau, groupEdgesPeauFiss = \
 425             insereFissureLongue_b ( facePeau, edgePeauFiss, groupEdgesBordPeau, bordsLibres, \
 426                                     groupsDemiCerclesPeau, groups_demiCercles, verticesOutCercles, \
 427                                     nbSegGenLong, nbSegGenBout, profondeur, \
 428                                     mailleur )
 429
 430   # --- maillage face de fissure
 431
 432   meshFaceFiss = \
 433             insereFissureLongue_c ( faceFiss, edgePeauFiss, groupEdgesPeauFiss, group_generFiss, groupEdgesFaceFissPipe, \
 434                                     profondeur, rayonPipe, \
 435                                     mailleur )
 436
 437   # --- maillage meshBoiteDefaut
 438
 439   meshBoiteDefaut, group_faceFissInPipe, group_faceFissOutPipe = \
 440             insereFissureLongue_d ( internalBoundary, meshFondFiss, meshFacePeau, meshFaceFiss, \
 441                                     mailleur )
 442
 443
 444   groups = maillageSain.GetGroups()
 445   grps1 = [ grp for grp in groups if grp.GetName() == 'P1']
 446   grps2 = [ grp for grp in groups if grp.GetName() == 'P2']
 447   coords1 = maillageSain.GetNodeXYZ(grps1[0].GetID(1))
 448   coords2 = maillageSain.GetNodeXYZ(grps2[0].GetID(1))
 449   logging.info("coords1 %s, coords2 %s",coords1, coords2)
 450
 451   faceFissure = meshBoiteDefaut.GetMesh().UnionListOfGroups( [ group_faceFissOutPipe, group_faceFissInPipe ], 'FACE1' )
 452   maillageSain = enleveDefaut(maillageSain, zoneDefaut, zoneDefaut_skin, zoneDefaut_internalFaces, zoneDefaut_internalEdges)
 453   putName(maillageSain, nomFicSain+"_coupe")
 454   extrusionFaceFissure, normfiss = shapeSurFissure(facePorteFissure)
 455   maillageComplet = RegroupeSainEtDefaut(maillageSain, meshBoiteDefaut, extrusionFaceFissure, facePorteFissure, 'COUDE')
 456
 457   groups = maillageComplet.GetGroups()
 458   grps1 = [ grp for grp in groups if grp.GetName() == 'P1']
 459   grps2 = [ grp for grp in groups if grp.GetName() == 'P2']
 460   nodeid1 = maillageComplet.AddNode(coords1[0], coords1[1], coords1[2])
 461   nodeid2 = maillageComplet.AddNode(coords2[0], coords2[1], coords2[2])
 462   grps1[0].Add([nodeid1])
 463   grps2[0].Add([nodeid2])
 464   ma0d1 = maillageComplet.Add0DElement(nodeid1)
 465   ma0d2 = maillageComplet.Add0DElement(nodeid2)
 466   grpma0d1 = maillageComplet.CreateEmptyGroup( SMESH.ELEM0D, 'P1' )
 467   nbAdd = grpma0d1.Add( [ma0d1] )
 468   grpma0d2 = maillageComplet.CreateEmptyGroup( SMESH.ELEM0D, 'P2' )
 469   nbAdd = grpma0d2.Add( [ma0d2] )
 470
 471 #  grps = [ grp for grp in groups if grp.GetName() == 'affectedEdges']
 472 #  grps[0].SetName('affEdges')
 473 #  grps = [ grp for grp in groups if grp.GetName() == 'affectedFaces']
 474 #  grps[0].SetName('affFaces')
 475 #  grps = [ grp for grp in groups if grp.GetName() == 'affectedVolumes']
 476 #  grps[0].SetName('affVols')
 477
 478   maillageComplet.ConvertToQuadratic( 1 )
 479   grps = [ grp for grp in groups if grp.GetName() == 'FONDFISS']
 480   fond = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FONDFISS' )
 481
 482   grps = [ grp for grp in groups if grp.GetName() == 'FACE1']
 483   nb = maillageComplet.Reorient2D( grps[0], normfiss, grps[0].GetID(1))
 484
 485   plansim = geompy.MakePlane(O, normfiss, 10000)
 486   fissnorm = geompy.MakeMirrorByPlane(normfiss, plansim)
 487   grps = [ grp for grp in groups if grp.GetName() == 'FACE2']
 488   nb = maillageComplet.Reorient2D( grps[0], fissnorm, grps[0].GetID(1))
 489   #isDone = maillageComplet.ReorientObject( grps[0] )
 490   fond = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FACE2' )
 491
 492   maillageComplet.ExportMED(fichierMaillageFissure)
 493   putName(maillageComplet, nomFicFissure)
 494   logging.info("fichier maillage fissure %s", fichierMaillageFissure)
 495
 496   if salome.sg.hasDesktop():
 497     salome.sg.updateObjBrowser()
 498
 499   return  maillageComplet