decoupage insereFissureGenerale, renommée construitFissureGenerale, premiere phase : géometrie

This commit is contained in:
Paul RASCLE 2014-09-08 14:58:52 +02:00
parent 3bd39da0ba
commit cfbaf62c42
29 changed files with 1710 additions and 84 deletions

View File

@ -18,7 +18,7 @@ from blocFissure.gmu.fissureGenerique import fissureGenerique
from blocFissure.gmu.triedreBase import triedreBase from blocFissure.gmu.triedreBase import triedreBase
from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
from blocFissure.gmu.insereFissureGenerale import insereFissureGenerale from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale
O, OX, OY, OZ = triedreBase() O, OX, OY, OZ = triedreBase()
@ -41,7 +41,7 @@ class cubeAngle(fissureGenerique):
# --------------------------------------------------------------------------- # ---------------------------------------------------------------------------
def setParamShapeFissure(self): def setParamShapeFissure(self):
""" """
paramètres de la fissure pour méthode insereFissureGenerale paramètres de la fissure pour méthode construitFissureGenerale
lgInfluence : distance autour de la shape de fissure a remailler (A ajuster selon le maillage) lgInfluence : distance autour de la shape de fissure a remailler (A ajuster selon le maillage)
rayonPipe : le rayon du pile maillé en hexa autour du fond de fissure rayonPipe : le rayon du pile maillé en hexa autour du fond de fissure
""" """
@ -85,9 +85,9 @@ class cubeAngle(fissureGenerique):
def genereMaillageFissure(self, geometriesSaines, maillagesSains, def genereMaillageFissure(self, geometriesSaines, maillagesSains,
shapesFissure, shapeFissureParams, shapesFissure, shapeFissureParams,
maillageFissureParams, elementsDefaut, step): maillageFissureParams, elementsDefaut, step):
maillageFissure = insereFissureGenerale(maillagesSains, maillageFissure = construitFissureGenerale(maillagesSains,
shapesFissure, shapeFissureParams, shapesFissure, shapeFissureParams,
maillageFissureParams, elementsDefaut, step) maillageFissureParams, elementsDefaut, step)
return maillageFissure return maillageFissure
# --------------------------------------------------------------------------- # ---------------------------------------------------------------------------

View File

@ -13,7 +13,7 @@ class cubeAngle2(cubeAngle):
# --------------------------------------------------------------------------- # ---------------------------------------------------------------------------
def setParamShapeFissure(self): def setParamShapeFissure(self):
""" """
paramètres de la fissure pour méthode insereFissureGenerale paramètres de la fissure pour méthode construitFissureGenerale
lgInfluence : distance autour de la shape de fissure a remailler (A ajuster selon le maillage) lgInfluence : distance autour de la shape de fissure a remailler (A ajuster selon le maillage)
rayonPipe : le rayon du pile maillé en hexa autour du fond de fissure rayonPipe : le rayon du pile maillé en hexa autour du fond de fissure
""" """

View File

@ -18,7 +18,7 @@ from blocFissure.gmu.fissureGenerique import fissureGenerique
from blocFissure.gmu.triedreBase import triedreBase from blocFissure.gmu.triedreBase import triedreBase
from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
from blocFissure.gmu.insereFissureGenerale import insereFissureGenerale from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale
O, OX, OY, OZ = triedreBase() O, OX, OY, OZ = triedreBase()
@ -45,7 +45,7 @@ class cylindre(fissureGenerique):
# --------------------------------------------------------------------------- # ---------------------------------------------------------------------------
def setParamShapeFissure(self): def setParamShapeFissure(self):
""" """
paramètres de la fissure pour méthode insereFissureGenerale paramètres de la fissure pour méthode construitFissureGenerale
lgInfluence : distance autour de la shape de fissure a remailler (A ajuster selon le maillage) lgInfluence : distance autour de la shape de fissure a remailler (A ajuster selon le maillage)
rayonPipe : le rayon du pile maillé en hexa autour du fond de fissure rayonPipe : le rayon du pile maillé en hexa autour du fond de fissure
""" """
@ -89,9 +89,9 @@ class cylindre(fissureGenerique):
def genereMaillageFissure(self, geometriesSaines, maillagesSains, def genereMaillageFissure(self, geometriesSaines, maillagesSains,
shapesFissure, shapeFissureParams, shapesFissure, shapeFissureParams,
maillageFissureParams, elementsDefaut, step): maillageFissureParams, elementsDefaut, step):
maillageFissure = insereFissureGenerale(maillagesSains, maillageFissure = construitFissureGenerale(maillagesSains,
shapesFissure, shapeFissureParams, shapesFissure, shapeFissureParams,
maillageFissureParams, elementsDefaut, step) maillageFissureParams, elementsDefaut, step)
return maillageFissure return maillageFissure
# --------------------------------------------------------------------------- # ---------------------------------------------------------------------------

View File

@ -15,7 +15,7 @@ from cylindre import cylindre
from blocFissure.gmu.triedreBase import triedreBase from blocFissure.gmu.triedreBase import triedreBase
from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
from blocFissure.gmu.insereFissureGenerale import insereFissureGenerale from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale
O, OX, OY, OZ = triedreBase() O, OX, OY, OZ = triedreBase()

View File

@ -18,7 +18,7 @@ from blocFissure.gmu.fissureGenerique import fissureGenerique
from blocFissure.gmu.triedreBase import triedreBase from blocFissure.gmu.triedreBase import triedreBase
from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
from blocFissure.gmu.insereFissureGenerale import insereFissureGenerale from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale
O, OX, OY, OZ = triedreBase() O, OX, OY, OZ = triedreBase()
@ -47,7 +47,7 @@ class ellipse_1(fissureGenerique):
# --------------------------------------------------------------------------- # ---------------------------------------------------------------------------
def setParamShapeFissure(self): def setParamShapeFissure(self):
""" """
paramètres de la fissure pour méthode insereFissureGenerale paramètres de la fissure pour méthode construitFissureGenerale
lgInfluence : distance autour de la shape de fissure a remailler (A ajuster selon le maillage) lgInfluence : distance autour de la shape de fissure a remailler (A ajuster selon le maillage)
rayonPipe : le rayon du pile maillé en hexa autour du fond de fissure rayonPipe : le rayon du pile maillé en hexa autour du fond de fissure
convexe : optionnel, True : la face est convexe (vue de l'exterieur) sert si on ne donne pas de point interne convexe : optionnel, True : la face est convexe (vue de l'exterieur) sert si on ne donne pas de point interne
@ -93,9 +93,9 @@ class ellipse_1(fissureGenerique):
def genereMaillageFissure(self, geometriesSaines, maillagesSains, def genereMaillageFissure(self, geometriesSaines, maillagesSains,
shapesFissure, shapeFissureParams, shapesFissure, shapeFissureParams,
maillageFissureParams, elementsDefaut, step): maillageFissureParams, elementsDefaut, step):
maillageFissure = insereFissureGenerale(maillagesSains, maillageFissure = construitFissureGenerale(maillagesSains,
shapesFissure, shapeFissureParams, shapesFissure, shapeFissureParams,
maillageFissureParams, elementsDefaut, step) maillageFissureParams, elementsDefaut, step)
return maillageFissure return maillageFissure
# --------------------------------------------------------------------------- # ---------------------------------------------------------------------------

View File

@ -18,7 +18,7 @@ from ellipse_1 import ellipse_1
from blocFissure.gmu.triedreBase import triedreBase from blocFissure.gmu.triedreBase import triedreBase
from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
from blocFissure.gmu.insereFissureGenerale import insereFissureGenerale from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale
O, OX, OY, OZ = triedreBase() O, OX, OY, OZ = triedreBase()

View File

@ -18,7 +18,7 @@ from blocFissure.gmu.fissureGenerique import fissureGenerique
from blocFissure.gmu.triedreBase import triedreBase from blocFissure.gmu.triedreBase import triedreBase
from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
from blocFissure.gmu.insereFissureGenerale import insereFissureGenerale from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale
O, OX, OY, OZ = triedreBase() O, OX, OY, OZ = triedreBase()
@ -41,7 +41,7 @@ class eprouvetteCourbe(fissureGenerique):
# --------------------------------------------------------------------------- # ---------------------------------------------------------------------------
def setParamShapeFissure(self): def setParamShapeFissure(self):
""" """
paramètres de la fissure pour méthode insereFissureGenerale paramètres de la fissure pour méthode construitFissureGenerale
lgInfluence : distance autour de la shape de fissure a remailler (A ajuster selon le maillage) lgInfluence : distance autour de la shape de fissure a remailler (A ajuster selon le maillage)
rayonPipe : le rayon du pile maillé en hexa autour du fond de fissure rayonPipe : le rayon du pile maillé en hexa autour du fond de fissure
convexe : optionnel True : la face est convexe (vue de l'exterieur) sert si on ne donne pas de point interne convexe : optionnel True : la face est convexe (vue de l'exterieur) sert si on ne donne pas de point interne
@ -87,9 +87,9 @@ class eprouvetteCourbe(fissureGenerique):
def genereMaillageFissure(self, geometriesSaines, maillagesSains, def genereMaillageFissure(self, geometriesSaines, maillagesSains,
shapesFissure, shapeFissureParams, shapesFissure, shapeFissureParams,
maillageFissureParams, elementsDefaut, step): maillageFissureParams, elementsDefaut, step):
maillageFissure = insereFissureGenerale(maillagesSains, maillageFissure = construitFissureGenerale(maillagesSains,
shapesFissure, shapeFissureParams, shapesFissure, shapeFissureParams,
maillageFissureParams, elementsDefaut, step) maillageFissureParams, elementsDefaut, step)
return maillageFissure return maillageFissure
# --------------------------------------------------------------------------- # ---------------------------------------------------------------------------

View File

@ -19,7 +19,7 @@ from blocFissure.gmu.fissureGenerique import fissureGenerique
from blocFissure.gmu.triedreBase import triedreBase from blocFissure.gmu.triedreBase import triedreBase
from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
from blocFissure.gmu.insereFissureGenerale import insereFissureGenerale from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale
O, OX, OY, OZ = triedreBase() O, OX, OY, OZ = triedreBase()
@ -42,7 +42,7 @@ class eprouvetteDroite(fissureGenerique):
# --------------------------------------------------------------------------- # ---------------------------------------------------------------------------
def setParamShapeFissure(self): def setParamShapeFissure(self):
""" """
paramètres de la fissure pour méthode insereFissureGenerale paramètres de la fissure pour méthode construitFissureGenerale
lgInfluence : distance autour de la shape de fissure a remailler (A ajuster selon le maillage) lgInfluence : distance autour de la shape de fissure a remailler (A ajuster selon le maillage)
rayonPipe : le rayon du pile maillé en hexa autour du fond de fissure rayonPipe : le rayon du pile maillé en hexa autour du fond de fissure
convexe : optionnel True : la face est convexe (vue de l'exterieur) sert si on ne donne pas de point interne convexe : optionnel True : la face est convexe (vue de l'exterieur) sert si on ne donne pas de point interne
@ -89,9 +89,9 @@ class eprouvetteDroite(fissureGenerique):
def genereMaillageFissure(self, geometriesSaines, maillagesSains, def genereMaillageFissure(self, geometriesSaines, maillagesSains,
shapesFissure, shapeFissureParams, shapesFissure, shapeFissureParams,
maillageFissureParams, elementsDefaut, step): maillageFissureParams, elementsDefaut, step):
maillageFissure = insereFissureGenerale(maillagesSains, maillageFissure = construitFissureGenerale(maillagesSains,
shapesFissure, shapeFissureParams, shapesFissure, shapeFissureParams,
maillageFissureParams, elementsDefaut, step) maillageFissureParams, elementsDefaut, step)
return maillageFissure return maillageFissure
# --------------------------------------------------------------------------- # ---------------------------------------------------------------------------

View File

@ -18,7 +18,7 @@ from eprouvetteDroite import eprouvetteDroite
from blocFissure.gmu.triedreBase import triedreBase from blocFissure.gmu.triedreBase import triedreBase
from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
from blocFissure.gmu.insereFissureGenerale import insereFissureGenerale from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale
O, OX, OY, OZ = triedreBase() O, OX, OY, OZ = triedreBase()

View File

@ -5,8 +5,8 @@ import logging
from blocFissure import gmu from blocFissure import gmu
from blocFissure.gmu import initLog from blocFissure.gmu import initLog
#initLog.setDebug() #initLog.setDebug()
#initLog.setVerbose() initLog.setVerbose()
initLog.setPerfTests() #initLog.setPerfTests()
from blocFissure.gmu import geomsmesh from blocFissure.gmu import geomsmesh
from blocFissure.gmu.casStandard import casStandard from blocFissure.gmu.casStandard import casStandard
@ -131,7 +131,7 @@ runall = True
if runall: if runall:
torun = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,] torun = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,]
else: #prob 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27 else: #prob 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27
torun = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,] torun = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,]
for i in range(len(problemes)): for i in range(len(problemes)):
if torun[i]: if torun[i]:

View File

@ -18,7 +18,7 @@ from blocFissure.gmu.fissureGenerique import fissureGenerique
from blocFissure.gmu.triedreBase import triedreBase from blocFissure.gmu.triedreBase import triedreBase
from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
from blocFissure.gmu.insereFissureGenerale import insereFissureGenerale from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale
O, OX, OY, OZ = triedreBase() O, OX, OY, OZ = triedreBase()
@ -41,7 +41,7 @@ class faceGauche(fissureGenerique):
# --------------------------------------------------------------------------- # ---------------------------------------------------------------------------
def setParamShapeFissure(self): def setParamShapeFissure(self):
""" """
paramètres de la fissure pour méthode insereFissureGenerale paramètres de la fissure pour méthode construitFissureGenerale
lgInfluence : distance autour de la shape de fissure a remailler (A ajuster selon le maillage) lgInfluence : distance autour de la shape de fissure a remailler (A ajuster selon le maillage)
rayonPipe : le rayon du pile maillé en hexa autour du fond de fissure rayonPipe : le rayon du pile maillé en hexa autour du fond de fissure
convexe : optionnel True : la face est convexe (vue de l'exterieur) sert si on ne donne pas de point interne convexe : optionnel True : la face est convexe (vue de l'exterieur) sert si on ne donne pas de point interne
@ -87,9 +87,9 @@ class faceGauche(fissureGenerique):
def genereMaillageFissure(self, geometriesSaines, maillagesSains, def genereMaillageFissure(self, geometriesSaines, maillagesSains,
shapesFissure, shapeFissureParams, shapesFissure, shapeFissureParams,
maillageFissureParams, elementsDefaut, step): maillageFissureParams, elementsDefaut, step):
maillageFissure = insereFissureGenerale(maillagesSains, maillageFissure = construitFissureGenerale(maillagesSains,
shapesFissure, shapeFissureParams, shapesFissure, shapeFissureParams,
maillageFissureParams, elementsDefaut, step) maillageFissureParams, elementsDefaut, step)
return maillageFissure return maillageFissure
# --------------------------------------------------------------------------- # ---------------------------------------------------------------------------

