mirror of
https://git.salome-platform.org/gitpub/modules/smesh.git
synced 2025-04-05 00:28:25 +05:00
656 lines
29 KiB
Python
656 lines
29 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
import logging
|
|
import salome
|
|
from geomsmesh import geompy
|
|
from geomsmesh import smesh
|
|
from salome.smesh import smeshBuilder
|
|
import SMESH
|
|
import math
|
|
|
|
from extractionOrientee import extractionOrientee
|
|
from sortFaces import sortFaces
|
|
from sortEdges import sortEdges
|
|
from eliminateDoubles import eliminateDoubles
|
|
from substractSubShapes import substractSubShapes
|
|
from produitMixte import produitMixte
|
|
from findWireEndVertices import findWireEndVertices
|
|
from getSubshapeIds import getSubshapeIds
|
|
from putName import putName
|
|
from distance2 import distance2
|
|
from enleveDefaut import enleveDefaut
|
|
from shapeSurFissure import shapeSurFissure
|
|
from regroupeSainEtDefaut import RegroupeSainEtDefaut
|
|
from triedreBase import triedreBase
|
|
|
|
# -----------------------------------------------------------------------------
|
|
# --- procedure complete fissure longue
|
|
|
|
def insereFissureLongue(geometriesSaines, maillagesSains,
|
|
shapesFissure, shapeFissureParams,
|
|
maillageFissureParams, elementsDefaut, step=-1):
|
|
"""
|
|
TODO: a completer
|
|
"""
|
|
logging.info('start')
|
|
|
|
#geometrieSaine = geometriesSaines[0]
|
|
#maillageSain = maillagesSains[0]
|
|
#isHexa = maillagesSains[1]
|
|
shapeDefaut = shapesFissure[0] # face de fissure, debordant
|
|
#tailleDefaut = shapesFissure[2]
|
|
wiretube = shapesFissure[4] # wire fond de fissure, debordant
|
|
planfiss = shapesFissure[7] # plan de fissure
|
|
pipefiss = shapesFissure[8] # pipe, debordant
|
|
|
|
profondeur = shapeFissureParams['profondeur']
|
|
rayonPipe = profondeur/4.0
|
|
|
|
nomRep = maillageFissureParams['nomRep']
|
|
nomFicSain = maillageFissureParams['nomFicSain']
|
|
nomFicFissure = maillageFissureParams['nomFicFissure']
|
|
|
|
#nbsegExt = maillageFissureParams['nbsegExt'] # 5
|
|
#nbsegGen = maillageFissureParams['nbsegGen'] # 25
|
|
#nbsegRad = maillageFissureParams['nbsegRad'] # 5
|
|
#scaleRad = maillageFissureParams['scaleRad'] # 4
|
|
#nbsegCercle = maillageFissureParams['nbsegCercle'] # 6
|
|
#nbsegFis = maillageFissureParams['nbsegFis'] # 20
|
|
#lensegEllipsoide = maillageFissureParams['lensegEllipso'] # 1.0
|
|
|
|
#fichierMaillageSain = nomRep + '/' + nomFicSain + '.med'
|
|
fichierMaillageFissure = nomRep + '/' + nomFicFissure + '.med'
|
|
|
|
facesDefaut = elementsDefaut[0]
|
|
#centreDefaut = elementsDefaut[1]
|
|
#normalDefaut = elementsDefaut[2]
|
|
#extrusionDefaut = 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]
|
|
|
|
facePorteFissure = shapeDefaut
|
|
WirePorteFondFissure = wiretube
|
|
fillingFaceExterne = facesDefaut[0]
|
|
logging.debug("fillingFaceExterne %s", fillingFaceExterne)
|
|
geompy.addToStudy(fillingFaceExterne, "fillingFaceExterne")
|
|
edgesFilling = geompy.ExtractShapes(fillingFaceExterne, geompy.ShapeType["EDGE"], False)
|
|
|
|
O, OX, OY, OZ = triedreBase()
|
|
|
|
# -----------------------------------------------------------------------------
|
|
# --- peau et face de fissure
|
|
|
|
# --- partition peau defaut - face de fissure prolongee - wire de fond de fissure prolongée
|
|
partitionPeauFissFond = geompy.MakePartition([facePorteFissure, WirePorteFondFissure, fillingFaceExterne], [], [], [], geompy.ShapeType["FACE"], 0, [], 0)
|
|
geompy.addToStudy( partitionPeauFissFond, 'partitionPeauFissFond' )
|
|
|
|
edges = geompy.ExtractShapes(WirePorteFondFissure, geompy.ShapeType["EDGE"], False)
|
|
|
|
lgmax = 0
|
|
imax = 0
|
|
for i, edge in enumerate(edges):
|
|
props = geompy.BasicProperties(edge)
|
|
lg = props[0]
|
|
if lg > lgmax:
|
|
lgmax = lg
|
|
imax = i
|
|
edgemax = edges[imax]
|
|
geompy.addToStudy(edgemax, 'edgemax')
|
|
centreFondFiss = geompy.MakeVertexOnCurve(edgemax, 0.5)
|
|
geompy.addToStudy(centreFondFiss, 'centreFondFiss')
|
|
tangentFondFiss = geompy.MakeTangentOnCurve(edgemax, 0.5)
|
|
geompy.addToStudy(tangentFondFiss, 'tangentFondFiss')
|
|
|
|
bord1FondFiss = geompy.MakeVertexOnCurve(edgemax, 0.0)
|
|
geompy.addToStudy(bord1FondFiss, 'bord1FondFiss')
|
|
tangentBord1FondFiss = geompy.MakeTangentOnCurve(edgemax, 0.0)
|
|
geompy.addToStudy(tangentBord1FondFiss, 'tangentBord1FondFiss')
|
|
|
|
bord2FondFiss = geompy.MakeVertexOnCurve(edgemax, 1.0)
|
|
geompy.addToStudy(bord2FondFiss, 'bord2FondFiss')
|
|
tangentBord2FondFiss = geompy.MakeTangentOnCurve(edgemax, 1.0)
|
|
geompy.addToStudy(tangentBord2FondFiss, 'tangentBord2FondFiss')
|
|
|
|
planBord1 = geompy.MakePlane(bord1FondFiss, tangentBord1FondFiss, 3*rayonPipe)
|
|
planBord2 = geompy.MakePlane(bord2FondFiss, tangentBord2FondFiss, 3*rayonPipe)
|
|
geompy.addToStudy(planBord1, 'planBord1')
|
|
geompy.addToStudy(planBord2, 'planBord2')
|
|
|
|
[edgesInside, edgesOutside, edgesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "EDGE", 1.e-3)
|
|
[facesInside, facesOutside, facesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "FACE", 1.e-3)
|
|
|
|
# --- partition peau -face fissure - pipe fond de fissure prolongé
|
|
partitionPeauFissByPipe = geompy.MakePartition([facesInside[0], facesOnside[0]], [pipefiss], [], [], geompy.ShapeType["FACE"], 0, [], 0)
|
|
geompy.addToStudy( partitionPeauFissByPipe, 'partitionPeauFissByPipe' )
|
|
|
|
# --- identification face de peau
|
|
[facesPeauFissInside, facesPeauFissOutside, facesPeauFissOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissByPipe, centreFondFiss, "FACE", 0.1, "peauFiss_bord_")
|
|
facesPeauSorted, minsur, maxsurf = sortFaces(facesPeauFissOnside) # 4 demi disques, une grande face
|
|
facePeau = facesPeauSorted[-1] # la plus grande face
|
|
geompy.addToStudyInFather(partitionPeauFissByPipe, facePeau, "facePeau")
|
|
|
|
# --- identification edges de bord face peau
|
|
edgesBords = []
|
|
for i, edge in enumerate(edgesFilling):
|
|
edgepeau = geompy.GetInPlace(facePeau, edge)
|
|
edgesBords.append(edgepeau)
|
|
groupEdgesBordPeau = geompy.CreateGroup(facePeau, geompy.ShapeType["EDGE"])
|
|
geompy.UnionList(groupEdgesBordPeau, edgesBords)
|
|
geompy.addToStudyInFather(facePeau, groupEdgesBordPeau , "EdgesBords")
|
|
|
|
# --- identification face fissure externe au pipe et edge commune peau fissure
|
|
for face in facesPeauFissInside:
|
|
try:
|
|
sharedEdges = geompy.GetSharedShapesMulti([facePeau, face], geompy.ShapeType["EDGE"])
|
|
if sharedEdges is not None:
|
|
faceFiss = face
|
|
edgePeauFiss = sharedEdges[0]
|
|
geompy.addToStudyInFather(partitionPeauFissByPipe, faceFiss, "faceFiss")
|
|
geompy.addToStudyInFather(faceFiss, edgePeauFiss, "edgePeauFiss")
|
|
geompy.addToStudyInFather(facePeau, edgePeauFiss, "edgePeauFiss")
|
|
break
|
|
except:
|
|
pass
|
|
verticesEdgePeauFiss = geompy.ExtractShapes(edgePeauFiss, geompy.ShapeType["VERTEX"], False)
|
|
|
|
# --- identification edges demi cercle dans face de peau
|
|
edgesFacePeau = geompy.ExtractShapes(facePeau, geompy.ShapeType["EDGE"], False)
|
|
edgesFacePeauSorted, minlg, maxlg = sortEdges(edgesFacePeau)
|
|
demiCerclesPeau = edgesFacePeauSorted[0:4]
|
|
verticesDemiCerclesPeau = []
|
|
for i, edge in enumerate(demiCerclesPeau):
|
|
name = "demiCerclePeau_%d"%i
|
|
geompy.addToStudyInFather(facePeau, edge, name)
|
|
verticesDemiCerclesPeau += geompy.ExtractShapes(edge, geompy.ShapeType["VERTEX"], False)
|
|
verticesDemiCerclesPeau = eliminateDoubles(facePeau, verticesDemiCerclesPeau)
|
|
for i, vertex in enumerate(verticesDemiCerclesPeau):
|
|
name = "verticesDemiCerclesPeau_%d"%i
|
|
geompy.addToStudyInFather(facePeau, vertex, name)
|
|
verticesOutCercles = substractSubShapes(facePeau, verticesDemiCerclesPeau, verticesEdgePeauFiss)
|
|
for i, vertex in enumerate(verticesOutCercles):
|
|
name = "verticesOutCercles_%d"%i
|
|
geompy.addToStudyInFather(facePeau, vertex, name)
|
|
|
|
# --- demi cercles regroupés
|
|
groupsDemiCerclesPeau = []
|
|
for i, vertex in enumerate(verticesEdgePeauFiss):
|
|
demis = []
|
|
for edge in demiCerclesPeau:
|
|
if geompy.MinDistance(vertex, edge) < 1.e-5:
|
|
demis.append(edge)
|
|
group = geompy.CreateGroup(facePeau, geompy.ShapeType["EDGE"])
|
|
geompy.UnionList(group, demis)
|
|
name = "Cercle%d"%i
|
|
geompy.addToStudyInFather(facePeau, group , name)
|
|
groupsDemiCerclesPeau.append(group)
|
|
|
|
# --- identification edges commune pipe face fissure externe au pipe
|
|
edgePeauFissId = geompy.GetSubShapeID(partitionPeauFissByPipe, edgePeauFiss)
|
|
edgesFaceFiss = geompy.ExtractShapes(faceFiss, geompy.ShapeType["EDGE"], False)
|
|
edgesFaceFissPipe = []
|
|
for edge in edgesFaceFiss:
|
|
if geompy.GetSubShapeID(partitionPeauFissByPipe, edge) != edgePeauFissId:
|
|
edgesFaceFissPipe.append(edge)
|
|
name = "edgeFaceFissPipe_%d"%len(edgesFaceFissPipe)
|
|
geompy.addToStudyInFather(faceFiss, edge, name)
|
|
groupEdgesFaceFissPipe = geompy.CreateGroup(faceFiss, geompy.ShapeType["EDGE"])
|
|
geompy.UnionList(groupEdgesFaceFissPipe, edgesFaceFissPipe)
|
|
geompy.addToStudyInFather(faceFiss, groupEdgesFaceFissPipe, "edgesFaceFissPipe")
|
|
|
|
# -----------------------------------------------------------------------------
|
|
# --- pipe de fond de fissure
|
|
|
|
wireFondFiss = geompy.MakeWire(edgesInside, 1e-07)
|
|
|
|
disque = geompy.MakeDiskPntVecR(centreFondFiss, tangentFondFiss, rayonPipe)
|
|
[vertex] = geompy.ExtractShapes(disque, geompy.ShapeType["VERTEX"], False)
|
|
vertproj = geompy.MakeProjection(vertex, planfiss)
|
|
vec1 = geompy.MakeVector(centreFondFiss, vertex)
|
|
try:
|
|
# si centreFondFiss et vertproj sont proches: exception. Angle = +- 90°
|
|
vec2 = geompy.MakeVector(centreFondFiss, vertproj)
|
|
angle = geompy.GetAngleRadians(vec1, vec2)
|
|
except:
|
|
# on utilise la projection du centre sur la peau pour avoir un vecteur non nul
|
|
vertproj = geompy.MakeProjection(centreFondFiss, facePeau)
|
|
vec2 = geompy.MakeVector(centreFondFiss, vertproj)
|
|
angle = geompy.GetAngleRadians(vec1, vec2)
|
|
sommetAxe = geompy.MakeTranslationVector(centreFondFiss, tangentFondFiss)
|
|
pm = produitMixte(centreFondFiss, vertex, vertproj, sommetAxe)
|
|
if pm > 0:
|
|
disque = geompy.MakeRotation(disque, tangentFondFiss, angle)
|
|
else:
|
|
disque = geompy.MakeRotation(disque, tangentFondFiss, -angle)
|
|
[vertexReference] = geompy.ExtractShapes(disque, geompy.ShapeType["VERTEX"], False)
|
|
|
|
pipeFondFiss = geompy.MakePipe(disque, wireFondFiss)
|
|
pipeFondFiss = geompy.MakePartition([pipeFondFiss], [planfiss, wireFondFiss, planBord1, planBord2], [], [], geompy.ShapeType["SOLID"], 0, [], 0)
|
|
#pipe = geompy.MakePipe(disque, WirePorteFondFissure)
|
|
#pipe = geompy.MakePartition([pipe],[fillingFaceExterne], [], [], geompy.ShapeType["SOLID"], 0, [], 0)
|
|
#pipes = geompy.ExtractShapes(pipe, geompy.ShapeType["SOLID"], False)
|
|
#pipesSorted, volmin, volmax = sortSolids(pipes)
|
|
#pipeFondFiss = pipesSorted[-1]
|
|
#pipeFondFiss = geompy.MakePartition([pipeFondFiss], [planfiss, wireFondFiss, planBord1, planBord2], [], [], geompy.ShapeType["SOLID"], 0, [], 0)
|
|
|
|
geompy.addToStudy( disque, 'disque')
|
|
geompy.addToStudy( wireFondFiss, 'wireFondFiss')
|
|
geompy.addToStudy( pipeFondFiss, 'pipeFondFiss')
|
|
|
|
VerticesEndFondFiss = findWireEndVertices(wireFondFiss)
|
|
for i, v in enumerate(VerticesEndFondFiss):
|
|
name = "vertexEndFondFiss_%d"%i
|
|
geompy.addToStudyInFather(wireFondFiss, v, name)
|
|
VerticesEndPipeFiss = []
|
|
for v in VerticesEndFondFiss:
|
|
VerticesEndPipeFiss.append(geompy.GetInPlace(pipeFondFiss, v))
|
|
for i, v in enumerate(VerticesEndPipeFiss):
|
|
name = "vertexEndPipeFiss_%d"%i
|
|
geompy.addToStudyInFather(pipeFondFiss, v, name)
|
|
|
|
geompy.addToStudyInFather(pipeFondFiss, VerticesEndPipeFiss[0], "PFOR")
|
|
geompy.addToStudyInFather(pipeFondFiss, VerticesEndPipeFiss[1], "PFEX")
|
|
if geompy.MinDistance(VerticesEndPipeFiss[0], verticesOutCercles[0]) > geompy.MinDistance(VerticesEndPipeFiss[0], verticesOutCercles[1]):
|
|
a = verticesOutCercles[0]
|
|
verticesOutCercles[0] = verticesOutCercles[1]
|
|
verticesOutCercles[1] = a
|
|
geompy.addToStudyInFather(facePeau, verticesOutCercles[0], "THOR")
|
|
geompy.addToStudyInFather(facePeau, verticesOutCercles[1], "THEX")
|
|
|
|
[facesPipeInside, facesPipeOutside, facesPipeOnside] = extractionOrientee(fillingFaceExterne, pipeFondFiss, centreFondFiss, "FACE", 0.1, "pipe_bord_")
|
|
[edgesPipeInside, edgesPipeOutside, edgesPipeOnside] = extractionOrientee(fillingFaceExterne, pipeFondFiss, centreFondFiss, "EDGE", 0.1, "pipe_bord_")
|
|
disqueInt1 = geompy.GetInPlaceByHistory(pipeFondFiss, planBord1)
|
|
disqueInt2 = geompy.GetInPlaceByHistory(pipeFondFiss, planBord2)
|
|
disques = facesPipeOnside + [disqueInt1, disqueInt2]
|
|
edgesDiskInt = geompy.ExtractShapes(disqueInt1, geompy.ShapeType["EDGE"], False)
|
|
edgesDiskInt = edgesDiskInt +geompy.ExtractShapes(disqueInt2, geompy.ShapeType["EDGE"], False)
|
|
edgesSorted, minlg, maxlg = sortEdges(edgesDiskInt) # 4 rayons, 2 demi cercles
|
|
|
|
centre = geompy.MakeVertexOnSurface(planfiss, 0.5, 0.5)
|
|
refpoint = geompy.MakeTranslationVector(centre, geompy.GetNormal(planfiss,centre))
|
|
geompy.addToStudy(refpoint, 'refpoint')
|
|
[facesPipeInplan, facesPipeOutplan, facesPipeOnplan] = extractionOrientee(planfiss, pipeFondFiss, refpoint, "FACE", 0.1, "pipe_plan_")
|
|
[edgesPipeInplan, edgesPipeOutplan, edgesPipeOnplan] = extractionOrientee(planfiss, pipeFondFiss, refpoint, "EDGE", 0.1, "pipe_plan_")
|
|
|
|
# --- rayon disques = (edgesPipeOnside inter edgesPipeOnplan) + rayons disque internes
|
|
# demi cercles = edgesPipeOnside moins edgesPipeOnplan + demi cercles disque internes
|
|
# generatrices = edgesPipeOnplan moins rayon disques (3 grandes et 6 petites)
|
|
edgesIdPipeOnside = getSubshapeIds(pipeFondFiss, edgesPipeOnside)
|
|
edgesIdPipeOnplan = getSubshapeIds(pipeFondFiss, edgesPipeOnplan)
|
|
rayons = []
|
|
demiCercles = []
|
|
for i, edgeId in enumerate(edgesIdPipeOnside):
|
|
if edgeId in edgesIdPipeOnplan:
|
|
rayons.append(edgesPipeOnside[i])
|
|
else:
|
|
demiCercles.append(edgesPipeOnside[i])
|
|
demiCerclesExternes = demiCercles
|
|
rayons = rayons + edgesSorted[:4] # les 4 plus petits sont les rayons
|
|
demiCercles = demiCercles + edgesSorted[4:] # les suivants sont les arcs de cercle
|
|
rayonsId = getSubshapeIds(pipeFondFiss, rayons)
|
|
generatrices = []
|
|
for i, edgeId in enumerate(edgesIdPipeOnplan):
|
|
if edgeId not in rayonsId:
|
|
generatrices.append(edgesPipeOnplan[i])
|
|
|
|
# --- generatrices en contact avec la face fissure externe au pipe
|
|
generFiss = []
|
|
for edge in generatrices:
|
|
distance = geompy.MinDistance(vertexReference, edge)
|
|
logging.debug("distance %s", distance)
|
|
if distance < 1.e-5:
|
|
generFiss.append(edge)
|
|
break
|
|
for edge in generatrices:
|
|
distance = geompy.MinDistance(generFiss[0], edge)
|
|
logging.debug("distance %s", distance)
|
|
if distance < 1.e-5:
|
|
generFiss.append(edge)
|
|
groupGenerFiss = geompy.CreateGroup(pipeFondFiss, geompy.ShapeType["EDGE"])
|
|
geompy.UnionList(groupGenerFiss, generFiss)
|
|
geompy.addToStudyInFather(pipeFondFiss, groupGenerFiss, "GenFiss")
|
|
|
|
# --- demi cercles externes regroupés
|
|
groupsDemiCerclesPipe = []
|
|
for i, vertex in enumerate(verticesEdgePeauFiss):
|
|
demis = []
|
|
for edge in demiCerclesExternes:
|
|
if geompy.MinDistance(vertex, edge) < 0.1:
|
|
demis.append(edge)
|
|
group = geompy.CreateGroup(pipeFondFiss, geompy.ShapeType["EDGE"])
|
|
geompy.UnionList(group, demis)
|
|
name = "Cercle%d"%i
|
|
geompy.addToStudyInFather(pipeFondFiss, group , name)
|
|
groupsDemiCerclesPipe.append(group)
|
|
|
|
# --- faces fissure dans le pipe
|
|
|
|
facesFissinPipe = []
|
|
generFissId = getSubshapeIds(pipeFondFiss, generFiss)
|
|
logging.debug("generatrice fissure %s", generFissId)
|
|
for face in facesPipeOnplan:
|
|
edges =geompy.ExtractShapes(face, geompy.ShapeType["EDGE"], False)
|
|
edgesId = getSubshapeIds(pipeFondFiss, edges)
|
|
logging.debug(" edges %s", edgesId)
|
|
for i,edgeId in enumerate(edgesId):
|
|
if edgeId in generFissId:
|
|
logging.debug("face found")
|
|
facesFissinPipe.append(face)
|
|
name = "faceFissInPipe_%d"%i
|
|
geompy.addToStudyInFather(pipeFondFiss, face, name)
|
|
break
|
|
groupFaceFissInPipe = geompy.CreateGroup(pipeFondFiss, geompy.ShapeType["FACE"])
|
|
geompy.UnionList(groupFaceFissInPipe, facesFissinPipe)
|
|
name = "FaceFissInPipe"
|
|
geompy.addToStudyInFather(pipeFondFiss, groupFaceFissInPipe , name)
|
|
|
|
# --- edges de fond de fissure
|
|
|
|
edgesFondFiss = []
|
|
for i, edge in enumerate(edgesInside):
|
|
anEdge = geompy.GetInPlace(pipeFondFiss, edge)
|
|
logging.debug(" edge %s ", anEdge)
|
|
edgesFondFiss.append(anEdge)
|
|
name ="edgeFondFissure_%d"%i
|
|
geompy.addToStudyInFather(pipeFondFiss, anEdge, name)
|
|
groupEdgeFondFiss = geompy.CreateGroup(pipeFondFiss, geompy.ShapeType["EDGE"])
|
|
geompy.UnionList(groupEdgeFondFiss, edgesFondFiss)
|
|
name = "FONDFISS"
|
|
geompy.addToStudyInFather(pipeFondFiss, groupEdgeFondFiss , name)
|
|
|
|
# -------------------------------------------------------------------------
|
|
# --- maillage
|
|
|
|
# --- edges de bord face defaut à respecter
|
|
|
|
aFilterManager = smesh.CreateFilterManager()
|
|
nbAdded, internalBoundary, _NoneGroup = internalBoundary.MakeBoundaryElements( SMESH.BND_1DFROM2D, '', '', 0, [ ])
|
|
criteres = []
|
|
unCritere = smesh.GetCriterion(SMESH.EDGE,SMESH.FT_FreeBorders,SMESH.FT_Undefined,0)
|
|
criteres.append(unCritere)
|
|
filtre = smesh.GetFilterFromCriteria(criteres)
|
|
bordsLibres = internalBoundary.MakeGroupByFilter( 'bords', filtre )
|
|
smesh.SetName(bordsLibres, 'bordsLibres')
|
|
|
|
# --- pour aider l'algo hexa-tetra a ne pas mettre de pyramides a l'exterieur des volumes replies sur eux-memes
|
|
# on designe les faces de peau en quadrangles par le groupe "skinFaces"
|
|
|
|
skinFaces = internalBoundary.CreateEmptyGroup( SMESH.FACE, 'skinFaces' )
|
|
nbAdd = skinFaces.AddFrom( internalBoundary.GetMesh() )
|
|
|
|
# --- maillage pipe fond fissure
|
|
|
|
meshFondFiss = smesh.Mesh(pipeFondFiss)
|
|
algo2d = meshFondFiss.Quadrangle(algo=smeshBuilder.QUADRANGLE)
|
|
algo3d = meshFondFiss.Prism()
|
|
putName(algo3d.GetSubMesh(), "pipe")
|
|
putName(algo3d, "algo3d_pipe")
|
|
putName(algo2d, "algo2d_pipe")
|
|
|
|
for i, face in enumerate(disques):
|
|
algo2d = meshFondFiss.Quadrangle(algo=smeshBuilder.RADIAL_QUAD,geom=face)
|
|
putName(algo2d.GetSubMesh(), "disque", i)
|
|
putName(algo2d, "algo2d_disque", i)
|
|
|
|
for i, edge in enumerate(rayons):
|
|
algo1d = meshFondFiss.Segment(geom=edge)
|
|
hypo1d = algo1d.NumberOfSegments(4)
|
|
putName(algo1d.GetSubMesh(), "rayon", i)
|
|
putName(algo1d, "algo1d_rayon", i)
|
|
putName(hypo1d, "hypo1d_rayon", i)
|
|
|
|
for i, edge in enumerate(demiCercles):
|
|
algo1d = meshFondFiss.Segment(geom=edge)
|
|
hypo1d = algo1d.NumberOfSegments(6)
|
|
putName(algo1d.GetSubMesh(), "demiCercle", i)
|
|
putName(algo1d, "algo1d_demiCercle", i)
|
|
putName(hypo1d, "hypo1d_demiCercle", i)
|
|
|
|
generSorted, minlg, maxlg = sortEdges(generatrices)
|
|
nbSegGenLong = int(math.sqrt(3.0)*maxlg/(profondeur - rayonPipe)) # on veut 2 triangles equilateraux dans la largeur de la face
|
|
nbSegGenBout = 6
|
|
logging.info("min %s, max %s, nombre de segments %s, nombre de generatrices %s", minlg, maxlg, nbSegGenLong, len(generSorted))
|
|
for i, edge in enumerate(generSorted):
|
|
algo1d = meshFondFiss.Segment(geom=edge)
|
|
if i < 6:
|
|
hypo1d = algo1d.NumberOfSegments(nbSegGenBout)
|
|
else:
|
|
hypo1d = algo1d.NumberOfSegments(nbSegGenLong)
|
|
putName(algo1d.GetSubMesh(), "generatrice", i)
|
|
putName(algo1d, "algo1d_generatrice", i)
|
|
putName(hypo1d, "hypo1d_generatrice", i)
|
|
isDone = meshFondFiss.Compute()
|
|
logging.info("meshFondFiss computed")
|
|
|
|
disks = []
|
|
for i, face in enumerate(disques[:4]):
|
|
name = "disk%d"%i
|
|
disks.append(meshFondFiss.GroupOnGeom(face, name, SMESH.FACE))
|
|
peauext_pipe = meshFondFiss.GetMesh().UnionListOfGroups( disks, 'PEAUEXT' )
|
|
|
|
grpPFOR = meshFondFiss.GroupOnGeom(VerticesEndPipeFiss[0], "PFOR", SMESH.NODE)
|
|
grpPFEX = meshFondFiss.GroupOnGeom(VerticesEndPipeFiss[1], "PFEX", SMESH.NODE)
|
|
|
|
grp = meshFondFiss.GroupOnGeom(groupFaceFissInPipe, "fisInPi", SMESH.FACE)
|
|
group_edgeFondFiss = meshFondFiss.GroupOnGeom(groupEdgeFondFiss, "FONDFISS", SMESH.EDGE)
|
|
noeudsFondFissure = meshFondFiss.GroupOnGeom(groupEdgeFondFiss, "nfondfis", SMESH.NODE)
|
|
groups_demiCercles = []
|
|
groupnodes_demiCercles = []
|
|
for i, group in enumerate(groupsDemiCerclesPipe):
|
|
name = "Cercle%d"%i
|
|
groups_demiCercles.append(meshFondFiss.GroupOnGeom(group, name, SMESH.EDGE))
|
|
name = "nCercle%d"%i
|
|
groupnodes_demiCercles.append(meshFondFiss.GroupOnGeom(group, name, SMESH.NODE))
|
|
group_generFiss = meshFondFiss.GroupOnGeom(groupGenerFiss, "GenFiss", SMESH.EDGE)
|
|
groupnode_generFiss = meshFondFiss.GroupOnGeom(groupGenerFiss, "GenFiss", SMESH.NODE)
|
|
grpNode0 = meshFondFiss.IntersectGroups(groupnode_generFiss, groupnodes_demiCercles[0], "Node0")
|
|
grpNode1 = meshFondFiss.IntersectGroups(groupnode_generFiss, groupnodes_demiCercles[1], "Node1")
|
|
idNode0 = grpNode0.GetID(1)
|
|
idNode1 = grpNode1.GetID(1)
|
|
coordsMesh = []
|
|
coordsMesh.append(meshFondFiss.GetNodeXYZ(idNode0))
|
|
coordsMesh.append(meshFondFiss.GetNodeXYZ(idNode1))
|
|
coordsGeom = []
|
|
for vertex in verticesEdgePeauFiss:
|
|
coord = geompy.PointCoordinates(vertex);
|
|
if distance2(coord, coordsMesh[0]) < 0.1:
|
|
meshFondFiss.MoveNode(idNode0, coord[0], coord[1], coord[2])
|
|
if distance2(coord, coordsMesh[1]) < 0.1:
|
|
meshFondFiss.MoveNode(idNode1, coord[0], coord[1], coord[2])
|
|
|
|
for groupNodes in groupnodes_demiCercles:
|
|
for idNode in groupNodes.GetListOfID():
|
|
coordMesh = meshFondFiss.GetNodeXYZ(idNode)
|
|
vertex = geompy.MakeVertex(coordMesh[0], coordMesh[1], coordMesh[2])
|
|
minDist = 100000
|
|
minCoord = None
|
|
imin = -1
|
|
for i, edge in enumerate(demiCerclesPeau):
|
|
discoord = geompy.MinDistanceComponents(vertex, edge)
|
|
if discoord[0] <minDist:
|
|
minDist = discoord[0]
|
|
minCoord = discoord[1:]
|
|
imin = i
|
|
if imin >= 0 and minDist > 1.E-6:
|
|
logging.debug("node id moved : %s distance=%s", idNode, minDist)
|
|
meshFondFiss.MoveNode(idNode, coordMesh[0] + minCoord[0], coordMesh[1] + minCoord[1], coordMesh[2] + minCoord[2])
|
|
|
|
|
|
# --- maillage face de peau
|
|
|
|
meshFacePeau = smesh.Mesh(facePeau)
|
|
algo2d = meshFacePeau.Triangle(algo=smeshBuilder.NETGEN_2D)
|
|
hypo2d = algo2d.Parameters()
|
|
hypo2d.SetMaxSize( 1000 )
|
|
hypo2d.SetOptimize( 1 )
|
|
hypo2d.SetFineness( 2 )
|
|
hypo2d.SetMinSize( 2 )
|
|
hypo2d.SetQuadAllowed( 0 )
|
|
putName(algo2d.GetSubMesh(), "facePeau")
|
|
putName(algo2d, "algo2d_facePeau")
|
|
putName(hypo2d, "hypo2d_facePeau")
|
|
#
|
|
lenEdgePeauFiss = geompy.BasicProperties(edgePeauFiss)[0]
|
|
frac = profondeur/lenEdgePeauFiss
|
|
nbSeg = nbSegGenLong +2*nbSegGenBout
|
|
ratio = (nbSegGenBout/float(profondeur)) / (nbSegGenLong/lenEdgePeauFiss)
|
|
logging.info("lenEdgePeauFiss %s, profondeur %s, nbSegGenLong %s, nbSegGenBout %s, frac %s, ratio %s", lenEdgePeauFiss, profondeur, nbSegGenLong, nbSegGenBout, frac, ratio)
|
|
algo1d = meshFacePeau.Segment(geom=edgePeauFiss)
|
|
hypo1d = algo1d.NumberOfSegments(nbSeg,[],[ ])
|
|
hypo1d.SetDistrType( 2 )
|
|
hypo1d.SetConversionMode( 1 )
|
|
hypo1d.SetTableFunction( [ 0, ratio, frac, 1, (1.-frac), 1, 1, ratio ] )
|
|
putName(algo1d.GetSubMesh(), "edgePeauFiss")
|
|
putName(algo1d, "algo1d_edgePeauFiss")
|
|
putName(hypo1d, "hypo1d_edgePeauFiss")
|
|
#
|
|
algo1d = meshFacePeau.UseExisting1DElements(geom=groupEdgesBordPeau)
|
|
hypo1d = algo1d.SourceEdges([ bordsLibres ],0,0)
|
|
putName(algo1d.GetSubMesh(), "bordsLibres")
|
|
putName(algo1d, "algo1d_bordsLibres")
|
|
putName(hypo1d, "hypo1d_bordsLibres")
|
|
#
|
|
for i in range(2):
|
|
algo1d = meshFacePeau.UseExisting1DElements(geom=groupsDemiCerclesPeau[i])
|
|
hypo1d = algo1d.SourceEdges([ groups_demiCercles[i] ],0,0)
|
|
putName(algo1d.GetSubMesh(), "DemiCercles", i)
|
|
putName(algo1d, "algo1d_groupDemiCercles", i)
|
|
putName(hypo1d, "hypo1d_groupDemiCercles", i)
|
|
#
|
|
isDone = meshFacePeau.Compute()
|
|
logging.info("meshFacePeau computed")
|
|
grpTHOR = meshFacePeau.GroupOnGeom(verticesOutCercles[0], "THOR", SMESH.NODE)
|
|
grpTHEX = meshFacePeau.GroupOnGeom(verticesOutCercles[1], "THEX", SMESH.NODE)
|
|
|
|
groupEdgesPeauFiss = meshFacePeau.GroupOnGeom(edgePeauFiss, "PeauFis", SMESH.EDGE)
|
|
|
|
peauext_face = meshFacePeau.CreateEmptyGroup( SMESH.FACE, 'PEAUEXT' )
|
|
nbAdd = peauext_face.AddFrom( meshFacePeau.GetMesh() )
|
|
|
|
|
|
# --- maillage face de fissure
|
|
|
|
meshFaceFiss = smesh.Mesh(faceFiss)
|
|
algo2d = meshFaceFiss.Triangle(algo=smeshBuilder.NETGEN_2D)
|
|
hypo2d = algo2d.Parameters()
|
|
hypo2d.SetMaxSize( (profondeur - rayonPipe)/math.sqrt(3.0) ) # pour avoir deux couches de triangles equilateraux partout sur la fissure
|
|
hypo2d.SetOptimize( 1 )
|
|
hypo2d.SetFineness( 2 )
|
|
hypo2d.SetMinSize( 2 )
|
|
hypo2d.SetQuadAllowed( 0 )
|
|
putName(algo2d.GetSubMesh(), "faceFiss")
|
|
putName(algo2d, "algo2d_faceFiss")
|
|
putName(hypo2d, "hypo2d_faceFiss")
|
|
#
|
|
algo1d = meshFaceFiss.UseExisting1DElements(geom=edgePeauFiss)
|
|
hypo1d = algo1d.SourceEdges([ groupEdgesPeauFiss ],0,0)
|
|
putName(algo1d.GetSubMesh(), "edgeFissPeau")
|
|
putName(algo1d, "algo1d_edgeFissPeau")
|
|
putName(hypo1d, "hypo1d_edgeFissPeau")
|
|
#
|
|
algo1d = meshFaceFiss.UseExisting1DElements(geom=groupEdgesFaceFissPipe)
|
|
hypo1d = algo1d.SourceEdges([ group_generFiss ],0,0)
|
|
putName(algo1d.GetSubMesh(), "edgeFissPeau")
|
|
putName(algo1d, "algo1d_edgeFissPeau")
|
|
putName(hypo1d, "hypo1d_edgeFissPeau")
|
|
#
|
|
isDone = meshFaceFiss.Compute()
|
|
logging.info("meshFaceFiss computed")
|
|
|
|
grp = meshFaceFiss.GroupOnGeom(faceFiss, "fisOutPi", SMESH.FACE)
|
|
|
|
meshBoiteDefaut = smesh.Concatenate([internalBoundary.GetMesh(),
|
|
meshFondFiss.GetMesh(),
|
|
meshFacePeau.GetMesh(),
|
|
meshFaceFiss.GetMesh()],
|
|
1, 1, 1e-05,False)
|
|
# pour aider l'algo hexa-tetra a ne pas mettre de pyramides a l'exterieur des volumes replies sur eux-memes
|
|
# on designe 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 ==> utiliser GHS3D
|
|
distene=True
|
|
if distene:
|
|
algo3d = meshBoiteDefaut.Tetrahedron(algo=smeshBuilder.GHS3D)
|
|
else:
|
|
algo3d = meshBoiteDefaut.Tetrahedron(algo=smeshBuilder.NETGEN)
|
|
hypo3d = algo3d.MaxElementVolume(1000.0)
|
|
putName(algo3d.GetSubMesh(), "boiteDefaut")
|
|
putName(algo3d, "algo3d_boiteDefaut")
|
|
isDone = meshBoiteDefaut.Compute()
|
|
logging.info("meshBoiteDefaut computed")
|
|
putName(meshBoiteDefaut, "boiteDefaut")
|
|
|
|
groups = maillageSain.GetGroups()
|
|
grps1 = [ grp for grp in groups if grp.GetName() == 'P1']
|
|
grps2 = [ grp for grp in groups if grp.GetName() == 'P2']
|
|
coords1 = maillageSain.GetNodeXYZ(grps1[0].GetID(1))
|
|
coords2 = maillageSain.GetNodeXYZ(grps2[0].GetID(1))
|
|
logging.info("coords1 %s, coords2 %s",coords1, coords2)
|
|
|
|
faceFissure = meshBoiteDefaut.GetMesh().UnionListOfGroups( [ group_faceFissOutPipe, group_faceFissInPipe ], 'FACE1' )
|
|
maillageSain = enleveDefaut(maillageSain, zoneDefaut, zoneDefaut_skin, zoneDefaut_internalFaces, zoneDefaut_internalEdges)
|
|
putName(maillageSain, nomFicSain+"_coupe")
|
|
extrusionFaceFissure, normfiss = shapeSurFissure(facePorteFissure)
|
|
maillageComplet = RegroupeSainEtDefaut(maillageSain, meshBoiteDefaut, extrusionFaceFissure, facePorteFissure, 'COUDE')
|
|
|
|
groups = maillageComplet.GetGroups()
|
|
grps1 = [ grp for grp in groups if grp.GetName() == 'P1']
|
|
grps2 = [ grp for grp in groups if grp.GetName() == 'P2']
|
|
nodeid1 = maillageComplet.AddNode(coords1[0], coords1[1], coords1[2])
|
|
nodeid2 = maillageComplet.AddNode(coords2[0], coords2[1], coords2[2])
|
|
grps1[0].Add([nodeid1])
|
|
grps2[0].Add([nodeid2])
|
|
ma0d1 = maillageComplet.Add0DElement(nodeid1)
|
|
ma0d2 = maillageComplet.Add0DElement(nodeid2)
|
|
grpma0d1 = maillageComplet.CreateEmptyGroup( SMESH.ELEM0D, 'P1' )
|
|
nbAdd = grpma0d1.Add( [ma0d1] )
|
|
grpma0d2 = maillageComplet.CreateEmptyGroup( SMESH.ELEM0D, 'P2' )
|
|
nbAdd = grpma0d2.Add( [ma0d2] )
|
|
|
|
# grps = [ grp for grp in groups if grp.GetName() == 'affectedEdges']
|
|
# grps[0].SetName('affEdges')
|
|
# grps = [ grp for grp in groups if grp.GetName() == 'affectedFaces']
|
|
# grps[0].SetName('affFaces')
|
|
# grps = [ grp for grp in groups if grp.GetName() == 'affectedVolumes']
|
|
# grps[0].SetName('affVols')
|
|
|
|
maillageComplet.ConvertToQuadratic( 1 )
|
|
grps = [ grp for grp in groups if grp.GetName() == 'FONDFISS']
|
|
fond = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FONDFISS' )
|
|
|
|
grps = [ grp for grp in groups if grp.GetName() == 'FACE1']
|
|
nb = maillageComplet.Reorient2D( grps[0], normfiss, grps[0].GetID(1))
|
|
|
|
plansim = geompy.MakePlane(O, normfiss, 10000)
|
|
fissnorm = geompy.MakeMirrorByPlane(normfiss, plansim)
|
|
grps = [ grp for grp in groups if grp.GetName() == 'FACE2']
|
|
nb = maillageComplet.Reorient2D( grps[0], fissnorm, grps[0].GetID(1))
|
|
#isDone = maillageComplet.ReorientObject( grps[0] )
|
|
fond = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FACE2' )
|
|
|
|
maillageComplet.ExportMED( fichierMaillageFissure, 0, SMESH.MED_V2_2, 1 )
|
|
putName(maillageComplet, nomFicFissure)
|
|
logging.info("fichier maillage fissure %s", fichierMaillageFissure)
|
|
|
|
if salome.sg.hasDesktop():
|
|
salome.sg.updateObjBrowser(1)
|
|
|
|
return maillageComplet |