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