View File

@ -19,7 +19,7 @@ from blocFissure.gmu.fissureGenerique import fissureGenerique
from blocFissure.gmu.triedreBase import triedreBase from blocFissure.gmu.triedreBase import triedreBase
from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
from blocFissure.gmu.insereFissureGenerale import insereFissureGenerale from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale
O, OX, OY, OZ = triedreBase() O, OX, OY, OZ = triedreBase()
@ -42,7 +42,7 @@ class faceGauche_2(fissureGenerique):
# --------------------------------------------------------------------------- # ---------------------------------------------------------------------------
def setParamShapeFissure(self): def setParamShapeFissure(self):
""" """
paramètres de la fissure pour méthode insereFissureGenerale paramètres de la fissure pour méthode construitFissureGenerale
lgInfluence : distance autour de la shape de fissure a remailler (A ajuster selon le maillage) lgInfluence : distance autour de la shape de fissure a remailler (A ajuster selon le maillage)
rayonPipe : le rayon du pile maillé en hexa autour du fond de fissure rayonPipe : le rayon du pile maillé en hexa autour du fond de fissure
convexe : optionnel True : la face est convexe (vue de l'exterieur) sert si on ne donne pas de point interne convexe : optionnel True : la face est convexe (vue de l'exterieur) sert si on ne donne pas de point interne
@ -88,9 +88,9 @@ class faceGauche_2(fissureGenerique):
def genereMaillageFissure(self, geometriesSaines, maillagesSains, def genereMaillageFissure(self, geometriesSaines, maillagesSains,
shapesFissure, shapeFissureParams, shapesFissure, shapeFissureParams,
maillageFissureParams, elementsDefaut, step): maillageFissureParams, elementsDefaut, step):
maillageFissure = insereFissureGenerale(maillagesSains, maillageFissure = construitFissureGenerale(maillagesSains,
shapesFissure, shapeFissureParams, shapesFissure, shapeFissureParams,
maillageFissureParams, elementsDefaut, step) maillageFissureParams, elementsDefaut, step)
return maillageFissure return maillageFissure
# --------------------------------------------------------------------------- # ---------------------------------------------------------------------------

View File

@ -18,7 +18,7 @@ from blocFissure.gmu.fissureGenerique import fissureGenerique
from blocFissure.gmu.triedreBase import triedreBase from blocFissure.gmu.triedreBase import triedreBase
from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
from blocFissure.gmu.insereFissureGenerale import insereFissureGenerale from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale
O, OX, OY, OZ = triedreBase() O, OX, OY, OZ = triedreBase()
@ -41,7 +41,7 @@ class vis_1(fissureGenerique):
# --------------------------------------------------------------------------- # ---------------------------------------------------------------------------
def setParamShapeFissure(self): def setParamShapeFissure(self):
""" """
paramètres de la fissure pour méthode insereFissureGenerale paramètres de la fissure pour méthode construitFissureGenerale
lgInfluence : distance autour de la shape de fissure a remailler (A ajuster selon le maillage) lgInfluence : distance autour de la shape de fissure a remailler (A ajuster selon le maillage)
rayonPipe : le rayon du pile maillé en hexa autour du fond de fissure rayonPipe : le rayon du pile maillé en hexa autour du fond de fissure
convexe : optionnel True : la face est convexe (vue de l'exterieur) sert si on ne donne pas de point interne convexe : optionnel True : la face est convexe (vue de l'exterieur) sert si on ne donne pas de point interne
@ -87,9 +87,9 @@ class vis_1(fissureGenerique):
def genereMaillageFissure(self, geometriesSaines, maillagesSains, def genereMaillageFissure(self, geometriesSaines, maillagesSains,
shapesFissure, shapeFissureParams, shapesFissure, shapeFissureParams,
maillageFissureParams, elementsDefaut, step): maillageFissureParams, elementsDefaut, step):
maillageFissure = insereFissureGenerale(maillagesSains, maillageFissure = construitFissureGenerale(maillagesSains,
shapesFissure, shapeFissureParams, shapesFissure, shapeFissureParams,
maillageFissureParams, elementsDefaut, step) maillageFissureParams, elementsDefaut, step)
return maillageFissure return maillageFissure
# --------------------------------------------------------------------------- # ---------------------------------------------------------------------------

View File

@ -2,9 +2,6 @@
import os import os
import initLog import initLog
#initLog.setDebug()
#initLog.setVerbose()
#initLog.setRelease()
# --- calcul path blocFissure # --- calcul path blocFissure

View File

@ -19,7 +19,7 @@ from blocFissure.gmu.initEtude import initEtude
from blocFissure.gmu.triedreBase import triedreBase from blocFissure.gmu.triedreBase import triedreBase
from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
from blocFissure.gmu.insereFissureGenerale import insereFissureGenerale from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale
O, OX, OY, OZ = triedreBase() O, OX, OY, OZ = triedreBase()
@ -124,9 +124,9 @@ class casStandard(fissureGenerique):
def genereMaillageFissure(self, geometriesSaines, maillagesSains, def genereMaillageFissure(self, geometriesSaines, maillagesSains,
shapesFissure, shapeFissureParams, shapesFissure, shapeFissureParams,
maillageFissureParams, elementsDefaut, step): maillageFissureParams, elementsDefaut, step):
maillageFissure = insereFissureGenerale(maillagesSains, maillageFissure = construitFissureGenerale(maillagesSains,
shapesFissure, shapeFissureParams, shapesFissure, shapeFissureParams,
maillageFissureParams, elementsDefaut, step) maillageFissureParams, elementsDefaut, step)
return maillageFissure return maillageFissure
# --------------------------------------------------------------------------- # ---------------------------------------------------------------------------

View File

@ -0,0 +1,31 @@
# -*- coding: utf-8 -*-
import logging
from geomsmesh import geompy
def compoundFromList(elements, nom=None):
"""
"""
logging.debug('start')
shapeList = []
for a in elements:
if not isinstance(a, list):
shapeList.append(a)
else:
if a[0] is not None:
shapeList.append(a[0])
if nom is not None:
for i,a in enumerate(shapeList):
nom = nom +"%d"%i
logging.debug('nom: %s',nom)
geompy.addToStudy(a, nom)
shapeCompound = None
if len(shapeList) > 0:
shapeCompound =geompy.MakeCompound(shapeList)
return shapeCompound

View File

