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], list(), list(), list(), geompy.ShapeType["FACE"], 0, list(), 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], list(), list(), geompy.ShapeType["FACE"], 0, list(), 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 = list()
 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 = list()
 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 = list()
 207   for i, vertex in enumerate(verticesEdgePeauFiss):
 208     demis = list()
 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 = list()
 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], list(), list(), geompy.ShapeType["SOLID"], 0, list(), 0)
 259   #pipe = geompy.MakePipe(disque, WirePorteFondFissure)
 260   #pipe = geompy.MakePartition([pipe],[fillingFaceExterne], list(), list(), geompy.ShapeType["SOLID"], 0, list(), 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], list(), list(), geompy.ShapeType["SOLID"], 0, list(), 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 = list()
 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 = list()
 311   demiCercles = list()
 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 = list()
 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 = list()
 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 = list()
 345   for i, vertex in enumerate(verticesEdgePeauFiss):
 346     demis = list()
 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 = list()
 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 = list()
 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 = list()
 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   is_done = meshFondFiss.Compute()
 453   text = "meshFondFiss.Compute"
 454   if is_done:
 455     logging.info(text+" OK")
 456   else:
 457     text = "Erreur au calcul du maillage.\n" + text
 458     logging.info(text)
 459     raise Exception(text)
 460
 461   disks = list()
 462   for i, face in enumerate(disques[:4]):
 463     name = "disk%d"%i
 464     disks.append(meshFondFiss.GroupOnGeom(face, name, SMESH.FACE))
 465   peauext_pipe = meshFondFiss.GetMesh().UnionListOfGroups( disks, 'PEAUEXT' )
 466
 467   grpPFOR = meshFondFiss.GroupOnGeom(VerticesEndPipeFiss[0], "PFOR", SMESH.NODE)
 468   grpPFEX = meshFondFiss.GroupOnGeom(VerticesEndPipeFiss[1], "PFEX", SMESH.NODE)
 469
 470   grp = meshFondFiss.GroupOnGeom(groupFaceFissInPipe, "fisInPi", SMESH.FACE)
 471   group_edgeFondFiss = meshFondFiss.GroupOnGeom(groupEdgeFondFiss, "FONDFISS", SMESH.EDGE)
 472   noeudsFondFissure = meshFondFiss.GroupOnGeom(groupEdgeFondFiss, "nfondfis", SMESH.NODE)
 473   groups_demiCercles = list()
 474   groupnodes_demiCercles = list()
 475   for i, group in enumerate(groupsDemiCerclesPipe):
 476     name = "Cercle%d"%i
 477     groups_demiCercles.append(meshFondFiss.GroupOnGeom(group, name, SMESH.EDGE))
 478     name = "nCercle%d"%i
 479     groupnodes_demiCercles.append(meshFondFiss.GroupOnGeom(group, name, SMESH.NODE))
 480   group_generFiss = meshFondFiss.GroupOnGeom(groupGenerFiss, "GenFiss", SMESH.EDGE)
 481   groupnode_generFiss = meshFondFiss.GroupOnGeom(groupGenerFiss, "GenFiss", SMESH.NODE)
 482   grpNode0 = meshFondFiss.IntersectGroups(groupnode_generFiss, groupnodes_demiCercles[0], "Node0")
 483   grpNode1 = meshFondFiss.IntersectGroups(groupnode_generFiss, groupnodes_demiCercles[1], "Node1")
 484   idNode0 = grpNode0.GetID(1)
 485   idNode1 = grpNode1.GetID(1)
 486   coordsMesh = list()
 487   coordsMesh.append(meshFondFiss.GetNodeXYZ(idNode0))
 488   coordsMesh.append(meshFondFiss.GetNodeXYZ(idNode1))
 489   coordsGeom = list()
 490   for vertex in verticesEdgePeauFiss:
 491     coord = geompy.PointCoordinates(vertex)
 492     if distance2(coord, coordsMesh[0]) < 0.1:
 493       meshFondFiss.MoveNode(idNode0, coord[0], coord[1], coord[2])
 494     if distance2(coord, coordsMesh[1]) < 0.1:
 495       meshFondFiss.MoveNode(idNode1, coord[0], coord[1], coord[2])
 496
 497   for groupNodes in groupnodes_demiCercles:
 498     for idNode in groupNodes.GetListOfID():
 499       coordMesh = meshFondFiss.GetNodeXYZ(idNode)
 500       vertex = geompy.MakeVertex(coordMesh[0], coordMesh[1], coordMesh[2])
 501       minDist = 100000
 502       minCoord = None
 503       imin = -1
 504       for i, edge in enumerate(demiCerclesPeau):
 505         discoord = geompy.MinDistanceComponents(vertex, edge)
 506         if discoord[0] <minDist:
 507           minDist = discoord[0]
 508           minCoord = discoord[1:]
 509           imin = i
 510       if imin >= 0 and minDist > 1.E-6:
 511         logging.debug("node id moved : %s distance=%s", idNode, minDist)
 512         meshFondFiss.MoveNode(idNode, coordMesh[0] + minCoord[0], coordMesh[1] + minCoord[1], coordMesh[2] + minCoord[2])
 513
 514
 515   # --- maillage face de peau
 516
 517   meshFacePeau = smesh.Mesh(facePeau)
 518   algo2d = meshFacePeau.Triangle(algo=smeshBuilder.NETGEN_2D)
 519   hypo2d = algo2d.Parameters()
 520   hypo2d.SetMaxSize( 1000 )
 521   hypo2d.SetOptimize( 1 )
 522   hypo2d.SetFineness( 2 )
 523   hypo2d.SetMinSize( 2 )
 524   hypo2d.SetQuadAllowed( 0 )
 525   putName(algo2d.GetSubMesh(), "facePeau")
 526   putName(algo2d, "algo2d_facePeau")
 527   putName(hypo2d, "hypo2d_facePeau")
 528   #
 529   lenEdgePeauFiss = geompy.BasicProperties(edgePeauFiss)[0]
 530   frac = profondeur/lenEdgePeauFiss
 531   nbSeg = nbSegGenLong +2*nbSegGenBout
 532   ratio = (nbSegGenBout/float(profondeur)) / (nbSegGenLong/lenEdgePeauFiss)
 533   logging.info("lenEdgePeauFiss %s, profondeur %s, nbSegGenLong %s, nbSegGenBout %s, frac %s, ratio %s", lenEdgePeauFiss, profondeur, nbSegGenLong, nbSegGenBout, frac, ratio)
 534   algo1d = meshFacePeau.Segment(geom=edgePeauFiss)
 535   hypo1d = algo1d.NumberOfSegments(nbSeg,list(),[  ])
 536   hypo1d.SetDistrType( 2 )
 537   hypo1d.SetConversionMode( 1 )
 538   hypo1d.SetTableFunction( [ 0, ratio, frac, 1, (1.-frac), 1, 1, ratio ] )
 539   putName(algo1d.GetSubMesh(), "edgePeauFiss")
 540   putName(algo1d, "algo1d_edgePeauFiss")
 541   putName(hypo1d, "hypo1d_edgePeauFiss")
 542   #
 543   algo1d = meshFacePeau.UseExisting1DElements(geom=groupEdgesBordPeau)
 544   hypo1d = algo1d.SourceEdges([ bordsLibres ],0,0)
 545   putName(algo1d.GetSubMesh(), "bordsLibres")
 546   putName(algo1d, "algo1d_bordsLibres")
 547   putName(hypo1d, "hypo1d_bordsLibres")
 548   #
 549   for i in range(2):
 550     algo1d = meshFacePeau.UseExisting1DElements(geom=groupsDemiCerclesPeau[i])
 551     hypo1d = algo1d.SourceEdges([ groups_demiCercles[i] ],0,0)
 552     putName(algo1d.GetSubMesh(), "DemiCercles", i)
 553     putName(algo1d, "algo1d_groupDemiCercles", i)
 554     putName(hypo1d, "hypo1d_groupDemiCercles", i)
 555   #
 556   is_done = meshFacePeau.Compute()
 557   text = "meshFacePeau.Compute"
 558   if is_done:
 559     logging.info(text+" OK")
 560   else:
 561     text = "Erreur au calcul du maillage.\n" + text
 562     logging.info(text)
 563     raise Exception(text)
 564   grpTHOR = meshFacePeau.GroupOnGeom(verticesOutCercles[0], "THOR", SMESH.NODE)
 565   grpTHEX = meshFacePeau.GroupOnGeom(verticesOutCercles[1], "THEX", SMESH.NODE)
 566
 567   groupEdgesPeauFiss = meshFacePeau.GroupOnGeom(edgePeauFiss, "PeauFis", SMESH.EDGE)
 568
 569   peauext_face = meshFacePeau.CreateEmptyGroup( SMESH.FACE, 'PEAUEXT' )
 570   nbAdd = peauext_face.AddFrom( meshFacePeau.GetMesh() )
 571
 572
 573   # --- maillage face de fissure
 574
 575   meshFaceFiss = smesh.Mesh(faceFiss)
 576   algo2d = meshFaceFiss.Triangle(algo=smeshBuilder.NETGEN_2D)
 577   hypo2d = algo2d.Parameters()
 578   hypo2d.SetMaxSize( (profondeur - rayonPipe)/math.sqrt(3.0) ) # pour avoir deux couches de triangles equilateraux partout sur la fissure
 579   hypo2d.SetOptimize( 1 )
 580   hypo2d.SetFineness( 2 )
 581   hypo2d.SetMinSize( 2 )
 582   hypo2d.SetQuadAllowed( 0 )
 583   putName(algo2d.GetSubMesh(), "faceFiss")
 584   putName(algo2d, "algo2d_faceFiss")
 585   putName(hypo2d, "hypo2d_faceFiss")
 586   #
 587   algo1d = meshFaceFiss.UseExisting1DElements(geom=edgePeauFiss)
 588   hypo1d = algo1d.SourceEdges([ groupEdgesPeauFiss ],0,0)
 589   putName(algo1d.GetSubMesh(), "edgeFissPeau")
 590   putName(algo1d, "algo1d_edgeFissPeau")
 591   putName(hypo1d, "hypo1d_edgeFissPeau")
 592   #
 593   algo1d = meshFaceFiss.UseExisting1DElements(geom=groupEdgesFaceFissPipe)
 594   hypo1d = algo1d.SourceEdges([ group_generFiss ],0,0)
 595   putName(algo1d.GetSubMesh(), "edgeFissPeau")
 596   putName(algo1d, "algo1d_edgeFissPeau")
 597   putName(hypo1d, "hypo1d_edgeFissPeau")
 598   #
 599   is_done = meshFaceFiss.Compute()
 600   text = "meshFaceFiss.Compute"
 601   if is_done:
 602     logging.info(text+" OK")
 603   else:
 604     text = "Erreur au calcul du maillage.\n" + text
 605     logging.info(text)
 606     raise Exception(text)
 607
 608   grp = meshFaceFiss.GroupOnGeom(faceFiss, "fisOutPi", SMESH.FACE)
 609
 610   meshBoiteDefaut = smesh.Concatenate( [internalBoundary.GetMesh(), \
 611                                         meshFondFiss.GetMesh(), \
 612                                         meshFacePeau.GetMesh(), \
 613                                         meshFaceFiss.GetMesh()], \
 614                                         1, 1, 1e-05,False)
 615   # pour aider l'algo hexa-tetra a ne pas mettre de pyramides a l'exterieur des volumes replies sur eux-memes
 616   # on designe les faces de peau en quadrangles par le groupe "skinFaces"
 617   group_faceFissOutPipe = None
 618   group_faceFissInPipe = None
 619   groups = meshBoiteDefaut.GetGroups()
 620   for grp in groups:
 621     if grp.GetType() == SMESH.FACE:
 622       #if "internalBoundary" in grp.GetName():
 623       #  grp.SetName("skinFaces")
 624       if grp.GetName() == "fisOutPi":
 625         group_faceFissOutPipe = grp
 626       elif grp.GetName() == "fisInPi":
 627         group_faceFissInPipe = grp
 628
 629   # le maillage NETGEN ne passe pas toujours ==> utiliser GHS3D
 630   distene=True
 631   if distene:
 632     algo3d = meshBoiteDefaut.Tetrahedron(algo=smeshBuilder.GHS3D)
 633   else:
 634     algo3d = meshBoiteDefaut.Tetrahedron(algo=smeshBuilder.NETGEN)
 635     hypo3d = algo3d.MaxElementVolume(1000.0)
 636   putName(algo3d.GetSubMesh(), "boiteDefaut")
 637   putName(algo3d, "algo3d_boiteDefaut")
 638   putName(meshBoiteDefaut, "boiteDefaut")
 639   is_done = meshBoiteDefaut.Compute()
 640   text = "meshBoiteDefaut.Compute"
 641   if is_done:
 642     logging.info(text+" OK")
 643   else:
 644     text = "Erreur au calcul du maillage.\n" + text
 645     logging.info(text)
 646     raise Exception(text)
 647
 648   groups = maillageSain.GetGroups()
 649   grps1 = [ grp for grp in groups if grp.GetName() == 'P1']
 650   grps2 = [ grp for grp in groups if grp.GetName() == 'P2']
 651   coords1 = maillageSain.GetNodeXYZ(grps1[0].GetID(1))
 652   coords2 = maillageSain.GetNodeXYZ(grps2[0].GetID(1))
 653   logging.info("coords1 %s, coords2 %s",coords1, coords2)
 654
 655   faceFissure = meshBoiteDefaut.GetMesh().UnionListOfGroups( [ group_faceFissOutPipe, group_faceFissInPipe ], 'FACE1' )
 656   maillageSain = enleveDefaut(maillageSain, zoneDefaut, zoneDefaut_skin, zoneDefaut_internalFaces, zoneDefaut_internalEdges)
 657   putName(maillageSain, nomFicSain+"_coupe")
 658   extrusionFaceFissure, normfiss = shapeSurFissure(facePorteFissure)
 659   maillageComplet = RegroupeSainEtDefaut(maillageSain, meshBoiteDefaut, extrusionFaceFissure, facePorteFissure, 'COUDE')
 660
 661   groups = maillageComplet.GetGroups()
 662   grps1 = [ grp for grp in groups if grp.GetName() == 'P1']
 663   grps2 = [ grp for grp in groups if grp.GetName() == 'P2']
 664   nodeid1 = maillageComplet.AddNode(coords1[0], coords1[1], coords1[2])
 665   nodeid2 = maillageComplet.AddNode(coords2[0], coords2[1], coords2[2])
 666   grps1[0].Add([nodeid1])
 667   grps2[0].Add([nodeid2])
 668   ma0d1 = maillageComplet.Add0DElement(nodeid1)
 669   ma0d2 = maillageComplet.Add0DElement(nodeid2)
 670   grpma0d1 = maillageComplet.CreateEmptyGroup( SMESH.ELEM0D, 'P1' )
 671   nbAdd = grpma0d1.Add( [ma0d1] )
 672   grpma0d2 = maillageComplet.CreateEmptyGroup( SMESH.ELEM0D, 'P2' )
 673   nbAdd = grpma0d2.Add( [ma0d2] )
 674
 675 #  grps = [ grp for grp in groups if grp.GetName() == 'affectedEdges']
 676 #  grps[0].SetName('affEdges')
 677 #  grps = [ grp for grp in groups if grp.GetName() == 'affectedFaces']
 678 #  grps[0].SetName('affFaces')
 679 #  grps = [ grp for grp in groups if grp.GetName() == 'affectedVolumes']
 680 #  grps[0].SetName('affVols')
 681
 682   maillageComplet.ConvertToQuadratic( 1 )
 683   grps = [ grp for grp in groups if grp.GetName() == 'FONDFISS']
 684   fond = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FONDFISS' )
 685
 686   grps = [ grp for grp in groups if grp.GetName() == 'FACE1']
 687   nb = maillageComplet.Reorient2D( grps[0], normfiss, grps[0].GetID(1))
 688
 689   plansim = geompy.MakePlane(O, normfiss, 10000)
 690   fissnorm = geompy.MakeMirrorByPlane(normfiss, plansim)
 691   grps = [ grp for grp in groups if grp.GetName() == 'FACE2']
 692   nb = maillageComplet.Reorient2D( grps[0], fissnorm, grps[0].GetID(1))
 693   #isDone = maillageComplet.ReorientObject( grps[0] )
 694   fond = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FACE2' )
 695
 696   maillageComplet.ExportMED(fichierMaillageFissure)
 697   putName(maillageComplet, nomFicFissure)
 698   logging.info("fichier maillage fissure %s", fichierMaillageFissure)
 699
 700   if salome.sg.hasDesktop():
 701     salome.sg.updateObjBrowser()
 702
 703   return  maillageComplet