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