@ -0,0 +1,937 @@
# -*- coding: utf-8 -*-
import logging
import salome
from geomsmesh import geompy
import GEOM
from geomsmesh import smesh
from salome.smesh import smeshBuilder
import SMESH
import math
import bisect
from extractionOrientee import extractionOrientee
from extractionOrienteeMulti import extractionOrienteeMulti
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 findWireIntermediateVertices import findWireIntermediateVertices
from orderEdgesFromWire import orderEdgesFromWire
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
from checkDecoupePartition import checkDecoupePartition
from whichSide import whichSide
from whichSideMulti import whichSideMulti
from whichSideVertex import whichSideVertex
from projettePointSurCourbe import projettePointSurCourbe
from prolongeWire import prolongeWire
from restreintFaceFissure import restreintFaceFissure
from partitionneFissureParPipe import partitionneFissureParPipe
from construitPartitionsPeauFissure import construitPartitionsPeauFissure
from compoundFromList import compoundFromList
from identifieElementsGeometriquesPeau import identifieElementsGeometriquesPeau
# -----------------------------------------------------------------------------
# --- procédure complète fissure générale
def construitFissureGenerale(maillagesSains,
shapesFissure, shapeFissureParams,
maillageFissureParams, elementsDefaut, step=-1):
"""
TODO: a completer
"""
logging.info('start')
shapeDefaut = shapesFissure[0] # faces de fissure, débordant
fondFiss = shapesFissure[4] # groupe d'edges de fond de fissure
rayonPipe = shapeFissureParams['rayonPipe']
if shapeFissureParams.has_key('lenSegPipe'):
lenSegPipe = shapeFissureParams['lenSegPipe']
else:
lenSegPipe = rayonPipe
nomRep = maillageFissureParams['nomRep']
nomFicSain = maillageFissureParams['nomFicSain']
nomFicFissure = maillageFissureParams['nomFicFissure']
nbsegRad = maillageFissureParams['nbsegRad'] # nombre de couches selon un rayon du pipe
nbsegCercle = maillageFissureParams['nbsegCercle'] # nombre de secteur dans un cercle du pipe
areteFaceFissure = maillageFissureParams['areteFaceFissure']
pointIn_x = 0.0
pointIn_y = 0.0
pointIn_z = 0.0
isPointInterne = False
if shapeFissureParams.has_key('pointIn_x'):
pointIn_x = shapeFissureParams['pointIn_x']
isPointInterne = True
if shapeFissureParams.has_key('pointIn_y'):
pointIn_y = shapeFissureParams['pointIn_y']
isPointInterne = True
if shapeFissureParams.has_key('pointIn_z'):
pointIn_z = shapeFissureParams['pointIn_z']
isPointInterne = True
if isPointInterne:
pointInterne = geompy.MakeVertex(pointIn_x, pointIn_y, pointIn_z)
else:
pointInterne = None
#fichierMaillageSain = nomRep + '/' + nomFicSain + '.med'
fichierMaillageFissure = nomRep + '/' + nomFicFissure + '.med'
# fillings des faces en peau
facesDefaut = elementsDefaut[0]
#centresDefaut = elementsDefaut[1]
#normalsDefaut = elementsDefaut[2]
#extrusionsDefaut = elementsDefaut[3]
dmoyen = elementsDefaut[4]
bordsPartages = elementsDefaut[5]
fillconts = elementsDefaut[6]
idFilToCont = elementsDefaut[7]
maillageSain = elementsDefaut[8]
internalBoundary = elementsDefaut[9]
zoneDefaut = elementsDefaut[10]
zoneDefaut_skin = elementsDefaut[11]
zoneDefaut_internalFaces = elementsDefaut[12]
zoneDefaut_internalEdges = elementsDefaut[13]
edgeFondExt = elementsDefaut[14]
centreFondFiss = elementsDefaut[15]
tgtCentre = elementsDefaut[16]
O, OX, OY, OZ = triedreBase()
# --- 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):
geompy.addToStudyInFather(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
# il peut y avoir plusieurs faces externes, dont certaines sont découpées par la fissure
# liste de faces externes : facesDefaut
# liste de partitions face externe - fissure : partitionPeauFissFond (None quand pas d'intersection)
partitionsPeauFissFond = construitPartitionsPeauFissure(facesDefaut, fissPipe)
# --- arêtes vives détectées (dans quadranglesToShapeNoCorner
# et quadranglesToShapeWithCorner)
aretesVivesCoupees = [] #= global
aretesVivesC = compoundFromList(bordsPartages, "areteVive")
# -------------------------------------------------------
# --- 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]
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]
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]
for ifil, partitionPeauFissFond in enumerate(partitionsPeauFissFond):
if partitionPeauFissFond is not None:
dataPPFF,aretesVivesCoupees = identifieElementsGeometriquesPeau(ifil, partitionPeauFissFond, edgesPipeFiss,
edgesFondFiss, wireFondFiss, aretesVivesC,
facesDefaut, centreFondFiss, rayonPipe,
aretesVivesCoupees)
ptEdgeFond[ifil] = dataPPFF['endsEdgeFond']
fsPipePeau[ifil] = dataPPFF['facesPipePeau']
edRadFPiPo[ifil] = dataPPFF['edgeRadFacePipePeau']
fsFissuExt[ifil] = dataPPFF['facesFissExt']
edFisExtPe[ifil] = dataPPFF['edgesFissExtPeau']
edFisExtPi[ifil] = dataPPFF['edgesFissExtPipe']
facesPeaux[ifil] = dataPPFF['facePeau']
edCircPeau[ifil] = dataPPFF['edgesCircPeau']
ptCircPeau[ifil] = dataPPFF['verticesCircPeau']
gpedgeBord[ifil] = dataPPFF['groupEdgesBordPeau']
gpedgeVifs[ifil] = dataPPFF['bordsVifs']
edFissPeau[ifil] = dataPPFF['edgesFissurePeau']
ptFisExtPi[ifil] = dataPPFF['verticesPipePeau']
# -----------------------------------------------------------------------
# fin de la boucle sur les faces de filling
# -----------------------------------------------------------------------
for i, avc in enumerate(aretesVivesCoupees):
name = "areteViveCoupee%d"%i
geompy.addToStudy(avc, name)
# --- identification des faces et edges de fissure externe pour maillage
facesFissExt = []
edgesFissExtPeau = []
edgesFissExtPipe = []
for ifil in range(nbFacesFilling): # TODO: éliminer les doublons (comparer tous les vertices triés, avec mesure de distance ?)
facesFissExt += fsFissuExt[ifil]
edgesFissExtPeau += edFisExtPe[ifil]
edgesFissExtPipe += edFisExtPi[ifil]
logging.debug("---------------------------- identification faces de fissure externes au pipe :%s ", len(facesFissExt))
# regroupement des faces de fissure externes au pipe.
if len(facesFissExt) > 1:
faceFissureExterne = geompy.MakePartition(facesFissExt, [], [], [], 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 = []
for bound in closedFreeBoundaries:
edgesBordFFE += geompy.ExtractShapes(bound, geompy.ShapeType["EDGE"], False)
edgesBordFFEid = [ (ed,geompy.GetSubShapeID(faceFissureExterne, ed)) for ed in edgesBordFFE]
logging.debug("edgesBordFFEid %s", edgesBordFFEid)
edgesPPE = geompy.ExtractShapes(edgesPipeFissureExterneC, geompy.ShapeType["EDGE"], False)
edgesPPEid = [ geompy.GetSubShapeID(faceFissureExterne, ed) for ed in edgesPPE]
logging.debug("edgesPPEid %s", edgesPPEid)
edgesPFE = [ edid[0] for edid in edgesBordFFEid if edid[1] not in edgesPPEid] # on garde toutes les edges de bord non en contact avec le pipe
logging.debug("edgesPFE %s", edgesPFE)
edgesPeauFissureExterneC = geompy.MakeCompound(edgesPFE)
else:
faceFissureExterne = facesFissExt[0]
edgesPeauFissureExterneC = geompy.MakeCompound(edgesFissExtPeau)
edgesPipeFissureExterneC = geompy.MakeCompound(edgesFissExtPipe)
wirePipeFissureExterne = geompy.MakeWire(geompy.ExtractShapes(edgesPipeFissureExterneC, geompy.ShapeType["EDGE"], False))
geompy.addToStudy(faceFissureExterne, "faceFissureExterne")
geompy.addToStudyInFather(faceFissureExterne, edgesPeauFissureExterneC, "edgesPeauFissureExterne")
geompy.addToStudyInFather(faceFissureExterne, edgesPipeFissureExterneC, "edgesPipeFissureExterne")
logging.debug("---------------------------- Preparation Maillage du Pipe --------------")
# -----------------------------------------------------------------------
# --- preparation maillage du pipe :
# - détections des points a respecter : jonction des edges/faces constituant
# la face de fissure externe au pipe
# - points sur les edges de fond de fissure et edges pipe/face fissure,
# - vecteurs tangents au fond de fissure (normal au disque maillé)
# --- option de maillage selon le rayon de courbure du fond de fissure
lenEdgeFondExt = 0
for edff in edgesFondFiss:
lenEdgeFondExt += geompy.BasicProperties(edff)[0]
disfond = []
for filling in facesDefaut:
disfond.append(geompy.MinDistance(centreFondFiss, filling))
disfond.sort()
rcourb = disfond[0]
nbSegQuart = 5 # on veut 5 segments min sur un quart de cercle
alpha = math.pi/(4*nbSegQuart)
deflexion = rcourb*(1.0 -math.cos(alpha))
lgmin = lenSegPipe*0.25
lgmax = lenSegPipe*1.5
logging.debug("rcourb: %s, lenFond:%s, deflexion: %s, lgmin: %s, lgmax: %s", rcourb, lenEdgeFondExt, deflexion, lgmin, lgmax)
meshFondExt = smesh.Mesh(wireFondFiss)
algo1d = meshFondExt.Segment()
hypo1d = algo1d.Adaptive(lgmin, lgmax, deflexion) # a ajuster selon la profondeur de la fissure
isDone = meshFondExt.Compute()
ptGSdic = {} # dictionnaire [paramètre sur la courbe] --> point géométrique
allNodeIds = meshFondExt.GetNodesId()
for nodeId in allNodeIds:
xyz = meshFondExt.GetNodeXYZ(nodeId)
#logging.debug("nodeId %s, coords %s", nodeId, str(xyz))
pt = geompy.MakeVertex(xyz[0], xyz[1], xyz[2])
u, PointOnEdge, EdgeInWireIndex = geompy.MakeProjectionOnWire(pt, wireFondFiss) # u compris entre 0 et 1
edgeOrder = edgesIdByOrientation[EdgeInWireIndex]
ptGSdic[(edgeOrder, EdgeInWireIndex, u)] = pt
#logging.debug("nodeId %s, u %s", nodeId, str(u))
usort = sorted(ptGSdic)
logging.debug("nombre de points obtenus par deflexion %s",len(usort))
centres = []
origins = []
normals = []
for edu in usort:
ied = edu[1]
u = edu[2]
vertcx = ptGSdic[edu]
norm = geompy.MakeTangentOnCurve(edgesFondFiss[ied], u)
plan = geompy.MakePlane(vertcx, norm, 3*rayonPipe)
part = geompy.MakePartition([plan], [wirePipeFiss], [], [], geompy.ShapeType["VERTEX"], 0, [], 0)
liste = geompy.ExtractShapes(part, geompy.ShapeType["VERTEX"], True)
if len(liste) == 5: # 4 coins du plan plus intersection recherchée
for point in liste:
if geompy.MinDistance(point, vertcx) < 1.1*rayonPipe: # les quatre coins sont plus loin
vertpx = point
break
centres.append(vertcx)
origins.append(vertpx)
normals.append(norm)
# name = "vertcx%d"%i
# geompy.addToStudyInFather(wireFondFiss, vertcx, name)
# name = "vertpx%d"%i
# geompy.addToStudyInFather(wireFondFiss, vertpx, name)
# name = "plan%d"%i
# geompy.addToStudyInFather(wireFondFiss, plan, name)
# --- maillage du pipe étendu, sans tenir compte de l'intersection avec la face de peau
logging.debug("nbsegCercle %s", nbsegCercle)
# -----------------------------------------------------------------------
# --- points géométriques
gptsdisks = [] # vertices géométrie de tous les disques
raydisks = [[] for i in range(nbsegCercle)]
for i in range(len(centres)): # boucle sur les disques
gptdsk = [] # vertices géométrie d'un disque
vertcx = centres[i]
vertpx = origins[i]
normal = normals[i]
vec1 = geompy.MakeVector(vertcx, vertpx)
points = [vertcx] # les points du rayon de référence
for j in range(nbsegRad):
pt = geompy.MakeTranslationVectorDistance(vertcx, vec1, (j+1)*float(rayonPipe)/nbsegRad)
points.append(pt)
gptdsk.append(points)
pt = geompy.MakeTranslationVectorDistance(vertcx, vec1, 1.5*rayonPipe)
rayon = geompy.MakeLineTwoPnt(vertcx, pt)
raydisks[0].append(rayon)
for k in range(nbsegCercle-1):
angle = (k+1)*2*math.pi/nbsegCercle
pts = [vertcx] # les points d'un rayon obtenu par rotation
for j in range(nbsegRad):
pt = geompy.MakeRotation(points[j+1], normal, angle)
pts.append(pt)
gptdsk.append(pts)
ray = geompy.MakeRotation(rayon, normal, angle)
raydisks[k+1].append(ray)
gptsdisks.append(gptdsk)
# -----------------------------------------------------------------------
# --- recherche des points en trop (externes au volume à remailler)
# - on associe chaque extrémité du pipe à une face filling
# - on part des disques aux extrémités du pipe
# - pour chaque disque, on prend les vertices de géométrie,
# on marque leur position relative à la face.
# - on s'arrete quand tous les noeuds sont dedans
logging.debug("---------------------------- recherche des points du pipe a éliminer --------------")
pt0 = centres[0]
pt1 = centres[-1]
idFillingFromBout = [None, None] # contiendra l'index du filling pour les extrémités 0 et 1
for ifil in range(nbFacesFilling):
for ipt, pt in enumerate(ptEdgeFond[ifil]): # il y a un ou deux points débouchant sur cette face
if geompy.MinDistance(pt,pt0) < geompy.MinDistance(pt,pt1): # TODO: trouver plus fiable pour les cas tordus...
idFillingFromBout[0] = ifil
else:
idFillingFromBout[1] = ifil
logging.debug("association bouts du pipe - faces de filling: %s", idFillingFromBout)
facesPipePeau = []
edgeRadFacePipePeau = []
for ifil in range(nbFacesFilling):
facesPipePeau += fsPipePeau[ifil]
edgeRadFacePipePeau += edRadFPiPo[ifil]
logging.debug("recherche des disques de noeuds complètement internes")
idisklim = [] # indices des premier et dernier disques internes
idiskout = [] # indices des premier et dernier disques externes
for bout in range(2):
if bout == 0:
idisk = -1
inc = 1
numout = -1
else:
idisk = len(gptsdisks)
inc = -1
numout = len(gptsdisks)
inside = False
outside = True
while not inside:
idisk = idisk + inc
logging.debug("examen disque %s", idisk)
gptdsk = gptsdisks[idisk]
inside = True
for k in range(nbsegCercle):
points = gptdsk[k]
for j, pt in enumerate(points):
side = whichSideVertex(facesDefaut[idFillingFromBout[bout]], pt)
if side < 0:
if outside: # premier point detecté dedans
outside = False
numout = idisk -inc # le disque précédent était dehors
else:
inside = False # ce point est dehors
if not inside and not outside:
break
idisklim.append(idisk) # premier et dernier disques internes
idiskout.append(numout) # premier et dernier disques externes
# --- listes de nappes radiales en filling à chaque extrémité débouchante
facesDebouchantes = [False, False]
idFacesDebouchantes = [-1, -1] # contiendra les indices des faces disque débouchantes (facesPipePeau)
listNappes =[]
for i, idisk in enumerate(idisklim):
numout = idiskout[i]
logging.debug("extremité %s, indices disques interne %s, externe %s",i, idisk, numout)
nappes = []
if (idisk != 0) and (idisk != len(gptsdisks)-1): # si extrémité débouchante
for k in range(nbsegCercle):
if i == 0:
iddeb = max(0, numout)
idfin = max(iddeb+3,idisk+1) # il faut 3 rayons pour faire un filling qui suive le fond de fissure
#logging.debug("extremité %s, indices retenus interne %s, externe %s",i, idfin, iddeb)
comp = geompy.MakeCompound(raydisks[k][iddeb:idfin])
name='compoundRay%d'%k
geompy.addToStudy(comp, name)
else:
idfin = min(len(gptsdisks), numout+1)
iddeb = min(idfin-3, idisk) # il faut 3 rayons pour faire un filling qui suive le fond de fissure
#logging.debug("extremité %s, indices retenus interne %s, externe %s",i, idfin, iddeb)
comp = geompy.MakeCompound(raydisks[k][iddeb:idfin])
name='compoundRay%d'%k
geompy.addToStudy(comp, name)
nappe = geompy.MakeFilling(comp, 2, 5, 0.0001, 0.0001, 0, GEOM.FOM_Default)
nappes.append(nappe)
name='nappe%d'%k
geompy.addToStudy(nappe, name)
facesDebouchantes[i] = True
listNappes.append(nappes)
# --- mise en correspondance avec les indices des faces disque débouchantes (facesPipePeau)
for i, nappes in enumerate(listNappes):
if facesDebouchantes[i]:
for k, face in enumerate(facesPipePeau):
edge = geompy.MakeSection(face, nappes[0])
if geompy.NbShapes(edge, geompy.ShapeType["EDGE"]) > 0:
idFacesDebouchantes[i] = k
break
logging.debug("idFacesDebouchantes: %s", idFacesDebouchantes)
# --- construction des listes d'edges radiales sur chaque extrémité débouchante
listEdges = []
for i, nappes in enumerate(listNappes):
id = idFacesDebouchantes[i] # indice de face débouchante (facesPipePeau)
if id < 0:
listEdges.append([])
else:
face = facesPipePeau[id]
edges = [edgeRadFacePipePeau[id]]
for k, nappe in enumerate(nappes):
if k > 0:
obj = geompy.MakeSection(face, nappes[k]) # normalement une edge, parfois un compound d'edges dont un tout petit
edge = obj
vs = geompy.ExtractShapes(obj, geompy.ShapeType["VERTEX"], False)
if len(vs) > 2:
eds = geompy.ExtractShapes(obj, geompy.ShapeType["EDGE"], False)
[edsorted, minl,maxl] = sortEdges(eds)
edge = edsorted[-1]
else:
maxl = geompy.BasicProperties(edge)[0]
if maxl < 0.01: # problème MakeSection
logging.debug("problème MakeSection recherche edge radiale %s, longueur trop faible: %s, utilisation partition", k, maxl)
partNappeFace = geompy.MakePartition([face, nappes[k]], [] , [], [], geompy.ShapeType["FACE"], 0, [], 0)
edps= geompy.ExtractShapes(partNappeFace, geompy.ShapeType["EDGE"], False)
ednouv = []
for ii, ed in enumerate(edps):
vxs = geompy.ExtractShapes(ed, geompy.ShapeType["VERTEX"], False)
distx = [geompy.MinDistance(vx, face) for vx in vxs]
distx += [geompy.MinDistance(vx, nappes[k]) for vx in vxs]
dmax = max(distx)
logging.debug(" dmax %s",dmax)
if dmax < 0.01:
ednouv.append(ed)
logging.debug(" edges issues de la partition: %s", ednouv)
for ii, ed in enumerate(ednouv):
geompy.addToStudy(ed, "ednouv%d"%ii)
[edsorted, minl,maxl] = sortEdges(ednouv)
logging.debug(" longueur edge trouvée: %s", maxl)
edge = edsorted[-1]
edges.append(edge)
name = 'edgeEndPipe%d'%k
geompy.addToStudy(edge, name)
listEdges.append(edges)
# --- création des points du maillage du pipe sur la face de peau
for i, edges in enumerate(listEdges):
id = idFacesDebouchantes[i] # indice de face débouchante (facesPipePeau)
if id >= 0:
gptdsk = []
if id > 0: # id vaut 0 ou 1
id = -1 # si id vaut 1, on prend le dernier élément de la liste (1 ou 2 extrémités débouchent sur la face)
centre = ptEdgeFond[idFillingFromBout[i]][id]
name = "centre%d"%id
geompy.addToStudy(centre, name)
vertPipePeau = ptFisExtPi[idFillingFromBout[i]][id]
geompy.addToStudyInFather(centre, vertPipePeau, "vertPipePeau")
grpsEdgesCirc = edCircPeau[idFillingFromBout[i]] # liste de groupes
edgesCirc = []
for grpEdgesCirc in grpsEdgesCirc:
edgesCirc += geompy.ExtractShapes(grpEdgesCirc, geompy.ShapeType["EDGE"], False)
for k, edge in enumerate(edges):
extrems = geompy.ExtractShapes(edge, geompy.ShapeType["VERTEX"], True)
if geompy.MinDistance(centre, extrems[0]) < geompy.MinDistance(centre, extrems[1]):
bout = extrems[1]
else:
bout = extrems[0]
# ajustement du point extrémité (bout) sur l'edge circulaire en face de peau
logging.debug("edgesCirc: %s", edgesCirc)
distEdgeCirc = [(geompy.MinDistance(bout, edgeCirc), k2, edgeCirc) for k2, edgeCirc in enumerate(edgesCirc)]
distEdgeCirc.sort()
logging.debug("distEdgeCirc: %s", distEdgeCirc)
u = projettePointSurCourbe(bout, distEdgeCirc[0][2])
if (abs(u) < 0.02) or (abs(1-u) < 0.02): # les points très proches d'une extrémité doivent y être mis précisément.
extrCircs = geompy.ExtractShapes(distEdgeCirc[0][2], geompy.ShapeType["VERTEX"], True)
if geompy.MinDistance(bout, extrCircs[0]) < geompy.MinDistance(bout, extrCircs[1]):
bout = extrCircs[0]
else:
bout = extrCircs[1]
pass
else:
bout = geompy.MakeVertexOnCurve(distEdgeCirc[0][2], u)
name ="bout%d"%k
geompy.addToStudyInFather(centre, bout, name)
# enregistrement des points dans la structure
points = []
for j in range(nbsegRad +1):
u = j/float(nbsegRad)
points.append(geompy.MakeVertexOnCurve(edge, u))
if geompy.MinDistance(bout, points[0]) < geompy.MinDistance(centre, points[0]):
points.reverse()
points[0] = centre
points[-1] = bout
gptdsk.append(points)
if i == 0:
gptsdisks[idisklim[0] -1] = gptdsk
idisklim[0] = idisklim[0] -1
else:
gptsdisks[idisklim[1] +1] = gptdsk
idisklim[1] = idisklim[1] +1
# --- ajustement precis des points sur edgesPipeFissureExterneC
edgesPFE = geompy.ExtractShapes(edgesPipeFissureExterneC, geompy.ShapeType["EDGE"], False)
verticesPFE = findWireIntermediateVertices(wirePipeFissureExterne) # vertices intermédiaires (des points en trop dans ptsInWireFissExtPipe)
idiskmin = idisklim[0] + 1 # on ne prend pas le disque sur la peau, déjà ajusté
idiskmax = idisklim[1] # on ne prend pas le disque sur la peau, déjà ajusté
idiskint = []
for vtx in verticesPFE:
distPtVt = []
for idisk in range(idiskmin, idiskmax):
gptdsk = gptsdisks[idisk]
pt = gptdsk[0][-1] # le point sur l'edge de la fissure externe au pipe
distPtVt.append((geompy.MinDistance(pt, vtx), idisk))
distPtVt.sort()
idiskint.append(distPtVt[0][1])
gptsdisks[idiskint[-1]][0][-1] = vtx
logging.debug("ajustement point sur edgePipeFissureExterne, vertex: %s %s", idiskint[-1], distPtVt[0][0])
for idisk in range(idiskmin, idiskmax):
if idisk in idiskint:
break
logging.debug("ajustement point sur edgePipeFissureExterne: %s", idisk)
gptdsk = gptsdisks[idisk]
pt = gptdsk[0][-1] # le point sur l'edge de la fissure externe au pipe
distPtEd = [(geompy.MinDistance(pt, edgePFE), k, edgePFE) for k, edgePFE in enumerate(edgesPFE)]
distPtEd.sort()
edgePFE = distPtEd[0][2]
u = projettePointSurCourbe(pt, edgePFE)
ptproj = geompy.MakeVertexOnCurve(edgePFE, u)
gptsdisks[idisk][0][-1] = ptproj
# -----------------------------------------------------------------------
# --- maillage effectif du pipe
logging.debug("---------------------------- maillage effectif du pipe --------------")
meshPipe = smesh.Mesh(None, "meshPipe")
fondFissGroup = meshPipe.CreateEmptyGroup(SMESH.EDGE, "FONDFISS")
nodesFondFissGroup = meshPipe.CreateEmptyGroup(SMESH.NODE, "nfondfis")
faceFissGroup = meshPipe.CreateEmptyGroup(SMESH.FACE, "fisInPi")
edgeFaceFissGroup = meshPipe.CreateEmptyGroup(SMESH.EDGE, "edgeFaceFiss")
edgeCircPipe0Group = meshPipe.CreateEmptyGroup(SMESH.EDGE, "edgeCircPipe0")
edgeCircPipe1Group = meshPipe.CreateEmptyGroup(SMESH.EDGE, "edgeCircPipe1")
faceCircPipe0Group = meshPipe.CreateEmptyGroup(SMESH.FACE, "faceCircPipe0")
faceCircPipe1Group = meshPipe.CreateEmptyGroup(SMESH.FACE, "faceCircPipe1")
mptsdisks = [] # vertices maillage de tous les disques
mEdges = [] # identifiants edges maillage fond de fissure
mEdgeFaces = [] # identifiants edges maillage edge face de fissure externe
mFaces = [] # identifiants faces maillage fissure
mVols = [] # identifiants volumes maillage pipe
mptdsk = None
for idisk in range(idisklim[0], idisklim[1]+1): # boucle sur les disques internes
# -----------------------------------------------------------------------
# --- points
gptdsk = gptsdisks[idisk]
if idisk > idisklim[0]:
oldmpts = mptdsk
mptdsk = [] # vertices maillage d'un disque
for k in range(nbsegCercle):
points = gptdsk[k]
mptids = []
for j, pt in enumerate(points):
if j == 0 and k > 0:
id = mptdsk[0][0]
else:
coords = geompy.PointCoordinates(pt)
id = meshPipe.AddNode(coords[0], coords[1], coords[2])
mptids.append(id)
mptdsk.append(mptids)
mptsdisks.append(mptdsk)
# -----------------------------------------------------------------------
# --- groupes edges cercles debouchants
if idisk == idisklim[0]:
pts = []
for k in range(nbsegCercle):
pts.append(mptdsk[k][-1])
edges = []
for k in range(len(pts)):
k1 = (k+1)%len(pts)
idEdge = meshPipe.AddEdge([pts[k], pts[k1]])
edges.append(idEdge)
edgeCircPipe0Group.Add(edges)
if idisk == idisklim[1]:
pts = []
for k in range(nbsegCercle):
pts.append(mptdsk[k][-1])
edges = []
for k in range(len(pts)):
k1 = (k+1)%len(pts)
idEdge = meshPipe.AddEdge([pts[k], pts[k1]])
edges.append(idEdge)
edgeCircPipe1Group.Add(edges)
# -----------------------------------------------------------------------
# --- groupes faces debouchantes
if idisk == idisklim[0]:
faces = []
for j in range(nbsegRad):
for k in range(nbsegCercle):
k1 = k+1
if k == nbsegCercle-1:
k1 = 0
if j == 0:
idf = meshPipe.AddFace([mptdsk[k][0], mptdsk[k][1], mptdsk[k1][1]]) # triangle
else:
idf = meshPipe.AddFace([mptdsk[k][j], mptdsk[k][j+1], mptdsk[k1][j+1], mptdsk[k1][j]]) # quadrangle
faces.append(idf)
faceCircPipe0Group.Add(faces)
if idisk == idisklim[1]:
faces = []
for j in range(nbsegRad):
for k in range(nbsegCercle):
k1 = k+1
if k == nbsegCercle-1:
k1 = 0
if j == 0:
idf = meshPipe.AddFace([mptdsk[k][0], mptdsk[k][1], mptdsk[k1][1]]) # triangle
else:
idf = meshPipe.AddFace([mptdsk[k][j], mptdsk[k][j+1], mptdsk[k1][j+1], mptdsk[k1][j]]) # quadrangle
faces.append(idf)
faceCircPipe1Group.Add(faces)
# -----------------------------------------------------------------------
# --- mailles volumiques, groupes noeuds et edges de fond de fissure, groupe de face de fissure
if idisk == idisklim[0]:
mEdges.append(0)
mEdgeFaces.append(0)
mFaces.append([0])
mVols.append([[0]])
nodesFondFissGroup.Add([mptdsk[0][0]])
else:
ide = meshPipe.AddEdge([oldmpts[0][0], mptdsk[0][0]])
mEdges.append(ide)
fondFissGroup.Add([ide])
nodesFondFissGroup.Add([mptdsk[0][0]])
ide2 = meshPipe.AddEdge([oldmpts[0][-1], mptdsk[0][-1]])
mEdgeFaces.append(ide2)
edgeFaceFissGroup.Add([ide2])
idFaces = []
idVols = []
for j in range(nbsegRad):
idf = meshPipe.AddFace([oldmpts[0][j], mptdsk[0][j], mptdsk[0][j+1], oldmpts[0][j+1]])
faceFissGroup.Add([idf])
idFaces.append(idf)
idVolCercle = []
for k in range(nbsegCercle):
k1 = k+1
if k == nbsegCercle-1:
k1 = 0
if j == 0:
idv = meshPipe.AddVolume([mptdsk[k][j], mptdsk[k][j+1], mptdsk[k1][j+1],
oldmpts[k][j], oldmpts[k][j+1], oldmpts[k1][j+1]])
else:
idv = meshPipe.AddVolume([mptdsk[k][j], mptdsk[k][j+1], mptdsk[k1][j+1], mptdsk[k1][j],
oldmpts[k][j], oldmpts[k][j+1], oldmpts[k1][j+1], oldmpts[k1][j]])
idVolCercle.append(idv)
idVols.append(idVolCercle)
mFaces.append(idFaces)
mVols.append(idVols)
pipeFissGroup = meshPipe.CreateEmptyGroup( SMESH.VOLUME, 'PIPEFISS' )
nbAdd = pipeFissGroup.AddFrom( meshPipe.GetMesh() )
nb, new_mesh, new_group = meshPipe.MakeBoundaryElements(SMESH.BND_2DFROM3D, "pipeBoundaries")
edgesCircPipeGroup = [edgeCircPipe0Group, edgeCircPipe1Group]
# --- fin du maillage du pipe
# -----------------------------------------------------------------------
# --- edges de bord, faces défaut à 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 à ne pas mettre de pyramides à l'exterieur des volumes repliés sur eux-mêmes
# on désigne les faces de peau en quadrangles par le groupe "skinFaces"
skinFaces = internalBoundary.CreateEmptyGroup( SMESH.FACE, 'skinFaces' )
nbAdd = skinFaces.AddFrom( internalBoundary.GetMesh() )
# --- maillage des éventuelles arêtes vives entre faces reconstruites
if len(aretesVivesCoupees) > 0:
aretesVivesC = geompy.MakeCompound(aretesVivesCoupees)
meshAretesVives = smesh.Mesh(aretesVivesC)
algo1d = meshAretesVives.Segment()
hypo1d = algo1d.LocalLength(dmoyen,[],1e-07)
putName(algo1d.GetSubMesh(), "aretesVives")
putName(algo1d, "algo1d_aretesVives")
putName(hypo1d, "hypo1d_aretesVives")
isDone = meshAretesVives.Compute()
logging.info("aretesVives fini")
grpAretesVives = meshAretesVives.CreateEmptyGroup( SMESH.EDGE, 'grpAretesVives' )
nbAdd = grpAretesVives.AddFrom( meshAretesVives.GetMesh() )
# -----------------------------------------------------------------------
# --- maillage faces de fissure
logging.debug("---------------------------- maillage faces de fissure externes au pipe :%s --------------", len(facesFissExt))
meshFaceFiss = smesh.Mesh(faceFissureExterne)
algo2d = meshFaceFiss.Triangle(algo=smeshBuilder.NETGEN_1D2D)
hypo2d = algo2d.Parameters()
hypo2d.SetMaxSize( areteFaceFissure )
hypo2d.SetSecondOrder( 0 )
hypo2d.SetOptimize( 1 )
hypo2d.SetFineness( 2 )
hypo2d.SetMinSize( rayonPipe/float(nbsegRad) )
hypo2d.SetQuadAllowed( 0 )
putName(algo2d.GetSubMesh(), "faceFiss")
putName(algo2d, "algo2d_faceFiss")
putName(hypo2d, "hypo2d_faceFiss")
algo1d = meshFaceFiss.UseExisting1DElements(geom=edgesPipeFissureExterneC)
hypo1d = algo1d.SourceEdges([ 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)
# --- maillage faces de peau
boutFromIfil = [None for i in range(nbFacesFilling)]
if idFillingFromBout[0] != idFillingFromBout[1]: # repérage des extremites du pipe quand elles débouchent sur des faces différentes
boutFromIfil[idFillingFromBout[0]] = 0
boutFromIfil[idFillingFromBout[1]] = 1
logging.debug("---------------------------- maillage faces de peau --------------")
meshesFacesPeau = []
for ifil in range(nbFacesFilling):
meshFacePeau = None
if partitionsPeauFissFond[ifil] is None: # face de peau maillage sain intacte
# --- edges de bord de la face de filling
filling = facesDefaut[ifil]
edgesFilling = geompy.ExtractShapes(filling, geompy.ShapeType["EDGE"], False)
groupEdgesBordPeau = geompy.CreateGroup(filling, geompy.ShapeType["EDGE"])
geompy.UnionList(groupEdgesBordPeau, edgesFilling)
geompy.addToStudyInFather(filling, groupEdgesBordPeau , "EdgesBords")
meshFacePeau = smesh.Mesh(facesDefaut[ifil])
algo1d = meshFacePeau.UseExisting1DElements(geom=groupEdgesBordPeau)
hypo1d = algo1d.SourceEdges([ bordsLibres ],0,0)
putName(algo1d.GetSubMesh(), "bordsLibres", ifil)
putName(algo1d, "algo1d_bordsLibres", ifil)
putName(hypo1d, "hypo1d_bordsLibres", ifil)
else:
facePeau = facesPeaux[ifil] # pour chaque face : la face de peau finale a mailler (percée des faces débouchantes)
edgesCircPeau = edCircPeau[ifil] # pour chaque face de peau : [subshape edge circulaire aux débouchés du pipe]
verticesCircPeau = ptCircPeau[ifil] # pour chaque face de peau : [subshape point sur edge circulaire aux débouchés du pipe]
groupEdgesBordPeau = gpedgeBord[ifil] # pour chaque face de peau : groupe subshape des edges aux bords liés à la partie saine
bordsVifs = gpedgeVifs[ifil] # pour chaque face de peau : groupe subshape des edges aux bords correspondant à des arêtes vives
edgesFissurePeau = edFissPeau[ifil] # pour chaque face de peau : [subshape edge en peau des faces de fissure externes]
meshFacePeau = smesh.Mesh(facePeau)
algo1d = meshFacePeau.UseExisting1DElements(geom=groupEdgesBordPeau)
hypo1d = algo1d.SourceEdges([ bordsLibres ],0,0)
putName(algo1d.GetSubMesh(), "bordsLibres", ifil)
putName(algo1d, "algo1d_bordsLibres", ifil)
putName(hypo1d, "hypo1d_bordsLibres", ifil)
algo1d = meshFacePeau.UseExisting1DElements(geom=geompy.MakeCompound(edgesFissurePeau))
hypo1d = algo1d.SourceEdges([ grpEdgesPeauFissureExterne ],0,0)
putName(algo1d.GetSubMesh(), "edgePeauFiss", ifil)
putName(algo1d, "algo1d_edgePeauFiss", ifil)
putName(hypo1d, "hypo1d_edgePeauFiss", ifil)
if bordsVifs is not None:
algo1d = meshFacePeau.UseExisting1DElements(geom=bordsVifs)
hypo1d = algo1d.SourceEdges([ grpAretesVives ],0,0)
putName(algo1d.GetSubMesh(), "bordsVifs", ifil)
putName(algo1d, "algo1d_bordsVifs", ifil)
putName(hypo1d, "hypo1d_bordsVifs", ifil)
for i, edgeCirc in enumerate(edgesCircPeau):
if edgeCirc is not None:
algo1d = meshFacePeau.UseExisting1DElements(geom=edgeCirc)
if boutFromIfil[ifil] is None:
hypo1d = algo1d.SourceEdges([ edgesCircPipeGroup[i] ],0,0)
else:
hypo1d = algo1d.SourceEdges([ edgesCircPipeGroup[boutFromIfil[ifil]] ],0,0)
name = "cercle%d"%i
putName(algo1d.GetSubMesh(), name, ifil)
putName(algo1d, "algo1d_" + name, ifil)
putName(hypo1d, "hypo1d_" + name, ifil)
algo2d = meshFacePeau.Triangle(algo=smeshBuilder.NETGEN_1D2D)
hypo2d = algo2d.Parameters()
hypo2d.SetMaxSize( dmoyen )
hypo2d.SetOptimize( 1 )
hypo2d.SetFineness( 2 )
hypo2d.SetMinSize( rayonPipe/float(nbsegRad) )
hypo2d.SetQuadAllowed( 0 )
putName(algo2d.GetSubMesh(), "facePeau", ifil)
putName(algo2d, "algo2d_facePeau", ifil)
putName(hypo2d, "hypo2d_facePeau", ifil)
isDone = meshFacePeau.Compute()
logging.info("meshFacePeau %d fini", ifil)
GroupFaces = meshFacePeau.CreateEmptyGroup( SMESH.FACE, "facePeau%d"%ifil )
nbAdd = GroupFaces.AddFrom( meshFacePeau.GetMesh() )
meshesFacesPeau.append(meshFacePeau)
# --- regroupement des maillages du défaut
listMeshes = [internalBoundary.GetMesh(),
meshPipe.GetMesh(),
meshFaceFiss.GetMesh()]
for mp in meshesFacesPeau:
listMeshes.append(mp.GetMesh())
meshBoiteDefaut = smesh.Concatenate(listMeshes, 1, 1, 1e-05,False)
# pour aider l'algo hexa-tetra à ne pas mettre de pyramides à l'exterieur des volumes repliés sur eux-mêmes
# on désigne les faces de peau en quadrangles par le groupe "skinFaces"
group_faceFissOutPipe = None
group_faceFissInPipe = None
groups = meshBoiteDefaut.GetGroups()
for grp in groups:
if grp.GetType() == SMESH.FACE:
#if "internalBoundary" in grp.GetName():
# grp.SetName("skinFaces")
if grp.GetName() == "fisOutPi":
group_faceFissOutPipe = grp
elif grp.GetName() == "fisInPi":
group_faceFissInPipe = grp
# le maillage NETGEN ne passe pas toujours ==> 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()
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)
putName(maillageSain, nomFicSain+"_coupe")
extrusionFaceFissure, normfiss = shapeSurFissure(facesPortFissure)
maillageComplet = RegroupeSainEtDefaut(maillageSain, meshBoiteDefaut,
None, None, 'COMPLET', normfiss)
logging.info("conversion quadratique")
maillageComplet.ConvertToQuadratic( 1 )
logging.info("groupes")
groups = maillageComplet.GetGroups()
grps = [ grp for grp in groups if grp.GetName() == 'FONDFISS']
fond = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FONDFISS' )
logging.info("réorientation face de fissure FACE1")
grps = [ grp for grp in groups if grp.GetName() == 'FACE1']
nb = maillageComplet.Reorient2D( grps[0], normfiss, grps[0].GetID(1))
logging.info("réorientation face de fissure FACE2")
plansim = geompy.MakePlane(O, normfiss, 10000)
fissnorm = geompy.MakeMirrorByPlane(normfiss, plansim)
grps = [ grp for grp in groups if grp.GetName() == 'FACE2']
nb = maillageComplet.Reorient2D( grps[0], fissnorm, grps[0].GetID(1))
fond = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FACE2' )
logging.info("export maillage fini")
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)
logging.info("maillage fissure fini")
return maillageComplet

