src/Tools/blocFissure/gmu/insereFissureLongue.py

   1 # -*- coding: utf-8 -*-
   2 # Copyright (C) 2014-2021  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 logging
  22 import salome
  23 from .geomsmesh import geompy
  24 from .geomsmesh import geomPublish
  25 from .geomsmesh import geomPublishInFather
  26 from . import initLog
  27 from .geomsmesh import smesh
  28 from salome.smesh import smeshBuilder
  29 import SMESH
  30 import math
  31
  32 from .extractionOrientee import extractionOrientee
  33 from .sortFaces import sortFaces
  34 from .sortEdges import sortEdges
  35 from .eliminateDoubles import eliminateDoubles
  36 from .substractSubShapes import substractSubShapes
  37 from .produitMixte import produitMixte
  38 from .findWireEndVertices import findWireEndVertices
  39 from .getSubshapeIds import getSubshapeIds
  40 from .putName import putName
  41 from .distance2 import distance2
  42 from .enleveDefaut import enleveDefaut
  43 from .shapeSurFissure import shapeSurFissure
  44 from .regroupeSainEtDefaut import RegroupeSainEtDefaut
  45 from .triedreBase import triedreBase
  46
  47 # -----------------------------------------------------------------------------
  48 # --- procedure complete fissure longue
  49
  50 def insereFissureLongue(geometriesSaines, maillagesSains,
  51                         shapesFissure, shapeFissureParams,
  52                         maillageFissureParams, elementsDefaut, step=-1):
  53   """
  54   TODO: a completer
  55   """
  56   logging.info('start')
  57
  58   #geometrieSaine    = geometriesSaines[0]
  59   #maillageSain      = maillagesSains[0]
  60   #isHexa            = maillagesSains[1]
  61   shapeDefaut       = shapesFissure[0] # face de fissure, debordant
  62   #tailleDefaut      = shapesFissure[2]
  63   wiretube          = shapesFissure[4] # wire fond de fissure, debordant
  64   planfiss          = shapesFissure[7] # plan de fissure
  65   pipefiss          = shapesFissure[8] # pipe, debordant
  66
  67   profondeur  = shapeFissureParams['profondeur']
  68   rayonPipe   = profondeur/4.0
  69
  70   nomRep            = maillageFissureParams['nomRep']
  71   nomFicSain        = maillageFissureParams['nomFicSain']
  72   nomFicFissure     = maillageFissureParams['nomFicFissure']
  73
  74   #nbsegExt          = maillageFissureParams['nbsegExt']      # 5
  75   #nbsegGen          = maillageFissureParams['nbsegGen']      # 25
  76   #nbsegRad          = maillageFissureParams['nbsegRad']      # 5
  77   #scaleRad          = maillageFissureParams['scaleRad']      # 4
  78   #nbsegCercle       = maillageFissureParams['nbsegCercle']   # 6
  79   #nbsegFis          = maillageFissureParams['nbsegFis']      # 20
  80   #lensegEllipsoide  = maillageFissureParams['lensegEllipso'] # 1.0
  81
  82   #fichierMaillageSain = nomRep + '/' + nomFicSain + '.med'
  83   fichierMaillageFissure = nomRep + '/' + nomFicFissure + '.med'
  84
  85   facesDefaut              = elementsDefaut[0]
  86   #centreDefaut             = elementsDefaut[1]
  87   #normalDefaut             = elementsDefaut[2]
  88   #extrusionDefaut          = elementsDefaut[3]
  89   #dmoyen                   = elementsDefaut[4]
  90   #bordsPartages            = elementsDefaut[5]
  91   #fillconts                = elementsDefaut[6]
  92   #idFilToCont              = elementsDefaut[7]
  93   maillageSain             = elementsDefaut[8]
  94   internalBoundary         = elementsDefaut[9]
  95   zoneDefaut               = elementsDefaut[10]
  96   zoneDefaut_skin          = elementsDefaut[11]
  97   zoneDefaut_internalFaces = elementsDefaut[12]
  98   zoneDefaut_internalEdges = elementsDefaut[13]
  99
 100   facePorteFissure =  shapeDefaut
 101   WirePorteFondFissure = wiretube
 102   fillingFaceExterne = facesDefaut[0]
 103   logging.debug("fillingFaceExterne %s", fillingFaceExterne)
 104   geomPublish(initLog.debug, fillingFaceExterne, "fillingFaceExterne")
 105   edgesFilling = geompy.ExtractShapes(fillingFaceExterne, geompy.ShapeType["EDGE"], False)
 106
 107   O, OX, OY, OZ = triedreBase()
 108
 109   # -----------------------------------------------------------------------------
 110   # --- peau et face de fissure
 111
 112   # --- partition peau defaut - face de fissure prolongee - wire de fond de fissure prolongée
 113   partitionPeauFissFond = geompy.MakePartition([facePorteFissure, WirePorteFondFissure, fillingFaceExterne], [], [], [], geompy.ShapeType["FACE"], 0, [], 0)
 114   geomPublish(initLog.debug,  partitionPeauFissFond, 'partitionPeauFissFond' )
 115
 116   edges = geompy.ExtractShapes(WirePorteFondFissure, geompy.ShapeType["EDGE"], False)
 117
 118   lgmax = 0
 119   imax = 0
 120   for i, edge in enumerate(edges):
 121     props = geompy.BasicProperties(edge)
 122     lg = props[0]
 123     if lg > lgmax:
 124       lgmax = lg
 125       imax = i
 126   edgemax = edges[imax]
 127   geomPublish(initLog.debug, edgemax, 'edgemax')
 128   centreFondFiss = geompy.MakeVertexOnCurve(edgemax, 0.5)
 129   geomPublish(initLog.debug, centreFondFiss, 'centreFondFiss')
 130   tangentFondFiss = geompy.MakeTangentOnCurve(edgemax, 0.5)
 131   geomPublish(initLog.debug, tangentFondFiss, 'tangentFondFiss')
 132
 133   bord1FondFiss = geompy.MakeVertexOnCurve(edgemax, 0.0)
 134   geomPublish(initLog.debug, bord1FondFiss, 'bord1FondFiss')
 135   tangentBord1FondFiss = geompy.MakeTangentOnCurve(edgemax, 0.0)
 136   geomPublish(initLog.debug, tangentBord1FondFiss, 'tangentBord1FondFiss')
 137
 138   bord2FondFiss = geompy.MakeVertexOnCurve(edgemax, 1.0)
 139   geomPublish(initLog.debug, bord2FondFiss, 'bord2FondFiss')
 140   tangentBord2FondFiss = geompy.MakeTangentOnCurve(edgemax, 1.0)
 141   geomPublish(initLog.debug, tangentBord2FondFiss, 'tangentBord2FondFiss')
 142
 143   planBord1 = geompy.MakePlane(bord1FondFiss, tangentBord1FondFiss, 3*rayonPipe)
 144   planBord2 = geompy.MakePlane(bord2FondFiss, tangentBord2FondFiss, 3*rayonPipe)
 145   geomPublish(initLog.debug, planBord1, 'planBord1')
 146   geomPublish(initLog.debug, planBord2, 'planBord2')
 147
 148   [edgesInside, edgesOutside, edgesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "EDGE", 1.e-3)
 149   [facesInside, facesOutside, facesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "FACE", 1.e-3)
 150
 151   # --- partition peau -face fissure - pipe fond de fissure prolongé
 152   partitionPeauFissByPipe = geompy.MakePartition([facesInside[0], facesOnside[0]], [pipefiss], [], [], geompy.ShapeType["FACE"], 0, [], 0)
 153   geomPublish(initLog.debug,  partitionPeauFissByPipe, 'partitionPeauFissByPipe' )
 154
 155   # --- identification face de peau
 156   [facesPeauFissInside, facesPeauFissOutside, facesPeauFissOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissByPipe, centreFondFiss, "FACE", 0.1, "peauFiss_bord_")
 157   facesPeauSorted, minsur, maxsurf = sortFaces(facesPeauFissOnside) # 4 demi disques, une grande face
 158   facePeau = facesPeauSorted[-1] # la plus grande face
 159   geomPublishInFather(initLog.debug,partitionPeauFissByPipe, facePeau, "facePeau")
 160
 161   # --- identification edges de bord face peau
 162   edgesBords = []
 163   for i, edge in enumerate(edgesFilling):
 164     edgepeau = geompy.GetInPlace(facePeau, edge)
 165     edgesBords.append(edgepeau)
 166   groupEdgesBordPeau = geompy.CreateGroup(facePeau, geompy.ShapeType["EDGE"])
 167   geompy.UnionList(groupEdgesBordPeau, edgesBords)
 168   geomPublishInFather(initLog.debug,facePeau, groupEdgesBordPeau , "EdgesBords")
 169
 170   # --- identification face fissure externe au pipe et edge commune peau fissure
 171   for face in facesPeauFissInside:
 172     try:
 173       sharedEdges = geompy.GetSharedShapesMulti([facePeau, face], geompy.ShapeType["EDGE"])
 174       if sharedEdges is not None:
 175         faceFiss = face
 176         edgePeauFiss = sharedEdges[0]
 177         geomPublishInFather(initLog.debug,partitionPeauFissByPipe, faceFiss, "faceFiss")
 178         geomPublishInFather(initLog.debug,faceFiss, edgePeauFiss, "edgePeauFiss")
 179         geomPublishInFather(initLog.debug,facePeau, edgePeauFiss, "edgePeauFiss")
 180         break
 181     except:
 182       pass
 183   verticesEdgePeauFiss = geompy.ExtractShapes(edgePeauFiss, geompy.ShapeType["VERTEX"], False)
 184
 185   # --- identification edges demi cercle dans face de peau
 186   edgesFacePeau = geompy.ExtractShapes(facePeau, geompy.ShapeType["EDGE"], False)
 187   edgesFacePeauSorted, minlg, maxlg = sortEdges(edgesFacePeau)
 188   demiCerclesPeau = edgesFacePeauSorted[0:4]
 189   verticesDemiCerclesPeau = []
 190   for i, edge in enumerate(demiCerclesPeau):
 191     name = "demiCerclePeau_%d"%i
 192     geomPublishInFather(initLog.debug,facePeau, edge, name)
 193     verticesDemiCerclesPeau += geompy.ExtractShapes(edge, geompy.ShapeType["VERTEX"], False)
 194   verticesDemiCerclesPeau = eliminateDoubles(facePeau, verticesDemiCerclesPeau)
 195   for i, vertex in enumerate(verticesDemiCerclesPeau):
 196     name = "verticesDemiCerclesPeau_%d"%i
 197     geomPublishInFather(initLog.debug,facePeau, vertex, name)
 198   verticesOutCercles = substractSubShapes(facePeau, verticesDemiCerclesPeau, verticesEdgePeauFiss)
 199   for i, vertex in enumerate(verticesOutCercles):
 200     name = "verticesOutCercles_%d"%i
 201     geomPublishInFather(initLog.debug,facePeau, vertex, name)
 202
 203   # --- demi cercles  regroupés
 204   groupsDemiCerclesPeau = []
 205   for i, vertex in enumerate(verticesEdgePeauFiss):
 206     demis = []
 207     for edge in demiCerclesPeau:
 208       if geompy.MinDistance(vertex, edge) < 1.e-5:
 209         demis.append(edge)
 210     group = geompy.CreateGroup(facePeau, geompy.ShapeType["EDGE"])
 211     geompy.UnionList(group, demis)
 212     name = "Cercle%d"%i
 213     geomPublishInFather(initLog.debug,facePeau, group , name)
 214     groupsDemiCerclesPeau.append(group)
 215
 216   # --- identification edges commune pipe face fissure externe au pipe
 217   edgePeauFissId = geompy.GetSubShapeID(partitionPeauFissByPipe, edgePeauFiss)
 218   edgesFaceFiss = geompy.ExtractShapes(faceFiss, geompy.ShapeType["EDGE"], False)
 219   edgesFaceFissPipe = []
 220   for edge in edgesFaceFiss:
 221     if geompy.GetSubShapeID(partitionPeauFissByPipe, edge) != edgePeauFissId:
 222       edgesFaceFissPipe.append(edge)
 223       name = "edgeFaceFissPipe_%d"%len(edgesFaceFissPipe)
 224       geomPublishInFather(initLog.debug,faceFiss, edge, name)
 225   groupEdgesFaceFissPipe = geompy.CreateGroup(faceFiss, geompy.ShapeType["EDGE"])
 226   geompy.UnionList(groupEdgesFaceFissPipe, edgesFaceFissPipe)
 227   geomPublishInFather(initLog.debug,faceFiss, groupEdgesFaceFissPipe, "edgesFaceFissPipe")
 228
 229   # -----------------------------------------------------------------------------
 230   # --- pipe de fond de fissure
 231
 232   wireFondFiss = geompy.MakeWire(edgesInside, 1e-07)
 233
 234   disque = geompy.MakeDiskPntVecR(centreFondFiss, tangentFondFiss, rayonPipe)
 235   [vertex] = geompy.ExtractShapes(disque, geompy.ShapeType["VERTEX"], False)
 236   vertproj = geompy.MakeProjection(vertex, planfiss)
 237   vec1 = geompy.MakeVector(centreFondFiss, vertex)
 238   try:
 239     # si centreFondFiss et vertproj sont proches: exception. Angle = +- 90°
 240     vec2 = geompy.MakeVector(centreFondFiss, vertproj)
 241     angle = geompy.GetAngleRadians(vec1, vec2)
 242   except:
 243     # on utilise la projection du centre sur la peau pour avoir un vecteur non nul
 244     vertproj = geompy.MakeProjection(centreFondFiss, facePeau)
 245     vec2 = geompy.MakeVector(centreFondFiss, vertproj)
 246     angle = geompy.GetAngleRadians(vec1, vec2)
 247   sommetAxe = geompy.MakeTranslationVector(centreFondFiss, tangentFondFiss)
 248   pm = produitMixte(centreFondFiss, vertex, vertproj, sommetAxe)
 249   if pm > 0:
 250     disque = geompy.MakeRotation(disque, tangentFondFiss, angle)
 251   else:
 252     disque = geompy.MakeRotation(disque, tangentFondFiss, -angle)
 253   [vertexReference] = geompy.ExtractShapes(disque, geompy.ShapeType["VERTEX"], False)
 254
 255   pipeFondFiss = geompy.MakePipe(disque, wireFondFiss)
 256   pipeFondFiss = geompy.MakePartition([pipeFondFiss], [planfiss, wireFondFiss, planBord1, planBord2], [], [], geompy.ShapeType["SOLID"], 0, [], 0)
 257   #pipe = geompy.MakePipe(disque, WirePorteFondFissure)
 258   #pipe = geompy.MakePartition([pipe],[fillingFaceExterne], [], [], geompy.ShapeType["SOLID"], 0, [], 0)
 259   #pipes = geompy.ExtractShapes(pipe, geompy.ShapeType["SOLID"], False)
 260   #pipesSorted, volmin, volmax = sortSolids(pipes)
 261   #pipeFondFiss = pipesSorted[-1]
 262   #pipeFondFiss = geompy.MakePartition([pipeFondFiss], [planfiss, wireFondFiss, planBord1, planBord2], [], [], geompy.ShapeType["SOLID"], 0, [], 0)
 263
 264   geomPublish(initLog.debug,  disque, 'disque')
 265   geomPublish(initLog.debug,  wireFondFiss, 'wireFondFiss')
 266   geomPublish(initLog.debug,  pipeFondFiss, 'pipeFondFiss')
 267
 268   VerticesEndFondFiss = findWireEndVertices(wireFondFiss)
 269   for i, v in enumerate(VerticesEndFondFiss):
 270     name = "vertexEndFondFiss_%d"%i
 271     geomPublishInFather(initLog.debug,wireFondFiss, v, name)
 272   VerticesEndPipeFiss = []
 273   for v in VerticesEndFondFiss:
 274     VerticesEndPipeFiss.append(geompy.GetInPlace(pipeFondFiss, v))
 275   for i, v in enumerate(VerticesEndPipeFiss):
 276     name = "vertexEndPipeFiss_%d"%i
 277     geomPublishInFather(initLog.debug,pipeFondFiss, v, name)
 278
 279   geomPublishInFather(initLog.debug,pipeFondFiss, VerticesEndPipeFiss[0], "PFOR")
 280   geomPublishInFather(initLog.debug,pipeFondFiss, VerticesEndPipeFiss[1], "PFEX")
 281   if geompy.MinDistance(VerticesEndPipeFiss[0], verticesOutCercles[0]) > geompy.MinDistance(VerticesEndPipeFiss[0], verticesOutCercles[1]):
 282     a = verticesOutCercles[0]
 283     verticesOutCercles[0] = verticesOutCercles[1]
 284     verticesOutCercles[1] = a
 285   geomPublishInFather(initLog.debug,facePeau, verticesOutCercles[0], "THOR")
 286   geomPublishInFather(initLog.debug,facePeau, verticesOutCercles[1], "THEX")
 287
 288   [facesPipeInside, facesPipeOutside, facesPipeOnside] = extractionOrientee(fillingFaceExterne, pipeFondFiss, centreFondFiss, "FACE", 0.1, "pipe_bord_")
 289   [edgesPipeInside, edgesPipeOutside, edgesPipeOnside] = extractionOrientee(fillingFaceExterne, pipeFondFiss, centreFondFiss, "EDGE", 0.1, "pipe_bord_")
 290   disqueInt1 = geompy.GetInPlaceByHistory(pipeFondFiss, planBord1)
 291   disqueInt2 = geompy.GetInPlaceByHistory(pipeFondFiss, planBord2)
 292   disques = facesPipeOnside + [disqueInt1, disqueInt2]
 293   edgesDiskInt = geompy.ExtractShapes(disqueInt1, geompy.ShapeType["EDGE"], False)
 294   edgesDiskInt = edgesDiskInt +geompy.ExtractShapes(disqueInt2, geompy.ShapeType["EDGE"], False)
 295   edgesSorted, minlg, maxlg = sortEdges(edgesDiskInt) # 4 rayons, 2 demi cercles
 296
 297   centre = geompy.MakeVertexOnSurface(planfiss, 0.5, 0.5)
 298   refpoint = geompy.MakeTranslationVector(centre, geompy.GetNormal(planfiss,centre))
 299   geomPublish(initLog.debug, refpoint, 'refpoint')
 300   [facesPipeInplan, facesPipeOutplan, facesPipeOnplan] = extractionOrientee(planfiss, pipeFondFiss, refpoint, "FACE", 0.1, "pipe_plan_")
 301   [edgesPipeInplan, edgesPipeOutplan, edgesPipeOnplan] = extractionOrientee(planfiss, pipeFondFiss, refpoint, "EDGE", 0.1, "pipe_plan_")
 302
 303   # --- rayon disques = (edgesPipeOnside inter edgesPipeOnplan) + rayons disque internes
 304   #     demi cercles  = edgesPipeOnside moins edgesPipeOnplan + demi cercles disque internes
 305   #     generatrices  = edgesPipeOnplan moins rayon disques (3 grandes et 6 petites)
 306   edgesIdPipeOnside = getSubshapeIds(pipeFondFiss, edgesPipeOnside)
 307   edgesIdPipeOnplan = getSubshapeIds(pipeFondFiss, edgesPipeOnplan)
 308   rayons = []
 309   demiCercles = []
 310   for i, edgeId in enumerate(edgesIdPipeOnside):
 311     if edgeId in edgesIdPipeOnplan:
 312       rayons.append(edgesPipeOnside[i])
 313     else:
 314       demiCercles.append(edgesPipeOnside[i])
 315   demiCerclesExternes = demiCercles
 316   rayons = rayons + edgesSorted[:4]            # les 4 plus petits sont les rayons
 317   demiCercles = demiCercles  + edgesSorted[4:] # les suivants sont les arcs de cercle
 318   rayonsId = getSubshapeIds(pipeFondFiss, rayons)
 319   generatrices = []
 320   for i, edgeId in enumerate(edgesIdPipeOnplan):
 321     if edgeId not in rayonsId:
 322       generatrices.append(edgesPipeOnplan[i])
 323
 324   # --- generatrices en contact avec la face fissure externe au pipe
 325   generFiss = []
 326   for edge in generatrices:
 327     distance = geompy.MinDistance(vertexReference, edge)
 328     logging.debug("distance %s", distance)
 329     if distance < 1.e-5:
 330       generFiss.append(edge)
 331       break
 332   for edge in generatrices:
 333     distance = geompy.MinDistance(generFiss[0], edge)
 334     logging.debug("distance %s", distance)
 335     if distance < 1.e-5:
 336       generFiss.append(edge)
 337   groupGenerFiss = geompy.CreateGroup(pipeFondFiss, geompy.ShapeType["EDGE"])
 338   geompy.UnionList(groupGenerFiss, generFiss)
 339   geomPublishInFather(initLog.debug,pipeFondFiss, groupGenerFiss, "GenFiss")
 340
 341   # --- demi cercles externes regroupés
 342   groupsDemiCerclesPipe = []
 343   for i, vertex in enumerate(verticesEdgePeauFiss):
 344     demis = []
 345     for edge in demiCerclesExternes:
 346       if geompy.MinDistance(vertex, edge) < 0.1:
 347         demis.append(edge)
 348     group = geompy.CreateGroup(pipeFondFiss, geompy.ShapeType["EDGE"])
 349     geompy.UnionList(group, demis)
 350     name = "Cercle%d"%i
 351     geomPublishInFather(initLog.debug,pipeFondFiss, group , name)
 352     groupsDemiCerclesPipe.append(group)
 353
 354   # --- faces fissure dans le pipe
 355
 356   facesFissinPipe = []
 357   generFissId = getSubshapeIds(pipeFondFiss, generFiss)
 358   logging.debug("generatrice fissure %s", generFissId)
 359   for face in facesPipeOnplan:
 360     edges =geompy.ExtractShapes(face, geompy.ShapeType["EDGE"], False)
 361     edgesId = getSubshapeIds(pipeFondFiss, edges)
 362     logging.debug("  edges %s", edgesId)
 363     for i,edgeId in enumerate(edgesId):
 364       if edgeId in generFissId:
 365         logging.debug("face found")
 366         facesFissinPipe.append(face)
 367         name = "faceFissInPipe_%d"%i
 368         geomPublishInFather(initLog.debug,pipeFondFiss, face, name)
 369         break
 370   groupFaceFissInPipe = geompy.CreateGroup(pipeFondFiss, geompy.ShapeType["FACE"])
 371   geompy.UnionList(groupFaceFissInPipe, facesFissinPipe)
 372   name = "FaceFissInPipe"
 373   geomPublishInFather(initLog.debug,pipeFondFiss, groupFaceFissInPipe , name)
 374
 375   # --- edges de fond de fissure
 376
 377   edgesFondFiss = []
 378   for i, edge in enumerate(edgesInside):
 379     anEdge = geompy.GetInPlace(pipeFondFiss, edge)
 380     logging.debug("  edge %s ", anEdge)
 381     edgesFondFiss.append(anEdge)
 382     name ="edgeFondFissure_%d"%i
 383     geomPublishInFather(initLog.debug,pipeFondFiss, anEdge, name)
 384   groupEdgeFondFiss = geompy.CreateGroup(pipeFondFiss, geompy.ShapeType["EDGE"])
 385   geompy.UnionList(groupEdgeFondFiss, edgesFondFiss)
 386   name = "FONDFISS"
 387   geomPublishInFather(initLog.debug,pipeFondFiss, groupEdgeFondFiss , name)
 388
 389   # -------------------------------------------------------------------------
 390   # --- maillage
 391
 392   # --- edges de bord face defaut à respecter
 393
 394   aFilterManager = smesh.CreateFilterManager()
 395   nbAdded, internalBoundary, _NoneGroup = internalBoundary.MakeBoundaryElements( SMESH.BND_1DFROM2D, '', '', 0, [  ])
 396   criteres = []
 397   unCritere = smesh.GetCriterion(SMESH.EDGE,SMESH.FT_FreeBorders,SMESH.FT_Undefined,0)
 398   criteres.append(unCritere)
 399   filtre = smesh.GetFilterFromCriteria(criteres)
 400   bordsLibres = internalBoundary.MakeGroupByFilter( 'bords', filtre )
 401   smesh.SetName(bordsLibres, 'bordsLibres')
 402
 403   # --- pour aider l'algo hexa-tetra a ne pas mettre de pyramides a l'exterieur des volumes replies sur eux-memes
 404   #     on designe les faces de peau en quadrangles par le groupe "skinFaces"
 405
 406   skinFaces = internalBoundary.CreateEmptyGroup( SMESH.FACE, 'skinFaces' )
 407   nbAdd = skinFaces.AddFrom( internalBoundary.GetMesh() )
 408
 409   # --- maillage pipe fond fissure
 410
 411   meshFondFiss = smesh.Mesh(pipeFondFiss)
 412   algo2d = meshFondFiss.Quadrangle(algo=smeshBuilder.QUADRANGLE)
 413   algo3d = meshFondFiss.Prism()
 414   putName(algo3d.GetSubMesh(), "pipe")
 415   putName(algo3d, "algo3d_pipe")
 416   putName(algo2d, "algo2d_pipe")
 417
 418   for i, face in enumerate(disques):
 419     algo2d = meshFondFiss.Quadrangle(algo=smeshBuilder.RADIAL_QUAD,geom=face)
 420     putName(algo2d.GetSubMesh(), "disque", i)
 421     putName(algo2d, "algo2d_disque", i)
 422
 423   for i, edge in enumerate(rayons):
 424     algo1d = meshFondFiss.Segment(geom=edge)
 425     hypo1d = algo1d.NumberOfSegments(4)
 426     putName(algo1d.GetSubMesh(), "rayon", i)
 427     putName(algo1d, "algo1d_rayon", i)
 428     putName(hypo1d, "hypo1d_rayon", i)
 429
 430   for i, edge in enumerate(demiCercles):
 431     algo1d = meshFondFiss.Segment(geom=edge)
 432     hypo1d = algo1d.NumberOfSegments(6)
 433     putName(algo1d.GetSubMesh(), "demiCercle", i)
 434     putName(algo1d, "algo1d_demiCercle", i)
 435     putName(hypo1d, "hypo1d_demiCercle", i)
 436
 437   generSorted, minlg, maxlg = sortEdges(generatrices)
 438   nbSegGenLong = int(math.sqrt(3.0)*maxlg/(profondeur - rayonPipe)) # on veut 2 triangles equilateraux dans la largeur de la face
 439   nbSegGenBout = 6
 440   logging.info("min %s, max %s, nombre de segments %s, nombre de generatrices %s", minlg, maxlg, nbSegGenLong, len(generSorted))
 441   for i, edge in enumerate(generSorted):
 442     algo1d = meshFondFiss.Segment(geom=edge)
 443     if i < 6:
 444       hypo1d = algo1d.NumberOfSegments(nbSegGenBout)
 445     else:
 446       hypo1d = algo1d.NumberOfSegments(nbSegGenLong)
 447     putName(algo1d.GetSubMesh(), "generatrice", i)
 448     putName(algo1d, "algo1d_generatrice", i)
 449     putName(hypo1d, "hypo1d_generatrice", i)
 450   isDone = meshFondFiss.Compute()
 451   logging.info("meshFondFiss computed")
 452
 453   disks = []
 454   for i, face in enumerate(disques[:4]):
 455     name = "disk%d"%i
 456     disks.append(meshFondFiss.GroupOnGeom(face, name, SMESH.FACE))
 457   peauext_pipe = meshFondFiss.GetMesh().UnionListOfGroups( disks, 'PEAUEXT' )
 458
 459   grpPFOR = meshFondFiss.GroupOnGeom(VerticesEndPipeFiss[0], "PFOR", SMESH.NODE)
 460   grpPFEX = meshFondFiss.GroupOnGeom(VerticesEndPipeFiss[1], "PFEX", SMESH.NODE)
 461
 462   grp = meshFondFiss.GroupOnGeom(groupFaceFissInPipe, "fisInPi", SMESH.FACE)
 463   group_edgeFondFiss = meshFondFiss.GroupOnGeom(groupEdgeFondFiss, "FONDFISS", SMESH.EDGE)
 464   noeudsFondFissure = meshFondFiss.GroupOnGeom(groupEdgeFondFiss, "nfondfis", SMESH.NODE)
 465   groups_demiCercles = []
 466   groupnodes_demiCercles = []
 467   for i, group in enumerate(groupsDemiCerclesPipe):
 468     name = "Cercle%d"%i
 469     groups_demiCercles.append(meshFondFiss.GroupOnGeom(group, name, SMESH.EDGE))
 470     name = "nCercle%d"%i
 471     groupnodes_demiCercles.append(meshFondFiss.GroupOnGeom(group, name, SMESH.NODE))
 472   group_generFiss = meshFondFiss.GroupOnGeom(groupGenerFiss, "GenFiss", SMESH.EDGE)
 473   groupnode_generFiss = meshFondFiss.GroupOnGeom(groupGenerFiss, "GenFiss", SMESH.NODE)
 474   grpNode0 = meshFondFiss.IntersectGroups(groupnode_generFiss, groupnodes_demiCercles[0], "Node0")
 475   grpNode1 = meshFondFiss.IntersectGroups(groupnode_generFiss, groupnodes_demiCercles[1], "Node1")
 476   idNode0 = grpNode0.GetID(1)
 477   idNode1 = grpNode1.GetID(1)
 478   coordsMesh = []
 479   coordsMesh.append(meshFondFiss.GetNodeXYZ(idNode0))
 480   coordsMesh.append(meshFondFiss.GetNodeXYZ(idNode1))
 481   coordsGeom = []
 482   for vertex in verticesEdgePeauFiss:
 483     coord = geompy.PointCoordinates(vertex);
 484     if distance2(coord, coordsMesh[0]) < 0.1:
 485       meshFondFiss.MoveNode(idNode0, coord[0], coord[1], coord[2])
 486     if distance2(coord, coordsMesh[1]) < 0.1:
 487       meshFondFiss.MoveNode(idNode1, coord[0], coord[1], coord[2])
 488
 489   for groupNodes in groupnodes_demiCercles:
 490     for idNode in groupNodes.GetListOfID():
 491       coordMesh = meshFondFiss.GetNodeXYZ(idNode)
 492       vertex = geompy.MakeVertex(coordMesh[0], coordMesh[1], coordMesh[2])
 493       minDist = 100000
 494       minCoord = None
 495       imin = -1
 496       for i, edge in enumerate(demiCerclesPeau):
 497         discoord = geompy.MinDistanceComponents(vertex, edge)
 498         if discoord[0] <minDist:
 499           minDist = discoord[0]
 500           minCoord = discoord[1:]
 501           imin = i
 502       if imin >= 0 and minDist > 1.E-6:
 503         logging.debug("node id moved : %s distance=%s", idNode, minDist)
 504         meshFondFiss.MoveNode(idNode, coordMesh[0] + minCoord[0], coordMesh[1] + minCoord[1], coordMesh[2] + minCoord[2])
 505
 506
 507   # --- maillage face de peau
 508
 509   meshFacePeau = smesh.Mesh(facePeau)
 510   algo2d = meshFacePeau.Triangle(algo=smeshBuilder.NETGEN_2D)
 511   hypo2d = algo2d.Parameters()
 512   hypo2d.SetMaxSize( 1000 )
 513   hypo2d.SetOptimize( 1 )
 514   hypo2d.SetFineness( 2 )
 515   hypo2d.SetMinSize( 2 )
 516   hypo2d.SetQuadAllowed( 0 )
 517   putName(algo2d.GetSubMesh(), "facePeau")
 518   putName(algo2d, "algo2d_facePeau")
 519   putName(hypo2d, "hypo2d_facePeau")
 520   #
 521   lenEdgePeauFiss = geompy.BasicProperties(edgePeauFiss)[0]
 522   frac = profondeur/lenEdgePeauFiss
 523   nbSeg = nbSegGenLong +2*nbSegGenBout
 524   ratio = (nbSegGenBout/float(profondeur)) / (nbSegGenLong/lenEdgePeauFiss)
 525   logging.info("lenEdgePeauFiss %s, profondeur %s, nbSegGenLong %s, nbSegGenBout %s, frac %s, ratio %s", lenEdgePeauFiss, profondeur, nbSegGenLong, nbSegGenBout, frac, ratio)
 526   algo1d = meshFacePeau.Segment(geom=edgePeauFiss)
 527   hypo1d = algo1d.NumberOfSegments(nbSeg,[],[  ])
 528   hypo1d.SetDistrType( 2 )
 529   hypo1d.SetConversionMode( 1 )
 530   hypo1d.SetTableFunction( [ 0, ratio, frac, 1, (1.-frac), 1, 1, ratio ] )
 531   putName(algo1d.GetSubMesh(), "edgePeauFiss")
 532   putName(algo1d, "algo1d_edgePeauFiss")
 533   putName(hypo1d, "hypo1d_edgePeauFiss")
 534   #
 535   algo1d = meshFacePeau.UseExisting1DElements(geom=groupEdgesBordPeau)
 536   hypo1d = algo1d.SourceEdges([ bordsLibres ],0,0)
 537   putName(algo1d.GetSubMesh(), "bordsLibres")
 538   putName(algo1d, "algo1d_bordsLibres")
 539   putName(hypo1d, "hypo1d_bordsLibres")
 540   #
 541   for i in range(2):
 542     algo1d = meshFacePeau.UseExisting1DElements(geom=groupsDemiCerclesPeau[i])
 543     hypo1d = algo1d.SourceEdges([ groups_demiCercles[i] ],0,0)
 544     putName(algo1d.GetSubMesh(), "DemiCercles", i)
 545     putName(algo1d, "algo1d_groupDemiCercles", i)
 546     putName(hypo1d, "hypo1d_groupDemiCercles", i)
 547   #
 548   isDone = meshFacePeau.Compute()
 549   logging.info("meshFacePeau computed")
 550   grpTHOR = meshFacePeau.GroupOnGeom(verticesOutCercles[0], "THOR", SMESH.NODE)
 551   grpTHEX = meshFacePeau.GroupOnGeom(verticesOutCercles[1], "THEX", SMESH.NODE)
 552
 553   groupEdgesPeauFiss = meshFacePeau.GroupOnGeom(edgePeauFiss, "PeauFis", SMESH.EDGE)
 554
 555   peauext_face = meshFacePeau.CreateEmptyGroup( SMESH.FACE, 'PEAUEXT' )
 556   nbAdd = peauext_face.AddFrom( meshFacePeau.GetMesh() )
 557
 558
 559   # --- maillage face de fissure
 560
 561   meshFaceFiss = smesh.Mesh(faceFiss)
 562   algo2d = meshFaceFiss.Triangle(algo=smeshBuilder.NETGEN_2D)
 563   hypo2d = algo2d.Parameters()
 564   hypo2d.SetMaxSize( (profondeur - rayonPipe)/math.sqrt(3.0) ) # pour avoir deux couches de triangles equilateraux partout sur la fissure
 565   hypo2d.SetOptimize( 1 )
 566   hypo2d.SetFineness( 2 )
 567   hypo2d.SetMinSize( 2 )
 568   hypo2d.SetQuadAllowed( 0 )
 569   putName(algo2d.GetSubMesh(), "faceFiss")
 570   putName(algo2d, "algo2d_faceFiss")
 571   putName(hypo2d, "hypo2d_faceFiss")
 572   #
 573   algo1d = meshFaceFiss.UseExisting1DElements(geom=edgePeauFiss)
 574   hypo1d = algo1d.SourceEdges([ groupEdgesPeauFiss ],0,0)
 575   putName(algo1d.GetSubMesh(), "edgeFissPeau")
 576   putName(algo1d, "algo1d_edgeFissPeau")
 577   putName(hypo1d, "hypo1d_edgeFissPeau")
 578   #
 579   algo1d = meshFaceFiss.UseExisting1DElements(geom=groupEdgesFaceFissPipe)
 580   hypo1d = algo1d.SourceEdges([ group_generFiss ],0,0)
 581   putName(algo1d.GetSubMesh(), "edgeFissPeau")
 582   putName(algo1d, "algo1d_edgeFissPeau")
 583   putName(hypo1d, "hypo1d_edgeFissPeau")
 584   #
 585   isDone = meshFaceFiss.Compute()
 586   logging.info("meshFaceFiss computed")
 587
 588   grp = meshFaceFiss.GroupOnGeom(faceFiss, "fisOutPi", SMESH.FACE)
 589
 590   meshBoiteDefaut = smesh.Concatenate([internalBoundary.GetMesh(),
 591                                    meshFondFiss.GetMesh(),
 592                                    meshFacePeau.GetMesh(),
 593                                    meshFaceFiss.GetMesh()],
 594                                    1, 1, 1e-05,False)
 595   # pour aider l'algo hexa-tetra a ne pas mettre de pyramides a l'exterieur des volumes replies sur eux-memes
 596   # on designe les faces de peau en quadrangles par le groupe "skinFaces"
 597   group_faceFissOutPipe = None
 598   group_faceFissInPipe = None
 599   groups = meshBoiteDefaut.GetGroups()
 600   for grp in groups:
 601     if grp.GetType() == SMESH.FACE:
 602       #if "internalBoundary" in grp.GetName():
 603       #  grp.SetName("skinFaces")
 604       if grp.GetName() == "fisOutPi":
 605         group_faceFissOutPipe = grp
 606       elif grp.GetName() == "fisInPi":
 607         group_faceFissInPipe = grp
 608
 609   # le maillage NETGEN ne passe pas toujours ==> utiliser GHS3D
 610   distene=True
 611   if distene:
 612     algo3d = meshBoiteDefaut.Tetrahedron(algo=smeshBuilder.GHS3D)
 613   else:
 614     algo3d = meshBoiteDefaut.Tetrahedron(algo=smeshBuilder.NETGEN)
 615     hypo3d = algo3d.MaxElementVolume(1000.0)
 616   putName(algo3d.GetSubMesh(), "boiteDefaut")
 617   putName(algo3d, "algo3d_boiteDefaut")
 618   isDone = meshBoiteDefaut.Compute()
 619   logging.info("meshBoiteDefaut computed")
 620   putName(meshBoiteDefaut, "boiteDefaut")
 621
 622   groups = maillageSain.GetGroups()
 623   grps1 = [ grp for grp in groups if grp.GetName() == 'P1']
 624   grps2 = [ grp for grp in groups if grp.GetName() == 'P2']
 625   coords1 = maillageSain.GetNodeXYZ(grps1[0].GetID(1))
 626   coords2 = maillageSain.GetNodeXYZ(grps2[0].GetID(1))
 627   logging.info("coords1 %s, coords2 %s",coords1, coords2)
 628
 629   faceFissure = meshBoiteDefaut.GetMesh().UnionListOfGroups( [ group_faceFissOutPipe, group_faceFissInPipe ], 'FACE1' )
 630   maillageSain = enleveDefaut(maillageSain, zoneDefaut, zoneDefaut_skin, zoneDefaut_internalFaces, zoneDefaut_internalEdges)
 631   putName(maillageSain, nomFicSain+"_coupe")
 632   extrusionFaceFissure, normfiss = shapeSurFissure(facePorteFissure)
 633   maillageComplet = RegroupeSainEtDefaut(maillageSain, meshBoiteDefaut, extrusionFaceFissure, facePorteFissure, 'COUDE')
 634
 635   groups = maillageComplet.GetGroups()
 636   grps1 = [ grp for grp in groups if grp.GetName() == 'P1']
 637   grps2 = [ grp for grp in groups if grp.GetName() == 'P2']
 638   nodeid1 = maillageComplet.AddNode(coords1[0], coords1[1], coords1[2])
 639   nodeid2 = maillageComplet.AddNode(coords2[0], coords2[1], coords2[2])
 640   grps1[0].Add([nodeid1])
 641   grps2[0].Add([nodeid2])
 642   ma0d1 = maillageComplet.Add0DElement(nodeid1)
 643   ma0d2 = maillageComplet.Add0DElement(nodeid2)
 644   grpma0d1 = maillageComplet.CreateEmptyGroup( SMESH.ELEM0D, 'P1' )
 645   nbAdd = grpma0d1.Add( [ma0d1] )
 646   grpma0d2 = maillageComplet.CreateEmptyGroup( SMESH.ELEM0D, 'P2' )
 647   nbAdd = grpma0d2.Add( [ma0d2] )
 648
 649 #  grps = [ grp for grp in groups if grp.GetName() == 'affectedEdges']
 650 #  grps[0].SetName('affEdges')
 651 #  grps = [ grp for grp in groups if grp.GetName() == 'affectedFaces']
 652 #  grps[0].SetName('affFaces')
 653 #  grps = [ grp for grp in groups if grp.GetName() == 'affectedVolumes']
 654 #  grps[0].SetName('affVols')
 655
 656   maillageComplet.ConvertToQuadratic( 1 )
 657   grps = [ grp for grp in groups if grp.GetName() == 'FONDFISS']
 658   fond = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FONDFISS' )
 659
 660   grps = [ grp for grp in groups if grp.GetName() == 'FACE1']
 661   nb = maillageComplet.Reorient2D( grps[0], normfiss, grps[0].GetID(1))
 662
 663   plansim = geompy.MakePlane(O, normfiss, 10000)
 664   fissnorm = geompy.MakeMirrorByPlane(normfiss, plansim)
 665   grps = [ grp for grp in groups if grp.GetName() == 'FACE2']
 666   nb = maillageComplet.Reorient2D( grps[0], fissnorm, grps[0].GetID(1))
 667   #isDone = maillageComplet.ReorientObject( grps[0] )
 668   fond = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FACE2' )
 669
 670   maillageComplet.ExportMED(fichierMaillageFissure)
 671   putName(maillageComplet, nomFicFissure)
 672   logging.info("fichier maillage fissure %s", fichierMaillageFissure)
 673
 674   if salome.sg.hasDesktop():
 675     salome.sg.updateObjBrowser()
 676
 677   return  maillageComplet