import GEOM
import SALOMEDS
import SMESH
-#import StdMeshers
-#import GHS3DPlugin
-#import NETGENPlugin
import logging
from .fissureGenerique import fissureGenerique
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
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)
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 \
+ )
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)
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+import os
+
import logging
import salome
from .geomsmesh import geompy
TODO: a completer
"""
logging.info('start')
-
+
shapeDefaut = shapesFissure[0] # faces de fissure, débordant
fondFiss = shapesFissure[4] # groupe d'edges de fond de fissure
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]
# --- 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
# 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']
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)
# - 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)
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)
salome.sg.updateObjBrowser()
logging.info("maillage fissure fini")
-
+
return maillageComplet
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
geomPublish(initLog.debug, part, 'partitionPeauFissFond%d'%ipart )
else:
partitionsPeauFissFond.append(None)
- ipart = ipart +1
+ ipart += 1
- return partitionsPeauFissFond
\ No newline at end of file
+ return partitionsPeauFissFond
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+import os
+
import logging
from .geomsmesh import smesh
import SMESH
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
[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)
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
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
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])
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+"""fissureGenerique"""
import logging
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
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
self.maillageFissureParams, elementsDefaut, step)
self.setReferencesMaillageFissure()
- mesures = getStatsMaillageFissure(maillageFissure, self.referencesMaillageFissure, self.maillageFissureParams)
-
-
-
-
-
-
+ ok_maillage = getStatsMaillageFissure(maillageFissure, self.referencesMaillageFissure, self.maillageFissureParams)
+ return ok_maillage
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)
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
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()
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])
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])
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"
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
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)
\ No newline at end of file
+
+ return (faceFissureExterne, edgesPipeFissureExterneC, wirePipeFissureExterne, edgesPeauFissureExterneC)
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)
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)
\ No newline at end of file
+ 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)
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]
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()):
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)))
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
"""
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)
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)
# -----------------------------------------------------------------------------
# --- 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")
-
- #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)
-
- 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
-
+def quadranglesToShapeWithCorner(meshQuad, shapeDefaut, listOfCorners):
+ """ """
+ # TODO: rédiger la docstring
+
+ 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
+
# 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
-
\ No newline at end of file
+# 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
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')
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:
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