View File

@ -0,0 +1,43 @@
# -*- coding: utf-8 -*-
import logging
from geomsmesh import geompy
from checkDecoupePartition import checkDecoupePartition
# -----------------------------------------------------------------------------
# --- peau et face de fissure
#
# --- partition peau défaut - face de fissure prolongée - wire de fond de fissure prolongée
# il peut y avoir plusieurs faces externes, dont certaines sont découpées par la fissure
# liste de faces externes : facesDefaut
# liste de partitions face externe - fissure : partitionPeauFissFond (None quand pas d'intersection)
def construitPartitionsPeauFissure(facesDefaut, fissPipe):
"""
partition peau défaut - face de fissure prolongée - wire de fond de fissure prolongée.
Il peut y avoir plusieurs faces externes, dont certaines sont découpées par la fissure.
@param facesDefaut liste de faces externes
@param fissPipe partition face de fissure etendue par pipe prolongé
@return partitionsPeauFissFond : liste de partitions face externe - fissure (None quand pas d'intersection)
"""
logging.info('start')
partitionsPeauFissFond = []
ipart = 0
for filling in facesDefaut:
part = geompy.MakePartition([fissPipe, filling], [], [], [], geompy.ShapeType["FACE"], 0, [], 0)
isPart = checkDecoupePartition([fissPipe, filling], part)
if isPart: # on recrée la partition avec toutes les faces filling en outil pour avoir une face de fissure correcte
otherFD = [fd for fd in facesDefaut if fd != filling]
if len(otherFD) > 0:
fissPipePart = geompy.MakePartition([fissPipe], otherFD, [], [], geompy.ShapeType["FACE"], 0, [], 0)
else:
fissPipePart = fissPipe
part = geompy.MakePartition([fissPipePart, filling], [], [], [], geompy.ShapeType["FACE"], 0, [], 0)
partitionsPeauFissFond.append(part)
geompy.addToStudy( part, 'partitionPeauFissFond%d'%ipart )
else:
partitionsPeauFissFond.append(None)
ipart = ipart +1
return partitionsPeauFissFond

