mirror of
https://git.salome-platform.org/gitpub/modules/smesh.git
synced 2024-11-12 00:29:17 +05:00
Correcion de programmation - fichiers en python
This commit is contained in:
GERALD NICOLAS
parent
e66f809aa1
commit
361885ae5e
@ -28,9 +28,6 @@ import math
|
||||
import GEOM
|
||||
import SALOMEDS
|
||||
import SMESH
|
||||
#import StdMeshers
|
||||
#import GHS3DPlugin
|
||||
#import NETGENPlugin
|
||||
import logging
|
||||
|
||||
from .fissureGenerique import fissureGenerique
|
||||
@ -44,8 +41,8 @@ from .construitFissureGenerale import construitFissureGenerale
|
||||
O, OX, OY, OZ = triedreBase()
|
||||
|
||||
class casStandard(fissureGenerique):
|
||||
"""
|
||||
problème de fissure standard, défini par :
|
||||
"""problème de fissure standard, défini par :
|
||||
|
||||
- un maillage sain (hexaèdres),
|
||||
- une face géométrique de fissure, qui doit légèrement dépasser hors du volume maillé
|
||||
- les numéros d'arêtes (edges géométriques) correspondant au fond de fissure
|
||||
@ -66,7 +63,7 @@ class casStandard(fissureGenerique):
|
||||
if 'reptrav' in self.dicoParams:
|
||||
self.reptrav = self.dicoParams['reptrav']
|
||||
else:
|
||||
self.reptrav = '.'
|
||||
self.reptrav = os.curdir
|
||||
self.numeroCas = numeroCas
|
||||
if self.numeroCas != 0:
|
||||
self.nomCas = self.nomProbleme +"_%d"%(self.numeroCas)
|
||||
@ -176,11 +173,13 @@ class casStandard(fissureGenerique):
|
||||
if self.references is not None:
|
||||
self.referencesMaillageFissure = self.references
|
||||
else:
|
||||
self.referencesMaillageFissure = dict(Entity_Quad_Pyramid = 0,
|
||||
Entity_Quad_Triangle = 0,
|
||||
Entity_Quad_Edge = 0,
|
||||
Entity_Quad_Penta = 0,
|
||||
Entity_Quad_Hexa = 0,
|
||||
Entity_Node = 0,
|
||||
Entity_Quad_Tetra = 0,
|
||||
Entity_Quad_Quadrangle = 0)
|
||||
self.referencesMaillageFissure = dict( \
|
||||
Entity_Quad_Quadrangle = 0, \
|
||||
Entity_Quad_Hexa = 0, \
|
||||
Entity_Node = 0, \
|
||||
Entity_Quad_Edge = 0, \
|
||||
Entity_Quad_Triangle = 0, \
|
||||
Entity_Quad_Tetra = 0, \
|
||||
Entity_Quad_Pyramid = 0, \
|
||||
Entity_Quad_Penta = 0 \
|
||||
)
|
||||
|
||||
@ -25,12 +25,11 @@ from .geomsmesh import geomPublishInFather
|
||||
from . import initLog
|
||||
|
||||
def compoundFromList(elements, nom=None):
|
||||
"""
|
||||
|
||||
"""
|
||||
"""compoundFromList"""
|
||||
|
||||
logging.debug('start')
|
||||
|
||||
shapeList = []
|
||||
shapeList = list()
|
||||
for a in elements:
|
||||
if not isinstance(a, list):
|
||||
shapeList.append(a)
|
||||
|
||||
@ -18,6 +18,8 @@
|
||||
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
|
||||
#
|
||||
|
||||
import os
|
||||
|
||||
import logging
|
||||
import salome
|
||||
from .geomsmesh import geompy
|
||||
@ -82,7 +84,7 @@ def construitFissureGenerale(maillagesSains,
|
||||
TODO: a completer
|
||||
"""
|
||||
logging.info('start')
|
||||
|
||||
|
||||
shapeDefaut = shapesFissure[0] # faces de fissure, débordant
|
||||
fondFiss = shapesFissure[4] # groupe d'edges de fond de fissure
|
||||
|
||||
@ -121,8 +123,7 @@ def construitFissureGenerale(maillagesSains,
|
||||
else:
|
||||
pointInterne = None
|
||||
|
||||
#fichierMaillageSain = nomRep + '/' + nomFicSain + '.med'
|
||||
fichierMaillageFissure = nomRep + '/' + nomFicFissure + '.med'
|
||||
fichierMaillageFissure = os.path.join (nomRep , '{}.med'.format(nomFicFissure))
|
||||
|
||||
# fillings des faces en peau
|
||||
facesDefaut = elementsDefaut[0]
|
||||
@ -150,17 +151,18 @@ def construitFissureGenerale(maillagesSains,
|
||||
|
||||
# --- restriction de la face de fissure au domaine solide :
|
||||
# partition face fissure étendue par fillings, on garde la face interne
|
||||
|
||||
|
||||
facesPortFissure = restreintFaceFissure(shapeDefaut, facesDefaut, pointInterne)
|
||||
|
||||
|
||||
# --- pipe de fond de fissure, prolongé, partition face fissure par pipe
|
||||
# identification des edges communes pipe et face fissure
|
||||
|
||||
|
||||
(fissPipe, edgesPipeFiss, edgesFondFiss, wirePipeFiss, wireFondFiss) = partitionneFissureParPipe(shapesFissure, elementsDefaut, rayonPipe)
|
||||
edgesFondFiss, edgesIdByOrientation = orderEdgesFromWire(wireFondFiss)
|
||||
|
||||
for i,edge in enumerate(edgesFondFiss):
|
||||
geomPublishInFather(initLog.debug, wireFondFiss, edge, "edgeFondFiss%d"%i)
|
||||
|
||||
|
||||
# --- peau et face de fissure
|
||||
#
|
||||
# --- partition peau défaut - face de fissure prolongée - wire de fond de fissure prolongée
|
||||
@ -169,39 +171,40 @@ def construitFissureGenerale(maillagesSains,
|
||||
# liste de partitions face externe - fissure : partitionPeauFissFond (None quand pas d'intersection)
|
||||
|
||||
partitionsPeauFissFond = construitPartitionsPeauFissure(facesDefaut, fissPipe)
|
||||
|
||||
|
||||
# --- arêtes vives détectées (dans quadranglesToShapeNoCorner
|
||||
# et quadranglesToShapeWithCorner)
|
||||
|
||||
|
||||
aretesVivesC = compoundFromList(bordsPartages, "areteVive")
|
||||
aretesVivesCoupees = [] # ensembles des arêtes vives identifiées sur les faces de peau dans l'itération sur partitionsPeauFissFond
|
||||
|
||||
aretesVivesCoupees = list() # ensembles des arêtes vives identifiées sur les faces de peau dans l'itération sur partitionsPeauFissFond
|
||||
|
||||
# --- 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 = [ [] for i in range(nbFacesFilling)] # pour chaque face [points edge fond de fissure aux débouchés du pipe]
|
||||
fsPipePeau = [ [] for i in range(nbFacesFilling)] # pour chaque face [faces du pipe débouchantes]
|
||||
edRadFPiPo = [ [] for i in range(nbFacesFilling)] # pour chaque face [edge radiale des faces du pipe débouchantes ]
|
||||
fsFissuExt = [ [] for i in range(nbFacesFilling)] # pour chaque face [faces de fissure externes au pipe]
|
||||
edFisExtPe = [ [] for i in range(nbFacesFilling)] # pour chaque face [edge en peau des faces de fissure externes (pas subshape facePeau)]
|
||||
edFisExtPi = [ [] for i in range(nbFacesFilling)] # pour chaque face [edge commun au pipe des faces de fissure externes]
|
||||
logging.info("nbFacesFilling : {} ".format(nbFacesFilling))
|
||||
|
||||
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 = [ [] for i in range(nbFacesFilling)] # pour chaque face de peau : [subshape edge circulaire aux débouchés du pipe]
|
||||
ptCircPeau = [ [] for i in range(nbFacesFilling)] # pour chaque face de peau : [subshape point sur edge circulaire aux débouchés du pipe]
|
||||
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 = [ [] for i in range(nbFacesFilling)] # pour chaque face de peau : [subshape edge en peau des faces de fissure externes]
|
||||
ptFisExtPi = [ [] for i in range(nbFacesFilling)] # pour chaque face de peau : [point commun edFissPeau edCircPeau]
|
||||
|
||||
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:
|
||||
dataPPFF,aretesVivesCoupees = identifieElementsGeometriquesPeau(ifil, partitionPeauFissFond, edgesPipeFiss,
|
||||
edgesFondFiss, wireFondFiss, aretesVivesC,
|
||||
facesDefaut, centreFondFiss, rayonPipe,
|
||||
aretesVivesCoupees)
|
||||
aretesVivesCoupees)
|
||||
ptEdgeFond[ifil] = dataPPFF['endsEdgeFond']
|
||||
fsPipePeau[ifil] = dataPPFF['facesPipePeau']
|
||||
edRadFPiPo[ifil] = dataPPFF['edgeRadFacePipePeau']
|
||||
@ -216,18 +219,18 @@ def construitFissureGenerale(maillagesSains,
|
||||
edFissPeau[ifil] = dataPPFF['edgesFissurePeau']
|
||||
ptFisExtPi[ifil] = dataPPFF['verticesPipePeau']
|
||||
|
||||
facesPipePeau = []
|
||||
edgeRadFacePipePeau = []
|
||||
facesPipePeau = list()
|
||||
edgeRadFacePipePeau = list()
|
||||
for ifil in range(nbFacesFilling):
|
||||
facesPipePeau += fsPipePeau[ifil]
|
||||
edgeRadFacePipePeau += edRadFPiPo[ifil]
|
||||
|
||||
|
||||
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
|
||||
|
||||
|
||||
(faceFissureExterne, edgesPipeFissureExterneC,
|
||||
wirePipeFissureExterne, edgesPeauFissureExterneC) = identifieFacesEdgesFissureExterne(fsFissuExt, edFisExtPe,
|
||||
edFisExtPi, edgesPipeFiss)
|
||||
@ -236,52 +239,52 @@ def construitFissureGenerale(maillagesSains,
|
||||
# - 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é)
|
||||
|
||||
(centres, gptsdisks, raydisks) = calculePointsAxiauxPipe(edgesFondFiss, edgesIdByOrientation, facesDefaut,
|
||||
|
||||
(centres, gptsdisks, raydisks) = calculePointsAxiauxPipe(edgesFondFiss, edgesIdByOrientation, facesDefaut,
|
||||
centreFondFiss, wireFondFiss, wirePipeFiss,
|
||||
lenSegPipe, rayonPipe, nbsegCercle, nbsegRad)
|
||||
|
||||
|
||||
# --- recherche des points en trop (externes au volume à remailler)
|
||||
# - on associe chaque extrémité du pipe à une face filling
|
||||
# - 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
|
||||
|
||||
|
||||
(idFillingFromBout, idisklim, idiskout) = elimineExtremitesPipe(ptEdgeFond, facesDefaut, centres, gptsdisks, nbsegCercle)
|
||||
|
||||
# --- construction des listes d'edges radiales sur chaque extrémité débouchante
|
||||
|
||||
|
||||
(listEdges, idFacesDebouchantes) = construitEdgesRadialesDebouchantes(idisklim, idiskout, gptsdisks, raydisks,
|
||||
facesPipePeau, edgeRadFacePipePeau, nbsegCercle)
|
||||
|
||||
|
||||
# --- création des points du maillage du pipe sur la face de peau
|
||||
|
||||
|
||||
(gptsdisks, idisklim) = creePointsPipePeau(listEdges, idFacesDebouchantes, idFillingFromBout,
|
||||
ptEdgeFond, ptFisExtPi, edCircPeau, gptsdisks, idisklim, nbsegRad)
|
||||
|
||||
|
||||
# --- ajustement precis des points sur edgesPipeFissureExterneC
|
||||
|
||||
|
||||
gptsdisks = ajustePointsEdgePipeFissure(edgesPipeFissureExterneC, wirePipeFissureExterne, gptsdisks, idisklim)
|
||||
|
||||
|
||||
# --- maillage effectif du pipe
|
||||
|
||||
(meshPipe, meshPipeGroups, edgesCircPipeGroup) = construitMaillagePipe(gptsdisks, idisklim, nbsegCercle, nbsegRad)
|
||||
|
||||
|
||||
# --- edges de bord, faces défaut à respecter
|
||||
|
||||
|
||||
(internalBoundary, bordsLibres, grpAretesVives) = mailleAretesEtJonction(internalBoundary, aretesVivesCoupees, lgAretesVives)
|
||||
|
||||
# --- maillage faces de fissure
|
||||
|
||||
(meshFaceFiss, grpFaceFissureExterne,
|
||||
|
||||
(meshFaceFiss, grpFaceFissureExterne,
|
||||
grpEdgesPeauFissureExterne, grpEdgesPipeFissureExterne) = mailleFacesFissure(faceFissureExterne, edgesPipeFissureExterneC, edgesPeauFissureExterneC,
|
||||
meshPipeGroups, areteFaceFissure, rayonPipe, nbsegRad)
|
||||
|
||||
# --- maillage faces de peau
|
||||
|
||||
|
||||
meshesFacesPeau = mailleFacesPeau(partitionsPeauFissFond, idFillingFromBout, facesDefaut,
|
||||
facesPeaux, edCircPeau, ptCircPeau, gpedgeBord, gpedgeVifs, edFissPeau,
|
||||
facesPeaux, edCircPeau, ptCircPeau, gpedgeBord, gpedgeVifs, edFissPeau,
|
||||
bordsLibres, grpEdgesPeauFissureExterne, grpAretesVives,
|
||||
edgesCircPipeGroup, dmoyen, rayonPipe, nbsegRad)
|
||||
|
||||
@ -318,7 +321,7 @@ def construitFissureGenerale(maillagesSains,
|
||||
isDone = meshBoiteDefaut.Compute()
|
||||
putName(meshBoiteDefaut, "boiteDefaut")
|
||||
logging.info("meshBoiteDefaut fini")
|
||||
|
||||
|
||||
faceFissure = meshBoiteDefaut.GetMesh().UnionListOfGroups( [ group_faceFissOutPipe, group_faceFissInPipe ], 'FACE1' )
|
||||
maillageSain = enleveDefaut(maillageSain, zoneDefaut, zoneDefaut_skin,
|
||||
zoneDefaut_internalFaces, zoneDefaut_internalEdges)
|
||||
@ -354,5 +357,5 @@ def construitFissureGenerale(maillagesSains,
|
||||
salome.sg.updateObjBrowser()
|
||||
|
||||
logging.info("maillage fissure fini")
|
||||
|
||||
|
||||
return maillageComplet
|
||||
|
||||
@ -50,7 +50,7 @@ def construitPartitionsPeauFissure(facesDefaut, fissPipe):
|
||||
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:
|
||||
if otherFD:
|
||||
fissPipePart = geompy.MakePartition([fissPipe], otherFD, [], [], geompy.ShapeType["FACE"], 0, [], 0)
|
||||
else:
|
||||
fissPipePart = fissPipe
|
||||
@ -59,6 +59,6 @@ def construitPartitionsPeauFissure(facesDefaut, fissPipe):
|
||||
geomPublish(initLog.debug, part, 'partitionPeauFissFond%d'%ipart )
|
||||
else:
|
||||
partitionsPeauFissFond.append(None)
|
||||
ipart = ipart +1
|
||||
ipart += 1
|
||||
|
||||
return partitionsPeauFissFond
|
||||
return partitionsPeauFissFond
|
||||
|
||||
@ -18,6 +18,8 @@
|
||||
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
|
||||
#
|
||||
|
||||
import os
|
||||
|
||||
import logging
|
||||
from .geomsmesh import smesh
|
||||
import SMESH
|
||||
@ -62,7 +64,7 @@ def creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure,
|
||||
nomRep = maillageFissureParams['nomRep']
|
||||
nomFicSain = maillageFissureParams['nomFicSain']
|
||||
|
||||
fichierMaillageSain = nomRep + '/' + nomFicSain + '.med'
|
||||
fichierMaillageSain = os.path.join (nomRep , '{}.med'.format(nomFicSain))
|
||||
|
||||
# --- centre de fond de fissure et tangente
|
||||
|
||||
@ -80,10 +82,10 @@ def creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure,
|
||||
[maillageSain, internalBoundary, zoneDefaut, zoneDefaut_skin, zoneDefaut_internalFaces, zoneDefaut_internalEdges] = \
|
||||
peauInterne(fichierMaillageSain, shapeDefaut, nomZones)
|
||||
|
||||
facesDefaut = []
|
||||
centresDefaut = []
|
||||
normalsDefaut =[]
|
||||
extrusionsDefaut = []
|
||||
facesDefaut = list()
|
||||
centresDefaut = list()
|
||||
normalsDefaut = list()
|
||||
extrusionsDefaut = list()
|
||||
isPlane = False
|
||||
if isHexa and not isPlane:
|
||||
meshQuad = smesh.CopyMesh( zoneDefaut_skin, 'meshQuad', 0, 0)
|
||||
@ -100,7 +102,7 @@ def creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure,
|
||||
else:
|
||||
[facesDefaut, centreDefaut, normalDefaut, extrusionDefaut] = \
|
||||
creeZoneDefautGeom( geometrieSaine, shapeDefaut, origShapes, verticesShapes, dmoyen, lgExtrusion)
|
||||
bordsPartages = []
|
||||
bordsPartages = list()
|
||||
for face in facesDefaut:
|
||||
bordsPartages.append([None,None]) # TODO : traitement des arêtes vives ?
|
||||
fillconts = facesDefaut
|
||||
|
||||
@ -53,11 +53,11 @@ def creeZoneDefautMaillage(maillagesSains, shapeDefaut, tailleDefaut,
|
||||
isHexa = maillagesSains[1]
|
||||
lists = maillageSain.CreateHoleSkin(tailleDefaut, shapeDefaut, nomZones, coordsNoeudsFissure)
|
||||
|
||||
logging.debug("lists=%s", lists)
|
||||
logging.debug("lists={}".format(lists))
|
||||
|
||||
trace = True
|
||||
origShapes = []
|
||||
verticesShapes = []
|
||||
origShapes = list()
|
||||
verticesShapes = list()
|
||||
|
||||
cumul = 0 # somme des distances carrées entre point ordonnés (taille des arêtes)
|
||||
nb = 0 # nombre d'arêtes évaluées
|
||||
@ -65,8 +65,8 @@ def creeZoneDefautMaillage(maillagesSains, shapeDefaut, tailleDefaut,
|
||||
for aList in lists:
|
||||
aShape = aList[0]
|
||||
origShapes.append(aShape)
|
||||
logging.debug(" shapeId %s", aShape)
|
||||
vertices = []
|
||||
logging.debug(" shapeId {}".format(aShape))
|
||||
vertices = list()
|
||||
xyz0 = None
|
||||
for inode in range(1, len(aList)):
|
||||
xyz = maillageSain.GetNodeXYZ(aList[inode])
|
||||
|
||||
@ -17,6 +17,7 @@
|
||||
#
|
||||
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
|
||||
#
|
||||
"""fissureGenerique"""
|
||||
|
||||
import logging
|
||||
|
||||
@ -24,9 +25,9 @@ from blocFissure import gmu
|
||||
from blocFissure.gmu.initEtude import initEtude
|
||||
from blocFissure.gmu.getStatsMaillageFissure import getStatsMaillageFissure
|
||||
|
||||
class fissureGenerique():
|
||||
"""
|
||||
classe générique problème fissure:
|
||||
class fissureGenerique(object):
|
||||
"""classe générique problème fissure:
|
||||
|
||||
génération géométrie et maillage sain
|
||||
définition et positionnement d'une fissure
|
||||
génération d'un bloc défaut inséré dans le maillage sain
|
||||
@ -41,46 +42,58 @@ class fissureGenerique():
|
||||
self.fissureLongue = False
|
||||
|
||||
def setParamGeometrieSaine(self):
|
||||
self.geomParams = {}
|
||||
"""setParamGeometrieSaine"""
|
||||
self.geomParams = dict()
|
||||
|
||||
def genereGeometrieSaine(self, geomParams):
|
||||
"""genereGeometrieSaine"""
|
||||
geometriesSaines = [None]
|
||||
return geometriesSaines
|
||||
|
||||
def setParamMaillageSain(self):
|
||||
self.meshParams = {}
|
||||
"""setParamMaillageSain"""
|
||||
self.meshParams = dict()
|
||||
|
||||
def genereMaillageSain(self, geometriesSaines, meshParams):
|
||||
"""genereMaillageSain"""
|
||||
maillagesSains = [None]
|
||||
return maillagesSains
|
||||
|
||||
def setParamShapeFissure(self):
|
||||
self.shapeFissureParams = {}
|
||||
"""setParamShapeFissure"""
|
||||
self.shapeFissureParams = dict()
|
||||
|
||||
def genereShapeFissure(self, geometriesSaines, geomParams, shapeFissureParams):
|
||||
"""genereShapeFissure"""
|
||||
shapesFissure = [None]
|
||||
return shapesFissure
|
||||
|
||||
def setParamMaillageFissure(self):
|
||||
self.maillageFissureParams = {}
|
||||
"""setParamMaillageFissure"""
|
||||
self.maillageFissureParams = dict()
|
||||
|
||||
def genereZoneDefaut(self, geometriesSaines, maillagesSains, shapesFissure, maillageFissureParams):
|
||||
"""genereZoneDefaut"""
|
||||
elementsDefaut = [None]
|
||||
return elementsDefaut
|
||||
|
||||
def genereMaillageFissure(self, geometriesSaines, maillagesSains, shapesFissure,
|
||||
maillageFissureParams, elementsDefaut, step):
|
||||
maillageFissureParams, elementsDefaut):
|
||||
"""genereMaillageFissure"""
|
||||
maillageFissure = None
|
||||
return maillageFissure
|
||||
|
||||
def setReferencesMaillageFissure(self):
|
||||
referencesMaillageFissure = {}
|
||||
"""setReferencesMaillageFissure"""
|
||||
referencesMaillageFissure = dict()
|
||||
return referencesMaillageFissure
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def executeProbleme(self, step=-1):
|
||||
logging.info(" --- executeProbleme %s", self.nomCas)
|
||||
"""executeProbleme"""
|
||||
texte = " --- fissureGenerique.executeProbleme pour '{}', step = {}".format(self.nomCas,step)
|
||||
logging.info(texte)
|
||||
if step == 0:
|
||||
return
|
||||
|
||||
@ -109,10 +122,5 @@ class fissureGenerique():
|
||||
self.maillageFissureParams, elementsDefaut, step)
|
||||
|
||||
self.setReferencesMaillageFissure()
|
||||
mesures = getStatsMaillageFissure(maillageFissure, self.referencesMaillageFissure, self.maillageFissureParams)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
ok_maillage = getStatsMaillageFissure(maillageFissure, self.referencesMaillageFissure, self.maillageFissureParams)
|
||||
return ok_maillage
|
||||
|
||||
@ -41,6 +41,8 @@ def genereMeshCalculZoneDefaut(facefiss, minSize, maxSize):
|
||||
dans une liste sous la forme : [X0, Y0, Z0, ..., Xn, Yn, Zn]"""
|
||||
|
||||
logging.info('start')
|
||||
text = "Maillage de '{}'".format(facefiss.GetName())
|
||||
logging.info(text)
|
||||
|
||||
meshFissure = smesh.Mesh(facefiss)
|
||||
algo2d = meshFissure.Triangle(algo=smeshBuilder.NETGEN_1D2D)
|
||||
@ -51,15 +53,27 @@ def genereMeshCalculZoneDefaut(facefiss, minSize, maxSize):
|
||||
hypo2d.SetFineness( 2 )
|
||||
hypo2d.SetMinSize( minSize )
|
||||
hypo2d.SetQuadAllowed( 0 )
|
||||
isDone = meshFissure.Compute()
|
||||
smesh.SetName(algo2d, "algo2d_zoneFiss")
|
||||
smesh.SetName(hypo2d, "hypo1d_zoneFiss")
|
||||
|
||||
coordsNoeudsFissure = []
|
||||
isDone = meshFissure.Compute()
|
||||
|
||||
if isDone:
|
||||
logging.info(text+" : OK")
|
||||
logging.debug(text+" : OK")
|
||||
else:
|
||||
text = "Erreur au calcul du maillage.\n" + text
|
||||
logging.info(text)
|
||||
raise Exception(text)
|
||||
|
||||
coordsNoeudsFissure = list()
|
||||
nodeIds = meshFissure.GetNodesId()
|
||||
for id in nodeIds:
|
||||
coords = meshFissure.GetNodeXYZ(id)
|
||||
coordsNoeudsFissure.append(coords[0])
|
||||
coordsNoeudsFissure.append(coords[1])
|
||||
coordsNoeudsFissure.append(coords[2])
|
||||
|
||||
logging.info('end')
|
||||
|
||||
return coordsNoeudsFissure
|
||||
|
||||
@ -40,7 +40,7 @@ def getStatsMaillageFissure(maillage, referencesMaillageFissure, maillageFissure
|
||||
fichierNewRef = os.path.join(nomRep, "{}.new".format(nomFicFissure))
|
||||
logging.debug("fichierStatMaillageFissure=%s", fichierStatMaillageFissure)
|
||||
|
||||
OK = False
|
||||
ok_maillage = False
|
||||
if maillage is not None:
|
||||
mesures = maillage.GetMeshInfo()
|
||||
d_resu = dict()
|
||||
@ -50,12 +50,12 @@ def getStatsMaillageFissure(maillage, referencesMaillageFissure, maillageFissure
|
||||
logging.debug("dico mesures %s", d_resu)
|
||||
|
||||
text_2 = ""
|
||||
OK = True
|
||||
ok_maillage = True
|
||||
with open(fichierStatMaillageFissure, "w") as fic_stat :
|
||||
for key in ('Entity_Quad_Quadrangle', 'Entity_Quad_Hexa'):
|
||||
if d_resu[key] != referencesMaillageFissure[key]:
|
||||
text = "Ecart"
|
||||
OK = False
|
||||
ok_maillage = False
|
||||
else:
|
||||
text = "Valeur_OK"
|
||||
text += ": {} reference: {} calcul: {}".format(key,referencesMaillageFissure[key],d_resu[key])
|
||||
@ -67,7 +67,7 @@ def getStatsMaillageFissure(maillage, referencesMaillageFissure, maillageFissure
|
||||
if (d_resu[key] < (1.0 - tolerance)*referencesMaillageFissure[key]) \
|
||||
or (d_resu[key] > (1.0 + tolerance)*referencesMaillageFissure[key]):
|
||||
text = "Ecart"
|
||||
OK = False
|
||||
ok_maillage = False
|
||||
else:
|
||||
text = "Valeur_OK"
|
||||
text += ": {} reference: {} calcul: {}".format(key,referencesMaillageFissure[key],d_resu[key])
|
||||
@ -79,7 +79,7 @@ def getStatsMaillageFissure(maillage, referencesMaillageFissure, maillageFissure
|
||||
with open(fichierNewRef, "w") as fic_info :
|
||||
fic_info.write(text_2[:-4]+" \\")
|
||||
|
||||
if OK:
|
||||
if ok_maillage:
|
||||
print ("Calcul cohérent avec la référence.")
|
||||
else:
|
||||
text = "Calcul différent de la référence.\n"
|
||||
@ -88,4 +88,4 @@ def getStatsMaillageFissure(maillage, referencesMaillageFissure, maillageFissure
|
||||
text += "Il faut l'insérer pour créer le dictionnaire 'referencesMaillageFissure' dans le paramétrage du cas."
|
||||
print (text)
|
||||
|
||||
return OK
|
||||
return ok_maillage
|
||||
|
||||
@ -26,45 +26,50 @@ from .geomsmesh import geomPublishInFather
|
||||
from . import initLog
|
||||
|
||||
def identifieFacesEdgesFissureExterne(fsFissuExt, edFisExtPe, edFisExtPi, edgesPipeFiss):
|
||||
"""
|
||||
identification des faces et edges de fissure externe pour maillage
|
||||
"""
|
||||
"""identification des faces et edges de fissure externe pour maillage"""
|
||||
logging.info('start')
|
||||
|
||||
facesFissExt = []
|
||||
edgesFissExtPeau = []
|
||||
edgesFissExtPipe = []
|
||||
|
||||
logging.debug("---------------------------- fsFissuExt : {} ".format(fsFissuExt))
|
||||
facesFissExt = list()
|
||||
edgesFissExtPeau = list()
|
||||
edgesFissExtPipe = list()
|
||||
for ifil in range(len(fsFissuExt)): # 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))
|
||||
logging.debug("---------------------------- identification faces de fissure externes au pipe : {}".format(len(facesFissExt)))
|
||||
# regroupement des faces de fissure externes au pipe.
|
||||
|
||||
if len(facesFissExt) > 1:
|
||||
|
||||
if not facesFissExt:
|
||||
logging.info("---------------------------- fsFissuExt : {} ".format(fsFissuExt))
|
||||
raise Exception("stop identifieFacesEdgesFissureExterne ; aucune face de fissure externe au pipe n'a été trouvée.")
|
||||
|
||||
elif len(facesFissExt) > 1:
|
||||
faceFissureExterne = geompy.MakePartition(facesFissExt, [], [], [], geompy.ShapeType["FACE"], 0, [], 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
|
||||
(isDone, closedFreeBoundaries, openFreeBoundaries) = geompy.GetFreeBoundary(faceFissureExterne)
|
||||
edgesBordFFE = []
|
||||
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)
|
||||
logging.debug("edgesBordFFEid {}".format(edgesBordFFEid))
|
||||
edgesPPE = geompy.ExtractShapes(edgesPipeFissureExterneC, geompy.ShapeType["EDGE"], False)
|
||||
edgesPPEid = [ geompy.GetSubShapeID(faceFissureExterne, ed) for ed in edgesPPE]
|
||||
logging.debug("edgesPPEid %s", edgesPPEid)
|
||||
logging.debug("edgesPPEid {}".format(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)
|
||||
logging.debug("edgesPFE {}".format(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")
|
||||
|
||||
return (faceFissureExterne, edgesPipeFissureExterneC, wirePipeFissureExterne, edgesPeauFissureExterneC)
|
||||
|
||||
return (faceFissureExterne, edgesPipeFissureExterneC, wirePipeFissureExterne, edgesPeauFissureExterneC)
|
||||
|
||||
@ -33,6 +33,7 @@ def mailleFacesFissure(faceFissureExterne, edgesPipeFissureExterneC, edgesPeauFi
|
||||
maillage faces de fissure
|
||||
"""
|
||||
logging.info('start')
|
||||
logging.info("Maillage de {}".format(faceFissureExterne.GetName()))
|
||||
|
||||
meshFaceFiss = smesh.Mesh(faceFissureExterne)
|
||||
algo2d = meshFaceFiss.Triangle(algo=smeshBuilder.NETGEN_1D2D)
|
||||
@ -46,18 +47,25 @@ def mailleFacesFissure(faceFissureExterne, edgesPipeFissureExterneC, edgesPeauFi
|
||||
putName(algo2d.GetSubMesh(), "faceFiss")
|
||||
putName(algo2d, "algo2d_faceFiss")
|
||||
putName(hypo2d, "hypo2d_faceFiss")
|
||||
|
||||
|
||||
logging.info('Récupération des arêtes de {}'.format(edgesPipeFissureExterneC.GetName()))
|
||||
algo1d = meshFaceFiss.UseExisting1DElements(geom=edgesPipeFissureExterneC)
|
||||
hypo1d = algo1d.SourceEdges([ meshPipeGroups['edgeFaceFissGroup'] ],0,0)
|
||||
putName(algo1d.GetSubMesh(), "edgeFissPeau")
|
||||
putName(algo1d, "algo1d_edgeFissPeau")
|
||||
putName(hypo1d, "hypo1d_edgeFissPeau")
|
||||
|
||||
isDone = meshFaceFiss.Compute()
|
||||
logging.info("meshFaceFiss fini")
|
||||
|
||||
grpFaceFissureExterne = meshFaceFiss.GroupOnGeom(faceFissureExterne, "fisOutPi", SMESH.FACE)
|
||||
grpEdgesPeauFissureExterne = meshFaceFiss.GroupOnGeom(edgesPeauFissureExterneC,'edgesPeauFissureExterne',SMESH.EDGE)
|
||||
grpEdgesPipeFissureExterne = meshFaceFiss.GroupOnGeom(edgesPipeFissureExterneC,'edgesPipeFissureExterne',SMESH.EDGE)
|
||||
|
||||
return (meshFaceFiss, grpFaceFissureExterne, grpEdgesPeauFissureExterne, grpEdgesPipeFissureExterne)
|
||||
isDone = meshFaceFiss.Compute()
|
||||
text = "meshFaceFiss fini"
|
||||
if isDone:
|
||||
logging.info(text)
|
||||
else:
|
||||
text = "Erreur au calcul du maillage.\n" + text
|
||||
logging.info(text)
|
||||
raise Exception(text)
|
||||
|
||||
return (meshFaceFiss, grpFaceFissureExterne, grpEdgesPeauFissureExterne, grpEdgesPipeFissureExterne)
|
||||
|
||||
@ -32,7 +32,7 @@ def orderEdgesFromWire(aWire):
|
||||
logging.info("start")
|
||||
edges = geompy.ExtractShapes(aWire, geompy.ShapeType["EDGE"], False)
|
||||
|
||||
idverts = {}
|
||||
idverts = dict()
|
||||
for i, edge in enumerate(edges):
|
||||
verts = geompy.ExtractShapes(edge, geompy.ShapeType["VERTEX"], True)
|
||||
# idverts[(i,0)] = verts[0]
|
||||
@ -46,7 +46,7 @@ def orderEdgesFromWire(aWire):
|
||||
idverts[(i,0)] = verts[1]
|
||||
idverts[(i,1)] = verts[0]
|
||||
|
||||
idsubs = {}
|
||||
idsubs = dict()
|
||||
for kv, sub in idverts.items():
|
||||
subid = geompy.GetSubShapeID(aWire, sub)
|
||||
if subid in list(idsubs.keys()):
|
||||
@ -63,7 +63,7 @@ def orderEdgesFromWire(aWire):
|
||||
debut = kv[0]
|
||||
else:
|
||||
fin = kv[0]
|
||||
logging.debug("nombre d'edges: %s, indice edge début: %s, fin: %s",len(edges), debut, fin)
|
||||
logging.debug("nombre d'edges: {}, indice edge début: {}, fin: {}".format(len(edges), debut, fin))
|
||||
if debut < 0:
|
||||
logging.critical("les edges du wire ne sont pas orientées dans le même sens: pas de début trouvé")
|
||||
return edges, list(range(len(edges)))
|
||||
@ -82,9 +82,9 @@ def orderEdgesFromWire(aWire):
|
||||
logging.critical("les edges du wire ne sont pas orientées dans le même sens: une edge à l'envers")
|
||||
return edges, list(range(len(edges)))
|
||||
|
||||
logging.debug("liste des edges ordonnées selon le sens de parcours: %s", orderedList)
|
||||
logging.debug("liste des edges ordonnées selon le sens de parcours : {}".format(orderedList))
|
||||
accessList = list(range(len(orderedList)))
|
||||
for i,k in enumerate(orderedList):
|
||||
accessList[k] = i
|
||||
logging.info("position ordonnée des edges selon le sens de parcours: %s", accessList)
|
||||
logging.info("position ordonnée des edges selon le sens de parcours : {}".format(accessList))
|
||||
return edges, accessList
|
||||
|
||||
@ -34,6 +34,7 @@ def peauInterne(fichierMaillage, shapeDefaut, nomZones):
|
||||
"""
|
||||
Retrouve les groupes de défaut dans le maillage sain modifié par CreateHoleSkin (CreeZoneDefautMaillage)
|
||||
On récupère le volume et la peau de la zone de défaut, les éventuelles faces et arêtes internes de cette zone.
|
||||
Remarque : intérêt du passage par fichierMaillage plutôt que par maillageSain ?
|
||||
"""
|
||||
logging.info("start")
|
||||
([maillageSain], status) = smesh.CreateMeshesFromMED(fichierMaillage)
|
||||
@ -86,8 +87,8 @@ def peauInterne(fichierMaillage, shapeDefaut, nomZones):
|
||||
|
||||
maillageDefautCible = smesh.CopyMesh(zoneDefaut_skin, 'maillageCible', 0, 0)
|
||||
listOfCorner = lookForCorner(maillageDefautCible)
|
||||
logging.debug("listOfCorner = %s", listOfCorner)
|
||||
if len(listOfCorner) > 0:
|
||||
logging.debug("listOfCorner = {}".format(listOfCorner))
|
||||
if listOfCorner:
|
||||
logging.info("présence de coins à la surface externe de la zone à reconstruire")
|
||||
zoneDefaut_skin, internalBoundary = fusionMaillageDefaut(maillageSain, maillageDefautCible, internalBoundary, zoneDefaut_skin, shapeDefaut, listOfCorner)
|
||||
|
||||
|
||||
@ -36,101 +36,101 @@ from .listOfExtraFunctions import createLinesFromMesh
|
||||
# -----------------------------------------------------------------------------
|
||||
# --- groupe de quadrangles de face transformé en face géométrique par filling
|
||||
|
||||
def quadranglesToShapeWithCorner(meshQuad, shapeDefaut, shapeFissureParams, centreFondFiss, listOfCorners):
|
||||
""" """
|
||||
# TODO: rédiger la docstring
|
||||
|
||||
logging.info("start")
|
||||
def quadranglesToShapeWithCorner(meshQuad, shapeDefaut, listOfCorners):
|
||||
""" """
|
||||
# TODO: rédiger la docstring
|
||||
|
||||
#fillings = [[], []]
|
||||
tmpFillings = []
|
||||
noeuds_bords = []
|
||||
#bords_Partages = [[], []]
|
||||
tmpBords = []
|
||||
fillconts = []
|
||||
idFilToCont = []
|
||||
|
||||
facesNonCoupees = []
|
||||
facesCoupees = []
|
||||
aretesNonCoupees = []
|
||||
aretesCoupees = []
|
||||
|
||||
setOfNodes = []
|
||||
setOfLines = []
|
||||
listOfEdges = []
|
||||
# On crée une liste contenant le maillage de chaque face.
|
||||
listOfNewMeshes = createNewMeshesFromCorner(meshQuad, listOfCorners)
|
||||
for msh in listOfNewMeshes:
|
||||
# On crée une liste de noeuds correspondant aux faces suivant
|
||||
# le modèle liste[face][ligne][noeud].
|
||||
lines = createLinesFromMesh(msh, listOfCorners[0])
|
||||
setOfNodes.append(lines)
|
||||
|
||||
for face in setOfNodes:
|
||||
tmpFace = []
|
||||
for line in face:
|
||||
# On possède l'information 'ID' de chaque noeud composant chaque
|
||||
# ligne de chaque face. A partir de l'ID, on crée un vertex. Un
|
||||
# ensemble de vertices constitue une ligne. Un ensemble de lignes
|
||||
# constitue une face.
|
||||
tmpCoords = [meshQuad.GetNodeXYZ(node) for node in line]
|
||||
tmpPoints = [geompy.MakeVertex(val[0], val[1], val[2]) for val in tmpCoords]
|
||||
line = geompy.MakeInterpol(tmpPoints, False, False)
|
||||
tmpFace.append(line)
|
||||
setOfLines.append(tmpFace)
|
||||
|
||||
for i, face in enumerate(setOfLines):
|
||||
# A partir des lignes de chaque face,
|
||||
# on recrée un objet GEOM temporaire par filling.
|
||||
filling = geompy.MakeFilling(geompy.MakeCompound(face), 2, 5, 0.0001, 0.0001, 0, GEOM.FOM_Default, True)
|
||||
geomPublish(initLog.debug, filling, 'filling_{0}'.format(i + 1))
|
||||
tmpFillings.append(filling)
|
||||
logging.info("start")
|
||||
|
||||
#fillings = [list(), list()]
|
||||
tmpFillings = list()
|
||||
noeuds_bords = list()
|
||||
#bords_Partages = [list(), list()]
|
||||
tmpBords = list()
|
||||
fillconts = list()
|
||||
idFilToCont = list()
|
||||
|
||||
facesNonCoupees = list()
|
||||
facesCoupees = list()
|
||||
aretesNonCoupees = list()
|
||||
aretesCoupees = list()
|
||||
|
||||
setOfNodes = list()
|
||||
setOfLines = list()
|
||||
listOfEdges = list()
|
||||
# On crée une liste contenant le maillage de chaque face.
|
||||
listOfNewMeshes = createNewMeshesFromCorner(meshQuad, listOfCorners)
|
||||
for msh in listOfNewMeshes:
|
||||
# On crée une liste de noeuds correspondant aux faces suivant
|
||||
# le modèle liste[face][ligne][noeud].
|
||||
#lines = createLinesFromMesh(msh, listOfCorners[0])
|
||||
lines = createLinesFromMesh(msh)
|
||||
setOfNodes.append(lines)
|
||||
|
||||
for face in setOfNodes:
|
||||
tmpFace = list()
|
||||
for line in face:
|
||||
# On possède l'information 'ID' de chaque noeud composant chaque
|
||||
# ligne de chaque face. A partir de l'ID, on crée un vertex. Un
|
||||
# ensemble de vertices constitue une ligne. Un ensemble de lignes
|
||||
# constitue une face.
|
||||
tmpCoords = [meshQuad.GetNodeXYZ(node) for node in line]
|
||||
tmpPoints = [geompy.MakeVertex(val[0], val[1], val[2]) for val in tmpCoords]
|
||||
line = geompy.MakeInterpol(tmpPoints, False, False)
|
||||
tmpFace.append(line)
|
||||
setOfLines.append(tmpFace)
|
||||
|
||||
for i, face in enumerate(setOfLines):
|
||||
# A partir des lignes de chaque face,
|
||||
# on recrée un objet GEOM temporaire par filling.
|
||||
filling = geompy.MakeFilling(geompy.MakeCompound(face), 2, 5, 0.0001, 0.0001, 0, GEOM.FOM_Default, True)
|
||||
geomPublish(initLog.debug, filling, 'filling_{}'.format(i + 1))
|
||||
tmpFillings.append(filling)
|
||||
|
||||
for face in setOfNodes:
|
||||
# On prend la première ligne qui correspond aux bords partagés
|
||||
listOfEdges.append(face[0])
|
||||
|
||||
for edge in listOfEdges:
|
||||
# On utilise les points de bords pour créer des aretes vives
|
||||
tmpCoords = [meshQuad.GetNodeXYZ(node) for node in list(edge)]
|
||||
tmpPoints = [geompy.MakeVertex(val[0], val[1], val[2]) for val in tmpCoords]
|
||||
line = geompy.MakeInterpol(tmpPoints, False, False)
|
||||
tmpBords.append(line)
|
||||
|
||||
for i, filling in enumerate(tmpFillings):
|
||||
tmpPartition = geompy.MakePartition([filling], [shapeDefaut], list(), list(), geompy.ShapeType["FACE"], 0, list(), 0, True)
|
||||
tmpExplodeRef = geompy.ExtractShapes(filling, geompy.ShapeType["EDGE"], True)
|
||||
tmpExplodeNum = geompy.ExtractShapes(tmpPartition, geompy.ShapeType["EDGE"], True)
|
||||
if len(tmpExplodeRef) == len(tmpExplodeNum):
|
||||
geomPublish(initLog.debug, filling, "faceNonCoupee_{}".format(i + 1))
|
||||
facesNonCoupees.append(filling)
|
||||
else:
|
||||
geomPublish(initLog.debug, filling, "faceCoupee_{}".format(i + 1))
|
||||
facesCoupees.append(filling)
|
||||
fillings = facesCoupees, facesNonCoupees
|
||||
|
||||
for i, filling in enumerate(tmpBords):
|
||||
tmpPartition = geompy.MakePartition([shapeDefaut], [filling], list(), list(), geompy.ShapeType["SHELL"], 0, list(), 0, True)
|
||||
tmpExplodeRef = geompy.ExtractShapes(shapeDefaut, geompy.ShapeType["EDGE"], True) + geompy.ExtractShapes(shapeDefaut, geompy.ShapeType["VERTEX"], True)
|
||||
tmpExplodeNum = geompy.ExtractShapes(tmpPartition, geompy.ShapeType["EDGE"], True) + geompy.ExtractShapes(tmpPartition, geompy.ShapeType["VERTEX"], True)
|
||||
if len(tmpExplodeRef) == len(tmpExplodeNum):
|
||||
geomPublish(initLog.debug, filling, "areteNonCoupee_{}".format(i + 1))
|
||||
aretesNonCoupees.append(filling)
|
||||
else:
|
||||
geomPublish(initLog.debug, filling, "areteCoupee_{}".format(i + 1))
|
||||
aretesCoupees.append(filling)
|
||||
bords_Partages = aretesCoupees, aretesNonCoupees
|
||||
|
||||
for face in setOfNodes:
|
||||
# On prend la première ligne qui correspond aux bords partagés
|
||||
listOfEdges.append(face[0])
|
||||
|
||||
for edge in listOfEdges:
|
||||
# On utilise les points de bords pour créer des aretes vives
|
||||
tmpCoords = [meshQuad.GetNodeXYZ(node) for node in list(edge)]
|
||||
tmpPoints = [geompy.MakeVertex(val[0], val[1], val[2]) for val in tmpCoords]
|
||||
line = geompy.MakeInterpol(tmpPoints, False, False)
|
||||
tmpBords.append(line)
|
||||
|
||||
for i, filling in enumerate(tmpFillings):
|
||||
tmpPartition = geompy.MakePartition([filling], [shapeDefaut], [], [], geompy.ShapeType["FACE"], 0, [], 0, True)
|
||||
tmpExplodeRef = geompy.ExtractShapes(filling, geompy.ShapeType["EDGE"], True)
|
||||
tmpExplodeNum = geompy.ExtractShapes(tmpPartition, geompy.ShapeType["EDGE"], True)
|
||||
if len(tmpExplodeRef) == len(tmpExplodeNum):
|
||||
geomPublish(initLog.debug, filling, "faceNonCoupee_{0}".format(i + 1))
|
||||
facesNonCoupees.append(filling)
|
||||
else:
|
||||
geomPublish(initLog.debug, filling, "faceCoupee_{0}".format(i + 1))
|
||||
facesCoupees.append(filling)
|
||||
fillings = facesCoupees, facesNonCoupees
|
||||
|
||||
for i, filling in enumerate(tmpBords):
|
||||
tmpPartition = geompy.MakePartition([shapeDefaut], [filling], [], [], geompy.ShapeType["SHELL"], 0, [], 0, True)
|
||||
tmpExplodeRef = geompy.ExtractShapes(shapeDefaut, geompy.ShapeType["EDGE"], True) + geompy.ExtractShapes(shapeDefaut, geompy.ShapeType["VERTEX"], True)
|
||||
tmpExplodeNum = geompy.ExtractShapes(tmpPartition, geompy.ShapeType["EDGE"], True) + geompy.ExtractShapes(tmpPartition, geompy.ShapeType["VERTEX"], True)
|
||||
if len(tmpExplodeRef) == len(tmpExplodeNum):
|
||||
geomPublish(initLog.debug, filling, "areteNonCoupee_{0}".format(i + 1))
|
||||
aretesNonCoupees.append(filling)
|
||||
else:
|
||||
geomPublish(initLog.debug, filling, "areteCoupee_{0}".format(i + 1))
|
||||
aretesCoupees.append(filling)
|
||||
bords_Partages = aretesCoupees, aretesNonCoupees
|
||||
|
||||
# TODO: A enlever
|
||||
# for i, face in enumerate(setOfLines):
|
||||
# for j, line in enumerate(face):
|
||||
# geomPublish(initLog.debug, line, 'face{0}_ligne{1}'.format(i + 1, j + 1))
|
||||
# for j, line in enumerate(face):
|
||||
# geomPublish(initLog.debug, line, 'face{0}_ligne{1}'.format(i + 1, j + 1))
|
||||
|
||||
#TODO: A enlever
|
||||
#TODO: A enlever
|
||||
# for i, filling in enumerate(fillings[0]):
|
||||
# geomPublish(initLog.debug, filling, 'filling_{0}'.format(i + 1))
|
||||
# for j, line in enumerate(setOfLines[i]):
|
||||
# geompy.addToStudyInFather(filling, line, 'line_{0}'.format(j + 1))
|
||||
|
||||
return fillings, noeuds_bords, bords_Partages, fillconts, idFilToCont
|
||||
|
||||
# geomPublish(initLog.debug, filling, 'filling_{0}'.format(i + 1))
|
||||
# for j, line in enumerate(setOfLines[i]):
|
||||
# geompy.addToStudyInFather(filling, line, 'line_{0}'.format(j + 1))
|
||||
|
||||
return fillings, noeuds_bords, bords_Partages, fillconts, idFilToCont
|
||||
|
||||
@ -28,8 +28,8 @@ import traceback
|
||||
from .fissError import fissError
|
||||
|
||||
def restreintFaceFissure(shapeDefaut, facesDefaut, pointInterne):
|
||||
"""
|
||||
restriction de la face de fissure au domaine solide
|
||||
"""restriction de la face de fissure au domaine solide
|
||||
|
||||
partition face fissure étendue par fillings
|
||||
"""
|
||||
logging.info('start')
|
||||
@ -39,7 +39,7 @@ def restreintFaceFissure(shapeDefaut, facesDefaut, pointInterne):
|
||||
if pointInterne is not None:
|
||||
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])
|
||||
logging.debug("selection de la face la plus proche du point interne, distance={}".format(distfaces[0][0]))
|
||||
facesPortFissure = distfaces[0][2]
|
||||
else:
|
||||
try:
|
||||
@ -52,8 +52,8 @@ def restreintFaceFissure(shapeDefaut, facesDefaut, pointInterne):
|
||||
texte += "<li>le prémaillage de la face de fissure est trop grossier, les mailles à enlever dans le maillage sain "
|
||||
texte += "n'ont pas toutes été détectées.</li></ul>"
|
||||
raise fissError(traceback.extract_stack(),texte)
|
||||
logging.debug("surfaces faces fissure étendue, min %s, max %s", minSurf, maxSurf)
|
||||
logging.debug("surfaces faces fissure étendue, min {}, max {}".format(minSurf, maxSurf))
|
||||
facesPortFissure = facesPartShapeDefautSorted[-1]
|
||||
|
||||
|
||||
geomPublish(initLog.debug, facesPortFissure, "facesPortFissure")
|
||||
return facesPortFissure
|
||||
|
||||
Loading…
Reference in New Issue
Block a user