+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2014-2021 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License, or (at your option) any later version.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""procédure complète fissure générale"""
-
-import os
-import math
-
-import logging
-from . import initLog
-
-import salome
-from salome.smesh import smeshBuilder
-import GEOM
-import SMESH
-
-from .geomsmesh import geompy
-from .geomsmesh import geomPublish
-from .geomsmesh import geomPublishInFather
-from .geomsmesh import smesh
-
-from .extractionOrientee import extractionOrientee
-from .extractionOrienteeMulti import extractionOrienteeMulti
-from .sortFaces import sortFaces
-from .sortEdges import sortEdges
-from .substractSubShapes import substractSubShapes
-from .produitMixte import produitMixte
-from .findWireEndVertices import findWireEndVertices
-from .findWireIntermediateVertices import findWireIntermediateVertices
-from .orderEdgesFromWire import orderEdgesFromWire
-from .putName import putName
-from .enleveDefaut import enleveDefaut
-from .shapeSurFissure import shapeSurFissure
-from .regroupeSainEtDefaut import RegroupeSainEtDefaut
-from .triedreBase import triedreBase
-from .checkDecoupePartition import checkDecoupePartition
-from .whichSide import whichSide
-from .whichSideVertex import whichSideVertex
-from .projettePointSurCourbe import projettePointSurCourbe
-from .prolongeWire import prolongeWire
-from .putName import putName
-
-def insereFissureGenerale(maillagesSains,
- shapesFissure, shapeFissureParams,
- maillageFissureParams, elementsDefaut, \
- step=-1, mailleur="MeshGems", nro_cas=-1):
- """ TODO: a completer"""
- logging.info('start')
- logging.info("Maillage avec %s pour le cas n°%d", mailleur, nro_cas)
-
- shapeDefaut = shapesFissure[0] # faces de fissure, débordant
- fondFiss = shapesFissure[4] # groupe d'edges de fond de fissure
-
- rayonPipe = shapeFissureParams['rayonPipe']
- if 'lenSegPipe' in shapeFissureParams:
- lenSegPipe = shapeFissureParams['lenSegPipe']
- else:
- lenSegPipe = rayonPipe
-
- nomRep = maillageFissureParams['nomRep']
- nomFicSain = maillageFissureParams['nomFicSain']
- nomFicFissure = maillageFissureParams['nomFicFissure']
-
- nbsegRad = maillageFissureParams['nbsegRad'] # nombre de couches selon un rayon du pipe
- nbsegCercle = maillageFissureParams['nbsegCercle'] # nombre de secteur dans un cercle du pipe
- areteFaceFissure = maillageFissureParams['areteFaceFissure']
-
- pointIn_x = 0.0
- pointIn_y = 0.0
- pointIn_z = 0.0
- isPointInterne = False
- if 'pointIn_x' in shapeFissureParams:
- pointIn_x = shapeFissureParams['pointIn_x']
- isPointInterne = True
- if 'pointIn_y' in shapeFissureParams:
- pointIn_y = shapeFissureParams['pointIn_y']
- isPointInterne = True
- if 'pointIn_z' in shapeFissureParams:
- pointIn_z = shapeFissureParams['pointIn_z']
- isPointInterne = True
- if isPointInterne:
- pointInterne = geompy.MakeVertex(pointIn_x, pointIn_y, pointIn_z)
-
- #fichierMaillageSain = os.path.join(nomRep, '{}.med'.format(nomFicSain))
- fichierMaillageFissure = os.path.join(nomRep, '{}.med'.format(nomFicFissure))
-
- # fillings des faces en peau
- facesDefaut = elementsDefaut[0]
- #centresDefaut = elementsDefaut[1]
- #normalsDefaut = elementsDefaut[2]
- #extrusionsDefaut = elementsDefaut[3]
- dmoyen = elementsDefaut[4]
- bordsPartages = elementsDefaut[5]
- #fillconts = elementsDefaut[6]
- #idFilToCont = elementsDefaut[7]
- maillageSain = elementsDefaut[8]
- internalBoundary = elementsDefaut[9]
- zoneDefaut = elementsDefaut[10]
- zoneDefaut_skin = elementsDefaut[11]
- zoneDefaut_internalFaces = elementsDefaut[12]
- zoneDefaut_internalEdges = elementsDefaut[13]
- #edgeFondExt = elementsDefaut[14]
- centreFondFiss = elementsDefaut[15]
- tgtCentre = elementsDefaut[16]
-
- # --- restriction de la face de fissure au domaine solide :
- # partition face fissure étendue par fillings, on garde la plus grande face
-
- partShapeDefaut = geompy.MakePartition([shapeDefaut], facesDefaut, list(), list(), geompy.ShapeType["FACE"], 0, [], 0)
- geomPublish(initLog.debug, partShapeDefaut, 'partShapeDefaut')
- facesPartShapeDefaut = geompy.ExtractShapes(partShapeDefaut, geompy.ShapeType["FACE"], False)
- if isPointInterne:
- distfaces = [(geompy.MinDistance(face,pointInterne), i, face) for i, face in enumerate(facesPartShapeDefaut)]
- distfaces.sort()
- logging.debug("selection de la face la plus proche du point interne, distance=%s",distfaces[0][0])
- facesPortFissure = distfaces[0][2]
- else:
- facesPartShapeDefautSorted, minSurf, maxSurf = sortFaces(facesPartShapeDefaut) # la face de fissure dans le volume doit être la plus grande
- logging.debug("surfaces faces fissure étendue, min %s, max %s", minSurf, maxSurf)
- facesPortFissure = facesPartShapeDefautSorted[-1] #= global
-
- geomPublish(initLog.debug, facesPortFissure, "facesPortFissure")
-
- O, _, _, _ = triedreBase()
-
- # -----------------------------------------------------------------------------
- # --- pipe de fond de fissure, prolongé, partition face fissure par pipe
- # identification des edges communes pipe et face fissure
-
- if geompy.NumberOfFaces(shapeDefaut) == 1:
- plan = geompy.MakePlane(centreFondFiss, tgtCentre, 10000)
- shapeDefaut = geompy.MakePartition([shapeDefaut], [plan], [], [], geompy.ShapeType["FACE"], 0, [], 0) #= local
- #fondFissCoupe = geompy.GetInPlaceByHistory(shapeDefaut, fondFiss) #= inutile
- geomPublish(initLog.debug, shapeDefaut, 'shapeDefaut_coupe')
- #geomPublishInFather(initLog.debug,shapeDefaut, fondFissCoupe, 'fondFiss_coupe')
-
- extrem, norms = findWireEndVertices(fondFiss, True)
- logging.debug("extrem: %s, norm: %s",extrem, norms)
- cercle = geompy.MakeCircle(extrem[0], norms[0], rayonPipe)
- cercle = geompy.MakeRotation(cercle, norms[0], math.pi/3.0 ) # éviter d'avoir l'arête de couture du pipe presque confondue avec la face fissure
- geomPublish(initLog.debug, cercle, 'cercle')
- fondFissProlonge = prolongeWire(fondFiss, extrem, norms, 2*rayonPipe)
- pipeFiss = geompy.MakePipe(cercle, fondFissProlonge)
- geomPublish(initLog.debug, pipeFiss, 'pipeFiss')
- partFissPipe = geompy.MakePartition([shapeDefaut, pipeFiss], [], [], [], geompy.ShapeType["FACE"], 0, [], 1)
- geomPublish(initLog.debug, partFissPipe, 'partFissPipe')
- fissPipe = geompy.GetInPlaceByHistory(partFissPipe, shapeDefaut) #= global
- geomPublish(initLog.debug, fissPipe, 'fissPipe')
- partPipe = geompy.GetInPlaceByHistory(partFissPipe, pipeFiss) #= local
- geomPublish(initLog.debug, partPipe, 'partPipe')
-
- edgesPipeFiss = geompy.GetSharedShapesMulti([fissPipe, partPipe], geompy.ShapeType["EDGE"]) #= global
- for i, edge in enumerate(edgesPipeFiss):
- name = "edgePipe%d"%i
- geomPublishInFather(initLog.debug,fissPipe, edge, name)
- try:
- wirePipeFiss = geompy.MakeWire(edgesPipeFiss) #= global
- except:
- wirePipeFiss = geompy.MakeCompound(edgesPipeFiss)
- logging.debug("wirePipeFiss construit sous forme de compound")
- geomPublish(initLog.debug, wirePipeFiss, "wirePipeFiss")
-
- wireFondFiss = geompy.GetInPlace(partFissPipe,fondFiss)
- edgesFondFiss = geompy.GetSharedShapesMulti([fissPipe, wireFondFiss], geompy.ShapeType["EDGE"])
- for i, edge in enumerate(edgesFondFiss):
- name = "edgeFondFiss%d"%i
- geomPublishInFather(initLog.debug,fissPipe, edge, name)
- wireFondFiss = geompy.MakeWire(edgesFondFiss) #= global
- geomPublish(initLog.debug, wireFondFiss,"wireFondFiss")
-
- # -----------------------------------------------------------------------------
- # --- peau et face de fissure
- #
- # --- partition peau défaut - face de fissure prolongée - wire de fond de fissure prolongée
- # il peut y avoir plusieurs faces externes, dont certaines sont découpées par la fissure
- # liste de faces externes : facesDefaut
- # liste de partitions face externe - fissure : partitionPeauFissFond (None quand pas d'intersection)
-
- partitionsPeauFissFond = list() #= global
- ipart = 0
- for filling in facesDefaut:
- part = geompy.MakePartition([fissPipe, filling], list(), list(), list(), geompy.ShapeType["FACE"], 0, list(), 0)
- isPart = checkDecoupePartition([fissPipe, filling], part)
- if isPart: # on recrée la partition avec toutes les faces filling en outil pour avoir une face de fissure correcte
- otherFD = [fd for fd in facesDefaut if fd != filling]
- if len(otherFD) > 0:
- fissPipePart = geompy.MakePartition([fissPipe], otherFD, list(), list(), geompy.ShapeType["FACE"], 0, list(), 0)
- else:
- fissPipePart = fissPipe
- part = geompy.MakePartition([fissPipePart, filling], list(), list(), list(), geompy.ShapeType["FACE"], 0, list(), 0)
- partitionsPeauFissFond.append(part)
- geomPublish(initLog.debug, part, 'partitionPeauFissFond%d'%ipart )
- else:
- partitionsPeauFissFond.append(None)
- ipart = ipart +1
-
-
- # --- arêtes vives détectées (dans quadranglesToShapeNoCorner
- # et quadranglesToShapeWithCorner)
-
- aretesVives = list()
- aretesVivesCoupees = list() #= global
- ia = 0
- for a in bordsPartages:
- if not isinstance(a, list):
- aretesVives.append(a)
- name = "areteVive%d"%ia
- geomPublish(initLog.debug, a, name)
- ia += 1
- else:
- if a[0] is not None:
- aretesVives.append(a[0])
- name = "areteVive%d"%ia
- geomPublish(initLog.debug, a[0], name)
- ia += 1
-
- aretesVivesC = None #= global
- if len(aretesVives) > 0:
- aretesVivesC =geompy.MakeCompound(aretesVives)
-
- # -------------------------------------------------------
- # --- inventaire des faces de peau coupées par la fissure
- # pour chaque face de peau : 0, 1 ou 2 faces débouchante du fond de fissure
- # 0, 1 ou plus edges de la face de fissure externe au pipe
-
- nbFacesFilling = len(partitionsPeauFissFond)
- ptEdgeFond = [ list() for i in range(nbFacesFilling)] # pour chaque face [points edge fond de fissure aux débouchés du pipe]
- fsPipePeau = [ list() for i in range(nbFacesFilling)] # pour chaque face [faces du pipe débouchantes]
- edRadFPiPo = [ list() for i in range(nbFacesFilling)] # pour chaque face [edge radiale des faces du pipe débouchantes ]
- fsFissuExt = [ list() for i in range(nbFacesFilling)] # pour chaque face [faces de fissure externes au pipe]
- edFisExtPe = [ list() for i in range(nbFacesFilling)] # pour chaque face [edge en peau des faces de fissure externes (pas subshape facePeau)]
- edFisExtPi = [ list() for i in range(nbFacesFilling)] # pour chaque face [edge commun au pipe des faces de fissure externes]
- facesPeaux = [None for i in range(nbFacesFilling)] # pour chaque face : la face de peau finale a mailler (percée des faces débouchantes)
- edCircPeau = [ list() for i in range(nbFacesFilling)] # pour chaque face de peau : [subshape edge circulaire aux débouchés du pipe]
- ptCircPeau = [ list() for i in range(nbFacesFilling)] # pour chaque face de peau : [subshape point sur edge circulaire aux débouchés du pipe]
- gpedgeBord = [None for i in range(nbFacesFilling)] # pour chaque face de peau : groupe subshape des edges aux bords liés à la partie saine
- gpedgeVifs = [None for i in range(nbFacesFilling)] # pour chaque face de peau : groupes subshape des edges aux arêtes vives entre fillings
- edFissPeau = [ list() for i in range(nbFacesFilling)] # pour chaque face de peau : [subshape edge en peau des faces de fissure externes]
- ptFisExtPi = [ list() for i in range(nbFacesFilling)] # pour chaque face de peau : [point commun edFissPeau edCircPeau]
-
- for ifil, partitionPeauFissFond in enumerate(partitionsPeauFissFond):
- if partitionPeauFissFond is not None:
- fillingFaceExterne = facesDefaut[ifil]
- #fillingSansDecoupe = fillconts[idFilToCont[ifil]]
- logging.debug("traitement partitionPeauFissFond %s", ifil)
- # -----------------------------------------------------------------------
- # --- identification edges fond de fissure, edges pipe sur la face de fissure,
- # edges prolongées
-
- edgesPipeC = geompy.GetInPlace(partitionPeauFissFond, geompy.MakeCompound(edgesPipeFiss)) #= local
- geomPublishInFather(initLog.debug,partitionPeauFissFond, edgesPipeC, "edgesPipeFiss")
- edgesFondC = geompy.GetInPlace(partitionPeauFissFond, geompy.MakeCompound(edgesFondFiss)) #= local
- geomPublishInFather(initLog.debug,partitionPeauFissFond, edgesFondC, "edgesFondFiss")
-
- if aretesVivesC is None: #= global facesInside facesOnside
- [edgesInside, _, _] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "EDGE", 1.e-3)
- [facesInside, _, facesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "FACE", 1.e-3)
- else:
- [edgesInside, _, _] = extractionOrienteeMulti(facesDefaut, ifil, partitionPeauFissFond, centreFondFiss, "EDGE", 1.e-3)
- [facesInside, _, facesOnside] = extractionOrienteeMulti(facesDefaut, ifil, partitionPeauFissFond, centreFondFiss, "FACE", 1.e-3)
-
- edgesPipeIn = geompy.GetSharedShapesMulti([edgesPipeC, geompy.MakeCompound(edgesInside)], geompy.ShapeType["EDGE"]) #= global
- verticesPipePeau = list() #= global
-
- for i, edge in enumerate(edgesPipeIn):
- try:
- vertices = geompy.GetSharedShapesMulti([edge, geompy.MakeCompound(facesOnside)], geompy.ShapeType["VERTEX"])
- verticesPipePeau.append(vertices[0])
- name = "edgePipeIn%d"%i
- geomPublishInFather(initLog.debug,partitionPeauFissFond, edge, name)
- name = "verticePipePeau%d"%i
- geomPublishInFather(initLog.debug,partitionPeauFissFond, vertices[0], name)
- logging.debug("edgePipeIn%s coupe les faces OnSide", i)
- except:
- logging.debug("edgePipeIn%s ne coupe pas les faces OnSide", i)
- #edgesFondOut = list() #= inutile
- edgesFondIn =list() #= global
- if len(verticesPipePeau) > 0: # au moins une extrémité du pipe sur cette face de peau
- #tmp = geompy.GetSharedShapesMulti([edgesFondC, geompy.MakeCompound(edgesOutside)], geompy.ShapeType["EDGE"])
- #edgesFondOut = [ ed for ed in tmp if geompy.MinDistance(ed, geompy.MakeCompound(facesOnside)) < 1.e-3]
- tmp = geompy.GetSharedShapesMulti([edgesFondC, geompy.MakeCompound(edgesInside)], geompy.ShapeType["EDGE"])
- edgesFondIn = [ ed for ed in tmp if geompy.MinDistance(ed, geompy.MakeCompound(facesOnside)) < 1.e-3]
-
- verticesEdgesFondIn = list() # les points du fond de fissure au débouché du pipe sur la peau (indice de edgesFondIn)
- pipexts = list() # les segments de pipe associés au points de fond de fissure débouchants (même indice)
- cercles = list() # les cercles de generation des pipes débouchant (même indice)
- facesFissExt = list() # les faces de la fissure externe associés au points de fond de fissure débouchants (même indice)
- edgesFissExtPeau = list() # edges des faces de fissure externe sur la peau (même indice)
- edgesFissExtPipe = list() # edges des faces de fissure externe sur le pipe (même indice)
- #logging.debug("edgesFondIn %s", edgesFondIn)
-
- edgesFondFiss, edgesIdByOrientation = orderEdgesFromWire(wireFondFiss)
- for i,edge in enumerate(edgesFondFiss):
- geomPublishInFather(initLog.debug,wireFondFiss, edge, "edgeFondFiss%d"%i)
-
- for iedf, edge in enumerate(edgesFondIn):
- name = "edgeFondIn%d"%iedf
- geomPublishInFather(initLog.debug,partitionPeauFissFond, edge, name)
- dist = [ geompy.MinDistance(pt, edge) for pt in verticesPipePeau]
- ptPeau = verticesPipePeau[dist.index(min(dist))] # le point de verticesPipePeau a distance minimale de l'edge
- [parametre, PointOnEdge, EdgeInWireIndex] = geompy.MakeProjectionOnWire(ptPeau, wireFondFiss)
- logging.debug("parametre:%s, EdgeInWireIndex: %s, len(edgesFondFiss): %s", parametre, EdgeInWireIndex, len(edgesFondFiss))
- localEdgeInFondFiss = edgesFondFiss[EdgeInWireIndex]
- centre = PointOnEdge
- centre2 = geompy.MakeVertexOnCurve(localEdgeInFondFiss, parametre)
- geomPublishInFather(initLog.debug,partitionPeauFissFond, centre2, "centre2_%d"%iedf)
- verticesEdgesFondIn.append(centre)
- name = "verticeEdgesFondIn%d"%iedf
- geomPublishInFather(initLog.debug,partitionPeauFissFond, centre, name)
- norm = geompy.MakeTangentOnCurve(localEdgeInFondFiss, parametre)
- geomPublishInFather(initLog.debug,partitionPeauFissFond, centre, "norm%d"%iedf)
- cercle = geompy.MakeCircle(centre, norm, rayonPipe)
- geomPublishInFather(initLog.debug,partitionPeauFissFond, cercle, "cerclorig%d"%iedf)
- [vertex] = geompy.ExtractShapes(cercle, geompy.ShapeType["VERTEX"], False)
- vec1 = geompy.MakeVector(centre, vertex)
- vec2 = geompy.MakeVector(centre, ptPeau)
- angle = geompy.GetAngleRadians(vec1, vec2)
- # cas général : on reconstitue une portion de pipe, avec l'arête de couture qui coincide
- # avec la face de fissure, au niveau du débouché sur la face externe
- # cas dégénéré : le pipe débouche perpendiculairement à une surface plane à l'origine.
- # La partition filling / pipe reconstruit échoue.
- # - Si on partitionne le filling avec un simple pipe obtenu par extrusion droite du cercle,
- # cela donne un point en trop sur le cercle.
- # - Si on prend une vraie surface plane (pas un filling), on peut faire la partition avec
- # les pipes reconstruits
- logging.debug("angle=%s", angle)
- #if abs(angle) > 1.e-7:
- sommetAxe = geompy.MakeTranslationVector(centre, norm)
- pm = produitMixte(centre, vertex, ptPeau, sommetAxe)
- if pm > 0: # ajout de pi a (-)angle pour éviter des points confondus (partition échoue) dans les cas dégénérés
- cercle = geompy.MakeRotation(cercle, norm, angle + math.pi)
- else:
- cercle = geompy.MakeRotation(cercle, norm, -angle + math.pi)
- name = "cercle%d"%iedf
- geomPublishInFather(initLog.debug,partitionPeauFissFond, cercle, name)
- cercles.append(cercle)
-
- # --- estimation de la longueur du pipe necessaire de part et d'autre du point de sortie
- if aretesVivesC is None:
- faceTestPeau = fillingFaceExterne
- else:
- faceTestPeau = facesDefaut[ifil]
- sideCentre = whichSide(faceTestPeau, centre)
- locPt0 = geompy.MakeVertexOnCurve(localEdgeInFondFiss, 0.0)
- locPt1 = geompy.MakeVertexOnCurve(localEdgeInFondFiss, 1.0)
- sidePt0 = whichSide(faceTestPeau, locPt0)
- sidePt1 = whichSide(faceTestPeau, locPt1)
- logging.debug("position centre cercle: %s, extremité edge u0: %s, u1: %s", sideCentre, sidePt0, sidePt1)
- normFace = geompy.GetNormal(faceTestPeau, ptPeau)
- inclPipe = abs(geompy.GetAngleRadians(norm, normFace))
- lgp = max(rayonPipe/2., abs(3*rayonPipe*math.tan(inclPipe)))
- logging.debug("angle inclinaison Pipe en sortie: %s degres, lgp: %s", inclPipe*180/math.pi, lgp)
-
- # --- position des points extremite du pipe sur l'edge debouchante
- # il faut la distance curviligne ofp du point central par rapport à une extrémité de l'edge débouchante
- locEdgePart = geompy.MakePartition([localEdgeInFondFiss],[centre], list(), list(), geompy.ShapeType["EDGE"], 0, list(), 0)
- edgesLoc = geompy.ExtractShapes(locEdgePart, geompy.ShapeType["EDGE"], False)
- edgesLocSorted =[(geompy.MinDistance(edge, locPt0), kk, edge) for kk, edge in enumerate(edgesLoc)]
- edgesLocSorted.sort()
- ofp = geompy.BasicProperties(edgesLocSorted[0][2])[0] # distance curviligne centre locPt0
- logging.debug("distance curviligne centre extremite0: %s", ofp)
- p1 = geompy.MakeVertexOnCurveByLength(localEdgeInFondFiss, ofp +lgp, locPt0)
- p2 = geompy.MakeVertexOnCurveByLength(localEdgeInFondFiss, ofp -lgp, locPt0)
- geomPublishInFather(initLog.debug,wireFondFiss, p1, "p1_%d"%iedf)
- geomPublishInFather(initLog.debug,wireFondFiss, p2, "p2_%d"%iedf)
-
- edgePart = geompy.MakePartition([localEdgeInFondFiss], [p1,p2], list(), list(), geompy.ShapeType["EDGE"], 0, list(), 0)
- edps = geompy.ExtractShapes(edgePart, geompy.ShapeType["EDGE"], True)
- for edp in edps:
- if geompy.MinDistance(centre, edp) < 1.e-3:
- pipext = geompy.MakePipe(cercle, edp)
- name = "pipeExt%d"%iedf
- geomPublishInFather(initLog.debug,partitionPeauFissFond, pipext, name)
- pipexts.append(pipext)
-
- for face in facesInside:
- logging.debug("recherche edges communes entre une face inside et (faces onside, edges pipe et fond débouchante)")
- edgesPeauFis = list()
- edgesPipeFis = list()
- edgesPipeFnd = list()
- try:
- edgesPeauFis = geompy.GetSharedShapesMulti([geompy.MakeCompound(facesOnside), face], geompy.ShapeType["EDGE"])
- logging.debug(" faces onside %s",edgesPeauFis)
- edgesPipeFis = geompy.GetSharedShapesMulti([geompy.MakeCompound(edgesPipeIn), face], geompy.ShapeType["EDGE"])
- logging.debug(" edgesPipeIn %s", edgesPipeFis)
- edgesPipeFnd = geompy.GetSharedShapesMulti([geompy.MakeCompound(edgesFondIn), face], geompy.ShapeType["EDGE"])
- logging.debug(" edgesFondIn %s ", edgesPipeFnd)
- except:
- logging.debug(" pb edges communes %s %s %s",edgesPeauFis, edgesPipeFis, edgesPipeFnd)
- if (len(edgesPeauFis) > 0) and (len(edgesPipeFis) > 0) and (len(edgesPipeFnd) == 0):
- dist = geompy.MinDistance(geompy.MakeCompound(edgesPeauFis), ptPeau)
- logging.debug(" test distance extrémité reference %s", dist)
- if dist < 1.e-3: # c'est la face de fissure externe associée
- logging.debug(" face %s inside ajoutée", i)
- facesFissExt.append(face)
- name="faceFissExt%d"%iedf
- geomPublishInFather(initLog.debug,partitionPeauFissFond, face, name)
- dist = 1.
- for _, edpe in enumerate(edgesPeauFis):
- for _, edpi in enumerate(edgesPipeFis):
- dist = geompy.MinDistance(edpe, edpi)
- if dist < 1.e-3:
- edgesFissExtPeau.append(edpe)
- name="edgesFissExtPeau%d"%iedf
- geomPublishInFather(initLog.debug,partitionPeauFissFond, edpe, name)
- edgesFissExtPipe.append(edpi)
- name="edgesFissExtPipe%d"%iedf
- geomPublishInFather(initLog.debug,partitionPeauFissFond, edpi, name)
- break
- if dist < 1.e-3:
- break
-
- if len(verticesPipePeau) == 0: # aucune extrémité du pipe sur cette face de peau
- # il faut recenser les edges de fissure sur la face de peau
- j = 0
- for face in facesInside:
- edgesPeauFis = list()
- edgesPipeFis = list()
- edgesPipeFnd = list()
- try:
- edgesPeauFis = geompy.GetSharedShapesMulti([geompy.MakeCompound(facesOnside), face], geompy.ShapeType["EDGE"])
- edgesPipeFis = geompy.GetSharedShapesMulti([geompy.MakeCompound(edgesPipeIn), face], geompy.ShapeType["EDGE"])
- edgesPipeFnd = geompy.GetSharedShapesMulti([geompy.MakeCompound(edgesFondIn), face], geompy.ShapeType["EDGE"])
- except:
- pass
- if (len(edgesPeauFis) > 0) and (len(edgesPipeFis) > 0) and (len(edgesPipeFnd) == 0):
- edgesFissExtPeau.append(edgesPeauFis[0])
- name="edgesFissExtPeau%d"%j
- geomPublishInFather(initLog.debug,partitionPeauFissFond, edgesPeauFis[0], name)
- j += 1
-
- # -----------------------------------------------------------------------
- # --- identification faces de peau : face de peau percée du pipe, extrémités du pipe
- # La partition avec le pipe peut créer un vertex (et un edge) de trop sur le cercle projeté,
- # quand le cercle est très proche de la face.
- # dans ce cas, la projection du cercle sur la face suivie d'une partition permet
- # d'éviter le point en trop
-
- facesAndFond = facesOnside
- facesAndFond.append(wireFondFiss)
- try:
- partitionPeauByPipe = geompy.MakePartition(facesAndFond, pipexts, list(), list(), geompy.ShapeType["FACE"], 0, list(), 1)
- except:
- logging.debug("probleme partition face pipe, contournement avec MakeSection")
- sections = list()
- for pipext in pipexts:
- sections.append(geompy.MakeSection(facesOnside[0], pipext))
- partitionPeauByPipe = geompy.MakePartition(facesAndFond, sections, list(), list(), geompy.ShapeType["FACE"], 0, list(), 1)
-
- # contrôle edge en trop sur edges circulaires
- if len(verticesPipePeau) > 0: # --- au moins une extrémité du pipe sur cette face de peau
- edgeEnTrop = list()
- outilPart = pipexts
- facesPeau = geompy.ExtractShapes(partitionPeauByPipe, geompy.ShapeType["FACE"], False)
- facesPeauSorted, _, _ = sortFaces(facesPeau)
- for i, face in enumerate(facesPeauSorted[:-1]): # on ne teste que la ou les petites faces "circulaires"
- nbv = geompy.NumberOfEdges(face)
- logging.debug("nombre d'edges sur face circulaire: %s", nbv)
- if nbv > 3:
- edgeEnTrop.append(True) # TODO : distinguer les cas avec deux faces circulaires dont l'une est correcte
- else:
- edgeEnTrop.append(False)
- refaire = sum(edgeEnTrop)
- if refaire > 0:
- dc = [(geompy.MinDistance(verticesEdgesFondIn[0], fac), i) for i, fac in enumerate(facesPeauSorted[:-1])]
- dc.sort()
- logging.debug("dc sorted: %s", dc)
- i0 = dc[0][1] # indice de facesPeauSorted qui correspond à verticesEdgesFondIn[0], donc 0 pour cercles
- direct = (i0 == 0)
- for i, bad in enumerate(edgeEnTrop):
- if direct:
- j = i
- else:
- j = 1-i
- if bad:
- outilPart[j] = geompy.MakeProjection(cercles[j],facesOnside[0])
- partitionPeauByPipe = geompy.MakePartition(facesAndFond, outilPart, list(), list(), geompy.ShapeType["FACE"], 0, list(), 1)
-
- name="partitionPeauByPipe%d"%ifil
- geomPublish(initLog.debug, partitionPeauByPipe, name)
- [edgesPeauFondIn, _, _] = extractionOrientee(fillingFaceExterne, partitionPeauByPipe, centreFondFiss, "EDGE", 1.e-3)
- [_, _, facesPeauFondOn] = extractionOrientee(fillingFaceExterne, partitionPeauByPipe, centreFondFiss, "FACE", 1.e-3)
-
- if len(verticesPipePeau) > 0: # --- au moins une extrémité du pipe sur cette face de peau
- facesPeauSorted, _, _ = sortFaces(facesPeauFondOn)
- facePeau = facesPeauSorted[-1] # la plus grande face
- else:
- facePeau =geompy.MakePartition(facesPeauFondOn, list(), list(), list(), geompy.ShapeType["FACE"], 0, list(), 1)
- name="facePeau%d"%ifil
- geomPublish(initLog.debug, facePeau, name)
-
- facesPipePeau = [None for i in range(len(edgesFissExtPipe))]
- endsEdgeFond = [None for i in range(len(edgesFissExtPipe))]
- edgeRadFacePipePeau = [None for i in range(len(edgesFissExtPipe))]
-
- edgesListees = list()
- edgesCircPeau = list()
- verticesCircPeau = list()
- if len(verticesPipePeau) > 0: # --- au moins une extrémité du pipe sur cette face de peau
-
- for face in facesPeauSorted[:-1]: # la ou les faces débouchantes, pas la grande face de peau
- logging.debug("examen face debouchante circulaire")
- for i,efep in enumerate(edgesFissExtPipe):
- dist = geompy.MinDistance(face, efep)
- logging.debug(" distance face circulaire edge %s", dist)
- if dist < 1e-3:
- for ik, edpfi in enumerate(edgesPeauFondIn):
- if geompy.MinDistance(face, edpfi) < 1e-3:
- ikok = ik
- break
- sharedVertices = geompy.GetSharedShapesMulti([face, edgesPeauFondIn[ikok]], geompy.ShapeType["VERTEX"])
- nameFace = "facePipePeau%d"%i
- nameVert = "endEdgeFond%d"%i
- nameEdge = "edgeRadFacePipePeau%d"%i
- facesPipePeau[i] = face
- endsEdgeFond[i] = sharedVertices[0]
- geomPublish(initLog.debug, face, nameFace)
- geomPublish(initLog.debug, sharedVertices[0], nameVert)
- edgesFace = geompy.ExtractShapes(face, geompy.ShapeType["EDGE"], True)
- for edge in edgesFace:
- if geompy.MinDistance(edge, sharedVertices[0]) < 1e-3:
- edgeRadFacePipePeau[i] = edge
- geomPublish(initLog.debug, edge, nameEdge)
- break
-
- # --- edges circulaires de la face de peau et points de jonction de la face externe de fissure
- logging.debug("facesPipePeau: %s", facesPipePeau)
- edgesCircPeau = [None for i in range(len(facesPipePeau))]
- verticesCircPeau = [None for i in range(len(facesPipePeau))]
- for i,fcirc in enumerate(facesPipePeau):
- edges = geompy.GetSharedShapesMulti([facePeau, fcirc], geompy.ShapeType["EDGE"])
- grpEdgesCirc = geompy.CreateGroup(facePeau, geompy.ShapeType["EDGE"])
- geompy.UnionList(grpEdgesCirc, edges)
- edgesCircPeau[i] = grpEdgesCirc
- name = "edgeCirc%d"%i
- geomPublishInFather(initLog.debug,facePeau, grpEdgesCirc, name)
- edgesListees = edgesListees + edges
- vertices = geompy.GetSharedShapesMulti([facePeau, fcirc], geompy.ShapeType["VERTEX"])
- grpVertCircPeau = geompy.CreateGroup(facePeau, geompy.ShapeType["VERTEX"])
- geompy.UnionList(grpVertCircPeau, vertices)
- verticesCircPeau[i] = grpVertCircPeau
- name = "pointEdgeCirc%d"%i
- geomPublishInFather(initLog.debug,facePeau, grpVertCircPeau, name)
- # --- au moins une extrémité du pipe sur cette face de peau
-
- # --- edges de bord de la face de peau
-
- edgesFilling = geompy.ExtractShapes(fillingFaceExterne, geompy.ShapeType["EDGE"], False)
- edgesBords = list()
- for i, edge in enumerate(edgesFilling):
- edgepeau = geompy.GetInPlace(facePeau, edge)
- name = "edgepeau%d"%i
- geomPublishInFather(initLog.debug,facePeau,edgepeau, name)
- logging.debug("edgepeau %s", geompy.ShapeInfo(edgepeau))
- if geompy.ShapeInfo(edgepeau)['EDGE'] > 1:
- logging.debug(" EDGES multiples")
- edgs = geompy.ExtractShapes(edgepeau, geompy.ShapeType["EDGE"], False)
- edgesBords += edgs
- edgesListees += edgs
- else:
- logging.debug(" EDGE")
- edgesBords.append(edgepeau)
- edgesListees.append(edgepeau)
- groupEdgesBordPeau = geompy.CreateGroup(facePeau, geompy.ShapeType["EDGE"])
- geompy.UnionList(groupEdgesBordPeau, edgesBords)
- bordsVifs = None
- if aretesVivesC is not None:
- bordsVifs = geompy.GetInPlace(facePeau, aretesVivesC)
- if bordsVifs is not None:
- geomPublishInFather(initLog.debug,facePeau, bordsVifs, "bordsVifs")
- groupEdgesBordPeau = geompy.CutGroups(groupEdgesBordPeau, bordsVifs)
- grptmp = None
- if len(aretesVivesCoupees) > 0:
- grpC = geompy.MakeCompound(aretesVivesCoupees)
- grptmp = geompy.GetInPlace(facePeau, grpC)
- if grptmp is not None:
- grpnew = geompy.CutGroups(bordsVifs, grptmp) # ce qui est nouveau dans bordsVifs
- else:
- grpnew = bordsVifs
- if grpnew is not None:
- edv = geompy.ExtractShapes(grpnew, geompy.ShapeType["EDGE"], False)
- aretesVivesCoupees += edv
- logging.debug("aretesVivesCoupees %s",aretesVivesCoupees)
- geomPublishInFather(initLog.debug,facePeau, groupEdgesBordPeau , "EdgesBords")
-
- # --- edges de la face de peau partagées avec la face de fissure
-
- edgesPeau = geompy.ExtractShapes(facePeau, geompy.ShapeType["EDGE"], False)
- edges = substractSubShapes(facePeau, edgesPeau, edgesListees)
- edgesFissurePeau = list()
- if len(verticesPipePeau) > 0: # --- au moins une extrémité du pipe sur cette face de peau
- edgesFissurePeau = [None for i in range(len(verticesCircPeau))] # edges associés aux extrémités du pipe, en premier
- for edge in edges:
- for i, grpVert in enumerate(verticesCircPeau):
- if (geompy.MinDistance(grpVert, edge) < 1.e-3) and (edge not in edgesFissurePeau):
- edgesFissurePeau[i] = edge
- name = "edgeFissurePeau%d"%i
- geomPublishInFather(initLog.debug,facePeau, edge, name)
- for edge in edges: # on ajoute après les edges manquantes
- if edge not in edgesFissurePeau:
- edgesFissurePeau.append(edge)
- else:
- for i, edge in enumerate(edges):
- edgesFissurePeau.append(edge)
- name = "edgeFissurePeau%d"%i
- geomPublishInFather(initLog.debug,facePeau, edge, name)
-
- ptEdgeFond[ifil] = endsEdgeFond # pour chaque face [points edge fond de fissure aux débouchés du pipe]
- fsPipePeau[ifil] = facesPipePeau # pour chaque face [faces du pipe débouchantes]
- edRadFPiPo[ifil] = edgeRadFacePipePeau # pour chaque face [edge radiale des faces du pipe débouchantes ]
- fsFissuExt[ifil] = facesFissExt # pour chaque face [faces de fissure externes au pipe]
- edFisExtPe[ifil] = edgesFissExtPeau # pour chaque face [edge en peau des faces de fissure externes (pas subshape facePeau)]
- edFisExtPi[ifil] = edgesFissExtPipe # pour chaque face [edge commun au pipe des faces de fissure externes]
- facesPeaux[ifil] = facePeau # pour chaque face : la face de peau finale a mailler (percee des faces débouchantes)
- edCircPeau[ifil] = edgesCircPeau # pour chaque face de peau : [groupe subshapes edges circulaires aux débouchés du pipe]
- ptCircPeau[ifil] = verticesCircPeau # pour chaque face de peau : [groupe subshapes points sur edges circulaires aux débouchés du pipe]
- gpedgeBord[ifil] = groupEdgesBordPeau # pour chaque face de peau : groupe subshape des edges aux bords liés à la partie saine
- gpedgeVifs[ifil] = bordsVifs # pour chaque face de peau : groupe subshape des edges aux bords correspondant à des arêtes vives
- edFissPeau[ifil] = edgesFissurePeau # pour chaque face de peau : [subshape edge en peau des faces de fissure externes]
- ptFisExtPi[ifil] = verticesPipePeau # pour chaque face de peau : [point commun edFissPeau edCircPeau]
-
- # -----------------------------------------------------------------------
- # fin de la boucle sur les faces de filling
- # -----------------------------------------------------------------------
-
- for i, avc in enumerate(aretesVivesCoupees):
- name = "areteViveCoupee%d"%i
- geomPublish(initLog.debug, avc, name)
-
- # --- identification des faces et edges de fissure externe pour maillage
-
- facesFissExt = list()
- edgesFissExtPeau = list()
- edgesFissExtPipe = list()
- for ifil in range(nbFacesFilling): # TODO: éliminer les doublons (comparer tous les vertices triés, avec mesure de distance ?)
- facesFissExt += fsFissuExt[ifil]
- edgesFissExtPeau += edFisExtPe[ifil]
- edgesFissExtPipe += edFisExtPi[ifil]
- logging.debug("---------------------------- identification faces de fissure externes au pipe :%s ", len(facesFissExt))
- # regroupement des faces de fissure externes au pipe.
-
- if len(facesFissExt) > 1:
- faceFissureExterne = geompy.MakePartition(facesFissExt, list(), list(), list(), geompy.ShapeType["FACE"], 0, list(), 0)
- edgesPipeFissureExterneC = geompy.GetInPlace(faceFissureExterne, geompy.MakeCompound(edgesPipeFiss)) # edgesFissExtPipe peut ne pas couvrir toute la longueur
- # edgesPeauFissureExterneC = geompy.GetInPlace(faceFissureExterne, geompy.MakeCompound(edgesFissExtPeau))
- # il peut manquer des edges de faceFissureExterne en contact avec la peau dans edgesFissExtPeau
- (_, closedFreeBoundaries, _) = geompy.GetFreeBoundary(faceFissureExterne)
- edgesBordFFE = list()
- for bound in closedFreeBoundaries:
- edgesBordFFE += geompy.ExtractShapes(bound, geompy.ShapeType["EDGE"], False)
- edgesBordFFEid = [ (ed,geompy.GetSubShapeID(faceFissureExterne, ed)) for ed in edgesBordFFE]
- logging.debug("edgesBordFFEid %s", edgesBordFFEid)
- edgesPPE = geompy.ExtractShapes(edgesPipeFissureExterneC, geompy.ShapeType["EDGE"], False)
- edgesPPEid = [ geompy.GetSubShapeID(faceFissureExterne, ed) for ed in edgesPPE]
- logging.debug("edgesPPEid %s", edgesPPEid)
- edgesPFE = [ edid[0] for edid in edgesBordFFEid if edid[1] not in edgesPPEid] # on garde toutes les edges de bord non en contact avec le pipe
- logging.debug("edgesPFE %s", edgesPFE)
- edgesPeauFissureExterneC = geompy.MakeCompound(edgesPFE)
- else:
- faceFissureExterne = facesFissExt[0]
- edgesPeauFissureExterneC = geompy.MakeCompound(edgesFissExtPeau)
- edgesPipeFissureExterneC = geompy.MakeCompound(edgesFissExtPipe)
- wirePipeFissureExterne = geompy.MakeWire(geompy.ExtractShapes(edgesPipeFissureExterneC, geompy.ShapeType["EDGE"], False))
- geomPublish(initLog.debug, faceFissureExterne, "faceFissureExterne")
- geomPublishInFather(initLog.debug,faceFissureExterne, edgesPeauFissureExterneC, "edgesPeauFissureExterne")
- geomPublishInFather(initLog.debug,faceFissureExterne, edgesPipeFissureExterneC, "edgesPipeFissureExterne")
-
- logging.debug("---------------------------- Preparation Maillage du Pipe --------------")
- # -----------------------------------------------------------------------
- # --- preparation maillage du pipe :
- # - détections des points a respecter : jonction des edges/faces constituant
- # la face de fissure externe au pipe
- # - points sur les edges de fond de fissure et edges pipe/face fissure,
- # - vecteurs tangents au fond de fissure (normal au disque maillé)
-
- # --- option de maillage selon le rayon de courbure du fond de fissure
- lenEdgeFondExt = 0
- for edff in edgesFondFiss:
- lenEdgeFondExt += geompy.BasicProperties(edff)[0]
-
- disfond = list()
- for filling in facesDefaut:
- disfond.append(geompy.MinDistance(centreFondFiss, filling))
- disfond.sort()
- rcourb = disfond[0]
- nbSegQuart = 5 # on veut 5 segments min sur un quart de cercle
- alpha = math.pi/(4*nbSegQuart)
- deflexion = rcourb*(1.0 -math.cos(alpha))
- lgmin = lenSegPipe*0.25
- lgmax = lenSegPipe*1.5
- logging.debug("rcourb: %s, lenFond:%s, deflexion: %s, lgmin: %s, lgmax: %s", rcourb, lenEdgeFondExt, deflexion, lgmin, lgmax)
-
- meshFondExt = smesh.Mesh(wireFondFiss)
- algo1d = meshFondExt.Segment()
- hypo1d = algo1d.Adaptive(lgmin, lgmax, deflexion) # a ajuster selon la profondeur de la fissure
-
- is_done = meshFondExt.Compute()
- text = "meshFondExt.Compute"
- if is_done:
- logging.info(text+" OK")
- else:
- text = "Erreur au calcul du maillage.\n" + text
- logging.info(text)
- raise Exception(text)
-
- ptGSdic = {} # dictionnaire [paramètre sur la courbe] --> point géométrique
- allNodeIds = meshFondExt.GetNodesId()
- for nodeId in allNodeIds:
- xyz = meshFondExt.GetNodeXYZ(nodeId)
- #logging.debug("nodeId %s, coords %s", nodeId, str(xyz))
- pt = geompy.MakeVertex(xyz[0], xyz[1], xyz[2])
- parametre, PointOnEdge, EdgeInWireIndex = geompy.MakeProjectionOnWire(pt, wireFondFiss) # parametre compris entre 0 et 1
- edgeOrder = edgesIdByOrientation[EdgeInWireIndex]
- ptGSdic[(edgeOrder, EdgeInWireIndex, parametre)] = pt
- #logging.debug("nodeId %s, parametre %s", nodeId, str(parametre))
- usort = sorted(ptGSdic)
- logging.debug("nombre de points obtenus par deflexion %s",len(usort))
-
- centres = list()
- origins = list()
- normals = list()
- for edu in usort:
- vertcx = ptGSdic[edu]
- norm = geompy.MakeTangentOnCurve(edgesFondFiss[edu[1]], edu[2])
- plan = geompy.MakePlane(vertcx, norm, 3*rayonPipe)
- part = geompy.MakePartition([plan], [wirePipeFiss], list(), list(), geompy.ShapeType["VERTEX"], 0, list(), 0)
- liste = geompy.ExtractShapes(part, geompy.ShapeType["VERTEX"], True)
- if len(liste) == 5: # 4 coins du plan plus intersection recherchée
- for point in liste:
- if geompy.MinDistance(point, vertcx) < 1.1*rayonPipe: # les quatre coins sont plus loin
- vertpx = point
- break
- centres.append(vertcx)
- origins.append(vertpx)
- normals.append(norm)
-# name = "vertcx%d"%i
-# geomPublishInFather(initLog.debug,wireFondFiss, vertcx, name)
-# name = "vertpx%d"%i
-# geomPublishInFather(initLog.debug,wireFondFiss, vertpx, name)
-# name = "plan%d"%i
-# geomPublishInFather(initLog.debug,wireFondFiss, plan, name)
-
- # --- maillage du pipe étendu, sans tenir compte de l'intersection avec la face de peau
-
- logging.debug("nbsegCercle %s", nbsegCercle)
-
- # -----------------------------------------------------------------------
- # --- points géométriques
-
- gptsdisks = list() # vertices géométrie de tous les disques
- raydisks = [list() for i in range(nbsegCercle)]
- for i, centres_i in enumerate(centres): # boucle sur les disques
- gptdsk = list() # vertices géométrie d'un disque
- vertcx = centres_i
- vertpx = origins[i]
- normal = normals[i]
- vec1 = geompy.MakeVector(vertcx, vertpx)
-
- points = [vertcx] # les points du rayon de référence
- for j in range(nbsegRad):
- pt = geompy.MakeTranslationVectorDistance(vertcx, vec1, (j+1)*float(rayonPipe)/nbsegRad)
- points.append(pt)
- gptdsk.append(points)
- pt = geompy.MakeTranslationVectorDistance(vertcx, vec1, 1.5*rayonPipe)
- rayon = geompy.MakeLineTwoPnt(vertcx, pt)
- raydisks[0].append(rayon)
-
- for k in range(nbsegCercle-1):
- angle = (k+1)*2*math.pi/nbsegCercle
- pts = [vertcx] # les points d'un rayon obtenu par rotation
- for j in range(nbsegRad):
- pt = geompy.MakeRotation(points[j+1], normal, angle)
- pts.append(pt)
- gptdsk.append(pts)
- ray = geompy.MakeRotation(rayon, normal, angle)
- raydisks[k+1].append(ray)
-
- gptsdisks.append(gptdsk)
-
- # -----------------------------------------------------------------------
- # --- recherche des points en trop (externes au volume à remailler)
- # - on associe chaque extrémité du pipe à une face filling
- # - on part des disques aux extrémités du pipe
- # - pour chaque disque, on prend les vertices de géométrie,
- # on marque leur position relative à la face.
- # - on s'arrete quand tous les noeuds sont dedans
-
- logging.debug("---------------------------- recherche des points du pipe a éliminer --------------")
-
- pt0 = centres[0]
- pt1 = centres[-1]
- idFillingFromBout = [None, None] # contiendra l'index du filling pour les extrémités 0 et 1
- for ifil in range(nbFacesFilling):
- for _, pt in enumerate(ptEdgeFond[ifil]): # il y a un ou deux points débouchant sur cette face
- if geompy.MinDistance(pt,pt0) < geompy.MinDistance(pt,pt1): # TODO: trouver plus fiable pour les cas tordus...
- idFillingFromBout[0] = ifil
- else:
- idFillingFromBout[1] = ifil
- logging.debug("association bouts du pipe - faces de filling: %s", idFillingFromBout)
-
- facesPipePeau = list()
- edgeRadFacePipePeau = list()
- for ifil in range(nbFacesFilling):
- facesPipePeau += fsPipePeau[ifil]
- edgeRadFacePipePeau += edRadFPiPo[ifil]
-
- logging.debug("recherche des disques de noeuds complètement internes")
- idisklim = list() # indices des premier et dernier disques internes
- idiskout = list() # indices des premier et dernier disques externes
- for bout in range(2):
- if bout == 0:
- idisk = -1
- inc = 1
- numout = -1
- else:
- idisk = len(gptsdisks)
- inc = -1
- numout = len(gptsdisks)
- inside = False
- outside = True
- while not inside:
- idisk = idisk + inc
- logging.debug("examen disque %s", idisk)
- gptdsk = gptsdisks[idisk]
- inside = True
- for k in range(nbsegCercle):
- points = gptdsk[k]
- for j, pt in enumerate(points):
- side = whichSideVertex(facesDefaut[idFillingFromBout[bout]], pt)
- if side < 0:
- if outside: # premier point detecté dedans
- outside = False
- numout = idisk -inc # le disque précédent était dehors
- else:
- inside = False # ce point est dehors
- if not inside and not outside:
- break
- idisklim.append(idisk) # premier et dernier disques internes
- idiskout.append(numout) # premier et dernier disques externes
-
- # --- listes de nappes radiales en filling à chaque extrémité débouchante
- facesDebouchantes = [False, False]
- idFacesDebouchantes = [-1, -1] # contiendra les indices des faces disque débouchantes (facesPipePeau)
- listNappes =list()
- for i, idisk in enumerate(idisklim):
- numout = idiskout[i]
- logging.debug("extremité %s, indices disques interne %s, externe %s",i, idisk, numout)
- nappes = list()
- if (idisk != 0) and (idisk != len(gptsdisks)-1): # si extrémité débouchante
- for k in range(nbsegCercle):
- if i == 0:
- iddeb = max(0, numout)
- idfin = max(iddeb+3,idisk+1) # il faut 3 rayons pour faire un filling qui suive le fond de fissure
- #logging.debug("extremité %s, indices retenus interne %s, externe %s",i, idfin, iddeb)
- comp = geompy.MakeCompound(raydisks[k][iddeb:idfin])
- name='compoundRay%d'%k
- geomPublish(initLog.debug, comp, name)
- else:
- idfin = min(len(gptsdisks), numout+1)
- iddeb = min(idfin-3, idisk) # il faut 3 rayons pour faire un filling qui suive le fond de fissure
- #logging.debug("extremité %s, indices retenus interne %s, externe %s",i, idfin, iddeb)
- comp = geompy.MakeCompound(raydisks[k][iddeb:idfin])
- name='compoundRay%d'%k
- geomPublish(initLog.debug, comp, name)
- nappe = geompy.MakeFilling(comp, 2, 5, 0.0001, 0.0001, 0, GEOM.FOM_Default)
- nappes.append(nappe)
- name='nappe%d'%k
- geomPublish(initLog.debug, nappe, name)
- facesDebouchantes[i] = True
- listNappes.append(nappes)
-
- # --- mise en correspondance avec les indices des faces disque débouchantes (facesPipePeau)
- for i, nappes in enumerate(listNappes):
- if facesDebouchantes[i]:
- for k, face in enumerate(facesPipePeau):
- edge = geompy.MakeSection(face, nappes[0])
- if geompy.NbShapes(edge, geompy.ShapeType["EDGE"]) > 0:
- idFacesDebouchantes[i] = k
- break
- logging.debug("idFacesDebouchantes: %s", idFacesDebouchantes)
-
- # --- construction des listes d'edges radiales sur chaque extrémité débouchante
- listEdges = list()
- for i, nappes in enumerate(listNappes):
- indice = idFacesDebouchantes[i] # indice de face débouchante (facesPipePeau)
- if indice < 0:
- listEdges.append(list())
- else:
- face = facesPipePeau[indice]
- edges = [edgeRadFacePipePeau[indice]]
- for k, nappe in enumerate(nappes):
- if k > 0:
- obj = geompy.MakeSection(face, nappes[k]) # normalement une edge, parfois un compound d'edges dont un tout petit
- edge = obj
- vs = geompy.ExtractShapes(obj, geompy.ShapeType["VERTEX"], False)
- if len(vs) > 2:
- eds = geompy.ExtractShapes(obj, geompy.ShapeType["EDGE"], False)
- [edsorted, _,maxl] = sortEdges(eds)
- edge = edsorted[-1]
- else:
- maxl = geompy.BasicProperties(edge)[0]
- if maxl < 0.01: # problème MakeSection
- logging.debug("problème MakeSection recherche edge radiale %s, longueur trop faible: %s, utilisation partition", k, maxl)
- partNappeFace = geompy.MakePartition([face, nappes[k]], list() , list(), list(), geompy.ShapeType["FACE"], 0, list(), 0)
- edps= geompy.ExtractShapes(partNappeFace, geompy.ShapeType["EDGE"], False)
- ednouv = list()
- for ii, ed in enumerate(edps):
- vxs = geompy.ExtractShapes(ed, geompy.ShapeType["VERTEX"], False)
- distx = [geompy.MinDistance(vx, face) for vx in vxs]
- distx += [geompy.MinDistance(vx, nappes[k]) for vx in vxs]
- dmax = max(distx)
- logging.debug(" dmax %s",dmax)
- if dmax < 0.01:
- ednouv.append(ed)
- logging.debug(" edges issues de la partition: %s", ednouv)
- for ii, ed in enumerate(ednouv):
- geomPublish(initLog.debug, ed, "ednouv%d"%ii)
- [edsorted, _,maxl] = sortEdges(ednouv)
- logging.debug(" longueur edge trouvée: %s", maxl)
- edge = edsorted[-1]
- edges.append(edge)
- name = 'edgeEndPipe%d'%k
- geomPublish(initLog.debug, edge, name)
- listEdges.append(edges)
-
- # --- création des points du maillage du pipe sur la face de peau
- for i, edges in enumerate(listEdges):
- indice = idFacesDebouchantes[i] # indice de face débouchante (facesPipePeau)
- if indice >= 0:
- gptdsk = list()
- if indice > 0: # indice vaut 0 ou 1
- indice = -1 # si indice vaut 1, on prend le dernier élément de la liste (1 ou 2 extrémités débouchent sur la face)
- centre = ptEdgeFond[idFillingFromBout[i]][indice]
- name = "centre%d"%indice
- geomPublish(initLog.debug, centre, name)
- vertPipePeau = ptFisExtPi[idFillingFromBout[i]][indice]
- geomPublishInFather(initLog.debug,centre, vertPipePeau, "vertPipePeau")
- grpsEdgesCirc = edCircPeau[idFillingFromBout[i]] # liste de groupes
- edgesCirc = list()
- for grpEdgesCirc in grpsEdgesCirc:
- edgesCirc += geompy.ExtractShapes(grpEdgesCirc, geompy.ShapeType["EDGE"], False)
- for k, edge in enumerate(edges):
- extrems = geompy.ExtractShapes(edge, geompy.ShapeType["VERTEX"], True)
- if geompy.MinDistance(centre, extrems[0]) < geompy.MinDistance(centre, extrems[1]):
- bout = extrems[1]
- else:
- bout = extrems[0]
- # ajustement du point extrémité (bout) sur l'edge circulaire en face de peau
- logging.debug("edgesCirc: %s", edgesCirc)
- distEdgeCirc = [(geompy.MinDistance(bout, edgeCirc), k2, edgeCirc) for k2, edgeCirc in enumerate(edgesCirc)]
- distEdgeCirc.sort()
- logging.debug("distEdgeCirc: %s", distEdgeCirc)
- u = projettePointSurCourbe(bout, distEdgeCirc[0][2])
- if (abs(u) < 0.02) or (abs(1-u) < 0.02): # les points très proches d'une extrémité doivent y être mis précisément.
- extrCircs = geompy.ExtractShapes(distEdgeCirc[0][2], geompy.ShapeType["VERTEX"], True)
- if geompy.MinDistance(bout, extrCircs[0]) < geompy.MinDistance(bout, extrCircs[1]):
- bout = extrCircs[0]
- else:
- bout = extrCircs[1]
- else:
- bout = geompy.MakeVertexOnCurve(distEdgeCirc[0][2], u)
- name ="bout%d"%k
- geomPublishInFather(initLog.debug,centre, bout, name)
- # enregistrement des points dans la structure
- points = list()
- for j in range(nbsegRad +1):
- u = j/float(nbsegRad)
- points.append(geompy.MakeVertexOnCurve(edge, u))
- if geompy.MinDistance(bout, points[0]) < geompy.MinDistance(centre, points[0]):
- points.reverse()
- points[0] = centre
- points[-1] = bout
- gptdsk.append(points)
- if i == 0:
- gptsdisks[idisklim[0] -1] = gptdsk
- idisklim[0] = idisklim[0] -1
- else:
- gptsdisks[idisklim[1] +1] = gptdsk
- idisklim[1] = idisklim[1] +1
-
- # --- ajustement precis des points sur edgesPipeFissureExterneC
-
- edgesPFE = geompy.ExtractShapes(edgesPipeFissureExterneC, geompy.ShapeType["EDGE"], False)
- verticesPFE, _ = findWireIntermediateVertices(wirePipeFissureExterne) # vertices intermédiaires (des points en trop dans ptsInWireFissExtPipe)
- idiskmin = idisklim[0] + 1 # on ne prend pas le disque sur la peau, déjà ajusté
- idiskmax = idisklim[1] # on ne prend pas le disque sur la peau, déjà ajusté
- idiskint = list()
- for vtx in verticesPFE:
- distPtVt = list()
- for idisk in range(idiskmin, idiskmax):
- gptdsk = gptsdisks[idisk]
- pt = gptdsk[0][-1] # le point sur l'edge de la fissure externe au pipe
- distPtVt.append((geompy.MinDistance(pt, vtx), idisk))
- distPtVt.sort()
- idiskint.append(distPtVt[0][1])
- gptsdisks[idiskint[-1]][0][-1] = vtx
- logging.debug("ajustement point sur edgePipeFissureExterne, vertex: %s %s", idiskint[-1], distPtVt[0][0])
- for idisk in range(idiskmin, idiskmax):
- if idisk in idiskint:
- break
- logging.debug("ajustement point sur edgePipeFissureExterne: %s", idisk)
- gptdsk = gptsdisks[idisk]
- pt = gptdsk[0][-1] # le point sur l'edge de la fissure externe au pipe
- distPtEd = [(geompy.MinDistance(pt, edgePFE), k, edgePFE) for k, edgePFE in enumerate(edgesPFE)]
- distPtEd.sort()
- edgePFE = distPtEd[0][2]
- u = projettePointSurCourbe(pt, edgePFE)
- ptproj = geompy.MakeVertexOnCurve(edgePFE, u)
- gptsdisks[idisk][0][-1] = ptproj
-
- # -----------------------------------------------------------------------
- # --- maillage effectif du pipe
-
- logging.debug("---------------------------- maillage effectif du pipe --------------")
- meshPipe = smesh.Mesh(None, "meshPipe")
- fondFissGroup = meshPipe.CreateEmptyGroup(SMESH.EDGE, "FONDFISS")
- nodesFondFissGroup = meshPipe.CreateEmptyGroup(SMESH.NODE, "nfondfis")
- faceFissGroup = meshPipe.CreateEmptyGroup(SMESH.FACE, "fisInPi")
- edgeFaceFissGroup = meshPipe.CreateEmptyGroup(SMESH.EDGE, "edgeFaceFiss")
- edgeCircPipe0Group = meshPipe.CreateEmptyGroup(SMESH.EDGE, "edgeCircPipe0")
- edgeCircPipe1Group = meshPipe.CreateEmptyGroup(SMESH.EDGE, "edgeCircPipe1")
- faceCircPipe0Group = meshPipe.CreateEmptyGroup(SMESH.FACE, "faceCircPipe0")
- faceCircPipe1Group = meshPipe.CreateEmptyGroup(SMESH.FACE, "faceCircPipe1")
- mptsdisks = list() # vertices maillage de tous les disques
- mEdges = list() # identifiants edges maillage fond de fissure
- mEdgeFaces = list() # identifiants edges maillage edge face de fissure externe
- mFaces = list() # identifiants faces maillage fissure
- mVols = list() # identifiants volumes maillage pipe
-
- mptdsk = list()
- for idisk in range(idisklim[0], idisklim[1]+1): # boucle sur les disques internes
-
- # -----------------------------------------------------------------------
- # --- points
-
- gptdsk = gptsdisks[idisk]
- if idisk > idisklim[0]:
- oldmpts = mptdsk
- mptdsk = list() # vertices maillage d'un disque
- for k in range(nbsegCercle):
- points = gptdsk[k]
- mptids = list()
- for j, pt in enumerate(points):
- if j == 0 and k > 0:
- indice = mptdsk[0][0]
- else:
- coords = geompy.PointCoordinates(pt)
- indice = meshPipe.AddNode(coords[0], coords[1], coords[2])
- mptids.append(indice)
- mptdsk.append(mptids)
- mptsdisks.append(mptdsk)
-
- # -----------------------------------------------------------------------
- # --- groupes edges cercles debouchants
-
- if idisk == idisklim[0]:
- pts = list()
- for k in range(nbsegCercle):
- pts.append(mptdsk[k][-1])
- edges = list()
- for k, pts_k in enumerate(pts):
- k1 = (k+1)%len(pts)
- idEdge = meshPipe.AddEdge([pts_k, pts[k1]])
- edges.append(idEdge)
- edgeCircPipe0Group.Add(edges)
-
- if idisk == idisklim[1]:
- pts = list()
- for k in range(nbsegCercle):
- pts.append(mptdsk[k][-1])
- edges = list()
- for k, pts_k in enumerate(pts):
- k1 = (k+1)%len(pts)
- idEdge = meshPipe.AddEdge([pts_k, pts[k1]])
- edges.append(idEdge)
- edgeCircPipe1Group.Add(edges)
-
- # -----------------------------------------------------------------------
- # --- groupes faces debouchantes
-
- if idisk == idisklim[0]:
- faces = list()
- for j in range(nbsegRad):
- for k in range(nbsegCercle):
- k1 = k+1
- if k == nbsegCercle-1:
- k1 = 0
- if j == 0:
- idf = meshPipe.AddFace([mptdsk[k][0], mptdsk[k][1], mptdsk[k1][1]]) # triangle
- else:
- idf = meshPipe.AddFace([mptdsk[k][j], mptdsk[k][j+1], mptdsk[k1][j+1], mptdsk[k1][j]]) # quadrangle
- faces.append(idf)
- faceCircPipe0Group.Add(faces)
-
- if idisk == idisklim[1]:
- faces = list()
- for j in range(nbsegRad):
- for k in range(nbsegCercle):
- k1 = k+1
- if k == nbsegCercle-1:
- k1 = 0
- if j == 0:
- idf = meshPipe.AddFace([mptdsk[k][0], mptdsk[k][1], mptdsk[k1][1]]) # triangle
- else:
- idf = meshPipe.AddFace([mptdsk[k][j], mptdsk[k][j+1], mptdsk[k1][j+1], mptdsk[k1][j]]) # quadrangle
- faces.append(idf)
- faceCircPipe1Group.Add(faces)
-
- # -----------------------------------------------------------------------
- # --- mailles volumiques, groupes noeuds et edges de fond de fissure, groupe de face de fissure
-
- if idisk == idisklim[0]:
- mEdges.append(0)
- mEdgeFaces.append(0)
- mFaces.append([0])
- mVols.append([[0]])
- nodesFondFissGroup.Add([mptdsk[0][0]])
- else:
- ide = meshPipe.AddEdge([oldmpts[0][0], mptdsk[0][0]])
- mEdges.append(ide)
- fondFissGroup.Add([ide])
- nodesFondFissGroup.Add([mptdsk[0][0]])
- ide2 = meshPipe.AddEdge([oldmpts[0][-1], mptdsk[0][-1]])
- mEdgeFaces.append(ide2)
- edgeFaceFissGroup.Add([ide2])
- idFaces = list()
- idVols = list()
-
- for j in range(nbsegRad):
- idf = meshPipe.AddFace([oldmpts[0][j], mptdsk[0][j], mptdsk[0][j+1], oldmpts[0][j+1]])
- faceFissGroup.Add([idf])
- idFaces.append(idf)
-
- idVolCercle = list()
- for k in range(nbsegCercle):
- k1 = k+1
- if k == nbsegCercle-1:
- k1 = 0
- if j == 0:
- idv = meshPipe.AddVolume([mptdsk[k][j], mptdsk[k][j+1], mptdsk[k1][j+1],
- oldmpts[k][j], oldmpts[k][j+1], oldmpts[k1][j+1]])
- else:
- idv = meshPipe.AddVolume([mptdsk[k][j], mptdsk[k][j+1], mptdsk[k1][j+1], mptdsk[k1][j],
- oldmpts[k][j], oldmpts[k][j+1], oldmpts[k1][j+1], oldmpts[k1][j]])
- idVolCercle.append(idv)
- idVols.append(idVolCercle)
-
- mFaces.append(idFaces)
- mVols.append(idVols)
-
- pipeFissGroup = meshPipe.CreateEmptyGroup( SMESH.VOLUME, 'PIPEFISS' )
- _ = pipeFissGroup.AddFrom( meshPipe.GetMesh() )
-
- _, _, _ = meshPipe.MakeBoundaryElements(SMESH.BND_2DFROM3D, "pipeBoundaries")
- edgesCircPipeGroup = [edgeCircPipe0Group, edgeCircPipe1Group]
-
- # --- fin du maillage du pipe
- # -----------------------------------------------------------------------
- # --- edges de bord, faces défaut à respecter
-
- _ = smesh.CreateFilterManager()
- _, internalBoundary, _NoneGroup = internalBoundary.MakeBoundaryElements( SMESH.BND_1DFROM2D, '', '', 0, [ ])
- criteres = list()
- unCritere = smesh.GetCriterion(SMESH.EDGE,SMESH.FT_FreeBorders,SMESH.FT_Undefined,0)
- criteres.append(unCritere)
- filtre = smesh.GetFilterFromCriteria(criteres)
- bordsLibres = internalBoundary.MakeGroupByFilter( 'bords', filtre )
- putName(bordsLibres, 'bordsLibres', i_pref=nro_cas)
-
- # --- pour aider l'algo hexa-tetra à ne pas mettre de pyramides à l'exterieur des volumes repliés sur eux-mêmes
- # on désigne les faces de peau en quadrangles par le groupe "skinFaces"
-
- skinFaces = internalBoundary.CreateEmptyGroup( SMESH.FACE, 'skinFaces' )
- _ = skinFaces.AddFrom( internalBoundary.GetMesh() )
-
- # --- maillage des éventuelles arêtes vives entre faces reconstruites
-
- if aretesVivesCoupees:
-
- aretesVivesC = geompy.MakeCompound(aretesVivesCoupees)
- meshAretesVives = smesh.Mesh(aretesVivesC)
- algo1d = meshAretesVives.Segment()
- hypo1d = algo1d.LocalLength(dmoyen,list(),1e-07)
- putName(algo1d.GetSubMesh(), "aretesVives", i_pref=nro_cas)
- putName(algo1d, "algo1d_aretesVives", i_pref=nro_cas)
- putName(hypo1d, "hypo1d_aretesVives", i_pref=nro_cas)
-
- is_done = meshAretesVives.Compute()
- text = "meshAretesVives.Compute"
- if is_done:
- logging.info(text+" OK")
- else:
- text = "Erreur au calcul du maillage.\n" + text
- logging.info(text)
- raise Exception(text)
- grpAretesVives = meshAretesVives.CreateEmptyGroup( SMESH.EDGE, 'grpAretesVives' )
- _ = grpAretesVives.AddFrom( meshAretesVives.GetMesh() )
-
- # -----------------------------------------------------------------------
- # --- maillage faces de fissure
-
- logging.debug("---------------------------- maillage faces de fissure externes au pipe :%s --------------", len(facesFissExt))
-
- meshFaceFiss = smesh.Mesh(faceFissureExterne)
- logging.info("Maillage avec %s", mailleur)
- if ( mailleur == "MeshGems"):
- algo2d = meshFaceFiss.Triangle(algo=smeshBuilder.MG_CADSurf)
- hypo2d = algo2d.Parameters()
- hypo2d.SetPhySize( areteFaceFissure )
- hypo2d.SetMinSize( rayonPipe/float(nbsegRad) )
- hypo2d.SetMaxSize( areteFaceFissure*3. )
- hypo2d.SetChordalError( areteFaceFissure*0.25 )
- hypo2d.SetVerbosity( 0 )
- else:
- algo2d = meshFaceFiss.Triangle(algo=smeshBuilder.NETGEN_1D2D)
- hypo2d = algo2d.Parameters()
- hypo2d.SetMaxSize( areteFaceFissure )
- hypo2d.SetSecondOrder( 0 )
- hypo2d.SetOptimize( 1 )
- hypo2d.SetFineness( 2 )
- hypo2d.SetMinSize( rayonPipe/float(nbsegRad) )
- hypo2d.SetQuadAllowed( 0 )
- putName(algo2d.GetSubMesh(), "faceFiss", i_pref=nro_cas)
- putName(algo2d, "algo2d_faceFiss", i_pref=nro_cas)
- putName(hypo2d, "hypo2d_faceFiss", i_pref=nro_cas)
-
- algo1d = meshFaceFiss.UseExisting1DElements(geom=edgesPipeFissureExterneC)
- hypo1d = algo1d.SourceEdges([ edgeFaceFissGroup ],0,0)
- putName(algo1d.GetSubMesh(), "edgeFissPeau", i_pref=nro_cas)
- putName(algo1d, "algo1d_edgeFissPeau", i_pref=nro_cas)
- putName(hypo1d, "hypo1d_edgeFissPeau", i_pref=nro_cas)
-
- _ = meshFaceFiss.GroupOnGeom(faceFissureExterne, "fisOutPi", SMESH.FACE)
- grpEdgesPeauFissureExterne = meshFaceFiss.GroupOnGeom(edgesPeauFissureExterneC,'edgesPeauFissureExterne',SMESH.EDGE)
- _ = meshFaceFiss.GroupOnGeom(edgesPipeFissureExterneC,'edgesPipeFissureExterne',SMESH.EDGE)
-
- is_done = meshFaceFiss.Compute()
- text = "meshFaceFiss.Compute"
- if is_done:
- logging.info(text+" OK")
- else:
- text = "Erreur au calcul du maillage.\n" + text
- logging.info(text)
- raise Exception(text)
-
- # --- maillage faces de peau
-
- boutFromIfil = [None for i in range(nbFacesFilling)]
- if idFillingFromBout[0] != idFillingFromBout[1]: # repérage des extremites du pipe quand elles débouchent sur des faces différentes
- boutFromIfil[idFillingFromBout[0]] = 0
- boutFromIfil[idFillingFromBout[1]] = 1
-
- logging.debug("---------------------------- maillage faces de peau --------------")
- meshesFacesPeau = list()
- for ifil in range(nbFacesFilling):
- meshFacePeau = None
- if partitionsPeauFissFond[ifil] is None: # face de peau maillage sain intacte
-
- # --- edges de bord de la face de filling1328
-
- filling = facesDefaut[ifil]
- edgesFilling = geompy.ExtractShapes(filling, geompy.ShapeType["EDGE"], False)
- groupEdgesBordPeau = geompy.CreateGroup(filling, geompy.ShapeType["EDGE"])
- geompy.UnionList(groupEdgesBordPeau, edgesFilling)
- geomPublishInFather(initLog.debug,filling, groupEdgesBordPeau , "EdgesBords")
-
- meshFacePeau = smesh.Mesh(facesDefaut[ifil])
-
- algo1d = meshFacePeau.UseExisting1DElements(geom=groupEdgesBordPeau)
- hypo1d = algo1d.SourceEdges([ bordsLibres ],0,0)
- putName(algo1d.GetSubMesh(), "bordsLibres", ifil, nro_cas)
- putName(algo1d, "algo1d_bordsLibres", ifil, nro_cas)
- putName(hypo1d, "hypo1d_bordsLibres", ifil, nro_cas)
-
- else:
-
- facePeau = facesPeaux[ifil] # pour chaque face : la face de peau finale a mailler (percée des faces débouchantes)
- edgesCircPeau = edCircPeau[ifil] # pour chaque face de peau : [subshape edge circulaire aux débouchés du pipe]
- verticesCircPeau = ptCircPeau[ifil] # pour chaque face de peau : [subshape point sur edge circulaire aux débouchés du pipe]
- groupEdgesBordPeau = gpedgeBord[ifil] # pour chaque face de peau : groupe subshape des edges aux bords liés à la partie saine
- bordsVifs = gpedgeVifs[ifil] # pour chaque face de peau : groupe subshape des edges aux bords correspondant à des arêtes vives
- edgesFissurePeau = edFissPeau[ifil] # pour chaque face de peau : [subshape edge en peau des faces de fissure externes]
-
- meshFacePeau = smesh.Mesh(facePeau)
-
- algo1d = meshFacePeau.UseExisting1DElements(geom=groupEdgesBordPeau)
- hypo1d = algo1d.SourceEdges([ bordsLibres ],0,0)
- putName(algo1d.GetSubMesh(), "bordsLibres", ifil, nro_cas)
- putName(algo1d, "algo1d_bordsLibres", ifil, nro_cas)
- putName(hypo1d, "hypo1d_bordsLibres", ifil, nro_cas)
-
- algo1d = meshFacePeau.UseExisting1DElements(geom=geompy.MakeCompound(edgesFissurePeau))
- hypo1d = algo1d.SourceEdges([ grpEdgesPeauFissureExterne ],0,0)
- putName(algo1d.GetSubMesh(), "edgePeauFiss", ifil, nro_cas)
- putName(algo1d, "algo1d_edgePeauFiss", ifil, nro_cas)
- putName(hypo1d, "hypo1d_edgePeauFiss", ifil, nro_cas)
-
- if bordsVifs is not None:
- algo1d = meshFacePeau.UseExisting1DElements(geom=bordsVifs)
- hypo1d = algo1d.SourceEdges([ grpAretesVives ],0,0)
- putName(algo1d.GetSubMesh(), "bordsVifs", ifil, nro_cas)
- putName(algo1d, "algo1d_bordsVifs", ifil, nro_cas)
- putName(hypo1d, "hypo1d_bordsVifs", ifil, nro_cas)
-
- for i, edgeCirc in enumerate(edgesCircPeau):
- if edgeCirc is not None:
- algo1d = meshFacePeau.UseExisting1DElements(geom=edgeCirc)
- if boutFromIfil[ifil] is None:
- hypo1d = algo1d.SourceEdges([ edgesCircPipeGroup[i] ],0,0)
- else:
- hypo1d = algo1d.SourceEdges([ edgesCircPipeGroup[boutFromIfil[ifil]] ],0,0)
- name = "cercle%d"%i
- putName(algo1d.GetSubMesh(), name, ifil, nro_cas)
- putName(algo1d, "algo1d_" + name, ifil, nro_cas)
- putName(hypo1d, "hypo1d_" + name, ifil, nro_cas)
-
- logging.info("Maillage avec %s", mailleur)
- if ( mailleur == "MeshGems"):
- algo2d = meshFacePeau.Triangle(algo=smeshBuilder.MG_CADSurf)
- hypo2d = algo2d.Parameters()
- hypo2d.SetPhySize( dmoyen )
- hypo2d.SetMinSize( rayonPipe/float(nbsegRad) )
- hypo2d.SetMaxSize( dmoyen*3. )
- hypo2d.SetChordalError( dmoyen*0.25 )
- hypo2d.SetVerbosity( 0 )
- else:
- algo2d = meshFacePeau.Triangle(algo=smeshBuilder.NETGEN_1D2D)
- hypo2d = algo2d.Parameters()
- hypo2d.SetMaxSize( dmoyen*0.75 )
- hypo2d.SetOptimize( 1 )
- hypo2d.SetFineness( 2 )
- hypo2d.SetMinSize( rayonPipe/float(nbsegRad) )
- hypo2d.SetQuadAllowed( 0 )
- putName(algo2d.GetSubMesh(), "facePeau", ifil, nro_cas)
- putName(algo2d, "algo2d_facePeau", ifil, nro_cas)
- putName(hypo2d, "hypo2d_facePeau", ifil, nro_cas)
-
- is_done = meshFacePeau.Compute()
- text = "meshFacePeau {} Compute".format(ifil)
- if is_done:
- logging.info(text+" OK")
- else:
- text = "Erreur au calcul du maillage.\n" + text
- logging.info(text)
- raise Exception(text)
-
- GroupFaces = meshFacePeau.CreateEmptyGroup( SMESH.FACE, "facePeau%d"%ifil )
- _ = GroupFaces.AddFrom( meshFacePeau.GetMesh() )
- meshesFacesPeau.append(meshFacePeau)
-
- # --- regroupement des maillages du défaut
-
- listMeshes = [internalBoundary.GetMesh(),
- meshPipe.GetMesh(),
- meshFaceFiss.GetMesh()]
- for mp in meshesFacesPeau:
- listMeshes.append(mp.GetMesh())
-
- meshBoiteDefaut = smesh.Concatenate(listMeshes, 1, 1, 1e-05,False)
- # pour aider l'algo hexa-tetra à ne pas mettre de pyramides à l'exterieur des volumes repliés sur eux-mêmes
- # on désigne les faces de peau en quadrangles par le groupe "skinFaces"
- group_faceFissOutPipe = None
- group_faceFissInPipe = None
- groups = meshBoiteDefaut.GetGroups()
- for grp in groups:
- if grp.GetType() == SMESH.FACE:
- #if "internalBoundary" in grp.GetName():
- # grp.SetName("skinFaces")
- if grp.GetName() == "fisOutPi":
- group_faceFissOutPipe = grp
- elif grp.GetName() == "fisInPi":
- group_faceFissInPipe = grp
-
- # le maillage NETGEN ne passe pas toujours ==> on force l'usage de MG_Tetra
- mailleur = "MeshGems"
- logging.info("Maillage avec %s", mailleur)
- if ( mailleur == "MeshGems"):
- algo3d = meshBoiteDefaut.Tetrahedron(algo=smeshBuilder.MG_Tetra)
- else:
- algo3d = meshBoiteDefaut.Tetrahedron(algo=smeshBuilder.NETGEN)
- hypo3d = algo3d.MaxElementVolume(1000.0)
- hypo3d.SetVerboseLevel( 0 )
- hypo3d.SetStandardOutputLog( 0 )
- hypo3d.SetRemoveLogOnSuccess( 1 )
- putName(algo3d.GetSubMesh(), "boiteDefaut", i_pref=nro_cas)
- putName(algo3d, "algo3d_boiteDefaut", i_pref=nro_cas)
- putName(meshBoiteDefaut, "boiteDefaut", i_pref=nro_cas)
-
- is_done = meshBoiteDefaut.Compute()
- text = "meshBoiteDefaut.Compute"
- if is_done:
- logging.info(text+" OK")
- else:
- text = "Erreur au calcul du maillage.\n" + text
- logging.info(text)
- raise Exception(text)
-
- _ = meshBoiteDefaut.GetMesh().UnionListOfGroups( [ group_faceFissOutPipe, group_faceFissInPipe ], 'FACE1' )
- maillageSain = enleveDefaut(maillageSain, zoneDefaut, zoneDefaut_skin,
- zoneDefaut_internalFaces, zoneDefaut_internalEdges)
- putName(maillageSain, nomFicSain+"_coupe", i_pref=nro_cas)
- _, normfiss = shapeSurFissure(facesPortFissure)
- maillageComplet = RegroupeSainEtDefaut(maillageSain, meshBoiteDefaut,
- None, None, 'COMPLET', normfiss)
-
- logging.info("conversion quadratique")
- maillageComplet.ConvertToQuadratic( 1 )
- logging.info("groupes")
- groups = maillageComplet.GetGroups()
- grps = [ grp for grp in groups if grp.GetName() == 'FONDFISS']
- _ = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FONDFISS' )
-
- logging.info("réorientation face de fissure FACE1")
- grps = [ grp for grp in groups if grp.GetName() == 'FACE1']
- _ = maillageComplet.Reorient2D( grps[0], normfiss, grps[0].GetID(1))
-
- logging.info("réorientation face de fissure FACE2")
- plansim = geompy.MakePlane(O, normfiss, 10000)
- fissnorm = geompy.MakeMirrorByPlane(normfiss, plansim)
- grps = [ grp for grp in groups if grp.GetName() == 'FACE2']
- _ = maillageComplet.Reorient2D( grps[0], fissnorm, grps[0].GetID(1))
- _ = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FACE2' )
-
- logging.info("export maillage fini")
- maillageComplet.ExportMED(fichierMaillageFissure)
- putName(maillageComplet, nomFicFissure)
- logging.info("fichier maillage fissure %s", fichierMaillageFissure)
-
- if salome.sg.hasDesktop():
- salome.sg.updateObjBrowser()
-
- logging.info("maillage fissure fini")
-
- return maillageComplet