View File

@ -16,7 +16,7 @@ from fissureGenerique import fissureGenerique
from triedreBase import triedreBase from triedreBase import triedreBase
from genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut from genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
from creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain from creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
from insereFissureGenerale import insereFissureGenerale from construitFissureGenerale import construitFissureGenerale
from sortEdges import sortEdges from sortEdges import sortEdges
O, OX, OY, OZ = triedreBase() O, OX, OY, OZ = triedreBase()
@ -651,9 +651,9 @@ class fissureCoude(fissureGenerique):
def genereMaillageFissure(self, geometriesSaines, maillagesSains, def genereMaillageFissure(self, geometriesSaines, maillagesSains,
shapesFissure, shapeFissureParams, shapesFissure, shapeFissureParams,
maillageFissureParams, elementsDefaut, step): maillageFissureParams, elementsDefaut, step):
maillageFissure = insereFissureGenerale(maillagesSains, maillageFissure = construitFissureGenerale(maillagesSains,
shapesFissure, shapeFissureParams, shapesFissure, shapeFissureParams,
maillageFissureParams, elementsDefaut, step) maillageFissureParams, elementsDefaut, step)
return maillageFissure return maillageFissure
# --------------------------------------------------------------------------- # ---------------------------------------------------------------------------

View File

@ -9,14 +9,14 @@ publie = False
def getCentreFondFiss(shapesFissure): def getCentreFondFiss(shapesFissure):
""" """
identification du centre de fond de fissure, identification du centre de fond de fissure,
transformation fond de fissure en edge unique (seulement pour la procédure insereFissureGenerale). transformation fond de fissure en edge unique (seulement pour la procédure construitFissureGenerale).
On distingue le cas d'utilisation de la procédure insereFissureLongue par le nombre d'éléments de shapesFissure. On distingue le cas d'utilisation de la procédure insereFissureLongue par le nombre d'éléments de shapesFissure.
""" """
global publie global publie
logging.debug("start") logging.debug("start")
fondFiss = shapesFissure[4] # groupe d'edges de fond de fissure fondFiss = shapesFissure[4] # groupe d'edges de fond de fissure
if len(shapesFissure) == 6: # procédure insereFissureGenerale, et edge fond de fissure fournie explicitement if len(shapesFissure) == 6: # procédure construitFissureGenerale, et edge fond de fissure fournie explicitement
edgeFondExt = shapesFissure[5] edgeFondExt = shapesFissure[5]
else: else:
edgeFondExt = None edgeFondExt = None
@ -24,7 +24,7 @@ def getCentreFondFiss(shapesFissure):
if len(shapesFissure) > 6: # procédure insereFissureLongue (fissure plane, plusieurs edges sur le fond de fissure) if len(shapesFissure) > 6: # procédure insereFissureLongue (fissure plane, plusieurs edges sur le fond de fissure)
centreFondFiss = shapesFissure[1] centreFondFiss = shapesFissure[1]
tgtCentre = None tgtCentre = None
else: # procédure insereFissureGenerale, détermination edge unique et milieu de l'edge else: # procédure construitFissureGenerale, détermination edge unique et milieu de l'edge
if geompy.NumberOfEdges(fondFiss) > 1: if geompy.NumberOfEdges(fondFiss) > 1:
if geompy.NbShapes(fondFiss, geompy.ShapeType["WIRE"]) > 0: # wire if geompy.NbShapes(fondFiss, geompy.ShapeType["WIRE"]) > 0: # wire
aWire = fondFiss aWire = fondFiss

View File

@ -0,0 +1,137 @@
# -*- coding: utf-8 -*-
import logging
from geomsmesh import geompy
from substractSubShapes import substractSubShapes
def identifieEdgesPeau(edgesFissExtPipe,verticesPipePeau, facePeau, facesPeauSorted,
edgesPeauFondIn, fillingFaceExterne, aretesVivesC, aretesVivesCoupees):
"""
identification précise des edges et disques des faces de peau selon index extremité fissure
"""
logging.info('start')
facesPipePeau = [None for i in range(len(edgesFissExtPipe))]
endsEdgeFond = [None for i in range(len(edgesFissExtPipe))]
edgeRadFacePipePeau = [None for i in range(len(edgesFissExtPipe))]
edgesListees = []
edgesCircPeau = []
verticesCircPeau = []
if len(verticesPipePeau) > 0: # --- au moins une extrémité du pipe sur cette face de peau
for face in facesPeauSorted[:-1]: # la ou les faces débouchantes, pas la grande face de peau
logging.debug("examen face debouchante circulaire")
for i,efep in enumerate(edgesFissExtPipe):
dist = geompy.MinDistance(face, efep)
logging.debug(" distance face circulaire edge %s", dist)
if dist < 1e-3:
for ik, edpfi in enumerate(edgesPeauFondIn):
if geompy.MinDistance(face, edpfi) < 1e-3:
break
sharedVertices = geompy.GetSharedShapesMulti([face, edgesPeauFondIn[ik]], geompy.ShapeType["VERTEX"])
nameFace = "facePipePeau%d"%i
nameVert = "endEdgeFond%d"%i
nameEdge = "edgeRadFacePipePeau%d"%i
facesPipePeau[i] = face
endsEdgeFond[i] = sharedVertices[0]
geompy.addToStudy(face, nameFace)
geompy.addToStudy(sharedVertices[0], nameVert)
edgesFace = geompy.ExtractShapes(face, geompy.ShapeType["EDGE"], True)
for edge in edgesFace:
if geompy.MinDistance(edge, sharedVertices[0]) < 1e-3:
edgeRadFacePipePeau[i] = edge
geompy.addToStudy(edge, nameEdge)
break
pass
pass
pass
pass
# --- edges circulaires de la face de peau et points de jonction de la face externe de fissure
logging.debug("facesPipePeau: %s", facesPipePeau)
edgesCircPeau = [None for i in range(len(facesPipePeau))]
verticesCircPeau = [None for i in range(len(facesPipePeau))]
for i,fcirc in enumerate(facesPipePeau):
edges = geompy.GetSharedShapesMulti([facePeau, fcirc], geompy.ShapeType["EDGE"])
grpEdgesCirc = geompy.CreateGroup(facePeau, geompy.ShapeType["EDGE"])
geompy.UnionList(grpEdgesCirc, edges)
edgesCircPeau[i] = grpEdgesCirc
name = "edgeCirc%d"%i
geompy.addToStudyInFather(facePeau, grpEdgesCirc, name)
edgesListees = edgesListees + edges
vertices = geompy.GetSharedShapesMulti([facePeau, fcirc], geompy.ShapeType["VERTEX"])
grpVertCircPeau = geompy.CreateGroup(facePeau, geompy.ShapeType["VERTEX"])
geompy.UnionList(grpVertCircPeau, vertices)
verticesCircPeau[i] = grpVertCircPeau
name = "pointEdgeCirc%d"%i
geompy.addToStudyInFather(facePeau, grpVertCircPeau, name)
pass
pass # --- au moins une extrémité du pipe sur cette face de peau
# --- edges de bord de la face de peau
edgesFilling = geompy.ExtractShapes(fillingFaceExterne, geompy.ShapeType["EDGE"], False)
edgesBords = []
for i, edge in enumerate(edgesFilling):
edgepeau = geompy.GetInPlace(facePeau, edge)
name = "edgepeau%d"%i
geompy.addToStudyInFather(facePeau,edgepeau, name)
logging.debug("edgepeau %s", geompy.ShapeInfo(edgepeau))
if geompy.ShapeInfo(edgepeau)['EDGE'] > 1:
logging.debug(" EDGES multiples")
edgs = geompy.ExtractShapes(edgepeau, geompy.ShapeType["EDGE"], False)
edgesBords += edgs
edgesListees += edgs
else:
logging.debug(" EDGE")
edgesBords.append(edgepeau)
edgesListees.append(edgepeau)
groupEdgesBordPeau = geompy.CreateGroup(facePeau, geompy.ShapeType["EDGE"])
geompy.UnionList(groupEdgesBordPeau, edgesBords)
bordsVifs = None
if aretesVivesC is not None:
bordsVifs = geompy.GetInPlace(facePeau, aretesVivesC)
if bordsVifs is not None:
geompy.addToStudyInFather(facePeau, bordsVifs, "bordsVifs")
groupEdgesBordPeau = geompy.CutGroups(groupEdgesBordPeau, bordsVifs)
grptmp = None
if len(aretesVivesCoupees) > 0:
grpC = geompy.MakeCompound(aretesVivesCoupees)
grptmp = geompy.GetInPlace(facePeau, grpC)
if grptmp is not None:
grpnew = geompy.CutGroups(bordsVifs, grptmp) # ce qui est nouveau dans bordsVifs
else:
grpnew = bordsVifs
if grpnew is not None:
edv = geompy.ExtractShapes(grpnew, geompy.ShapeType["EDGE"], False)
aretesVivesCoupees += edv
logging.debug("aretesVivesCoupees %s",aretesVivesCoupees)
geompy.addToStudyInFather(facePeau, groupEdgesBordPeau , "EdgesBords")
# --- edges de la face de peau partagées avec la face de fissure
edgesPeau = geompy.ExtractShapes(facePeau, geompy.ShapeType["EDGE"], False)
edges = substractSubShapes(facePeau, edgesPeau, edgesListees)
edgesFissurePeau = []
if len(verticesPipePeau) > 0: # --- au moins une extrémité du pipe sur cette face de peau
edgesFissurePeau = [None for i in range(len(verticesCircPeau))] # edges associés aux extrémités du pipe, en premier
for edge in edges:
for i, grpVert in enumerate(verticesCircPeau):
if (geompy.MinDistance(grpVert, edge) < 1.e-3) and (edge not in edgesFissurePeau):
edgesFissurePeau[i] = edge
name = "edgeFissurePeau%d"%i
geompy.addToStudyInFather(facePeau, edge, name)
for edge in edges: # on ajoute après les edges manquantes
if edge not in edgesFissurePeau:
edgesFissurePeau.append(edge)
else:
for i, edge in enumerate(edges):
edgesFissurePeau.append(edge)
name = "edgeFissurePeau%d"%i
geompy.addToStudyInFather(facePeau, edge, name)
return (endsEdgeFond, facesPipePeau, edgeRadFacePipePeau,
edgesCircPeau, verticesCircPeau, groupEdgesBordPeau,
bordsVifs, edgesFissurePeau)

