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