View File

@ -0,0 +1,148 @@
# -*- coding: utf-8 -*-
import logging
import math
from geomsmesh import geompy
from produitMixte import produitMixte
from whichSide import whichSide
def identifieElementsDebouchants(ifil, facesDefaut, partitionPeauFissFond,
edgesFondIn, edgesFondFiss, wireFondFiss,
aretesVivesC, fillingFaceExterne,
edgesPipeIn, verticesPipePeau, rayonPipe,
facesInside, facesOnside):
"""
elements débouchants (intersection pipe et peau), indexés selon les edges du fond de fissure (edgesFondIn)
"""
logging.info('start')
verticesEdgesFondIn = [] # les points du fond de fissure au débouché du pipe sur la peau (indice de edgesFondIn)
pipexts = [] # les segments de pipe associés au points de fond de fissure débouchants (même indice)
cercles = [] # les cercles de generation des pipes débouchant (même indice)
facesFissExt = [] # les faces de la fissure externe associés au points de fond de fissure débouchants (même indice)
edgesFissExtPeau = [] # edges des faces de fissure externe sur la peau (même indice)
edgesFissExtPipe = [] # edges des faces de fissure externe sur le pipe (même indice)
#logging.debug("edgesFondIn %s", edgesFondIn)
for iedf, edge in enumerate(edgesFondIn):
name = "edgeFondIn%d"%iedf
geompy.addToStudyInFather(partitionPeauFissFond, edge, name)
dist = [ geompy.MinDistance(pt, edge) for pt in verticesPipePeau]
ptPeau = verticesPipePeau[dist.index(min(dist))] # le point de verticesPipePeau a distance minimale de l'edge
[u, PointOnEdge, EdgeInWireIndex] = geompy.MakeProjectionOnWire(ptPeau, wireFondFiss)
logging.debug("u:%s, EdgeInWireIndex: %s, len(edgesFondFiss): %s", u, EdgeInWireIndex, len(edgesFondFiss))
localEdgeInFondFiss = edgesFondFiss[EdgeInWireIndex]
centre = PointOnEdge
centre2 = geompy.MakeVertexOnCurve(localEdgeInFondFiss, u)
geompy.addToStudyInFather(partitionPeauFissFond, centre2, "centre2_%d"%iedf)
verticesEdgesFondIn.append(centre)
name = "verticeEdgesFondIn%d"%iedf
geompy.addToStudyInFather(partitionPeauFissFond, centre, name)
norm = geompy.MakeTangentOnCurve(localEdgeInFondFiss, u)
geompy.addToStudyInFather(partitionPeauFissFond, centre, "norm%d"%iedf)
cercle = geompy.MakeCircle(centre, norm, rayonPipe)
geompy.addToStudyInFather(partitionPeauFissFond, cercle, "cerclorig%d"%iedf)
[vertex] = geompy.ExtractShapes(cercle, geompy.ShapeType["VERTEX"], False)
vec1 = geompy.MakeVector(centre, vertex)
vec2 = geompy.MakeVector(centre, ptPeau)
angle = geompy.GetAngleRadians(vec1, vec2)
# cas général : on reconstitue une portion de pipe, avec l'arête de couture qui coincide
# avec la face de fissure, au niveau du débouché sur la face externe
# cas dégénéré : le pipe débouche perpendiculairement à une surface plane à l'origine.
# La partition filling / pipe reconstruit échoue.
# - Si on partitionne le filling avec un simple pipe obtenu par extrusion droite du cercle,
# cela donne un point en trop sur le cercle.
# - Si on prend une vraie surface plane (pas un filling), on peut faire la partition avec
# les pipes reconstruits
logging.debug("angle=%s", angle)
#if abs(angle) > 1.e-7:
sommetAxe = geompy.MakeTranslationVector(centre, norm)
pm = produitMixte(centre, vertex, ptPeau, sommetAxe)
if pm > 0: # ajout de pi a (-)angle pour éviter des points confondus (partition échoue) dans les cas dégénérés
cercle = geompy.MakeRotation(cercle, norm, angle + math.pi)
else:
cercle = geompy.MakeRotation(cercle, norm, -angle + math.pi)
name = "cercle%d"%iedf
geompy.addToStudyInFather(partitionPeauFissFond, cercle, name)
cercles.append(cercle)
# --- estimation de la longueur du pipe necessaire de part et d'autre du point de sortie
if aretesVivesC is None:
faceTestPeau = fillingFaceExterne
else:
faceTestPeau = facesDefaut[ifil]
sideCentre = whichSide(faceTestPeau, centre)
locPt0 = geompy.MakeVertexOnCurve(localEdgeInFondFiss, 0.0)
locPt1 = geompy.MakeVertexOnCurve(localEdgeInFondFiss, 1.0)
sidePt0 = whichSide(faceTestPeau, locPt0)
sidePt1 = whichSide(faceTestPeau, locPt1)
logging.debug("position centre cercle: %s, extremité edge u0: %s, u1: %s", sideCentre, sidePt0, sidePt1)
normFace = geompy.GetNormal(faceTestPeau, ptPeau)
inclPipe = abs(geompy.GetAngleRadians(norm, normFace))
lgp = max(rayonPipe/2., abs(3*rayonPipe*math.tan(inclPipe)))
logging.debug("angle inclinaison Pipe en sortie: %s degres, lgp: %s", inclPipe*180/math.pi, lgp)
# --- position des points extremite du pipe sur l'edge debouchante
# il faut la distance curviligne ofp du point central par rapport à une extrémité de l'edge débouchante
locEdgePart = geompy.MakePartition([localEdgeInFondFiss],[centre], [], [], geompy.ShapeType["EDGE"], 0, [], 0)
edgesLoc = geompy.ExtractShapes(locEdgePart, geompy.ShapeType["EDGE"], False)
edgesLocSorted =[(geompy.MinDistance(edge, locPt0), kk, edge) for kk, edge in enumerate(edgesLoc)]
edgesLocSorted.sort()
ofp = geompy.BasicProperties(edgesLocSorted[0][2])[0] # distance curviligne centre locPt0
logging.debug("distance curviligne centre extremite0: %s", ofp)
p1 = geompy.MakeVertexOnCurveByLength(localEdgeInFondFiss, ofp +lgp, locPt0)
p2 = geompy.MakeVertexOnCurveByLength(localEdgeInFondFiss, ofp -lgp, locPt0)
geompy.addToStudyInFather(wireFondFiss, p1, "p1_%d"%iedf)
geompy.addToStudyInFather(wireFondFiss, p2, "p2_%d"%iedf)
edgePart = geompy.MakePartition([localEdgeInFondFiss], [p1,p2], [], [], geompy.ShapeType["EDGE"], 0, [], 0)
edps = geompy.ExtractShapes(edgePart, geompy.ShapeType["EDGE"], True)
for edp in edps:
if geompy.MinDistance(centre, edp) < 1.e-3:
pipext = geompy.MakePipe(cercle, edp)
name = "pipeExt%d"%iedf
geompy.addToStudyInFather(partitionPeauFissFond, pipext, name)
pipexts.append(pipext)
for ifa, face in enumerate(facesInside):
logging.debug("recherche edges communes entre une face inside et (faces onside, edges pipe et fond débouchante)")
edgesPeauFis = []
edgesPipeFis = []
edgesPipeFnd = []
try:
edgesPeauFis = geompy.GetSharedShapesMulti([geompy.MakeCompound(facesOnside), face], geompy.ShapeType["EDGE"])
logging.debug(" faces onside %s",edgesPeauFis)
edgesPipeFis = geompy.GetSharedShapesMulti([geompy.MakeCompound(edgesPipeIn), face], geompy.ShapeType["EDGE"])
logging.debug(" edgesPipeIn %s", edgesPipeFis)
edgesPipeFnd = geompy.GetSharedShapesMulti([geompy.MakeCompound(edgesFondIn), face], geompy.ShapeType["EDGE"])
logging.debug(" edgesFondIn %s ", edgesPipeFnd)
except:
logging.debug(" pb edges communes %s %s %s",edgesPeauFis, edgesPipeFis, edgesPipeFnd)
pass
if (len(edgesPeauFis) > 0) and (len(edgesPipeFis) > 0) and (len(edgesPipeFnd) == 0):
dist = geompy.MinDistance(geompy.MakeCompound(edgesPeauFis), ptPeau)
logging.debug(" test distance extrémité reference %s", dist)
if dist < 1.e-3: # c'est la face de fissure externe associée
logging.debug(" face %s inside ajoutée", ifa)
facesFissExt.append(face)
name="faceFissExt%d"%iedf
geompy.addToStudyInFather(partitionPeauFissFond, face, name)
dist = 1.
for ipe, edpe in enumerate(edgesPeauFis):
for ipi, edpi in enumerate(edgesPipeFis):
dist = geompy.MinDistance(edpe, edpi)
if dist < 1.e-3:
edgesFissExtPeau.append(edpe)
name="edgesFissExtPeau%d"%iedf
geompy.addToStudyInFather(partitionPeauFissFond, edpe, name)
edgesFissExtPipe.append(edpi)
name="edgesFissExtPipe%d"%iedf
geompy.addToStudyInFather(partitionPeauFissFond, edpi, name)
break
if dist < 1.e-3:
break
return (verticesEdgesFondIn, pipexts, cercles, facesFissExt, edgesFissExtPeau, edgesFissExtPipe)

View File

@ -0,0 +1,55 @@
# -*- coding: utf-8 -*-
import logging
from geomsmesh import geompy
from extractionOrientee import extractionOrientee
from extractionOrienteeMulti import extractionOrienteeMulti
def identifieElementsFissure(ifil, facesDefaut, partitionPeauFissFond,
edgesPipeFiss, edgesFondFiss, aretesVivesC,
fillingFaceExterne, centreFondFiss):
"""
# -----------------------------------------------------------------------
# --- identification edges fond de fissure, edges pipe sur la face de fissure,
# edges prolongées
# edges internes communes pipe et fissure, points communs edges fissure peau et edges circulaires
"""
logging.info('start')
edgesPipeC = geompy.GetInPlace(partitionPeauFissFond, geompy.MakeCompound(edgesPipeFiss))
geompy.addToStudyInFather(partitionPeauFissFond, edgesPipeC, "edgesPipeFiss")
edgesFondC = geompy.GetInPlace(partitionPeauFissFond, geompy.MakeCompound(edgesFondFiss))
geompy.addToStudyInFather(partitionPeauFissFond, edgesFondC, "edgesFondFiss")
if aretesVivesC is None:
[edgesInside, edgesOutside, edgesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "EDGE", 1.e-3)
[facesInside, facesOutside, facesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "FACE", 1.e-3)
else:
[edgesInside, edgesOutside, edgesOnside] = extractionOrienteeMulti(facesDefaut, ifil, partitionPeauFissFond, centreFondFiss, "EDGE", 1.e-3)
[facesInside, facesOutside, facesOnside] = extractionOrienteeMulti(facesDefaut, ifil, partitionPeauFissFond, centreFondFiss, "FACE", 1.e-3)
edgesPipeIn = geompy.GetSharedShapesMulti([edgesPipeC, geompy.MakeCompound(edgesInside)], geompy.ShapeType["EDGE"])
verticesPipePeau = []
for i, edge in enumerate(edgesPipeIn):
try:
vertices = geompy.GetSharedShapesMulti([edge, geompy.MakeCompound(facesOnside)], geompy.ShapeType["VERTEX"])
verticesPipePeau.append(vertices[0])
name = "edgePipeIn%d"%i
geompy.addToStudyInFather(partitionPeauFissFond, edge, name)
name = "verticePipePeau%d"%i
geompy.addToStudyInFather(partitionPeauFissFond, vertices[0], name)
logging.debug("edgePipeIn%s coupe les faces OnSide", i)
except:
logging.debug("edgePipeIn%s ne coupe pas les faces OnSide", i)
edgesFondIn =[]
if len(verticesPipePeau) > 0: # au moins une extrémité du pipe sur cette face de peau
#tmp = geompy.GetSharedShapesMulti([edgesFondC, geompy.MakeCompound(edgesOutside)], geompy.ShapeType["EDGE"])
#edgesFondOut = [ ed for ed in tmp if geompy.MinDistance(ed, geompy.MakeCompound(facesOnside)) < 1.e-3]
tmp = geompy.GetSharedShapesMulti([edgesFondC, geompy.MakeCompound(edgesInside)], geompy.ShapeType["EDGE"])
edgesFondIn = [ ed for ed in tmp if geompy.MinDistance(ed, geompy.MakeCompound(facesOnside)) < 1.e-3]
return (edgesPipeIn, verticesPipePeau, edgesFondIn, facesInside, facesOnside)

View File

@ -0,0 +1,82 @@
# -*- coding: utf-8 -*-
import logging
import math
from geomsmesh import geompy
from extractionOrientee import extractionOrientee
from extractionOrienteeMulti import extractionOrienteeMulti
from orderEdgesFromWire import orderEdgesFromWire
from produitMixte import produitMixte
from whichSide import whichSide
from sortFaces import sortFaces
from substractSubShapes import substractSubShapes
from identifieElementsFissure import identifieElementsFissure
from identifieElementsDebouchants import identifieElementsDebouchants
from trouveEdgesFissPeau import trouveEdgesFissPeau
from identifieFacesPeau import identifieFacesPeau
from identifieEdgesPeau import identifieEdgesPeau
def identifieElementsGeometriquesPeau(ifil, partitionPeauFissFond, edgesPipeFiss,
edgesFondFiss, wireFondFiss, aretesVivesC,
facesDefaut, centreFondFiss, rayonPipe,
aretesVivesCoupees):
"""
"""
logging.info('start')
fillingFaceExterne = facesDefaut[ifil]
logging.debug("traitement partitionPeauFissFond %s", ifil)
# --- identification edges fond de fissure, edges pipe sur la face de fissure, edges prolongées
# edges internes communes pipe et fissure, points communs edges fissure peau et edges circulaires
(edgesPipeIn, verticesPipePeau, edgesFondIn, facesInside, facesOnside) = identifieElementsFissure(ifil, facesDefaut, partitionPeauFissFond,
edgesPipeFiss, edgesFondFiss, aretesVivesC,
fillingFaceExterne, centreFondFiss)
# --- elements débouchants (intersection pipe et peau), indexés selon les edges du fond de fissure (edgesFondIn)
(verticesEdgesFondIn, pipexts, cercles,
facesFissExt, edgesFissExtPeau, edgesFissExtPipe) = identifieElementsDebouchants(ifil, facesDefaut, partitionPeauFissFond,
edgesFondIn, edgesFondFiss, wireFondFiss,
aretesVivesC, fillingFaceExterne,
edgesPipeIn, verticesPipePeau, rayonPipe,
facesInside, facesOnside)
# --- pour les faces de peau sans extremité débouchante de fissure, il faut recenser les edges de fissure sur la face de peau
if len(verticesPipePeau) == 0: # aucune extrémité du pipe sur cette face de peau
edgesFissExtPeau = trouveEdgesFissPeau(facesInside, facesOnside, edgesPipeIn, edgesFondIn, partitionPeauFissFond, edgesFissExtPeau)
# --- inventaire des faces de peau : face de peau percée du pipe, extrémités du pipe
(facePeau, facesPeauSorted, edgesPeauFondIn) = identifieFacesPeau(ifil, verticesPipePeau, facesOnside, wireFondFiss,
verticesEdgesFondIn, pipexts, cercles,
fillingFaceExterne, centreFondFiss)
# --- identification précise des edges et disques des faces de peau selon index extremité fissure
(endsEdgeFond, facesPipePeau, edgeRadFacePipePeau,
edgesCircPeau, verticesCircPeau, groupEdgesBordPeau,
bordsVifs, edgesFissurePeau) = identifieEdgesPeau(edgesFissExtPipe, verticesPipePeau, facePeau, facesPeauSorted,
edgesPeauFondIn, fillingFaceExterne, aretesVivesC, aretesVivesCoupees)
dataPPFF = dict(endsEdgeFond = endsEdgeFond, # pour chaque face [points edge fond de fissure aux débouchés du pipe]
facesPipePeau = facesPipePeau, # pour chaque face [face
edgeRadFacePipePeau = edgeRadFacePipePeau, # pour chaque face [edge radiale des faces du pipe débouchantes ]
facesFissExt = facesFissExt, # pour chaque face [faces de fissure externes au pipe]
edgesFissExtPeau = edgesFissExtPeau, # pour chaque face [edge en peau des faces de fissure externes (pas subshape facePeau)]
edgesFissExtPipe = edgesFissExtPipe, # pour chaque face [edge commun au pipe des faces de fissure externes]
facePeau = facePeau, # pour chaque face : la face de peau finale a mailler (percee des faces débouchantes)
edgesCircPeau = edgesCircPeau, # pour chaque face de peau : [groupe subshapes edges circulaires aux débouchés du pipe]
verticesCircPeau = verticesCircPeau, # pour chaque face de peau : [groupe subshapes points sur edges circulaires aux débouchés du pipe]
groupEdgesBordPeau = groupEdgesBordPeau, # pour chaque face de peau : groupe subshape des edges aux bords liés à la partie saine
bordsVifs = bordsVifs, # pour chaque face de peau : groupe subshape des edges aux bords correspondant à des arêtes vives
edgesFissurePeau = edgesFissurePeau, # pour chaque face de peau : [subshape edge en peau des faces de fissure externes]
verticesPipePeau = verticesPipePeau # pour chaque face de peau : [point commun edFissPeau edCircPeau]
)
return dataPPFF, aretesVivesCoupees

View File

@ -0,0 +1,78 @@
# -*- coding: utf-8 -*-
import logging
from geomsmesh import geompy
from sortFaces import sortFaces
from extractionOrientee import extractionOrientee
def identifieFacesPeau(ifil, verticesPipePeau, facesOnside, wireFondFiss,
verticesEdgesFondIn, pipexts, cercles,
fillingFaceExterne, centreFondFiss):
"""
inventaire des faces de peau : face de peau percée du pipe, extrémités du pipe
La partition avec le pipe peut créer un vertex (et un edge) de trop sur le cercle projeté,
quand le cercle est très proche de la face.
dans ce cas, la projection du cercle sur la face suivie d'une partition permet
d'éviter le point en trop
"""
logging.info('start')
facesAndFond = facesOnside
facesAndFond.append(wireFondFiss)
try:
partitionPeauByPipe = geompy.MakePartition(facesAndFond, pipexts, [], [], geompy.ShapeType["FACE"], 0, [], 1)
except:
logging.debug("probleme partition face pipe, contournement avec MakeSection")
sections = []
for pipext in pipexts:
sections.append(geompy.MakeSection(facesOnside[0], pipext))
partitionPeauByPipe = geompy.MakePartition(facesAndFond, sections, [], [], geompy.ShapeType["FACE"], 0, [], 1)
# contrôle edge en trop sur edges circulaires
if len(verticesPipePeau) > 0: # --- au moins une extrémité du pipe sur cette face de peau
edgeEnTrop = []
outilPart = pipexts
facesPeau = geompy.ExtractShapes(partitionPeauByPipe, geompy.ShapeType["FACE"], False)
facesPeauSorted, minsur, maxsurf = sortFaces(facesPeau)
for i, face in enumerate(facesPeauSorted[:-1]): # on ne teste que la ou les petites faces "circulaires"
nbv = geompy.NumberOfEdges(face)
logging.debug("nombre d'edges sur face circulaire: %s", nbv)
if nbv > 3:
edgeEnTrop.append(True) # TODO : distinguer les cas avec deux faces circulaires dont l'une est correcte
else:
edgeEnTrop.append(False)
refaire = sum(edgeEnTrop)
if refaire > 0:
dc = [(geompy.MinDistance(verticesEdgesFondIn[0], fac), i) for i, fac in enumerate(facesPeauSorted[:-1])]
dc.sort()
logging.debug("dc sorted: %s", dc)
i0 = dc[0][1] # indice de facesPeauSorted qui correspond à verticesEdgesFondIn[0], donc 0 pour cercles
direct = (i0 == 0)
for i, bad in enumerate(edgeEnTrop):
if direct:
j = i
else:
j = 1-i
if bad:
outilPart[j] = geompy.MakeProjection(cercles[j],facesOnside[0])
pass
partitionPeauByPipe = geompy.MakePartition(facesAndFond, outilPart, [], [], geompy.ShapeType["FACE"], 0, [], 1)
pass
name="partitionPeauByPipe%d"%ifil
geompy.addToStudy(partitionPeauByPipe, name)
[edgesPeauFondIn, edgesPeauFondOut, edgesPeauFondOn] = extractionOrientee(fillingFaceExterne, partitionPeauByPipe, centreFondFiss, "EDGE", 1.e-3)
[facesPeauFondIn, facesPeauFondOut, facesPeauFondOn] = extractionOrientee(fillingFaceExterne, partitionPeauByPipe, centreFondFiss, "FACE", 1.e-3)
if len(verticesPipePeau) > 0: # --- au moins une extrémité du pipe sur cette face de peau
facesPeauSorted, minsur, maxsurf = sortFaces(facesPeauFondOn)
facePeau = facesPeauSorted[-1] # la plus grande face
else:
facePeau =geompy.MakePartition(facesPeauFondOn, [], [], [], geompy.ShapeType["FACE"], 0, [], 1)
facesPeauSorted = [facePeau]
name="facePeau%d"%ifil
geompy.addToStudy(facePeau, name)
return (facePeau, facesPeauSorted, edgesPeauFondIn)

View File

@ -115,7 +115,7 @@ def insereFissureGenerale(maillagesSains,
else: else:
facesPartShapeDefautSorted, minSurf, maxSurf = sortFaces(facesPartShapeDefaut) # la face de fissure dans le volume doit être la plus grande facesPartShapeDefautSorted, minSurf, maxSurf = sortFaces(facesPartShapeDefaut) # la face de fissure dans le volume doit être la plus grande
logging.debug("surfaces faces fissure étendue, min %s, max %s", minSurf, maxSurf) logging.debug("surfaces faces fissure étendue, min %s, max %s", minSurf, maxSurf)
facesPortFissure = facesPartShapeDefautSorted[-1] facesPortFissure = facesPartShapeDefautSorted[-1] #= global
geompy.addToStudy(facesPortFissure, "facesPortFissure") geompy.addToStudy(facesPortFissure, "facesPortFissure")
@ -127,10 +127,10 @@ def insereFissureGenerale(maillagesSains,
if geompy.NumberOfFaces(shapeDefaut) == 1: if geompy.NumberOfFaces(shapeDefaut) == 1:
plan = geompy.MakePlane(centreFondFiss, tgtCentre, 10000) plan = geompy.MakePlane(centreFondFiss, tgtCentre, 10000)
shapeDefaut = geompy.MakePartition([shapeDefaut], [plan], [], [], geompy.ShapeType["FACE"], 0, [], 0) shapeDefaut = geompy.MakePartition([shapeDefaut], [plan], [], [], geompy.ShapeType["FACE"], 0, [], 0) #= local
fondFissCoupe = geompy.GetInPlaceByHistory(shapeDefaut, fondFiss) #fondFissCoupe = geompy.GetInPlaceByHistory(shapeDefaut, fondFiss) #= inutile
geompy.addToStudy(shapeDefaut, 'shapeDefaut_coupe') geompy.addToStudy(shapeDefaut, 'shapeDefaut_coupe')
geompy.addToStudyInFather(shapeDefaut, fondFissCoupe, 'fondFiss_coupe') #geompy.addToStudyInFather(shapeDefaut, fondFissCoupe, 'fondFiss_coupe')
extrem, norms = findWireEndVertices(fondFiss, True) extrem, norms = findWireEndVertices(fondFiss, True)
logging.debug("extrem: %s, norm: %s",extrem, norms) logging.debug("extrem: %s, norm: %s",extrem, norms)
@ -142,17 +142,17 @@ def insereFissureGenerale(maillagesSains,
geompy.addToStudy(pipeFiss, 'pipeFiss') geompy.addToStudy(pipeFiss, 'pipeFiss')
partFissPipe = geompy.MakePartition([shapeDefaut, pipeFiss], [], [], [], geompy.ShapeType["FACE"], 0, [], 1) partFissPipe = geompy.MakePartition([shapeDefaut, pipeFiss], [], [], [], geompy.ShapeType["FACE"], 0, [], 1)
geompy.addToStudy(partFissPipe, 'partFissPipe') geompy.addToStudy(partFissPipe, 'partFissPipe')
fissPipe = geompy.GetInPlaceByHistory(partFissPipe, shapeDefaut) fissPipe = geompy.GetInPlaceByHistory(partFissPipe, shapeDefaut) #= global
geompy.addToStudy(fissPipe, 'fissPipe') geompy.addToStudy(fissPipe, 'fissPipe')
partPipe = geompy.GetInPlaceByHistory(partFissPipe, pipeFiss) partPipe = geompy.GetInPlaceByHistory(partFissPipe, pipeFiss) #= local
geompy.addToStudy(partPipe, 'partPipe') geompy.addToStudy(partPipe, 'partPipe')
edgesPipeFiss = geompy.GetSharedShapesMulti([fissPipe, partPipe], geompy.ShapeType["EDGE"]) edgesPipeFiss = geompy.GetSharedShapesMulti([fissPipe, partPipe], geompy.ShapeType["EDGE"]) #= global
for i, edge in enumerate(edgesPipeFiss): for i, edge in enumerate(edgesPipeFiss):
name = "edgePipe%d"%i name = "edgePipe%d"%i
geompy.addToStudyInFather(fissPipe, edge, name) geompy.addToStudyInFather(fissPipe, edge, name)
try: try:
wirePipeFiss = geompy.MakeWire(edgesPipeFiss) wirePipeFiss = geompy.MakeWire(edgesPipeFiss) #= global
except: except:
wirePipeFiss = geompy.MakeCompound(edgesPipeFiss) wirePipeFiss = geompy.MakeCompound(edgesPipeFiss)
logging.debug("wirePipeFiss construit sous forme de compound") logging.debug("wirePipeFiss construit sous forme de compound")
@ -163,7 +163,7 @@ def insereFissureGenerale(maillagesSains,
for i, edge in enumerate(edgesFondFiss): for i, edge in enumerate(edgesFondFiss):
name = "edgeFondFiss%d"%i name = "edgeFondFiss%d"%i
geompy.addToStudyInFather(fissPipe, edge, name) geompy.addToStudyInFather(fissPipe, edge, name)
wireFondFiss = geompy.MakeWire(edgesFondFiss) wireFondFiss = geompy.MakeWire(edgesFondFiss) #= global
geompy.addToStudy(wireFondFiss,"wireFondFiss") geompy.addToStudy(wireFondFiss,"wireFondFiss")
# ----------------------------------------------------------------------------- # -----------------------------------------------------------------------------
@ -174,7 +174,7 @@ def insereFissureGenerale(maillagesSains,
# liste de faces externes : facesDefaut # liste de faces externes : facesDefaut
# liste de partitions face externe - fissure : partitionPeauFissFond (None quand pas d'intersection) # liste de partitions face externe - fissure : partitionPeauFissFond (None quand pas d'intersection)
partitionsPeauFissFond = [] partitionsPeauFissFond = [] #= global
ipart = 0 ipart = 0
for filling in facesDefaut: for filling in facesDefaut:
part = geompy.MakePartition([fissPipe, filling], [], [], [], geompy.ShapeType["FACE"], 0, [], 0) part = geompy.MakePartition([fissPipe, filling], [], [], [], geompy.ShapeType["FACE"], 0, [], 0)
@ -197,7 +197,7 @@ def insereFissureGenerale(maillagesSains,
# et quadranglesToShapeWithCorner) # et quadranglesToShapeWithCorner)
aretesVives = [] aretesVives = []
aretesVivesCoupees = [] aretesVivesCoupees = [] #= global
ia = 0 ia = 0
for a in bordsPartages: for a in bordsPartages:
if not isinstance(a, list): if not isinstance(a, list):
@ -212,7 +212,7 @@ def insereFissureGenerale(maillagesSains,
geompy.addToStudy(a[0], name) geompy.addToStudy(a[0], name)
ia += 1 ia += 1
aretesVivesC = None aretesVivesC = None #= global
if len(aretesVives) > 0: if len(aretesVives) > 0:
aretesVivesC =geompy.MakeCompound(aretesVives) aretesVivesC =geompy.MakeCompound(aretesVives)
@ -237,28 +237,28 @@ def insereFissureGenerale(maillagesSains,
ptFisExtPi = [ [] for i in range(nbFacesFilling)] # pour chaque face de peau : [point commun edFissPeau edCircPeau] ptFisExtPi = [ [] for i in range(nbFacesFilling)] # pour chaque face de peau : [point commun edFissPeau edCircPeau]
for ifil, partitionPeauFissFond in enumerate(partitionsPeauFissFond): for ifil, partitionPeauFissFond in enumerate(partitionsPeauFissFond):
fillingFaceExterne = facesDefaut[ifil]
#fillingSansDecoupe = fillconts[idFilToCont[ifil]]
if partitionPeauFissFond is not None: if partitionPeauFissFond is not None:
fillingFaceExterne = facesDefaut[ifil]
#fillingSansDecoupe = fillconts[idFilToCont[ifil]]
logging.debug("traitement partitionPeauFissFond %s", ifil) logging.debug("traitement partitionPeauFissFond %s", ifil)
# ----------------------------------------------------------------------- # -----------------------------------------------------------------------
# --- identification edges fond de fissure, edges pipe sur la face de fissure, # --- identification edges fond de fissure, edges pipe sur la face de fissure,
# edges prolongées # edges prolongées
edgesPipeC = geompy.GetInPlace(partitionPeauFissFond, geompy.MakeCompound(edgesPipeFiss)) edgesPipeC = geompy.GetInPlace(partitionPeauFissFond, geompy.MakeCompound(edgesPipeFiss)) #= local
geompy.addToStudyInFather(partitionPeauFissFond, edgesPipeC, "edgesPipeFiss") geompy.addToStudyInFather(partitionPeauFissFond, edgesPipeC, "edgesPipeFiss")
edgesFondC = geompy.GetInPlace(partitionPeauFissFond, geompy.MakeCompound(edgesFondFiss)) edgesFondC = geompy.GetInPlace(partitionPeauFissFond, geompy.MakeCompound(edgesFondFiss)) #= local
geompy.addToStudyInFather(partitionPeauFissFond, edgesFondC, "edgesFondFiss") geompy.addToStudyInFather(partitionPeauFissFond, edgesFondC, "edgesFondFiss")
if aretesVivesC is None: if aretesVivesC is None: #= global facesInside facesOnside
[edgesInside, edgesOutside, edgesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "EDGE", 1.e-3) [edgesInside, edgesOutside, edgesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "EDGE", 1.e-3)
[facesInside, facesOutside, facesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "FACE", 1.e-3) [facesInside, facesOutside, facesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "FACE", 1.e-3)
else: else:
[edgesInside, edgesOutside, edgesOnside] = extractionOrienteeMulti(facesDefaut, ifil, partitionPeauFissFond, centreFondFiss, "EDGE", 1.e-3) [edgesInside, edgesOutside, edgesOnside] = extractionOrienteeMulti(facesDefaut, ifil, partitionPeauFissFond, centreFondFiss, "EDGE", 1.e-3)
[facesInside, facesOutside, facesOnside] = extractionOrienteeMulti(facesDefaut, ifil, partitionPeauFissFond, centreFondFiss, "FACE", 1.e-3) [facesInside, facesOutside, facesOnside] = extractionOrienteeMulti(facesDefaut, ifil, partitionPeauFissFond, centreFondFiss, "FACE", 1.e-3)
edgesPipeIn = geompy.GetSharedShapesMulti([edgesPipeC, geompy.MakeCompound(edgesInside)], geompy.ShapeType["EDGE"]) edgesPipeIn = geompy.GetSharedShapesMulti([edgesPipeC, geompy.MakeCompound(edgesInside)], geompy.ShapeType["EDGE"]) #= global
verticesPipePeau = [] verticesPipePeau = [] #= global
for i, edge in enumerate(edgesPipeIn): for i, edge in enumerate(edgesPipeIn):
try: try:
@ -271,13 +271,14 @@ def insereFissureGenerale(maillagesSains,
logging.debug("edgePipeIn%s coupe les faces OnSide", i) logging.debug("edgePipeIn%s coupe les faces OnSide", i)
except: except:
logging.debug("edgePipeIn%s ne coupe pas les faces OnSide", i) logging.debug("edgePipeIn%s ne coupe pas les faces OnSide", i)
edgesFondOut = [] #edgesFondOut = [] #= inutile
edgesFondIn =[] edgesFondIn =[] #= global
if len(verticesPipePeau) > 0: # au moins une extrémité du pipe sur cette face de peau if len(verticesPipePeau) > 0: # au moins une extrémité du pipe sur cette face de peau
tmp = geompy.GetSharedShapesMulti([edgesFondC, geompy.MakeCompound(edgesOutside)], geompy.ShapeType["EDGE"]) #tmp = geompy.GetSharedShapesMulti([edgesFondC, geompy.MakeCompound(edgesOutside)], geompy.ShapeType["EDGE"])
edgesFondOut = [ ed for ed in tmp if geompy.MinDistance(ed, geompy.MakeCompound(facesOnside)) < 1.e-3] #edgesFondOut = [ ed for ed in tmp if geompy.MinDistance(ed, geompy.MakeCompound(facesOnside)) < 1.e-3]
tmp = geompy.GetSharedShapesMulti([edgesFondC, geompy.MakeCompound(edgesInside)], geompy.ShapeType["EDGE"]) tmp = geompy.GetSharedShapesMulti([edgesFondC, geompy.MakeCompound(edgesInside)], geompy.ShapeType["EDGE"])
edgesFondIn = [ ed for ed in tmp if geompy.MinDistance(ed, geompy.MakeCompound(facesOnside)) < 1.e-3] edgesFondIn = [ ed for ed in tmp if geompy.MinDistance(ed, geompy.MakeCompound(facesOnside)) < 1.e-3]
verticesEdgesFondIn = [] # les points du fond de fissure au débouché du pipe sur la peau (indice de edgesFondIn) verticesEdgesFondIn = [] # les points du fond de fissure au débouché du pipe sur la peau (indice de edgesFondIn)
pipexts = [] # les segments de pipe associés au points de fond de fissure débouchants (même indice) pipexts = [] # les segments de pipe associés au points de fond de fissure débouchants (même indice)
cercles = [] # les cercles de generation des pipes débouchant (même indice) cercles = [] # les cercles de generation des pipes débouchant (même indice)

View File

@ -0,0 +1,61 @@
# -*- coding: utf-8 -*-
import math
import logging
from geomsmesh import geompy
from findWireEndVertices import findWireEndVertices
from prolongeWire import prolongeWire
def partitionneFissureParPipe(shapesFissure, elementsDefaut, rayonPipe):
"""
pipe de fond de fissure, prolongé, partition face fissure par pipe
identification des edges communes pipe et face fissure
"""
logging.info('start')
shapeDefaut = shapesFissure[0] # faces de fissure, débordant
fondFiss = shapesFissure[4] # groupe d'edges de fond de fissure
centreFondFiss = elementsDefaut[15]
tgtCentre = elementsDefaut[16]
if geompy.NumberOfFaces(shapeDefaut) == 1:
plan = geompy.MakePlane(centreFondFiss, tgtCentre, 10000)
shapeDefaut = geompy.MakePartition([shapeDefaut], [plan], [], [], geompy.ShapeType["FACE"], 0, [], 0)
#fondFissCoupe = geompy.GetInPlaceByHistory(shapeDefaut, fondFiss) #= inutile
geompy.addToStudy(shapeDefaut, 'shapeDefaut_coupe')
#geompy.addToStudyInFather(shapeDefaut, fondFissCoupe, 'fondFiss_coupe')
extrem, norms = findWireEndVertices(fondFiss, True)
logging.debug("extrem: %s, norm: %s",extrem, norms)
cercle = geompy.MakeCircle(extrem[0], norms[0], rayonPipe)
cercle = geompy.MakeRotation(cercle, norms[0], math.pi/3.0 ) # éviter d'avoir l'arête de couture du pipe presque confondue avec la face fissure
geompy.addToStudy(cercle, 'cercle')
fondFissProlonge = prolongeWire(fondFiss, extrem, norms, 2*rayonPipe)
pipeFiss = geompy.MakePipe(cercle, fondFissProlonge)
geompy.addToStudy(pipeFiss, 'pipeFiss')
partFissPipe = geompy.MakePartition([shapeDefaut, pipeFiss], [], [], [], geompy.ShapeType["FACE"], 0, [], 1)
geompy.addToStudy(partFissPipe, 'partFissPipe')
fissPipe = geompy.GetInPlaceByHistory(partFissPipe, shapeDefaut)
geompy.addToStudy(fissPipe, 'fissPipe')
partPipe = geompy.GetInPlaceByHistory(partFissPipe, pipeFiss)
geompy.addToStudy(partPipe, 'partPipe')
edgesPipeFiss = geompy.GetSharedShapesMulti([fissPipe, partPipe], geompy.ShapeType["EDGE"])
for i, edge in enumerate(edgesPipeFiss):
name = "edgePipe%d"%i
geompy.addToStudyInFather(fissPipe, edge, name)
try:
wirePipeFiss = geompy.MakeWire(edgesPipeFiss)
except:
wirePipeFiss = geompy.MakeCompound(edgesPipeFiss)
logging.debug("wirePipeFiss construit sous forme de compound")
geompy.addToStudy(wirePipeFiss, "wirePipeFiss")
wireFondFiss = geompy.GetInPlace(partFissPipe,fondFiss)
edgesFondFiss = geompy.GetSharedShapesMulti([fissPipe, wireFondFiss], geompy.ShapeType["EDGE"])
for i, edge in enumerate(edgesFondFiss):
name = "edgeFondFiss%d"%i
geompy.addToStudyInFather(fissPipe, edge, name)
wireFondFiss = geompy.MakeWire(edgesFondFiss)
geompy.addToStudy(wireFondFiss,"wireFondFiss")
return (fissPipe, edgesPipeFiss, edgesFondFiss, wirePipeFiss, wireFondFiss)

View File

@ -0,0 +1,27 @@
# -*- coding: utf-8 -*-
import logging
from geomsmesh import geompy
from sortFaces import sortFaces
def restreintFaceFissure(shapeDefaut, facesDefaut, pointInterne):
"""
restriction de la face de fissure au domaine solide
partition face fissure étendue par fillings
"""
logging.info('start')
partShapeDefaut = geompy.MakePartition([shapeDefaut], facesDefaut, [], [], geompy.ShapeType["FACE"], 0, [], 0)
geompy.addToStudy(partShapeDefaut, 'partShapeDefaut')
facesPartShapeDefaut = geompy.ExtractShapes(partShapeDefaut, geompy.ShapeType["FACE"], False)
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])
facesPortFissure = distfaces[0][2]
else:
facesPartShapeDefautSorted, minSurf, maxSurf = sortFaces(facesPartShapeDefaut) # la face de fissure dans le volume doit être la plus grande
logging.debug("surfaces faces fissure étendue, min %s, max %s", minSurf, maxSurf)
facesPortFissure = facesPartShapeDefautSorted[-1]
geompy.addToStudy(facesPortFissure, "facesPortFissure")
return facesPortFissure

View File

@ -0,0 +1,29 @@
# -*- coding: utf-8 -*-
import logging
from geomsmesh import geompy
def trouveEdgesFissPeau(facesInside, facesOnside, edgesPipeIn, edgesFondIn, partitionPeauFissFond, edgesFissExtPeau):
"""
pour les faces de peau sans extremité débouchante de fissure, il faut recenser les edges de fissure sur la face de peau
"""
logging.info('start')
j = 0
for face in facesInside:
edgesPeauFis = []
edgesPipeFis = []
edgesPipeFnd = []
try:
edgesPeauFis = geompy.GetSharedShapesMulti([geompy.MakeCompound(facesOnside), face], geompy.ShapeType["EDGE"])
edgesPipeFis = geompy.GetSharedShapesMulti([geompy.MakeCompound(edgesPipeIn), face], geompy.ShapeType["EDGE"])
edgesPipeFnd = geompy.GetSharedShapesMulti([geompy.MakeCompound(edgesFondIn), face], geompy.ShapeType["EDGE"])
except:
pass
if (len(edgesPeauFis) > 0) and (len(edgesPipeFis) > 0) and (len(edgesPipeFnd) == 0):
edgesFissExtPeau.append(edgesPeauFis[0])
name="edgesFissExtPeau%d"%j
geompy.addToStudyInFather(partitionPeauFissFond, edgesPeauFis[0], name)
j += 1
return edgesFissExtPeau