geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' )
mailleur = self.mailleur2d3d()
- coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,10, mailleur)
+ coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,10, mailleur, self.numeroCas)
centre = None
# ---------------------------------------------------------------------------
def genereZoneDefaut(self, geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams):
- elementsDefaut = creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams)
+ elementsDefaut = creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams, \
+ self.numeroCas)
return elementsDefaut
# ---------------------------------------------------------------------------
logging.info("genereMaillageSain %s", self.nomCas)
([objetSain], _) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests", "CylindreSain.med"))
- smesh.SetName(objetSain.GetMesh(), 'objetSain')
+ smesh.SetName(objetSain.GetMesh(), "{}_objetSain".format(self.nomProbleme))
return [objetSain, True] # True : maillage hexa
geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' )
mailleur = self.mailleur2d3d()
- coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,15, mailleur)
+ coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,15, mailleur, self.numeroCas)
centre = None
return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss]
# ---------------------------------------------------------------------------
def genereZoneDefaut(self, geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams):
- elementsDefaut = creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams)
+ elementsDefaut = creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams, \
+ self.numeroCas)
return elementsDefaut
# ---------------------------------------------------------------------------
geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' )
mailleur = self.mailleur2d3d()
- coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,15, mailleur)
+ coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,15, mailleur, self.numeroCas)
centre = None
return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss]
geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' )
mailleur = self.mailleur2d3d()
- coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,25, mailleur)
+ coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,25, mailleur, self.numeroCas)
centre = None
# ---------------------------------------------------------------------------
def genereZoneDefaut(self, geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams):
- elementsDefaut = creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams)
+ elementsDefaut = creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams, \
+ self.numeroCas)
return elementsDefaut
# ---------------------------------------------------------------------------
geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' )
mailleur = self.mailleur2d3d()
- coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,25, mailleur)
+ coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,25, mailleur, self.numeroCas)
centre = None
logging.info(texte)
([objetSain], _) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests", "EprouvetteCourbe.med"))
- smesh.SetName(objetSain.GetMesh(), 'objetSain')
+ smesh.SetName(objetSain.GetMesh(), "{}_objetSain".format(self.nomProbleme))
return [objetSain, True] # True : maillage hexa
geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' )
mailleur = self.mailleur2d3d()
- coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,10, mailleur)
+ coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,10, mailleur, self.numeroCas)
centre = None
# ---------------------------------------------------------------------------
def genereZoneDefaut(self, geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams):
- elementsDefaut = creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams)
+ elementsDefaut = creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams, \
+ self.numeroCas)
return elementsDefaut
# ---------------------------------------------------------------------------
logging.info("genereMaillageSain %s", self.nomCas)
([objetSain], _) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests", "eprouvetteDroite.med"))
- smesh.SetName(objetSain.GetMesh(), 'objetSain')
+ smesh.SetName(objetSain.GetMesh(), "{}_objetSain".format(self.nomProbleme))
return [objetSain, True] # True : maillage hexa
geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' )
mailleur = self.mailleur2d3d()
- coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,10, mailleur)
+ coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,10, mailleur, self.numeroCas)
centre = None
return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss]
# ---------------------------------------------------------------------------
def genereZoneDefaut(self, geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams):
- elementsDefaut = creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams)
+ elementsDefaut = creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams, \
+ self.numeroCas)
return elementsDefaut
# ---------------------------------------------------------------------------
geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' )
mailleur = self.mailleur2d3d()
- coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,10, mailleur)
+ coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,10, mailleur, self.numeroCas)
centre = None
return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss]
logging.info("genereMaillageSain %s", self.nomCas)
([objetSain], _) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests", "faceGaucheSain.med"))
- smesh.SetName(objetSain.GetMesh(), 'objetSain')
+ smesh.SetName(objetSain.GetMesh(), "{}_objetSain".format(self.nomProbleme))
return [objetSain, True] # True : maillage hexa
geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' )
mailleur = self.mailleur2d3d()
- coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,50, mailleur)
+ coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,50, mailleur, self.numeroCas)
centre = None
return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss]
# ---------------------------------------------------------------------------
def genereZoneDefaut(self, geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams):
- elementsDefaut = creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams)
+ elementsDefaut = creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams, \
+ self.numeroCas)
return elementsDefaut
# ---------------------------------------------------------------------------
logging.info("genereMaillageSain %s", self.nomCas)
([objetSain], _) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests", "boiteSaine.med"))
- smesh.SetName(objetSain.GetMesh(), 'objetSain')
+ smesh.SetName(objetSain.GetMesh(), "{}_objetSain".format(self.nomProbleme))
return [objetSain, True] # True : maillage hexa
geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' )
mailleur = self.mailleur2d3d()
- coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,25, mailleur)
+ coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,25, mailleur, self.numeroCas)
centre = None
return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss]
# ---------------------------------------------------------------------------
def genereZoneDefaut(self, geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams):
- elementsDefaut = creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams)
+ elementsDefaut = creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams, \
+ self.numeroCas)
return elementsDefaut
# ---------------------------------------------------------------------------
from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
from blocFissure.gmu.insereFissureLongue import insereFissureLongue
+from blocFissure.gmu.putName import putName
O, OX, OY, OZ = triedreBase()
algo3d = maillageSain.Hexahedron()
algo2d = maillageSain.Quadrangle()
- smesh.SetName(algo3d, "algo3d_maillageSain")
- smesh.SetName(algo2d, "algo2d_maillageSain")
+ putName(algo3d, "algo3d_maillageSain", i_pref=self.numeroCas)
+ putName(algo2d, "algo2d_maillageSain", i_pref=self.numeroCas)
algo1d_long_p1 = maillageSain.Segment(geom=long_p1)
hypo1d_long_p1 = algo1d_long_p1.NumberOfSegments(n_long_p1)
- smesh.SetName(algo1d_long_p1, "algo1d_long_p1")
- smesh.SetName(hypo1d_long_p1, "hypo1d_long_p1")
+ putName(algo1d_long_p1, "algo1d_long_p1", i_pref=self.numeroCas)
+ putName(hypo1d_long_p1, "hypo1d_long_p1", i_pref=self.numeroCas)
algo1d_ep = maillageSain.Segment(geom=ep)
hypo1d_ep = algo1d_ep.NumberOfSegments(n_ep)
- smesh.SetName(algo1d_ep, "algo1d_ep")
- smesh.SetName(hypo1d_ep, "hypo1d_ep")
+ putName(algo1d_ep, "algo1d_ep", i_pref=self.numeroCas)
+ putName(hypo1d_ep, "hypo1d_ep", i_pref=self.numeroCas)
algo1d_long_coude = maillageSain.Segment(geom=long_coude)
hypo1d_long_coude = algo1d_long_coude.NumberOfSegments(n_long_coude)
- smesh.SetName(algo1d_long_coude, "algo1d_long_coude")
- smesh.SetName(hypo1d_long_coude, "hypo1d_long_coude")
+ putName(algo1d_long_coude, "algo1d_long_coude", i_pref=self.numeroCas)
+ putName(hypo1d_long_coude, "hypo1d_long_coude", i_pref=self.numeroCas)
algo1d_circ_g = maillageSain.Segment(geom=circ_g)
hypo1d_circ_g = algo1d_circ_g.NumberOfSegments(n_circ_g)
- smesh.SetName(algo1d_circ_g, "algo1d_circ_g")
- smesh.SetName(hypo1d_circ_g, "hypo1d_circ_g")
+ putName(algo1d_circ_g, "algo1d_circ_g", i_pref=self.numeroCas)
+ putName(hypo1d_circ_g, "hypo1d_circ_g", i_pref=self.numeroCas)
algo1d_circ_d = maillageSain.Segment(geom=circ_d)
hypo1d_circ_d = algo1d_circ_d.NumberOfSegments(n_circ_d)
- smesh.SetName(algo1d_circ_d, "algo1d_circ_d")
- smesh.SetName(hypo1d_circ_d, "hypo1d_circ_d")
+ putName(algo1d_circ_d, "algo1d_circ_d", i_pref=self.numeroCas)
+ putName(hypo1d_circ_d, "hypo1d_circ_d", i_pref=self.numeroCas)
algo1d_long_p2 = maillageSain.Segment(geom=long_p2)
hypo1d_long_p2 = algo1d_long_p2.NumberOfSegments(n_long_p2)
- smesh.SetName(algo1d_long_p2, "algo1d_long_p2")
- smesh.SetName(hypo1d_long_p2, "hypo1d_long_p2")
+ putName(algo1d_long_p2, "algo1d_long_p2", i_pref=self.numeroCas)
+ putName(hypo1d_long_p2, "hypo1d_long_p2", i_pref=self.numeroCas)
_ = maillageSain.GroupOnGeom(P1,'P1',SMESH.NODE)
_ = maillageSain.GroupOnGeom(P2,'P2',SMESH.NODE)
pass
mailleur = self.mailleur2d3d()
- coordsNoeudsFissure = genereMeshCalculZoneDefaut(facefiss, 5 ,10, mailleur)
+ coordsNoeudsFissure = genereMeshCalculZoneDefaut(facefiss, 5 ,10, mailleur, self.numeroCas)
return [facefiss, centre, lgInfluence, coordsNoeudsFissure, wiretube, facetubel, facetuber, planfiss, pipefiss]
# ---------------------------------------------------------------------------
def genereZoneDefaut(self, geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams):
- elementsDefaut = creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams)
+ elementsDefaut = creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams, \
+ self.numeroCas)
return elementsDefaut
# ---------------------------------------------------------------------------
maillageFissure = insereFissureLongue(geometriesSaines, \
shapesFissure, shapeFissureParams, \
maillageFissureParams, elementsDefaut, \
- step, mailleur)
+ step, mailleur, self.numeroCas)
return maillageFissure
# ---------------------------------------------------------------------------
geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' )
mailleur = self.mailleur2d3d()
- coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 0.025, 0.1, mailleur)
+ coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 0.025, 0.1, mailleur, self.numeroCas)
centre = None
# ---------------------------------------------------------------------------
def genereZoneDefaut(self, geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams):
- elementsDefaut = creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams)
+ elementsDefaut = creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams, \
+ self.numeroCas)
return elementsDefaut
# ---------------------------------------------------------------------------
geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' )
mailleur = self.mailleur2d3d()
- coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 0.1 ,0.2, mailleur)
+ coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 0.1 ,0.2, mailleur, self.numeroCas)
centre = None
# ---------------------------------------------------------------------------
def genereZoneDefaut(self, geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams):
- elementsDefaut = creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams)
+ elementsDefaut = creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams, \
+ self.numeroCas)
return elementsDefaut
# ---------------------------------------------------------------------------
initEtude.py
initLog.py
insereFissureElliptique.py
- insereFissureGenerale.py
insereFissureLongue_a.py
insereFissureLongue_b.py
insereFissureLongue_c.py
from .geomsmesh import geompy
from .geomsmesh import smesh
+from .putName import putName
+
def calculePointsAxiauxPipe(edgesFondFiss, edgesIdByOrientation, facesDefaut,
centreFondFiss, wireFondFiss, wirePipeFiss,
- lenSegPipe, rayonPipe, nbsegCercle, nbsegRad):
+ lenSegPipe, rayonPipe, nbsegCercle, nbsegRad, \
+ nro_cas=-1):
"""Préparation maillage du pipe :
- détections des points a respecter : jonction des edges/faces constituant
"""
logging.info('start')
+ logging.info("Pour le cas n°%d", nro_cas)
# --- option de maillage selon le rayon de courbure du fond de fissure
lenEdgeFondExt = 0
meshFondExt = smesh.Mesh(wireFondFiss)
algo1d = meshFondExt.Segment()
- _ = algo1d.Adaptive(lgmin, lgmax, deflexion) # a ajuster selon la profondeur de la fissure
+ hypo1d = algo1d.Adaptive(lgmin, lgmax, deflexion) # a ajuster selon la profondeur de la fissure
+ putName(algo1d.GetSubMesh(), "wireFondFiss", i_pref=nro_cas)
+ putName(algo1d, "algo1d_wireFondFiss", i_pref=nro_cas)
+ putName(hypo1d, "hypo1d_wireFondFiss", i_pref=nro_cas)
is_done = meshFondExt.Compute()
text = "calculePointsAxiauxPipe meshFondExt.Compute"
from .genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
from .creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
from .construitFissureGenerale import construitFissureGenerale
+from .putName import putName
O, OX, OY, OZ = triedreBase()
- un maillage sain (hexaèdres),
- une face géométrique de fissure, qui doit légèrement dépasser hors du volume maillé
- - les numéros d'arêtes (edges géométriques) correspondant au fond de fissure
+ - les noms des groupes d'arêtes ou leurs numéros d'arêtes (edges au sens de GEOM) correspondant au fond de fissure
- les paramètres de maillage de la fissure
"""
referencesMaillageFissure = None
logging.info("genereMaillageSain %s", self.nomCas)
([objetSain], _) = smesh.CreateMeshesFromMED(self.dicoParams['maillageSain'])
- smesh.SetName(objetSain.GetMesh(), 'objetSain')
+ putName(objetSain.GetMesh(), 'objetSain', i_pref=self.numeroCas)
return [objetSain, True] # True : maillage hexa
coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, self.dicoParams['meshBrep'][0] ,self.dicoParams['meshBrep'][1], \
- mailleur)
+ mailleur, self.numeroCas)
centre = None
return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss]
# ---------------------------------------------------------------------------
def genereZoneDefaut(self, geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams):
- elementsDefaut = creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams)
+ elementsDefaut = creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams, \
+ self.numeroCas)
return elementsDefaut
# ---------------------------------------------------------------------------
step=-1, mailleur="MeshGems", nro_cas=-1):
"""procédure complète fissure générale"""
logging.info('start')
- logging.info("Usage du mailleur %s", mailleur)
- logging.info("pour le cas %d", nro_cas)
+ logging.info("Usage du mailleur %s pour le cas n°%d", mailleur, nro_cas)
shapeDefaut = shapesFissure[0] # faces de fissure, débordant
# - points sur les edges de fond de fissure et edges pipe/face fissure,
# - vecteurs tangents au fond de fissure (normal au disque maillé)
- (centres, gptsdisks, raydisks) = calculePointsAxiauxPipe(edgesFondFiss, edgesIdByOrientation, facesDefaut, \
- centreFondFiss, wireFondFiss, wirePipeFiss, \
- lenSegPipe, rayonPipe, nbsegCercle, nbsegRad)
+ (centres, gptsdisks, raydisks) = calculePointsAxiauxPipe (edgesFondFiss, edgesIdByOrientation, facesDefaut, \
+ centreFondFiss, wireFondFiss, wirePipeFiss, \
+ lenSegPipe, rayonPipe, nbsegCercle, nbsegRad, \
+ nro_cas)
# --- recherche des points en trop (externes au volume à remailler)
# - on associe chaque extrémité du pipe à une face filling
# --- maillage effectif du pipe
- (meshPipe, meshPipeGroups, edgesCircPipeGroup) = construitMaillagePipe(gptsdisks, idisklim, nbsegCercle, nbsegRad)
+ (meshPipe, meshPipeGroups, edgesCircPipeGroup) = \
+ construitMaillagePipe(gptsdisks, idisklim, nbsegCercle, nbsegRad)
# --- edges de bord, faces défaut à respecter
- (internalBoundary, bordsLibres, grpAretesVives) = mailleAretesEtJonction(internalBoundary, aretesVivesCoupees, lgAretesVives)
+ (internalBoundary, bordsLibres, grpAretesVives) = \
+ mailleAretesEtJonction(internalBoundary, aretesVivesCoupees, lgAretesVives, \
+ nro_cas)
# --- maillage faces de fissure
mailleFacesFissure(faceFissureExterne, \
edgesPipeFissureExterneC, edgesPeauFissureExterneC, \
meshPipeGroups, areteFaceFissure, rayonPipe, nbsegRad, \
- mailleur)
+ mailleur, nro_cas)
# --- maillage faces de peau
zoneDefaut, zoneDefaut_skin, zoneDefaut_internalFaces, zoneDefaut_internalEdges, \
facesPortFissure, \
maillageFissureParams, \
- mailleur )
+ mailleur, nro_cas )
if salome.sg.hasDesktop():
salome.sg.updateObjBrowser()
zoneDefaut, zoneDefaut_skin, zoneDefaut_internalFaces, zoneDefaut_internalEdges, \
facesPortFissure, \
maillageFissureParams, \
- mailleur="MeshGems"):
+ mailleur="MeshGems", nro_cas=-1):
"""construction de la fissure générale - maillage"""
logging.info('start')
- logging.info("Usage du mailleur %s", mailleur)
+ logging.info("Usage du mailleur %s pour le cas n°%d", mailleur, nro_cas)
nomRep = maillageFissureParams['nomRep']
nomFicSain = maillageFissureParams['nomFicSain']
hypo3d.SetVerboseLevel( 0 )
hypo3d.SetStandardOutputLog( 0 )
hypo3d.SetRemoveLogOnSuccess( 1 )
- putName(algo3d.GetSubMesh(), "boiteDefaut")
- putName(algo3d, "algo3d_boiteDefaut")
- putName(meshBoiteDefaut, "boiteDefaut")
+ putName(algo3d.GetSubMesh(), "boiteDefaut", i_pref=nro_cas)
+ putName(algo3d, "algo3d_boiteDefaut", i_pref=nro_cas)
+ putName(meshBoiteDefaut, "boiteDefaut", i_pref=nro_cas)
is_done = meshBoiteDefaut.Compute()
text = "meshBoiteDefaut.Compute"
'FACE1' )
maillageSain = enleveDefaut(maillageSain, zoneDefaut, zoneDefaut_skin,
zoneDefaut_internalFaces, zoneDefaut_internalEdges)
- putName(maillageSain, nomFicSain+"_coupe")
+ putName(maillageSain, nomFicSain+"_coupe", i_pref=nro_cas)
_, normfiss = shapeSurFissure(facesPortFissure)
maillageComplet = RegroupeSainEtDefaut(maillageSain, meshBoiteDefaut, \
None, None, 'COMPLET', normfiss)
from .getCentreFondFiss import getCentreFondFiss
def creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure, \
- shapeFissureParams, maillageFissureParams):
+ shapeFissureParams, maillageFissureParams, \
+ nro_cas=-1):
"""
#TODO: a compléter
"""
maillageSain.ExportMED(fichierMaillageSain)
logging.debug("fichier maillage sain %s", fichierMaillageSain)
[maillageSain, internalBoundary, zoneDefaut, zoneDefaut_skin, zoneDefaut_internalFaces, zoneDefaut_internalEdges] = \
- peauInterne(fichierMaillageSain, shapeDefaut, nomZones)
+ peauInterne(fichierMaillageSain, shapeDefaut, nomZones, \
+ nro_cas)
facesDefaut = list()
centresDefaut = list()
import logging
from .geomsmesh import geompy
-# -----------------------------------------------------------------------------
-# ---
-
def eliminateDoubles(obj, subshapes):
"""éliminer les doublons d'une liste de subshapes"""
idsubs[subid] = [sub]
shortList = list()
- for l_sub in idsubs.items():
+ for _, l_sub in idsubs.items():
shortList.append(l_sub[0])
logging.debug("shortList=%s", shortList)
from .creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
from .construitFissureGenerale import construitFissureGenerale
from .sortEdges import sortEdges
+from .putName import putName
O, OX, OY, OZ = triedreBase()
algo3d = maillageSain.Hexahedron()
algo2d = maillageSain.Quadrangle()
- smesh.SetName(algo3d, "algo3d_maillageSain")
- smesh.SetName(algo2d, "algo2d_maillageSain")
+ putName(algo3d, "algo3d_maillageSain", i_pref=self.numeroCas)
+ putName(algo2d, "algo2d_maillageSain", i_pref=self.numeroCas)
algo1d_long_p1 = maillageSain.Segment(geom=long_p1)
hypo1d_long_p1 = algo1d_long_p1.NumberOfSegments(n_long_p1)
- smesh.SetName(algo1d_long_p1, "algo1d_long_p1")
- smesh.SetName(hypo1d_long_p1, "hypo1d_long_p1")
+ putName(algo1d_long_p1, "algo1d_long_p1", i_pref=self.numeroCas)
+ putName(hypo1d_long_p1, "hypo1d_long_p1", i_pref=self.numeroCas)
algo1d_ep = maillageSain.Segment(geom=ep)
hypo1d_ep = algo1d_ep.NumberOfSegments(n_ep)
- smesh.SetName(algo1d_ep, "algo1d_ep")
- smesh.SetName(hypo1d_ep, "hypo1d_ep")
+ putName(algo1d_ep, "algo1d_ep", i_pref=self.numeroCas)
+ putName(hypo1d_ep, "hypo1d_ep", i_pref=self.numeroCas)
algo1d_long_coude = maillageSain.Segment(geom=long_coude)
hypo1d_long_coude = algo1d_long_coude.NumberOfSegments(n_long_coude)
- smesh.SetName(algo1d_long_coude, "algo1d_long_coude")
- smesh.SetName(hypo1d_long_coude, "hypo1d_long_coude")
+ putName(algo1d_long_coude, "algo1d_long_coude", i_pref=self.numeroCas)
+ putName(hypo1d_long_coude, "hypo1d_long_coude", i_pref=self.numeroCas)
algo1d_circ_g = maillageSain.Segment(geom=circ_g)
hypo1d_circ_g = algo1d_circ_g.NumberOfSegments(n_circ_g)
- smesh.SetName(algo1d_circ_g, "algo1d_circ_g")
- smesh.SetName(hypo1d_circ_g, "hypo1d_circ_g")
+ putName(algo1d_circ_g, "algo1d_circ_g", i_pref=self.numeroCas)
+ putName(hypo1d_circ_g, "hypo1d_circ_g", i_pref=self.numeroCas)
algo1d_circ_d = maillageSain.Segment(geom=circ_d)
hypo1d_circ_d = algo1d_circ_d.NumberOfSegments(n_circ_d)
- smesh.SetName(algo1d_circ_d, "algo1d_circ_d")
- smesh.SetName(hypo1d_circ_d, "hypo1d_circ_d")
+ putName(algo1d_circ_d, "algo1d_circ_d", i_pref=self.numeroCas)
+ putName(hypo1d_circ_d, "hypo1d_circ_d", i_pref=self.numeroCas)
algo1d_long_p2 = maillageSain.Segment(geom=long_p2)
hypo1d_long_p2 = algo1d_long_p2.NumberOfSegments(n_long_p2)
- smesh.SetName(algo1d_long_p2, "algo1d_long_p2")
- smesh.SetName(hypo1d_long_p2, "hypo1d_long_p2")
+ putName(algo1d_long_p2, "algo1d_long_p2", i_pref=self.numeroCas)
+ putName(hypo1d_long_p2, "hypo1d_long_p2", i_pref=self.numeroCas)
is_done = maillageSain.Compute()
text = "maillageSain.Compute"
geomPublish(initLog.debug, centre, 'centrefissPlace' )
coordsNoeudsFissure = genereMeshCalculZoneDefaut(facefiss, profondeur/2. ,profondeur, \
- mailleur)
+ mailleur, self.numeroCas)
return [facefiss, centre, lgInfluence, coordsNoeudsFissure, wiretube, edgetube]
# ---------------------------------------------------------------------------
def genereZoneDefaut(self, geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams):
- elementsDefaut = creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams)
+ elementsDefaut = creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams, \
+ self.numeroCas)
return elementsDefaut
# ---------------------------------------------------------------------------
from .listOfExtraFunctions import createNewMeshesFromCorner
from .listOfExtraFunctions import createLinesFromMesh
+from .putName import putName
-def fusionMaillageDefaut(maillageSain, maillageDefautCible, maillageInterneCible, zoneDefaut_skin, shapeDefaut, listOfCorners):
+def fusionMaillageDefaut(maillageSain, maillageDefautCible, maillageInterneCible, \
+ zoneDefaut_skin, shapeDefaut, listOfCorners, \
+ nro_cas=-1):
"""Groupe de quadrangles de face transformé en face géométrique par filling"""
logging.info("start")
+ logging.info("Pour le cas n°%d", nro_cas)
facesNonCoupees = list()
facesCoupees = list()
newZoneDefaut_skin = maillageSain.GetMesh().CutListOfGroups([zoneDefaut_skin], facesEnTrop, 'newZoneDefaut_skin')
- smesh.SetName(newMaillageInterne, 'newInternalBoundary')
+ putName(newMaillageInterne, 'newInternalBoundary', i_pref=nro_cas)
return newZoneDefaut_skin, newMaillageInterne
from .genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
def genereElemsFissureElliptique(shapeFissureParams, \
- mailleur="MeshGems"):
+ mailleur="MeshGems", nro_cas=-1):
"""Création élements géométriques fissure elliptique"""
logging.info('start')
shapeDefaut = facefis1
xyz_defaut = geompy.PointCoordinates(centreDefaut)
coordsNoeudsFissure = genereMeshCalculZoneDefaut(facefis1, demiPetitAxe/10.0, demiPetitAxe/5.0, \
- mailleur)
+ mailleur, nro_cas)
return shapeDefaut, xyz_defaut, tailleDefaut, coordsNoeudsFissure, pipe0, gener1, pipe1, facefis1, plane1, ellipsoide1
from .geomsmesh import smesh
+from .putName import putName
+
def genereMeshCalculZoneDefaut(facefiss, minSize, maxSize, \
- mailleur="MeshGems"):
+ mailleur="MeshGems", nro_cas=-1):
"""Maillage de l'objet géométrique 'facefiss'
. Avec l'algorithme MG_CADSurf :
"""
logging.info('start')
+ logging.info("Maillage avec %s pour le cas n°%d", mailleur, nro_cas)
meshFissure = smesh.Mesh(facefiss)
- text = "Maillage de '{}' avec {}".format(facefiss.GetName(),mailleur)
+ putName(meshFissure, "facefiss", i_pref=nro_cas)
+
+ text = "Maillage de '{}'".format(facefiss.GetName())
logging.info(text)
if ( mailleur == "MeshGems"):
algo2d = meshFissure.Triangle(algo=smeshBuilder.MG_CADSurf)
hypo2d.SetFineness( 2 )
hypo2d.SetMinSize( minSize )
hypo2d.SetQuadAllowed( 0 )
- smesh.SetName(algo2d, "algo2d_zoneFiss")
- smesh.SetName(hypo2d, "hypo1d_zoneFiss")
+ putName(algo2d, "algo2d_zoneFiss", i_pref=nro_cas)
+ putName(hypo2d, "hypo1d_zoneFiss", i_pref=nro_cas)
is_done = meshFissure.Compute()
text = "meshFissure.Compute"
zoneDefaut_internalFaces = elementsDefaut[12]
zoneDefaut_internalEdges = elementsDefaut[13]
- ## --- ellipse incomplete : generatrice
- #if step == 5:
- #return None
+ maillageComplet = None
- #allonge = demiGrandAxe/demiPetitAxe
- #rayonTore = demiPetitAxe/5.0
- #generatrice, FaceGenFiss, Pipe_1, FaceFissure, Plane_1, Pipe1Part = self.toreFissure(demiPetitAxe, allonge, rayonTore)
- #ellipsoide = self.ellipsoideDefaut(demiPetitAxe, allonge)
+ while True:
- ## --- positionnement sur le bloc defaut de generatrice, tore et plan fissure
- #if step == 6:
- #return None
+ ## --- ellipse incomplete : generatrice
+ #if step == 5:
+ #break
- #pipe0 = self.rotTrans(Pipe_1, orientation, centreDefaut, normalDefaut)
- #gener1 = self.rotTrans(generatrice, orientation, centreDefaut, normalDefaut)
- #pipe1 = self.rotTrans(Pipe1Part, orientation, centreDefaut, normalDefaut)
- #facefis1 = self.rotTrans(FaceFissure, orientation, centreDefaut, normalDefaut)
- #plane1 = self.rotTrans(Plane_1, orientation, centreDefaut, normalDefaut)
- #ellipsoide1 = self.rotTrans(ellipsoide, orientation, centreDefaut, normalDefaut)
+ #allonge = demiGrandAxe/demiPetitAxe
+ #rayonTore = demiPetitAxe/5.0
+ #generatrice, FaceGenFiss, Pipe_1, FaceFissure, Plane_1, Pipe1Part = self.toreFissure(demiPetitAxe, allonge, rayonTore)
+ #ellipsoide = self.ellipsoideDefaut(demiPetitAxe, allonge)
- #geomPublish(initLog.debug, pipe0, 'pipe0' )
- #geomPublish(initLog.debug, gener1, 'gener1' )
- #geomPublish(initLog.debug, pipe1, 'pipe1' )
- #geomPublish(initLog.debug, facefis1, 'facefis1' )
- #geomPublish(initLog.debug, plane1, 'plane1' )
- #geomPublish(initLog.debug, ellipsoide1, 'ellipsoide1' )
+ ## --- positionnement sur le bloc defaut de generatrice, tore et plan fissure
+ #if step == 6:
+ #break
- # --- partition du bloc défaut par génératrice, tore et plan fissure
- if step == 7:
- return None
+ #pipe0 = self.rotTrans(Pipe_1, orientation, centreDefaut, normalDefaut)
+ #gener1 = self.rotTrans(generatrice, orientation, centreDefaut, normalDefaut)
+ #pipe1 = self.rotTrans(Pipe1Part, orientation, centreDefaut, normalDefaut)
+ #facefis1 = self.rotTrans(FaceFissure, orientation, centreDefaut, normalDefaut)
+ #plane1 = self.rotTrans(Plane_1, orientation, centreDefaut, normalDefaut)
+ #ellipsoide1 = self.rotTrans(ellipsoide, orientation, centreDefaut, normalDefaut)
- [ blocPartition, _, tore, \
- faceFissure, facesExternes, facesExtBloc, facesExtElli,
- aretesInternes, ellipsoidep, sharedFaces, sharedEdges, edgesBords] = \
- partitionBlocDefaut(extrusionDefaut, facesDefaut, gener1, pipe1, facefis1, ellipsoide1)
- if not isHexa:
- edgesBords = None # maillage sain hexa ==> filling, et maillage edges Bords imposés du maillage sain
+ #geomPublish(initLog.debug, pipe0, 'pipe0' )
+ #geomPublish(initLog.debug, gener1, 'gener1' )
+ #geomPublish(initLog.debug, pipe1, 'pipe1' )
+ #geomPublish(initLog.debug, facefis1, 'facefis1' )
+ #geomPublish(initLog.debug, plane1, 'plane1' )
+ #geomPublish(initLog.debug, ellipsoide1, 'ellipsoide1' )
- # --- TORE
- # --- faces toriques du tore
- if step == 8:
- return None
+ # --- partition du bloc défaut par génératrice, tore et plan fissure
+ if step == 7:
+ break
- [facetore1, facetore2, _, _] = facesVolumesToriques(tore, plane1, facesDefaut)
+ [ blocPartition, _, tore, \
+ faceFissure, facesExternes, facesExtBloc, facesExtElli,
+ aretesInternes, ellipsoidep, sharedFaces, sharedEdges, edgesBords] = \
+ partitionBlocDefaut(extrusionDefaut, facesDefaut, gener1, pipe1, facefis1, ellipsoide1)
+ if not isHexa:
+ edgesBords = None # maillage sain hexa ==> filling, et maillage edges Bords imposés du maillage sain
- # --- faces 1/2 circulaires et edges dans le plan de fissure
- if step == 9:
- return None
+ # --- TORE
+ # --- faces toriques du tore
+ if step == 8:
+ break
- [faces, centres, edges, reverses] = facesCirculaires(extrusionDefaut, tore)
+ [facetore1, facetore2, _, _] = facesVolumesToriques(tore, plane1, facesDefaut)
- # --- recherche et classement des edges du tore par propagate
- if step == 10:
- return None
+ # --- faces 1/2 circulaires et edges dans le plan de fissure
+ if step == 9:
+ break
- [diams, circles, geners] = propagateTore(tore)
+ [faces, centres, edges, reverses] = facesCirculaires(extrusionDefaut, tore)
- # --- tri par longueur des 3 génératrices
- if step == 11:
- return None
+ # --- recherche et classement des edges du tore par propagate
+ if step == 10:
+ break
- [_, genint, gencnt] = sortGeneratrices(tore, geners)
+ [diams, circles, geners] = propagateTore(tore)
- # --- faces fissure dans et hors tore, et edges face hors tore
- if step == 12:
- return None
+ # --- tri par longueur des 3 génératrices
+ if step == 11:
+ break
- [_, facefissoutore, _, edgeext, reverext] = \
- facesFissure(ellipsoidep, faceFissure, extrusionDefaut, genint)
+ [_, genint, gencnt] = sortGeneratrices(tore, geners)
- # --- identification des faces tore et fissure dans le solide hors tore
- if step == 13:
- return None
+ # --- faces fissure dans et hors tore, et edges face hors tore
+ if step == 12:
+ break
- [_, _, _] = \
- facesToreInBloc(ellipsoidep, facefissoutore, facetore1, facetore2)
+ [_, facefissoutore, _, edgeext, reverext] = \
+ facesFissure(ellipsoidep, faceFissure, extrusionDefaut, genint)
- # --- identification des shapes modifiées par la duplication des noeuds de la face fissure (d'un coté de la face)
+ # --- identification des faces tore et fissure dans le solide hors tore
+ if step == 13:
+ break
- #shapesAModifier = self.shapesSurFissure(blocPartition, plane1 faceFissure, gencnt)
- if step == 14:
- return None
+ [_, _, _] = \
+ facesToreInBloc(ellipsoidep, facefissoutore, facetore1, facetore2)
- extrusionFaceFissure, _ = shapeSurFissure(plane1)
+ # --- identification des shapes modifiées par la duplication des noeuds de la face fissure (d'un coté de la face)
- # --- maillage du bloc partitionne
+ #shapesAModifier = self.shapesSurFissure(blocPartition, plane1 faceFissure, gencnt)
+ if step == 14:
+ break
- if step == 15:
- return None
+ extrusionFaceFissure, _ = shapeSurFissure(plane1)
- [_, blocComplet] = \
- meshBlocPart(blocPartition, faceFissure, tore, centres, edges, diams, circles, faces, \
- gencnt, facefissoutore, edgeext, facesExternes, facesExtBloc, facesExtElli, \
- aretesInternes, internalBoundary, ellipsoidep, sharedFaces, sharedEdges, edgesBords, \
- nbsegExt, nbsegGen, nbsegRad, scaleRad, reverses, reverext, nbsegCercle,
- nbsegFis, dmoyen, lensegEllipsoide) \
+ # --- maillage du bloc partitionne
- if step == 16:
- return None
- maillageSain = enleveDefaut(maillageSain, zoneDefaut, zoneDefaut_skin, zoneDefaut_internalFaces, zoneDefaut_internalEdges)
+ if step == 15:
+ break
- if step == 17:
- return None
- maillageComplet = RegroupeSainEtDefaut(maillageSain, blocComplet, extrusionFaceFissure, faceFissure, 'VOLUMES')
+ [_, blocComplet] = \
+ meshBlocPart(blocPartition, faceFissure, tore, centres, edges, diams, circles, faces, \
+ gencnt, facefissoutore, edgeext, facesExternes, facesExtBloc, facesExtElli, \
+ aretesInternes, internalBoundary, ellipsoidep, sharedFaces, sharedEdges, edgesBords, \
+ nbsegExt, nbsegGen, nbsegRad, scaleRad, reverses, reverext, nbsegCercle, \
+ nbsegFis, dmoyen, lensegEllipsoide)
+ if step == 16:
+ break
- if step == 18:
- return None
- maillageComplet.ExportMED(fichierMaillageFissure)
- putName(maillageComplet, nomFicFissure)
- logging.info("fichier maillage fissure : %s", fichierMaillageFissure)
+ maillageSain = enleveDefaut(maillageSain, zoneDefaut, zoneDefaut_skin, zoneDefaut_internalFaces, zoneDefaut_internalEdges)
+ if step == 17:
+ break
+
+ maillageComplet = RegroupeSainEtDefaut(maillageSain, blocComplet, extrusionFaceFissure, faceFissure, 'VOLUMES')
+ if step == 18:
+ break
+
+ maillageComplet.ExportMED(fichierMaillageFissure)
+ putName(maillageComplet, nomFicFissure)
+ logging.info("fichier maillage fissure : %s", fichierMaillageFissure)
+
+ break
if salome.sg.hasDesktop():
salome.sg.updateObjBrowser()
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2014-2021 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License, or (at your option) any later version.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""procédure complète fissure générale"""
-
-import os
-import math
-
-import logging
-from . import initLog
-
-import salome
-from salome.smesh import smeshBuilder
-import GEOM
-import SMESH
-
-from .geomsmesh import geompy
-from .geomsmesh import geomPublish
-from .geomsmesh import geomPublishInFather
-from .geomsmesh import smesh
-
-from .extractionOrientee import extractionOrientee
-from .extractionOrienteeMulti import extractionOrienteeMulti
-from .sortFaces import sortFaces
-from .sortEdges import sortEdges
-from .substractSubShapes import substractSubShapes
-from .produitMixte import produitMixte
-from .findWireEndVertices import findWireEndVertices
-from .findWireIntermediateVertices import findWireIntermediateVertices
-from .orderEdgesFromWire import orderEdgesFromWire
-from .putName import putName
-from .enleveDefaut import enleveDefaut
-from .shapeSurFissure import shapeSurFissure
-from .regroupeSainEtDefaut import RegroupeSainEtDefaut
-from .triedreBase import triedreBase
-from .checkDecoupePartition import checkDecoupePartition
-from .whichSide import whichSide
-from .whichSideVertex import whichSideVertex
-from .projettePointSurCourbe import projettePointSurCourbe
-from .prolongeWire import prolongeWire
-
-def insereFissureGenerale(maillagesSains,
- shapesFissure, shapeFissureParams,
- maillageFissureParams, elementsDefaut, \
- step=-1, mailleur="MeshGems"):
- """ 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 'lenSegPipe' in shapeFissureParams:
- lenSegPipe = shapeFissureParams['lenSegPipe']
- else:
- lenSegPipe = rayonPipe
-
- nomRep = maillageFissureParams['nomRep']
- nomFicSain = maillageFissureParams['nomFicSain']
- nomFicFissure = maillageFissureParams['nomFicFissure']
-
- nbsegRad = maillageFissureParams['nbsegRad'] # nombre de couches selon un rayon du pipe
- nbsegCercle = maillageFissureParams['nbsegCercle'] # nombre de secteur dans un cercle du pipe
- areteFaceFissure = maillageFissureParams['areteFaceFissure']
-
- pointIn_x = 0.0
- pointIn_y = 0.0
- pointIn_z = 0.0
- isPointInterne = False
- if 'pointIn_x' in shapeFissureParams:
- pointIn_x = shapeFissureParams['pointIn_x']
- isPointInterne = True
- if 'pointIn_y' in shapeFissureParams:
- pointIn_y = shapeFissureParams['pointIn_y']
- isPointInterne = True
- if 'pointIn_z' in shapeFissureParams:
- pointIn_z = shapeFissureParams['pointIn_z']
- isPointInterne = True
- if isPointInterne:
- pointInterne = geompy.MakeVertex(pointIn_x, pointIn_y, pointIn_z)
-
- #fichierMaillageSain = os.path.join(nomRep, '{}.med'.format(nomFicSain))
- fichierMaillageFissure = os.path.join(nomRep, '{}.med'.format(nomFicFissure))
-
- # fillings des faces en peau
- facesDefaut = elementsDefaut[0]
- #centresDefaut = elementsDefaut[1]
- #normalsDefaut = elementsDefaut[2]
- #extrusionsDefaut = elementsDefaut[3]
- dmoyen = elementsDefaut[4]
- bordsPartages = elementsDefaut[5]
- #fillconts = elementsDefaut[6]
- #idFilToCont = elementsDefaut[7]
- maillageSain = elementsDefaut[8]
- internalBoundary = elementsDefaut[9]
- zoneDefaut = elementsDefaut[10]
- zoneDefaut_skin = elementsDefaut[11]
- zoneDefaut_internalFaces = elementsDefaut[12]
- zoneDefaut_internalEdges = elementsDefaut[13]
- #edgeFondExt = elementsDefaut[14]
- centreFondFiss = elementsDefaut[15]
- tgtCentre = elementsDefaut[16]
-
- # --- restriction de la face de fissure au domaine solide :
- # partition face fissure étendue par fillings, on garde la plus grande face
-
- partShapeDefaut = geompy.MakePartition([shapeDefaut], facesDefaut, list(), list(), geompy.ShapeType["FACE"], 0, [], 0)
- geomPublish(initLog.debug, partShapeDefaut, 'partShapeDefaut')
- facesPartShapeDefaut = geompy.ExtractShapes(partShapeDefaut, geompy.ShapeType["FACE"], False)
- if isPointInterne:
- distfaces = [(geompy.MinDistance(face,pointInterne), i, face) for i, face in enumerate(facesPartShapeDefaut)]
- distfaces.sort()
- logging.debug("selection de la face la plus proche du point interne, distance=%s",distfaces[0][0])
- facesPortFissure = distfaces[0][2]
- else:
- facesPartShapeDefautSorted, minSurf, maxSurf = sortFaces(facesPartShapeDefaut) # la face de fissure dans le volume doit être la plus grande
- logging.debug("surfaces faces fissure étendue, min %s, max %s", minSurf, maxSurf)
- facesPortFissure = facesPartShapeDefautSorted[-1] #= global
-
- geomPublish(initLog.debug, facesPortFissure, "facesPortFissure")
-
- O, _, _, _ = triedreBase()
-
- # -----------------------------------------------------------------------------
- # --- pipe de fond de fissure, prolongé, partition face fissure par pipe
- # identification des edges communes pipe et face fissure
-
- if geompy.NumberOfFaces(shapeDefaut) == 1:
- plan = geompy.MakePlane(centreFondFiss, tgtCentre, 10000)
- shapeDefaut = geompy.MakePartition([shapeDefaut], [plan], [], [], geompy.ShapeType["FACE"], 0, [], 0) #= local
- #fondFissCoupe = geompy.GetInPlaceByHistory(shapeDefaut, fondFiss) #= inutile
- geomPublish(initLog.debug, shapeDefaut, 'shapeDefaut_coupe')
- #geomPublishInFather(initLog.debug,shapeDefaut, fondFissCoupe, 'fondFiss_coupe')
-
- extrem, norms = findWireEndVertices(fondFiss, True)
- logging.debug("extrem: %s, norm: %s",extrem, norms)
- cercle = geompy.MakeCircle(extrem[0], norms[0], rayonPipe)
- cercle = geompy.MakeRotation(cercle, norms[0], math.pi/3.0 ) # éviter d'avoir l'arête de couture du pipe presque confondue avec la face fissure
- geomPublish(initLog.debug, cercle, 'cercle')
- fondFissProlonge = prolongeWire(fondFiss, extrem, norms, 2*rayonPipe)
- pipeFiss = geompy.MakePipe(cercle, fondFissProlonge)
- geomPublish(initLog.debug, pipeFiss, 'pipeFiss')
- partFissPipe = geompy.MakePartition([shapeDefaut, pipeFiss], [], [], [], geompy.ShapeType["FACE"], 0, [], 1)
- geomPublish(initLog.debug, partFissPipe, 'partFissPipe')
- fissPipe = geompy.GetInPlaceByHistory(partFissPipe, shapeDefaut) #= global
- geomPublish(initLog.debug, fissPipe, 'fissPipe')
- partPipe = geompy.GetInPlaceByHistory(partFissPipe, pipeFiss) #= local
- geomPublish(initLog.debug, partPipe, 'partPipe')
-
- edgesPipeFiss = geompy.GetSharedShapesMulti([fissPipe, partPipe], geompy.ShapeType["EDGE"]) #= global
- for i, edge in enumerate(edgesPipeFiss):
- name = "edgePipe%d"%i
- geomPublishInFather(initLog.debug,fissPipe, edge, name)
- try:
- wirePipeFiss = geompy.MakeWire(edgesPipeFiss) #= global
- except:
- wirePipeFiss = geompy.MakeCompound(edgesPipeFiss)
- logging.debug("wirePipeFiss construit sous forme de compound")
- geomPublish(initLog.debug, wirePipeFiss, "wirePipeFiss")
-
- wireFondFiss = geompy.GetInPlace(partFissPipe,fondFiss)
- edgesFondFiss = geompy.GetSharedShapesMulti([fissPipe, wireFondFiss], geompy.ShapeType["EDGE"])
- for i, edge in enumerate(edgesFondFiss):
- name = "edgeFondFiss%d"%i
- geomPublishInFather(initLog.debug,fissPipe, edge, name)
- wireFondFiss = geompy.MakeWire(edgesFondFiss) #= global
- geomPublish(initLog.debug, wireFondFiss,"wireFondFiss")
-
- # -----------------------------------------------------------------------------
- # --- peau et face de fissure
- #
- # --- partition peau défaut - face de fissure prolongée - wire de fond de fissure prolongée
- # il peut y avoir plusieurs faces externes, dont certaines sont découpées par la fissure
- # liste de faces externes : facesDefaut
- # liste de partitions face externe - fissure : partitionPeauFissFond (None quand pas d'intersection)
-
- partitionsPeauFissFond = list() #= global
- ipart = 0
- for filling in facesDefaut:
- part = geompy.MakePartition([fissPipe, filling], list(), list(), list(), geompy.ShapeType["FACE"], 0, list(), 0)
- isPart = checkDecoupePartition([fissPipe, filling], part)
- if isPart: # on recrée la partition avec toutes les faces filling en outil pour avoir une face de fissure correcte
- otherFD = [fd for fd in facesDefaut if fd != filling]
- if len(otherFD) > 0:
- fissPipePart = geompy.MakePartition([fissPipe], otherFD, list(), list(), geompy.ShapeType["FACE"], 0, list(), 0)
- else:
- fissPipePart = fissPipe
- part = geompy.MakePartition([fissPipePart, filling], list(), list(), list(), geompy.ShapeType["FACE"], 0, list(), 0)
- partitionsPeauFissFond.append(part)
- geomPublish(initLog.debug, part, 'partitionPeauFissFond%d'%ipart )
- else:
- partitionsPeauFissFond.append(None)
- ipart = ipart +1
-
-
- # --- arêtes vives détectées (dans quadranglesToShapeNoCorner
- # et quadranglesToShapeWithCorner)
-
- aretesVives = list()
- aretesVivesCoupees = list() #= global
- ia = 0
- for a in bordsPartages:
- if not isinstance(a, list):
- aretesVives.append(a)
- name = "areteVive%d"%ia
- geomPublish(initLog.debug, a, name)
- ia += 1
- else:
- if a[0] is not None:
- aretesVives.append(a[0])
- name = "areteVive%d"%ia
- geomPublish(initLog.debug, a[0], name)
- ia += 1
-
- aretesVivesC = None #= global
- if len(aretesVives) > 0:
- aretesVivesC =geompy.MakeCompound(aretesVives)
-
- # -------------------------------------------------------
- # --- inventaire des faces de peau coupées par la fissure
- # pour chaque face de peau : 0, 1 ou 2 faces débouchante du fond de fissure
- # 0, 1 ou plus edges de la face de fissure externe au pipe
-
- nbFacesFilling = len(partitionsPeauFissFond)
- ptEdgeFond = [ list() for i in range(nbFacesFilling)] # pour chaque face [points edge fond de fissure aux débouchés du pipe]
- fsPipePeau = [ list() for i in range(nbFacesFilling)] # pour chaque face [faces du pipe débouchantes]
- edRadFPiPo = [ list() for i in range(nbFacesFilling)] # pour chaque face [edge radiale des faces du pipe débouchantes ]
- fsFissuExt = [ list() for i in range(nbFacesFilling)] # pour chaque face [faces de fissure externes au pipe]
- edFisExtPe = [ list() for i in range(nbFacesFilling)] # pour chaque face [edge en peau des faces de fissure externes (pas subshape facePeau)]
- edFisExtPi = [ list() for i in range(nbFacesFilling)] # pour chaque face [edge commun au pipe des faces de fissure externes]
- facesPeaux = [None for i in range(nbFacesFilling)] # pour chaque face : la face de peau finale a mailler (percée des faces débouchantes)
- edCircPeau = [ list() for i in range(nbFacesFilling)] # pour chaque face de peau : [subshape edge circulaire aux débouchés du pipe]
- ptCircPeau = [ list() for i in range(nbFacesFilling)] # pour chaque face de peau : [subshape point sur edge circulaire aux débouchés du pipe]
- gpedgeBord = [None for i in range(nbFacesFilling)] # pour chaque face de peau : groupe subshape des edges aux bords liés à la partie saine
- gpedgeVifs = [None for i in range(nbFacesFilling)] # pour chaque face de peau : groupes subshape des edges aux arêtes vives entre fillings
- edFissPeau = [ list() for i in range(nbFacesFilling)] # pour chaque face de peau : [subshape edge en peau des faces de fissure externes]
- ptFisExtPi = [ list() for i in range(nbFacesFilling)] # pour chaque face de peau : [point commun edFissPeau edCircPeau]
-
- for ifil, partitionPeauFissFond in enumerate(partitionsPeauFissFond):
- if partitionPeauFissFond is not None:
- fillingFaceExterne = facesDefaut[ifil]
- #fillingSansDecoupe = fillconts[idFilToCont[ifil]]
- logging.debug("traitement partitionPeauFissFond %s", ifil)
- # -----------------------------------------------------------------------
- # --- identification edges fond de fissure, edges pipe sur la face de fissure,
- # edges prolongées
-
- edgesPipeC = geompy.GetInPlace(partitionPeauFissFond, geompy.MakeCompound(edgesPipeFiss)) #= local
- geomPublishInFather(initLog.debug,partitionPeauFissFond, edgesPipeC, "edgesPipeFiss")
- edgesFondC = geompy.GetInPlace(partitionPeauFissFond, geompy.MakeCompound(edgesFondFiss)) #= local
- geomPublishInFather(initLog.debug,partitionPeauFissFond, edgesFondC, "edgesFondFiss")
-
- if aretesVivesC is None: #= global facesInside facesOnside
- [edgesInside, _, _] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "EDGE", 1.e-3)
- [facesInside, _, facesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "FACE", 1.e-3)
- else:
- [edgesInside, _, _] = extractionOrienteeMulti(facesDefaut, ifil, partitionPeauFissFond, centreFondFiss, "EDGE", 1.e-3)
- [facesInside, _, facesOnside] = extractionOrienteeMulti(facesDefaut, ifil, partitionPeauFissFond, centreFondFiss, "FACE", 1.e-3)
-
- edgesPipeIn = geompy.GetSharedShapesMulti([edgesPipeC, geompy.MakeCompound(edgesInside)], geompy.ShapeType["EDGE"]) #= global
- verticesPipePeau = list() #= global
-
- for i, edge in enumerate(edgesPipeIn):
- try:
- vertices = geompy.GetSharedShapesMulti([edge, geompy.MakeCompound(facesOnside)], geompy.ShapeType["VERTEX"])
- verticesPipePeau.append(vertices[0])
- name = "edgePipeIn%d"%i
- geomPublishInFather(initLog.debug,partitionPeauFissFond, edge, name)
- name = "verticePipePeau%d"%i
- geomPublishInFather(initLog.debug,partitionPeauFissFond, vertices[0], name)
- logging.debug("edgePipeIn%s coupe les faces OnSide", i)
- except:
- logging.debug("edgePipeIn%s ne coupe pas les faces OnSide", i)
- #edgesFondOut = list() #= inutile
- edgesFondIn =list() #= global
- if len(verticesPipePeau) > 0: # au moins une extrémité du pipe sur cette face de peau
- #tmp = geompy.GetSharedShapesMulti([edgesFondC, geompy.MakeCompound(edgesOutside)], geompy.ShapeType["EDGE"])
- #edgesFondOut = [ ed for ed in tmp if geompy.MinDistance(ed, geompy.MakeCompound(facesOnside)) < 1.e-3]
- tmp = geompy.GetSharedShapesMulti([edgesFondC, geompy.MakeCompound(edgesInside)], geompy.ShapeType["EDGE"])
- edgesFondIn = [ ed for ed in tmp if geompy.MinDistance(ed, geompy.MakeCompound(facesOnside)) < 1.e-3]
-
- verticesEdgesFondIn = list() # les points du fond de fissure au débouché du pipe sur la peau (indice de edgesFondIn)
- pipexts = list() # les segments de pipe associés au points de fond de fissure débouchants (même indice)
- cercles = list() # les cercles de generation des pipes débouchant (même indice)
- facesFissExt = list() # les faces de la fissure externe associés au points de fond de fissure débouchants (même indice)
- edgesFissExtPeau = list() # edges des faces de fissure externe sur la peau (même indice)
- edgesFissExtPipe = list() # edges des faces de fissure externe sur le pipe (même indice)
- #logging.debug("edgesFondIn %s", edgesFondIn)
-
- edgesFondFiss, edgesIdByOrientation = orderEdgesFromWire(wireFondFiss)
- for i,edge in enumerate(edgesFondFiss):
- geomPublishInFather(initLog.debug,wireFondFiss, edge, "edgeFondFiss%d"%i)
-
- for iedf, edge in enumerate(edgesFondIn):
- name = "edgeFondIn%d"%iedf
- geomPublishInFather(initLog.debug,partitionPeauFissFond, edge, name)
- dist = [ geompy.MinDistance(pt, edge) for pt in verticesPipePeau]
- ptPeau = verticesPipePeau[dist.index(min(dist))] # le point de verticesPipePeau a distance minimale de l'edge
- [parametre, PointOnEdge, EdgeInWireIndex] = geompy.MakeProjectionOnWire(ptPeau, wireFondFiss)
- logging.debug("parametre:%s, EdgeInWireIndex: %s, len(edgesFondFiss): %s", parametre, EdgeInWireIndex, len(edgesFondFiss))
- localEdgeInFondFiss = edgesFondFiss[EdgeInWireIndex]
- centre = PointOnEdge
- centre2 = geompy.MakeVertexOnCurve(localEdgeInFondFiss, parametre)
- geomPublishInFather(initLog.debug,partitionPeauFissFond, centre2, "centre2_%d"%iedf)
- verticesEdgesFondIn.append(centre)
- name = "verticeEdgesFondIn%d"%iedf
- geomPublishInFather(initLog.debug,partitionPeauFissFond, centre, name)
- norm = geompy.MakeTangentOnCurve(localEdgeInFondFiss, parametre)
- geomPublishInFather(initLog.debug,partitionPeauFissFond, centre, "norm%d"%iedf)
- cercle = geompy.MakeCircle(centre, norm, rayonPipe)
- geomPublishInFather(initLog.debug,partitionPeauFissFond, cercle, "cerclorig%d"%iedf)
- [vertex] = geompy.ExtractShapes(cercle, geompy.ShapeType["VERTEX"], False)
- vec1 = geompy.MakeVector(centre, vertex)
- vec2 = geompy.MakeVector(centre, ptPeau)
- angle = geompy.GetAngleRadians(vec1, vec2)
- # cas général : on reconstitue une portion de pipe, avec l'arête de couture qui coincide
- # avec la face de fissure, au niveau du débouché sur la face externe
- # cas dégénéré : le pipe débouche perpendiculairement à une surface plane à l'origine.
- # La partition filling / pipe reconstruit échoue.
- # - Si on partitionne le filling avec un simple pipe obtenu par extrusion droite du cercle,
- # cela donne un point en trop sur le cercle.
- # - Si on prend une vraie surface plane (pas un filling), on peut faire la partition avec
- # les pipes reconstruits
- logging.debug("angle=%s", angle)
- #if abs(angle) > 1.e-7:
- sommetAxe = geompy.MakeTranslationVector(centre, norm)
- pm = produitMixte(centre, vertex, ptPeau, sommetAxe)
- if pm > 0: # ajout de pi a (-)angle pour éviter des points confondus (partition échoue) dans les cas dégénérés
- cercle = geompy.MakeRotation(cercle, norm, angle + math.pi)
- else:
- cercle = geompy.MakeRotation(cercle, norm, -angle + math.pi)
- name = "cercle%d"%iedf
- geomPublishInFather(initLog.debug,partitionPeauFissFond, cercle, name)
- cercles.append(cercle)
-
- # --- estimation de la longueur du pipe necessaire de part et d'autre du point de sortie
- if aretesVivesC is None:
- faceTestPeau = fillingFaceExterne
- else:
- faceTestPeau = facesDefaut[ifil]
- sideCentre = whichSide(faceTestPeau, centre)
- locPt0 = geompy.MakeVertexOnCurve(localEdgeInFondFiss, 0.0)
- locPt1 = geompy.MakeVertexOnCurve(localEdgeInFondFiss, 1.0)
- sidePt0 = whichSide(faceTestPeau, locPt0)
- sidePt1 = whichSide(faceTestPeau, locPt1)
- logging.debug("position centre cercle: %s, extremité edge u0: %s, u1: %s", sideCentre, sidePt0, sidePt1)
- normFace = geompy.GetNormal(faceTestPeau, ptPeau)
- inclPipe = abs(geompy.GetAngleRadians(norm, normFace))
- lgp = max(rayonPipe/2., abs(3*rayonPipe*math.tan(inclPipe)))
- logging.debug("angle inclinaison Pipe en sortie: %s degres, lgp: %s", inclPipe*180/math.pi, lgp)
-
- # --- position des points extremite du pipe sur l'edge debouchante
- # il faut la distance curviligne ofp du point central par rapport à une extrémité de l'edge débouchante
- locEdgePart = geompy.MakePartition([localEdgeInFondFiss],[centre], list(), list(), geompy.ShapeType["EDGE"], 0, list(), 0)
- edgesLoc = geompy.ExtractShapes(locEdgePart, geompy.ShapeType["EDGE"], False)
- edgesLocSorted =[(geompy.MinDistance(edge, locPt0), kk, edge) for kk, edge in enumerate(edgesLoc)]
- edgesLocSorted.sort()
- ofp = geompy.BasicProperties(edgesLocSorted[0][2])[0] # distance curviligne centre locPt0
- logging.debug("distance curviligne centre extremite0: %s", ofp)
- p1 = geompy.MakeVertexOnCurveByLength(localEdgeInFondFiss, ofp +lgp, locPt0)
- p2 = geompy.MakeVertexOnCurveByLength(localEdgeInFondFiss, ofp -lgp, locPt0)
- geomPublishInFather(initLog.debug,wireFondFiss, p1, "p1_%d"%iedf)
- geomPublishInFather(initLog.debug,wireFondFiss, p2, "p2_%d"%iedf)
-
- edgePart = geompy.MakePartition([localEdgeInFondFiss], [p1,p2], list(), list(), geompy.ShapeType["EDGE"], 0, list(), 0)
- edps = geompy.ExtractShapes(edgePart, geompy.ShapeType["EDGE"], True)
- for edp in edps:
- if geompy.MinDistance(centre, edp) < 1.e-3:
- pipext = geompy.MakePipe(cercle, edp)
- name = "pipeExt%d"%iedf
- geomPublishInFather(initLog.debug,partitionPeauFissFond, pipext, name)
- pipexts.append(pipext)
-
- for face in facesInside:
- logging.debug("recherche edges communes entre une face inside et (faces onside, edges pipe et fond débouchante)")
- edgesPeauFis = list()
- edgesPipeFis = list()
- edgesPipeFnd = list()
- try:
- edgesPeauFis = geompy.GetSharedShapesMulti([geompy.MakeCompound(facesOnside), face], geompy.ShapeType["EDGE"])
- logging.debug(" faces onside %s",edgesPeauFis)
- edgesPipeFis = geompy.GetSharedShapesMulti([geompy.MakeCompound(edgesPipeIn), face], geompy.ShapeType["EDGE"])
- logging.debug(" edgesPipeIn %s", edgesPipeFis)
- edgesPipeFnd = geompy.GetSharedShapesMulti([geompy.MakeCompound(edgesFondIn), face], geompy.ShapeType["EDGE"])
- logging.debug(" edgesFondIn %s ", edgesPipeFnd)
- except:
- logging.debug(" pb edges communes %s %s %s",edgesPeauFis, edgesPipeFis, edgesPipeFnd)
- if (len(edgesPeauFis) > 0) and (len(edgesPipeFis) > 0) and (len(edgesPipeFnd) == 0):
- dist = geompy.MinDistance(geompy.MakeCompound(edgesPeauFis), ptPeau)
- logging.debug(" test distance extrémité reference %s", dist)
- if dist < 1.e-3: # c'est la face de fissure externe associée
- logging.debug(" face %s inside ajoutée", i)
- facesFissExt.append(face)
- name="faceFissExt%d"%iedf
- geomPublishInFather(initLog.debug,partitionPeauFissFond, face, name)
- dist = 1.
- for _, edpe in enumerate(edgesPeauFis):
- for _, edpi in enumerate(edgesPipeFis):
- dist = geompy.MinDistance(edpe, edpi)
- if dist < 1.e-3:
- edgesFissExtPeau.append(edpe)
- name="edgesFissExtPeau%d"%iedf
- geomPublishInFather(initLog.debug,partitionPeauFissFond, edpe, name)
- edgesFissExtPipe.append(edpi)
- name="edgesFissExtPipe%d"%iedf
- geomPublishInFather(initLog.debug,partitionPeauFissFond, edpi, name)
- break
- if dist < 1.e-3:
- break
-
- if len(verticesPipePeau) == 0: # aucune extrémité du pipe sur cette face de peau
- # il faut recenser les edges de fissure sur la face de peau
- j = 0
- for face in facesInside:
- edgesPeauFis = list()
- edgesPipeFis = list()
- edgesPipeFnd = list()
- try:
- edgesPeauFis = geompy.GetSharedShapesMulti([geompy.MakeCompound(facesOnside), face], geompy.ShapeType["EDGE"])
- edgesPipeFis = geompy.GetSharedShapesMulti([geompy.MakeCompound(edgesPipeIn), face], geompy.ShapeType["EDGE"])
- edgesPipeFnd = geompy.GetSharedShapesMulti([geompy.MakeCompound(edgesFondIn), face], geompy.ShapeType["EDGE"])
- except:
- pass
- if (len(edgesPeauFis) > 0) and (len(edgesPipeFis) > 0) and (len(edgesPipeFnd) == 0):
- edgesFissExtPeau.append(edgesPeauFis[0])
- name="edgesFissExtPeau%d"%j
- geomPublishInFather(initLog.debug,partitionPeauFissFond, edgesPeauFis[0], name)
- j += 1
-
- # -----------------------------------------------------------------------
- # --- identification faces de peau : face de peau percée du pipe, extrémités du pipe
- # La partition avec le pipe peut créer un vertex (et un edge) de trop sur le cercle projeté,
- # quand le cercle est très proche de la face.
- # dans ce cas, la projection du cercle sur la face suivie d'une partition permet
- # d'éviter le point en trop
-
- facesAndFond = facesOnside
- facesAndFond.append(wireFondFiss)
- try:
- partitionPeauByPipe = geompy.MakePartition(facesAndFond, pipexts, list(), list(), geompy.ShapeType["FACE"], 0, list(), 1)
- except:
- logging.debug("probleme partition face pipe, contournement avec MakeSection")
- sections = list()
- for pipext in pipexts:
- sections.append(geompy.MakeSection(facesOnside[0], pipext))
- partitionPeauByPipe = geompy.MakePartition(facesAndFond, sections, list(), list(), geompy.ShapeType["FACE"], 0, list(), 1)
-
- # contrôle edge en trop sur edges circulaires
- if len(verticesPipePeau) > 0: # --- au moins une extrémité du pipe sur cette face de peau
- edgeEnTrop = list()
- outilPart = pipexts
- facesPeau = geompy.ExtractShapes(partitionPeauByPipe, geompy.ShapeType["FACE"], False)
- facesPeauSorted, _, _ = sortFaces(facesPeau)
- for i, face in enumerate(facesPeauSorted[:-1]): # on ne teste que la ou les petites faces "circulaires"
- nbv = geompy.NumberOfEdges(face)
- logging.debug("nombre d'edges sur face circulaire: %s", nbv)
- if nbv > 3:
- edgeEnTrop.append(True) # TODO : distinguer les cas avec deux faces circulaires dont l'une est correcte
- else:
- edgeEnTrop.append(False)
- refaire = sum(edgeEnTrop)
- if refaire > 0:
- dc = [(geompy.MinDistance(verticesEdgesFondIn[0], fac), i) for i, fac in enumerate(facesPeauSorted[:-1])]
- dc.sort()
- logging.debug("dc sorted: %s", dc)
- i0 = dc[0][1] # indice de facesPeauSorted qui correspond à verticesEdgesFondIn[0], donc 0 pour cercles
- direct = (i0 == 0)
- for i, bad in enumerate(edgeEnTrop):
- if direct:
- j = i
- else:
- j = 1-i
- if bad:
- outilPart[j] = geompy.MakeProjection(cercles[j],facesOnside[0])
- partitionPeauByPipe = geompy.MakePartition(facesAndFond, outilPart, list(), list(), geompy.ShapeType["FACE"], 0, list(), 1)
-
- name="partitionPeauByPipe%d"%ifil
- geomPublish(initLog.debug, partitionPeauByPipe, name)
- [edgesPeauFondIn, _, _] = extractionOrientee(fillingFaceExterne, partitionPeauByPipe, centreFondFiss, "EDGE", 1.e-3)
- [_, _, facesPeauFondOn] = extractionOrientee(fillingFaceExterne, partitionPeauByPipe, centreFondFiss, "FACE", 1.e-3)
-
- if len(verticesPipePeau) > 0: # --- au moins une extrémité du pipe sur cette face de peau
- facesPeauSorted, _, _ = sortFaces(facesPeauFondOn)
- facePeau = facesPeauSorted[-1] # la plus grande face
- else:
- facePeau =geompy.MakePartition(facesPeauFondOn, list(), list(), list(), geompy.ShapeType["FACE"], 0, list(), 1)
- name="facePeau%d"%ifil
- geomPublish(initLog.debug, facePeau, name)
-
- facesPipePeau = [None for i in range(len(edgesFissExtPipe))]
- endsEdgeFond = [None for i in range(len(edgesFissExtPipe))]
- edgeRadFacePipePeau = [None for i in range(len(edgesFissExtPipe))]
-
- edgesListees = list()
- edgesCircPeau = list()
- verticesCircPeau = list()
- if len(verticesPipePeau) > 0: # --- au moins une extrémité du pipe sur cette face de peau
-
- for face in facesPeauSorted[:-1]: # la ou les faces débouchantes, pas la grande face de peau
- logging.debug("examen face debouchante circulaire")
- for i,efep in enumerate(edgesFissExtPipe):
- dist = geompy.MinDistance(face, efep)
- logging.debug(" distance face circulaire edge %s", dist)
- if dist < 1e-3:
- for ik, edpfi in enumerate(edgesPeauFondIn):
- if geompy.MinDistance(face, edpfi) < 1e-3:
- ikok = ik
- break
- sharedVertices = geompy.GetSharedShapesMulti([face, edgesPeauFondIn[ikok]], geompy.ShapeType["VERTEX"])
- nameFace = "facePipePeau%d"%i
- nameVert = "endEdgeFond%d"%i
- nameEdge = "edgeRadFacePipePeau%d"%i
- facesPipePeau[i] = face
- endsEdgeFond[i] = sharedVertices[0]
- geomPublish(initLog.debug, face, nameFace)
- geomPublish(initLog.debug, sharedVertices[0], nameVert)
- edgesFace = geompy.ExtractShapes(face, geompy.ShapeType["EDGE"], True)
- for edge in edgesFace:
- if geompy.MinDistance(edge, sharedVertices[0]) < 1e-3:
- edgeRadFacePipePeau[i] = edge
- geomPublish(initLog.debug, edge, nameEdge)
- break
-
- # --- edges circulaires de la face de peau et points de jonction de la face externe de fissure
- logging.debug("facesPipePeau: %s", facesPipePeau)
- edgesCircPeau = [None for i in range(len(facesPipePeau))]
- verticesCircPeau = [None for i in range(len(facesPipePeau))]
- for i,fcirc in enumerate(facesPipePeau):
- edges = geompy.GetSharedShapesMulti([facePeau, fcirc], geompy.ShapeType["EDGE"])
- grpEdgesCirc = geompy.CreateGroup(facePeau, geompy.ShapeType["EDGE"])
- geompy.UnionList(grpEdgesCirc, edges)
- edgesCircPeau[i] = grpEdgesCirc
- name = "edgeCirc%d"%i
- geomPublishInFather(initLog.debug,facePeau, grpEdgesCirc, name)
- edgesListees = edgesListees + edges
- vertices = geompy.GetSharedShapesMulti([facePeau, fcirc], geompy.ShapeType["VERTEX"])
- grpVertCircPeau = geompy.CreateGroup(facePeau, geompy.ShapeType["VERTEX"])
- geompy.UnionList(grpVertCircPeau, vertices)
- verticesCircPeau[i] = grpVertCircPeau
- name = "pointEdgeCirc%d"%i
- geomPublishInFather(initLog.debug,facePeau, grpVertCircPeau, name)
- # --- au moins une extrémité du pipe sur cette face de peau
-
- # --- edges de bord de la face de peau
-
- edgesFilling = geompy.ExtractShapes(fillingFaceExterne, geompy.ShapeType["EDGE"], False)
- edgesBords = list()
- for i, edge in enumerate(edgesFilling):
- edgepeau = geompy.GetInPlace(facePeau, edge)
- name = "edgepeau%d"%i
- geomPublishInFather(initLog.debug,facePeau,edgepeau, name)
- logging.debug("edgepeau %s", geompy.ShapeInfo(edgepeau))
- if geompy.ShapeInfo(edgepeau)['EDGE'] > 1:
- logging.debug(" EDGES multiples")
- edgs = geompy.ExtractShapes(edgepeau, geompy.ShapeType["EDGE"], False)
- edgesBords += edgs
- edgesListees += edgs
- else:
- logging.debug(" EDGE")
- edgesBords.append(edgepeau)
- edgesListees.append(edgepeau)
- groupEdgesBordPeau = geompy.CreateGroup(facePeau, geompy.ShapeType["EDGE"])
- geompy.UnionList(groupEdgesBordPeau, edgesBords)
- bordsVifs = None
- if aretesVivesC is not None:
- bordsVifs = geompy.GetInPlace(facePeau, aretesVivesC)
- if bordsVifs is not None:
- geomPublishInFather(initLog.debug,facePeau, bordsVifs, "bordsVifs")
- groupEdgesBordPeau = geompy.CutGroups(groupEdgesBordPeau, bordsVifs)
- grptmp = None
- if len(aretesVivesCoupees) > 0:
- grpC = geompy.MakeCompound(aretesVivesCoupees)
- grptmp = geompy.GetInPlace(facePeau, grpC)
- if grptmp is not None:
- grpnew = geompy.CutGroups(bordsVifs, grptmp) # ce qui est nouveau dans bordsVifs
- else:
- grpnew = bordsVifs
- if grpnew is not None:
- edv = geompy.ExtractShapes(grpnew, geompy.ShapeType["EDGE"], False)
- aretesVivesCoupees += edv
- logging.debug("aretesVivesCoupees %s",aretesVivesCoupees)
- geomPublishInFather(initLog.debug,facePeau, groupEdgesBordPeau , "EdgesBords")
-
- # --- edges de la face de peau partagées avec la face de fissure
-
- edgesPeau = geompy.ExtractShapes(facePeau, geompy.ShapeType["EDGE"], False)
- edges = substractSubShapes(facePeau, edgesPeau, edgesListees)
- edgesFissurePeau = list()
- if len(verticesPipePeau) > 0: # --- au moins une extrémité du pipe sur cette face de peau
- edgesFissurePeau = [None for i in range(len(verticesCircPeau))] # edges associés aux extrémités du pipe, en premier
- for edge in edges:
- for i, grpVert in enumerate(verticesCircPeau):
- if (geompy.MinDistance(grpVert, edge) < 1.e-3) and (edge not in edgesFissurePeau):
- edgesFissurePeau[i] = edge
- name = "edgeFissurePeau%d"%i
- geomPublishInFather(initLog.debug,facePeau, edge, name)
- for edge in edges: # on ajoute après les edges manquantes
- if edge not in edgesFissurePeau:
- edgesFissurePeau.append(edge)
- else:
- for i, edge in enumerate(edges):
- edgesFissurePeau.append(edge)
- name = "edgeFissurePeau%d"%i
- geomPublishInFather(initLog.debug,facePeau, edge, name)
-
- ptEdgeFond[ifil] = endsEdgeFond # pour chaque face [points edge fond de fissure aux débouchés du pipe]
- fsPipePeau[ifil] = facesPipePeau # pour chaque face [faces du pipe débouchantes]
- edRadFPiPo[ifil] = edgeRadFacePipePeau # pour chaque face [edge radiale des faces du pipe débouchantes ]
- fsFissuExt[ifil] = facesFissExt # pour chaque face [faces de fissure externes au pipe]
- edFisExtPe[ifil] = edgesFissExtPeau # pour chaque face [edge en peau des faces de fissure externes (pas subshape facePeau)]
- edFisExtPi[ifil] = edgesFissExtPipe # pour chaque face [edge commun au pipe des faces de fissure externes]
- facesPeaux[ifil] = facePeau # pour chaque face : la face de peau finale a mailler (percee des faces débouchantes)
- edCircPeau[ifil] = edgesCircPeau # pour chaque face de peau : [groupe subshapes edges circulaires aux débouchés du pipe]
- ptCircPeau[ifil] = verticesCircPeau # pour chaque face de peau : [groupe subshapes points sur edges circulaires aux débouchés du pipe]
- gpedgeBord[ifil] = groupEdgesBordPeau # pour chaque face de peau : groupe subshape des edges aux bords liés à la partie saine
- gpedgeVifs[ifil] = bordsVifs # pour chaque face de peau : groupe subshape des edges aux bords correspondant à des arêtes vives
- edFissPeau[ifil] = edgesFissurePeau # pour chaque face de peau : [subshape edge en peau des faces de fissure externes]
- ptFisExtPi[ifil] = verticesPipePeau # pour chaque face de peau : [point commun edFissPeau edCircPeau]
-
- # -----------------------------------------------------------------------
- # fin de la boucle sur les faces de filling
- # -----------------------------------------------------------------------
-
- for i, avc in enumerate(aretesVivesCoupees):
- name = "areteViveCoupee%d"%i
- geomPublish(initLog.debug, avc, name)
-
- # --- identification des faces et edges de fissure externe pour maillage
-
- facesFissExt = list()
- edgesFissExtPeau = list()
- edgesFissExtPipe = list()
- for ifil in range(nbFacesFilling): # TODO: éliminer les doublons (comparer tous les vertices triés, avec mesure de distance ?)
- facesFissExt += fsFissuExt[ifil]
- edgesFissExtPeau += edFisExtPe[ifil]
- edgesFissExtPipe += edFisExtPi[ifil]
- logging.debug("---------------------------- identification faces de fissure externes au pipe :%s ", len(facesFissExt))
- # regroupement des faces de fissure externes au pipe.
-
- if len(facesFissExt) > 1:
- faceFissureExterne = geompy.MakePartition(facesFissExt, list(), list(), list(), geompy.ShapeType["FACE"], 0, list(), 0)
- edgesPipeFissureExterneC = geompy.GetInPlace(faceFissureExterne, geompy.MakeCompound(edgesPipeFiss)) # edgesFissExtPipe peut ne pas couvrir toute la longueur
- # edgesPeauFissureExterneC = geompy.GetInPlace(faceFissureExterne, geompy.MakeCompound(edgesFissExtPeau))
- # il peut manquer des edges de faceFissureExterne en contact avec la peau dans edgesFissExtPeau
- (_, closedFreeBoundaries, _) = geompy.GetFreeBoundary(faceFissureExterne)
- edgesBordFFE = list()
- for bound in closedFreeBoundaries:
- edgesBordFFE += geompy.ExtractShapes(bound, geompy.ShapeType["EDGE"], False)
- edgesBordFFEid = [ (ed,geompy.GetSubShapeID(faceFissureExterne, ed)) for ed in edgesBordFFE]
- logging.debug("edgesBordFFEid %s", edgesBordFFEid)
- edgesPPE = geompy.ExtractShapes(edgesPipeFissureExterneC, geompy.ShapeType["EDGE"], False)
- edgesPPEid = [ geompy.GetSubShapeID(faceFissureExterne, ed) for ed in edgesPPE]
- logging.debug("edgesPPEid %s", edgesPPEid)
- edgesPFE = [ edid[0] for edid in edgesBordFFEid if edid[1] not in edgesPPEid] # on garde toutes les edges de bord non en contact avec le pipe
- logging.debug("edgesPFE %s", edgesPFE)
- edgesPeauFissureExterneC = geompy.MakeCompound(edgesPFE)
- else:
- faceFissureExterne = facesFissExt[0]
- edgesPeauFissureExterneC = geompy.MakeCompound(edgesFissExtPeau)
- edgesPipeFissureExterneC = geompy.MakeCompound(edgesFissExtPipe)
- wirePipeFissureExterne = geompy.MakeWire(geompy.ExtractShapes(edgesPipeFissureExterneC, geompy.ShapeType["EDGE"], False))
- geomPublish(initLog.debug, faceFissureExterne, "faceFissureExterne")
- geomPublishInFather(initLog.debug,faceFissureExterne, edgesPeauFissureExterneC, "edgesPeauFissureExterne")
- geomPublishInFather(initLog.debug,faceFissureExterne, edgesPipeFissureExterneC, "edgesPipeFissureExterne")
-
- logging.debug("---------------------------- Preparation Maillage du Pipe --------------")
- # -----------------------------------------------------------------------
- # --- preparation maillage du pipe :
- # - détections des points a respecter : jonction des edges/faces constituant
- # la face de fissure externe au pipe
- # - points sur les edges de fond de fissure et edges pipe/face fissure,
- # - vecteurs tangents au fond de fissure (normal au disque maillé)
-
- # --- option de maillage selon le rayon de courbure du fond de fissure
- lenEdgeFondExt = 0
- for edff in edgesFondFiss:
- lenEdgeFondExt += geompy.BasicProperties(edff)[0]
-
- disfond = list()
- for filling in facesDefaut:
- disfond.append(geompy.MinDistance(centreFondFiss, filling))
- disfond.sort()
- rcourb = disfond[0]
- nbSegQuart = 5 # on veut 5 segments min sur un quart de cercle
- alpha = math.pi/(4*nbSegQuart)
- deflexion = rcourb*(1.0 -math.cos(alpha))
- lgmin = lenSegPipe*0.25
- lgmax = lenSegPipe*1.5
- logging.debug("rcourb: %s, lenFond:%s, deflexion: %s, lgmin: %s, lgmax: %s", rcourb, lenEdgeFondExt, deflexion, lgmin, lgmax)
-
- meshFondExt = smesh.Mesh(wireFondFiss)
- algo1d = meshFondExt.Segment()
- hypo1d = algo1d.Adaptive(lgmin, lgmax, deflexion) # a ajuster selon la profondeur de la fissure
-
- is_done = meshFondExt.Compute()
- text = "meshFondExt.Compute"
- if is_done:
- logging.info(text+" OK")
- else:
- text = "Erreur au calcul du maillage.\n" + text
- logging.info(text)
- raise Exception(text)
-
- ptGSdic = {} # dictionnaire [paramètre sur la courbe] --> point géométrique
- allNodeIds = meshFondExt.GetNodesId()
- for nodeId in allNodeIds:
- xyz = meshFondExt.GetNodeXYZ(nodeId)
- #logging.debug("nodeId %s, coords %s", nodeId, str(xyz))
- pt = geompy.MakeVertex(xyz[0], xyz[1], xyz[2])
- parametre, PointOnEdge, EdgeInWireIndex = geompy.MakeProjectionOnWire(pt, wireFondFiss) # parametre compris entre 0 et 1
- edgeOrder = edgesIdByOrientation[EdgeInWireIndex]
- ptGSdic[(edgeOrder, EdgeInWireIndex, parametre)] = pt
- #logging.debug("nodeId %s, parametre %s", nodeId, str(parametre))
- usort = sorted(ptGSdic)
- logging.debug("nombre de points obtenus par deflexion %s",len(usort))
-
- centres = list()
- origins = list()
- normals = list()
- for edu in usort:
- vertcx = ptGSdic[edu]
- norm = geompy.MakeTangentOnCurve(edgesFondFiss[edu[1]], edu[2])
- plan = geompy.MakePlane(vertcx, norm, 3*rayonPipe)
- part = geompy.MakePartition([plan], [wirePipeFiss], list(), list(), geompy.ShapeType["VERTEX"], 0, list(), 0)
- liste = geompy.ExtractShapes(part, geompy.ShapeType["VERTEX"], True)
- if len(liste) == 5: # 4 coins du plan plus intersection recherchée
- for point in liste:
- if geompy.MinDistance(point, vertcx) < 1.1*rayonPipe: # les quatre coins sont plus loin
- vertpx = point
- break
- centres.append(vertcx)
- origins.append(vertpx)
- normals.append(norm)
-# name = "vertcx%d"%i
-# geomPublishInFather(initLog.debug,wireFondFiss, vertcx, name)
-# name = "vertpx%d"%i
-# geomPublishInFather(initLog.debug,wireFondFiss, vertpx, name)
-# name = "plan%d"%i
-# geomPublishInFather(initLog.debug,wireFondFiss, plan, name)
-
- # --- maillage du pipe étendu, sans tenir compte de l'intersection avec la face de peau
-
- logging.debug("nbsegCercle %s", nbsegCercle)
-
- # -----------------------------------------------------------------------
- # --- points géométriques
-
- gptsdisks = list() # vertices géométrie de tous les disques
- raydisks = [list() for i in range(nbsegCercle)]
- for i, centres_i in enumerate(centres): # boucle sur les disques
- gptdsk = list() # vertices géométrie d'un disque
- vertcx = centres_i
- vertpx = origins[i]
- normal = normals[i]
- vec1 = geompy.MakeVector(vertcx, vertpx)
-
- points = [vertcx] # les points du rayon de référence
- for j in range(nbsegRad):
- pt = geompy.MakeTranslationVectorDistance(vertcx, vec1, (j+1)*float(rayonPipe)/nbsegRad)
- points.append(pt)
- gptdsk.append(points)
- pt = geompy.MakeTranslationVectorDistance(vertcx, vec1, 1.5*rayonPipe)
- rayon = geompy.MakeLineTwoPnt(vertcx, pt)
- raydisks[0].append(rayon)
-
- for k in range(nbsegCercle-1):
- angle = (k+1)*2*math.pi/nbsegCercle
- pts = [vertcx] # les points d'un rayon obtenu par rotation
- for j in range(nbsegRad):
- pt = geompy.MakeRotation(points[j+1], normal, angle)
- pts.append(pt)
- gptdsk.append(pts)
- ray = geompy.MakeRotation(rayon, normal, angle)
- raydisks[k+1].append(ray)
-
- gptsdisks.append(gptdsk)
-
- # -----------------------------------------------------------------------
- # --- recherche des points en trop (externes au volume à remailler)
- # - on associe chaque extrémité du pipe à une face filling
- # - on part des disques aux extrémités du pipe
- # - pour chaque disque, on prend les vertices de géométrie,
- # on marque leur position relative à la face.
- # - on s'arrete quand tous les noeuds sont dedans
-
- logging.debug("---------------------------- recherche des points du pipe a éliminer --------------")
-
- pt0 = centres[0]
- pt1 = centres[-1]
- idFillingFromBout = [None, None] # contiendra l'index du filling pour les extrémités 0 et 1
- for ifil in range(nbFacesFilling):
- for _, pt in enumerate(ptEdgeFond[ifil]): # il y a un ou deux points débouchant sur cette face
- if geompy.MinDistance(pt,pt0) < geompy.MinDistance(pt,pt1): # TODO: trouver plus fiable pour les cas tordus...
- idFillingFromBout[0] = ifil
- else:
- idFillingFromBout[1] = ifil
- logging.debug("association bouts du pipe - faces de filling: %s", idFillingFromBout)
-
- facesPipePeau = list()
- edgeRadFacePipePeau = list()
- for ifil in range(nbFacesFilling):
- facesPipePeau += fsPipePeau[ifil]
- edgeRadFacePipePeau += edRadFPiPo[ifil]
-
- logging.debug("recherche des disques de noeuds complètement internes")
- idisklim = list() # indices des premier et dernier disques internes
- idiskout = list() # indices des premier et dernier disques externes
- for bout in range(2):
- if bout == 0:
- idisk = -1
- inc = 1
- numout = -1
- else:
- idisk = len(gptsdisks)
- inc = -1
- numout = len(gptsdisks)
- inside = False
- outside = True
- while not inside:
- idisk = idisk + inc
- logging.debug("examen disque %s", idisk)
- gptdsk = gptsdisks[idisk]
- inside = True
- for k in range(nbsegCercle):
- points = gptdsk[k]
- for j, pt in enumerate(points):
- side = whichSideVertex(facesDefaut[idFillingFromBout[bout]], pt)
- if side < 0:
- if outside: # premier point detecté dedans
- outside = False
- numout = idisk -inc # le disque précédent était dehors
- else:
- inside = False # ce point est dehors
- if not inside and not outside:
- break
- idisklim.append(idisk) # premier et dernier disques internes
- idiskout.append(numout) # premier et dernier disques externes
-
- # --- listes de nappes radiales en filling à chaque extrémité débouchante
- facesDebouchantes = [False, False]
- idFacesDebouchantes = [-1, -1] # contiendra les indices des faces disque débouchantes (facesPipePeau)
- listNappes =list()
- for i, idisk in enumerate(idisklim):
- numout = idiskout[i]
- logging.debug("extremité %s, indices disques interne %s, externe %s",i, idisk, numout)
- nappes = list()
- if (idisk != 0) and (idisk != len(gptsdisks)-1): # si extrémité débouchante
- for k in range(nbsegCercle):
- if i == 0:
- iddeb = max(0, numout)
- idfin = max(iddeb+3,idisk+1) # il faut 3 rayons pour faire un filling qui suive le fond de fissure
- #logging.debug("extremité %s, indices retenus interne %s, externe %s",i, idfin, iddeb)
- comp = geompy.MakeCompound(raydisks[k][iddeb:idfin])
- name='compoundRay%d'%k
- geomPublish(initLog.debug, comp, name)
- else:
- idfin = min(len(gptsdisks), numout+1)
- iddeb = min(idfin-3, idisk) # il faut 3 rayons pour faire un filling qui suive le fond de fissure
- #logging.debug("extremité %s, indices retenus interne %s, externe %s",i, idfin, iddeb)
- comp = geompy.MakeCompound(raydisks[k][iddeb:idfin])
- name='compoundRay%d'%k
- geomPublish(initLog.debug, comp, name)
- nappe = geompy.MakeFilling(comp, 2, 5, 0.0001, 0.0001, 0, GEOM.FOM_Default)
- nappes.append(nappe)
- name='nappe%d'%k
- geomPublish(initLog.debug, nappe, name)
- facesDebouchantes[i] = True
- listNappes.append(nappes)
-
- # --- mise en correspondance avec les indices des faces disque débouchantes (facesPipePeau)
- for i, nappes in enumerate(listNappes):
- if facesDebouchantes[i]:
- for k, face in enumerate(facesPipePeau):
- edge = geompy.MakeSection(face, nappes[0])
- if geompy.NbShapes(edge, geompy.ShapeType["EDGE"]) > 0:
- idFacesDebouchantes[i] = k
- break
- logging.debug("idFacesDebouchantes: %s", idFacesDebouchantes)
-
- # --- construction des listes d'edges radiales sur chaque extrémité débouchante
- listEdges = list()
- for i, nappes in enumerate(listNappes):
- indice = idFacesDebouchantes[i] # indice de face débouchante (facesPipePeau)
- if indice < 0:
- listEdges.append(list())
- else:
- face = facesPipePeau[indice]
- edges = [edgeRadFacePipePeau[indice]]
- for k, nappe in enumerate(nappes):
- if k > 0:
- obj = geompy.MakeSection(face, nappes[k]) # normalement une edge, parfois un compound d'edges dont un tout petit
- edge = obj
- vs = geompy.ExtractShapes(obj, geompy.ShapeType["VERTEX"], False)
- if len(vs) > 2:
- eds = geompy.ExtractShapes(obj, geompy.ShapeType["EDGE"], False)
- [edsorted, _,maxl] = sortEdges(eds)
- edge = edsorted[-1]
- else:
- maxl = geompy.BasicProperties(edge)[0]
- if maxl < 0.01: # problème MakeSection
- logging.debug("problème MakeSection recherche edge radiale %s, longueur trop faible: %s, utilisation partition", k, maxl)
- partNappeFace = geompy.MakePartition([face, nappes[k]], list() , list(), list(), geompy.ShapeType["FACE"], 0, list(), 0)
- edps= geompy.ExtractShapes(partNappeFace, geompy.ShapeType["EDGE"], False)
- ednouv = list()
- for ii, ed in enumerate(edps):
- vxs = geompy.ExtractShapes(ed, geompy.ShapeType["VERTEX"], False)
- distx = [geompy.MinDistance(vx, face) for vx in vxs]
- distx += [geompy.MinDistance(vx, nappes[k]) for vx in vxs]
- dmax = max(distx)
- logging.debug(" dmax %s",dmax)
- if dmax < 0.01:
- ednouv.append(ed)
- logging.debug(" edges issues de la partition: %s", ednouv)
- for ii, ed in enumerate(ednouv):
- geomPublish(initLog.debug, ed, "ednouv%d"%ii)
- [edsorted, _,maxl] = sortEdges(ednouv)
- logging.debug(" longueur edge trouvée: %s", maxl)
- edge = edsorted[-1]
- edges.append(edge)
- name = 'edgeEndPipe%d'%k
- geomPublish(initLog.debug, edge, name)
- listEdges.append(edges)
-
- # --- création des points du maillage du pipe sur la face de peau
- for i, edges in enumerate(listEdges):
- indice = idFacesDebouchantes[i] # indice de face débouchante (facesPipePeau)
- if indice >= 0:
- gptdsk = list()
- if indice > 0: # indice vaut 0 ou 1
- indice = -1 # si indice vaut 1, on prend le dernier élément de la liste (1 ou 2 extrémités débouchent sur la face)
- centre = ptEdgeFond[idFillingFromBout[i]][indice]
- name = "centre%d"%indice
- geomPublish(initLog.debug, centre, name)
- vertPipePeau = ptFisExtPi[idFillingFromBout[i]][indice]
- geomPublishInFather(initLog.debug,centre, vertPipePeau, "vertPipePeau")
- grpsEdgesCirc = edCircPeau[idFillingFromBout[i]] # liste de groupes
- edgesCirc = list()
- for grpEdgesCirc in grpsEdgesCirc:
- edgesCirc += geompy.ExtractShapes(grpEdgesCirc, geompy.ShapeType["EDGE"], False)
- for k, edge in enumerate(edges):
- extrems = geompy.ExtractShapes(edge, geompy.ShapeType["VERTEX"], True)
- if geompy.MinDistance(centre, extrems[0]) < geompy.MinDistance(centre, extrems[1]):
- bout = extrems[1]
- else:
- bout = extrems[0]
- # ajustement du point extrémité (bout) sur l'edge circulaire en face de peau
- logging.debug("edgesCirc: %s", edgesCirc)
- distEdgeCirc = [(geompy.MinDistance(bout, edgeCirc), k2, edgeCirc) for k2, edgeCirc in enumerate(edgesCirc)]
- distEdgeCirc.sort()
- logging.debug("distEdgeCirc: %s", distEdgeCirc)
- u = projettePointSurCourbe(bout, distEdgeCirc[0][2])
- if (abs(u) < 0.02) or (abs(1-u) < 0.02): # les points très proches d'une extrémité doivent y être mis précisément.
- extrCircs = geompy.ExtractShapes(distEdgeCirc[0][2], geompy.ShapeType["VERTEX"], True)
- if geompy.MinDistance(bout, extrCircs[0]) < geompy.MinDistance(bout, extrCircs[1]):
- bout = extrCircs[0]
- else:
- bout = extrCircs[1]
- else:
- bout = geompy.MakeVertexOnCurve(distEdgeCirc[0][2], u)
- name ="bout%d"%k
- geomPublishInFather(initLog.debug,centre, bout, name)
- # enregistrement des points dans la structure
- points = list()
- for j in range(nbsegRad +1):
- u = j/float(nbsegRad)
- points.append(geompy.MakeVertexOnCurve(edge, u))
- if geompy.MinDistance(bout, points[0]) < geompy.MinDistance(centre, points[0]):
- points.reverse()
- points[0] = centre
- points[-1] = bout
- gptdsk.append(points)
- if i == 0:
- gptsdisks[idisklim[0] -1] = gptdsk
- idisklim[0] = idisklim[0] -1
- else:
- gptsdisks[idisklim[1] +1] = gptdsk
- idisklim[1] = idisklim[1] +1
-
- # --- ajustement precis des points sur edgesPipeFissureExterneC
-
- edgesPFE = geompy.ExtractShapes(edgesPipeFissureExterneC, geompy.ShapeType["EDGE"], False)
- verticesPFE, _ = findWireIntermediateVertices(wirePipeFissureExterne) # vertices intermédiaires (des points en trop dans ptsInWireFissExtPipe)
- idiskmin = idisklim[0] + 1 # on ne prend pas le disque sur la peau, déjà ajusté
- idiskmax = idisklim[1] # on ne prend pas le disque sur la peau, déjà ajusté
- idiskint = list()
- for vtx in verticesPFE:
- distPtVt = list()
- for idisk in range(idiskmin, idiskmax):
- gptdsk = gptsdisks[idisk]
- pt = gptdsk[0][-1] # le point sur l'edge de la fissure externe au pipe
- distPtVt.append((geompy.MinDistance(pt, vtx), idisk))
- distPtVt.sort()
- idiskint.append(distPtVt[0][1])
- gptsdisks[idiskint[-1]][0][-1] = vtx
- logging.debug("ajustement point sur edgePipeFissureExterne, vertex: %s %s", idiskint[-1], distPtVt[0][0])
- for idisk in range(idiskmin, idiskmax):
- if idisk in idiskint:
- break
- logging.debug("ajustement point sur edgePipeFissureExterne: %s", idisk)
- gptdsk = gptsdisks[idisk]
- pt = gptdsk[0][-1] # le point sur l'edge de la fissure externe au pipe
- distPtEd = [(geompy.MinDistance(pt, edgePFE), k, edgePFE) for k, edgePFE in enumerate(edgesPFE)]
- distPtEd.sort()
- edgePFE = distPtEd[0][2]
- u = projettePointSurCourbe(pt, edgePFE)
- ptproj = geompy.MakeVertexOnCurve(edgePFE, u)
- gptsdisks[idisk][0][-1] = ptproj
-
- # -----------------------------------------------------------------------
- # --- maillage effectif du pipe
-
- logging.debug("---------------------------- maillage effectif du pipe --------------")
- meshPipe = smesh.Mesh(None, "meshPipe")
- fondFissGroup = meshPipe.CreateEmptyGroup(SMESH.EDGE, "FONDFISS")
- nodesFondFissGroup = meshPipe.CreateEmptyGroup(SMESH.NODE, "nfondfis")
- faceFissGroup = meshPipe.CreateEmptyGroup(SMESH.FACE, "fisInPi")
- edgeFaceFissGroup = meshPipe.CreateEmptyGroup(SMESH.EDGE, "edgeFaceFiss")
- edgeCircPipe0Group = meshPipe.CreateEmptyGroup(SMESH.EDGE, "edgeCircPipe0")
- edgeCircPipe1Group = meshPipe.CreateEmptyGroup(SMESH.EDGE, "edgeCircPipe1")
- faceCircPipe0Group = meshPipe.CreateEmptyGroup(SMESH.FACE, "faceCircPipe0")
- faceCircPipe1Group = meshPipe.CreateEmptyGroup(SMESH.FACE, "faceCircPipe1")
- mptsdisks = list() # vertices maillage de tous les disques
- mEdges = list() # identifiants edges maillage fond de fissure
- mEdgeFaces = list() # identifiants edges maillage edge face de fissure externe
- mFaces = list() # identifiants faces maillage fissure
- mVols = list() # identifiants volumes maillage pipe
-
- mptdsk = list()
- for idisk in range(idisklim[0], idisklim[1]+1): # boucle sur les disques internes
-
- # -----------------------------------------------------------------------
- # --- points
-
- gptdsk = gptsdisks[idisk]
- if idisk > idisklim[0]:
- oldmpts = mptdsk
- mptdsk = list() # vertices maillage d'un disque
- for k in range(nbsegCercle):
- points = gptdsk[k]
- mptids = list()
- for j, pt in enumerate(points):
- if j == 0 and k > 0:
- indice = mptdsk[0][0]
- else:
- coords = geompy.PointCoordinates(pt)
- indice = meshPipe.AddNode(coords[0], coords[1], coords[2])
- mptids.append(indice)
- mptdsk.append(mptids)
- mptsdisks.append(mptdsk)
-
- # -----------------------------------------------------------------------
- # --- groupes edges cercles debouchants
-
- if idisk == idisklim[0]:
- pts = list()
- for k in range(nbsegCercle):
- pts.append(mptdsk[k][-1])
- edges = list()
- for k, pts_k in enumerate(pts):
- k1 = (k+1)%len(pts)
- idEdge = meshPipe.AddEdge([pts_k, pts[k1]])
- edges.append(idEdge)
- edgeCircPipe0Group.Add(edges)
-
- if idisk == idisklim[1]:
- pts = list()
- for k in range(nbsegCercle):
- pts.append(mptdsk[k][-1])
- edges = list()
- for k, pts_k in enumerate(pts):
- k1 = (k+1)%len(pts)
- idEdge = meshPipe.AddEdge([pts_k, pts[k1]])
- edges.append(idEdge)
- edgeCircPipe1Group.Add(edges)
-
- # -----------------------------------------------------------------------
- # --- groupes faces debouchantes
-
- if idisk == idisklim[0]:
- faces = list()
- for j in range(nbsegRad):
- for k in range(nbsegCercle):
- k1 = k+1
- if k == nbsegCercle-1:
- k1 = 0
- if j == 0:
- idf = meshPipe.AddFace([mptdsk[k][0], mptdsk[k][1], mptdsk[k1][1]]) # triangle
- else:
- idf = meshPipe.AddFace([mptdsk[k][j], mptdsk[k][j+1], mptdsk[k1][j+1], mptdsk[k1][j]]) # quadrangle
- faces.append(idf)
- faceCircPipe0Group.Add(faces)
-
- if idisk == idisklim[1]:
- faces = list()
- for j in range(nbsegRad):
- for k in range(nbsegCercle):
- k1 = k+1
- if k == nbsegCercle-1:
- k1 = 0
- if j == 0:
- idf = meshPipe.AddFace([mptdsk[k][0], mptdsk[k][1], mptdsk[k1][1]]) # triangle
- else:
- idf = meshPipe.AddFace([mptdsk[k][j], mptdsk[k][j+1], mptdsk[k1][j+1], mptdsk[k1][j]]) # quadrangle
- faces.append(idf)
- faceCircPipe1Group.Add(faces)
-
- # -----------------------------------------------------------------------
- # --- mailles volumiques, groupes noeuds et edges de fond de fissure, groupe de face de fissure
-
- if idisk == idisklim[0]:
- mEdges.append(0)
- mEdgeFaces.append(0)
- mFaces.append([0])
- mVols.append([[0]])
- nodesFondFissGroup.Add([mptdsk[0][0]])
- else:
- ide = meshPipe.AddEdge([oldmpts[0][0], mptdsk[0][0]])
- mEdges.append(ide)
- fondFissGroup.Add([ide])
- nodesFondFissGroup.Add([mptdsk[0][0]])
- ide2 = meshPipe.AddEdge([oldmpts[0][-1], mptdsk[0][-1]])
- mEdgeFaces.append(ide2)
- edgeFaceFissGroup.Add([ide2])
- idFaces = list()
- idVols = list()
-
- for j in range(nbsegRad):
- idf = meshPipe.AddFace([oldmpts[0][j], mptdsk[0][j], mptdsk[0][j+1], oldmpts[0][j+1]])
- faceFissGroup.Add([idf])
- idFaces.append(idf)
-
- idVolCercle = list()
- for k in range(nbsegCercle):
- k1 = k+1
- if k == nbsegCercle-1:
- k1 = 0
- if j == 0:
- idv = meshPipe.AddVolume([mptdsk[k][j], mptdsk[k][j+1], mptdsk[k1][j+1],
- oldmpts[k][j], oldmpts[k][j+1], oldmpts[k1][j+1]])
- else:
- idv = meshPipe.AddVolume([mptdsk[k][j], mptdsk[k][j+1], mptdsk[k1][j+1], mptdsk[k1][j],
- oldmpts[k][j], oldmpts[k][j+1], oldmpts[k1][j+1], oldmpts[k1][j]])
- idVolCercle.append(idv)
- idVols.append(idVolCercle)
-
- mFaces.append(idFaces)
- mVols.append(idVols)
-
- pipeFissGroup = meshPipe.CreateEmptyGroup( SMESH.VOLUME, 'PIPEFISS' )
- _ = pipeFissGroup.AddFrom( meshPipe.GetMesh() )
-
- _, _, _ = meshPipe.MakeBoundaryElements(SMESH.BND_2DFROM3D, "pipeBoundaries")
- edgesCircPipeGroup = [edgeCircPipe0Group, edgeCircPipe1Group]
-
- # --- fin du maillage du pipe
- # -----------------------------------------------------------------------
- # --- edges de bord, faces défaut à respecter
-
- _ = smesh.CreateFilterManager()
- _, internalBoundary, _NoneGroup = internalBoundary.MakeBoundaryElements( SMESH.BND_1DFROM2D, '', '', 0, [ ])
- criteres = list()
- unCritere = smesh.GetCriterion(SMESH.EDGE,SMESH.FT_FreeBorders,SMESH.FT_Undefined,0)
- criteres.append(unCritere)
- filtre = smesh.GetFilterFromCriteria(criteres)
- bordsLibres = internalBoundary.MakeGroupByFilter( 'bords', filtre )
- 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' )
- _ = skinFaces.AddFrom( internalBoundary.GetMesh() )
-
- # --- maillage des éventuelles arêtes vives entre faces reconstruites
-
- if aretesVivesCoupees:
-
- aretesVivesC = geompy.MakeCompound(aretesVivesCoupees)
- meshAretesVives = smesh.Mesh(aretesVivesC)
- algo1d = meshAretesVives.Segment()
- hypo1d = algo1d.LocalLength(dmoyen,list(),1e-07)
- putName(algo1d.GetSubMesh(), "aretesVives")
- putName(algo1d, "algo1d_aretesVives")
- putName(hypo1d, "hypo1d_aretesVives")
-
- is_done = meshAretesVives.Compute()
- text = "meshAretesVives.Compute"
- if is_done:
- logging.info(text+" OK")
- else:
- text = "Erreur au calcul du maillage.\n" + text
- logging.info(text)
- raise Exception(text)
- grpAretesVives = meshAretesVives.CreateEmptyGroup( SMESH.EDGE, 'grpAretesVives' )
- _ = grpAretesVives.AddFrom( meshAretesVives.GetMesh() )
-
- # -----------------------------------------------------------------------
- # --- maillage faces de fissure
-
- logging.debug("---------------------------- maillage faces de fissure externes au pipe :%s --------------", len(facesFissExt))
-
- meshFaceFiss = smesh.Mesh(faceFissureExterne)
- logging.info("Maillage avec %s", mailleur)
- if ( mailleur == "MeshGems"):
- algo2d = meshFaceFiss.Triangle(algo=smeshBuilder.MG_CADSurf)
- hypo2d = algo2d.Parameters()
- hypo2d.SetPhySize( areteFaceFissure )
- hypo2d.SetMinSize( rayonPipe/float(nbsegRad) )
- hypo2d.SetMaxSize( areteFaceFissure*3. )
- hypo2d.SetChordalError( areteFaceFissure*0.25 )
- hypo2d.SetVerbosity( 0 )
- else:
- algo2d = meshFaceFiss.Triangle(algo=smeshBuilder.NETGEN_1D2D)
- hypo2d = algo2d.Parameters()
- hypo2d.SetMaxSize( areteFaceFissure )
- hypo2d.SetSecondOrder( 0 )
- hypo2d.SetOptimize( 1 )
- hypo2d.SetFineness( 2 )
- hypo2d.SetMinSize( rayonPipe/float(nbsegRad) )
- hypo2d.SetQuadAllowed( 0 )
- putName(algo2d.GetSubMesh(), "faceFiss")
- 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")
-
- _ = meshFaceFiss.GroupOnGeom(faceFissureExterne, "fisOutPi", SMESH.FACE)
- grpEdgesPeauFissureExterne = meshFaceFiss.GroupOnGeom(edgesPeauFissureExterneC,'edgesPeauFissureExterne',SMESH.EDGE)
- _ = meshFaceFiss.GroupOnGeom(edgesPipeFissureExterneC,'edgesPipeFissureExterne',SMESH.EDGE)
-
- is_done = meshFaceFiss.Compute()
- text = "meshFaceFiss.Compute"
- if is_done:
- logging.info(text+" OK")
- else:
- text = "Erreur au calcul du maillage.\n" + text
- logging.info(text)
- raise Exception(text)
-
- # --- maillage faces de peau
-
- boutFromIfil = [None for i in range(nbFacesFilling)]
- if idFillingFromBout[0] != idFillingFromBout[1]: # repérage des extremites du pipe quand elles débouchent sur des faces différentes
- boutFromIfil[idFillingFromBout[0]] = 0
- boutFromIfil[idFillingFromBout[1]] = 1
-
- logging.debug("---------------------------- maillage faces de peau --------------")
- meshesFacesPeau = list()
- for ifil in range(nbFacesFilling):
- meshFacePeau = None
- if partitionsPeauFissFond[ifil] is None: # face de peau maillage sain intacte
-
- # --- edges de bord de la face de filling
- filling = facesDefaut[ifil]
- edgesFilling = geompy.ExtractShapes(filling, geompy.ShapeType["EDGE"], False)
- groupEdgesBordPeau = geompy.CreateGroup(filling, geompy.ShapeType["EDGE"])
- geompy.UnionList(groupEdgesBordPeau, edgesFilling)
- geomPublishInFather(initLog.debug,filling, groupEdgesBordPeau , "EdgesBords")
-
- meshFacePeau = smesh.Mesh(facesDefaut[ifil])
-
- algo1d = meshFacePeau.UseExisting1DElements(geom=groupEdgesBordPeau)
- hypo1d = algo1d.SourceEdges([ bordsLibres ],0,0)
- putName(algo1d.GetSubMesh(), "bordsLibres", ifil)
- 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)
-
- logging.info("Maillage avec %s", mailleur)
- if ( mailleur == "MeshGems"):
- algo2d = meshFacePeau.Triangle(algo=smeshBuilder.MG_CADSurf)
- hypo2d = algo2d.Parameters()
- hypo2d.SetPhySize( dmoyen )
- hypo2d.SetMinSize( rayonPipe/float(nbsegRad) )
- hypo2d.SetMaxSize( dmoyen*3. )
- hypo2d.SetChordalError( dmoyen*0.25 )
- hypo2d.SetVerbosity( 0 )
- else:
- algo2d = meshFacePeau.Triangle(algo=smeshBuilder.NETGEN_1D2D)
- hypo2d = algo2d.Parameters()
- hypo2d.SetMaxSize( dmoyen*0.75 )
- hypo2d.SetOptimize( 1 )
- hypo2d.SetFineness( 2 )
- hypo2d.SetMinSize( rayonPipe/float(nbsegRad) )
- hypo2d.SetQuadAllowed( 0 )
- putName(algo2d.GetSubMesh(), "facePeau", ifil)
- putName(algo2d, "algo2d_facePeau", ifil)
- putName(hypo2d, "hypo2d_facePeau", ifil)
-
- is_done = meshFacePeau.Compute()
- text = "meshFacePeau {} Compute".format(ifil)
- if is_done:
- logging.info(text+" OK")
- else:
- text = "Erreur au calcul du maillage.\n" + text
- logging.info(text)
- raise Exception(text)
-
- GroupFaces = meshFacePeau.CreateEmptyGroup( SMESH.FACE, "facePeau%d"%ifil )
- _ = GroupFaces.AddFrom( meshFacePeau.GetMesh() )
- meshesFacesPeau.append(meshFacePeau)
-
- # --- regroupement des maillages du défaut
-
- listMeshes = [internalBoundary.GetMesh(),
- meshPipe.GetMesh(),
- meshFaceFiss.GetMesh()]
- for mp in meshesFacesPeau:
- listMeshes.append(mp.GetMesh())
-
- meshBoiteDefaut = smesh.Concatenate(listMeshes, 1, 1, 1e-05,False)
- # pour aider l'algo hexa-tetra à ne pas mettre de pyramides à l'exterieur des volumes repliés sur eux-mêmes
- # on désigne les faces de peau en quadrangles par le groupe "skinFaces"
- group_faceFissOutPipe = None
- group_faceFissInPipe = None
- groups = meshBoiteDefaut.GetGroups()
- for grp in groups:
- if grp.GetType() == SMESH.FACE:
- #if "internalBoundary" in grp.GetName():
- # grp.SetName("skinFaces")
- if grp.GetName() == "fisOutPi":
- group_faceFissOutPipe = grp
- elif grp.GetName() == "fisInPi":
- group_faceFissInPipe = grp
-
- # le maillage NETGEN ne passe pas toujours ==> on force l'usage de MG_Tetra
- mailleur = "MeshGems"
- logging.info("Maillage avec %s", mailleur)
- if ( mailleur == "MeshGems"):
- algo3d = meshBoiteDefaut.Tetrahedron(algo=smeshBuilder.MG_Tetra)
- else:
- algo3d = meshBoiteDefaut.Tetrahedron(algo=smeshBuilder.NETGEN)
- hypo3d = algo3d.MaxElementVolume(1000.0)
- hypo3d.SetVerboseLevel( 0 )
- hypo3d.SetStandardOutputLog( 0 )
- hypo3d.SetRemoveLogOnSuccess( 1 )
- putName(algo3d.GetSubMesh(), "boiteDefaut")
- putName(algo3d, "algo3d_boiteDefaut")
- putName(meshBoiteDefaut, "boiteDefaut")
-
- is_done = meshBoiteDefaut.Compute()
- text = "meshBoiteDefaut.Compute"
- if is_done:
- logging.info(text+" OK")
- else:
- text = "Erreur au calcul du maillage.\n" + text
- logging.info(text)
- raise Exception(text)
-
- _ = meshBoiteDefaut.GetMesh().UnionListOfGroups( [ group_faceFissOutPipe, group_faceFissInPipe ], 'FACE1' )
- maillageSain = enleveDefaut(maillageSain, zoneDefaut, zoneDefaut_skin,
- zoneDefaut_internalFaces, zoneDefaut_internalEdges)
- putName(maillageSain, nomFicSain+"_coupe")
- _, normfiss = shapeSurFissure(facesPortFissure)
- maillageComplet = RegroupeSainEtDefaut(maillageSain, meshBoiteDefaut,
- None, None, 'COMPLET', normfiss)
-
- logging.info("conversion quadratique")
- maillageComplet.ConvertToQuadratic( 1 )
- logging.info("groupes")
- groups = maillageComplet.GetGroups()
- grps = [ grp for grp in groups if grp.GetName() == 'FONDFISS']
- _ = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FONDFISS' )
-
- logging.info("réorientation face de fissure FACE1")
- grps = [ grp for grp in groups if grp.GetName() == 'FACE1']
- _ = maillageComplet.Reorient2D( grps[0], normfiss, grps[0].GetID(1))
-
- logging.info("réorientation face de fissure FACE2")
- plansim = geompy.MakePlane(O, normfiss, 10000)
- fissnorm = geompy.MakeMirrorByPlane(normfiss, plansim)
- grps = [ grp for grp in groups if grp.GetName() == 'FACE2']
- _ = maillageComplet.Reorient2D( grps[0], fissnorm, grps[0].GetID(1))
- _ = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FACE2' )
-
- logging.info("export maillage fini")
- maillageComplet.ExportMED(fichierMaillageFissure)
- putName(maillageComplet, nomFicFissure)
- logging.info("fichier maillage fissure %s", fichierMaillageFissure)
-
- if salome.sg.hasDesktop():
- salome.sg.updateObjBrowser()
-
- logging.info("maillage fissure fini")
-
- return maillageComplet
def insereFissureLongue(geometriesSaines, \
shapesFissure, shapeFissureParams, \
maillageFissureParams, elementsDefaut, \
- step=-1, mailleur="MeshGems"):
+ step=-1, mailleur="MeshGems", nro_cas=-1):
"""procedure complete fissure longue"""
logging.info('start')
- logging.info("Usage du mailleur %s", mailleur)
+ logging.info("Usage du mailleur %s pour le cas n°%d", mailleur, nro_cas)
#geometrieSaine = geometriesSaines[0]
shapeDefaut = shapesFissure[0] # face de fissure, debordant
planfiss, planBord1, planBord2, \
facePeau, verticesOutCercles, verticesEdgePeauFiss, \
fillingFaceExterne, rayonPipe, \
- internalBoundary)
+ internalBoundary, \
+ nro_cas)
# --- maillage pipe fond fissure
insereFissureLongue_c (pipeFondFiss, disques, rayons, demiCercles, demiCerclesPeau, generatrices, \
VerticesEndPipeFiss, verticesEdgePeauFiss, \
groupFaceFissInPipe, groupEdgeFondFiss, groupsDemiCerclesPipe, groupGenerFiss, \
- profondeur, rayonPipe)
+ profondeur, rayonPipe, \
+ nro_cas)
# --- maillage face de peau
insereFissureLongue_d ( facePeau, edgePeauFiss, groupEdgesBordPeau, bordsLibres, \
groupsDemiCerclesPeau, groups_demiCercles, verticesOutCercles, \
nbSegGenLong, nbSegGenBout, profondeur, \
- mailleur )
+ mailleur, nro_cas )
# --- maillage face de fissure
meshFaceFiss = \
insereFissureLongue_e ( faceFiss, edgePeauFiss, groupEdgesPeauFiss, group_generFiss, groupEdgesFaceFissPipe, \
profondeur, rayonPipe, \
- mailleur )
+ mailleur, nro_cas )
# --- maillage meshBoiteDefaut
meshBoiteDefaut, group_faceFissInPipe, group_faceFissOutPipe = \
insereFissureLongue_f ( internalBoundary, meshFondFiss, meshFacePeau, meshFaceFiss, \
- mailleur )
+ mailleur, nro_cas )
# --- maillage complet
insereFissureLongue_g (nomFicFissure, fichierMaillageFissure, nomFicSain, maillageSain, \
meshBoiteDefaut, facePorteFissure, \
group_faceFissInPipe, group_faceFissOutPipe, \
- zoneDefaut, zoneDefaut_skin, zoneDefaut_internalEdges, zoneDefaut_internalFaces)
+ zoneDefaut, zoneDefaut_skin, zoneDefaut_internalEdges, zoneDefaut_internalFaces, \
+ nro_cas)
if salome.sg.hasDesktop():
edgesFacePeauSorted, _, _ = sortEdges(edgesFacePeau)
demiCerclesPeau = edgesFacePeauSorted[0:4]
verticesDemiCerclesPeau = list()
- for i, edge in enumerate(demiCerclesPeau):
- name = "demiCerclePeau_%d"%i
+ for i_aux, edge in enumerate(demiCerclesPeau):
+ name = "demiCerclePeau_{}".format(i_aux)
geomPublishInFather(initLog.debug,facePeau, edge, name)
verticesDemiCerclesPeau += geompy.ExtractShapes(edge, geompy.ShapeType["VERTEX"], False)
verticesDemiCerclesPeau = eliminateDoubles(facePeau, verticesDemiCerclesPeau)
- for i, vertex in enumerate(verticesDemiCerclesPeau):
- name = "verticesDemiCerclesPeau_%d"%i
+ for i_aux, vertex in enumerate(verticesDemiCerclesPeau):
+ name = "verticesDemiCerclesPeau_{}".format(i_aux)
geomPublishInFather(initLog.debug,facePeau, vertex, name)
verticesOutCercles = substractSubShapes(facePeau, verticesDemiCerclesPeau, verticesEdgePeauFiss)
- for i, vertex in enumerate(verticesOutCercles):
- name = "verticesOutCercles_%d"%i
+ for i_aux, vertex in enumerate(verticesOutCercles):
+ name = "verticesOutCercles_{}".format(i_aux)
geomPublishInFather(initLog.debug,facePeau, vertex, name)
# --- demi cercles regroupés
groupsDemiCerclesPeau = list()
- for i, vertex in enumerate(verticesEdgePeauFiss):
+ for i_aux, vertex in enumerate(verticesEdgePeauFiss):
demis = list()
for edge in demiCerclesPeau:
- if geompy.MinDistance(vertex, edge) < 1.e-5:
+ if ( geompy.MinDistance(vertex, edge) < 1.e-5 ):
demis.append(edge)
group = geompy.CreateGroup(facePeau, geompy.ShapeType["EDGE"])
geompy.UnionList(group, demis)
- name = "Cercle%d"%i
+ name = "Cercle{}".format(i_aux)
geomPublishInFather(initLog.debug,facePeau, group , name)
groupsDemiCerclesPeau.append(group)
from .produitMixte import produitMixte
from .findWireEndVertices import findWireEndVertices
from .getSubshapeIds import getSubshapeIds
+from .putName import putName
# -----------------------------------------------------------------------------
-def insereFissureLongue_b(edgesInside, centreFondFiss, tangentFondFiss, \
- planfiss, planBord1, planBord2, \
- facePeau, verticesOutCercles, verticesEdgePeauFiss, \
- fillingFaceExterne, rayonPipe, \
- internalBoundary):
+def insereFissureLongue_b (edgesInside, centreFondFiss, tangentFondFiss, \
+ planfiss, planBord1, planBord2, \
+ facePeau, verticesOutCercles, verticesEdgePeauFiss, \
+ fillingFaceExterne, rayonPipe, \
+ internalBoundary, \
+ nro_cas=-1):
"""procedure complete fissure longue"""
logging.info('start')
+ logging.info("Maillage pour le cas n°%d", nro_cas)
# -----------------------------------------------------------------------------
# --- pipe de fond de fissure
_ = smesh.CreateFilterManager()
_, internalBoundary, _ = internalBoundary.MakeBoundaryElements( SMESH.BND_1DFROM2D, '', '', 0, [ ])
+ putName(internalBoundary, 'internalBoundary', i_pref=nro_cas)
criteres = list()
un_critere = smesh.GetCriterion(SMESH.EDGE,SMESH.FT_FreeBorders,SMESH.FT_Undefined,0)
criteres.append(un_critere)
filtre = smesh.GetFilterFromCriteria(criteres)
bordsLibres = internalBoundary.MakeGroupByFilter( 'bords', filtre )
- smesh.SetName(bordsLibres, 'bordsLibres')
+ putName(bordsLibres, 'bordsLibres', i_pref=nro_cas)
# --- pour aider l'algo hexa-tetra a ne pas mettre de pyramides a l'exterieur des volumes replies sur eux-memes
# on designe les faces de peau en quadrangles par le groupe "skinFaces"
def insereFissureLongue_c (pipeFondFiss, disques, rayons, demiCercles, demiCerclesPeau, generatrices, \
VerticesEndPipeFiss, verticesEdgePeauFiss, \
groupFaceFissInPipe, groupEdgeFondFiss, groupsDemiCerclesPipe, groupGenerFiss, \
- profondeur, rayonPipe):
+ profondeur, rayonPipe, \
+ nro_cas=-1):
"""maillage pipe fond fissure"""
logging.info('start')
+ logging.info("Maillage pour le cas n°%d", nro_cas)
meshFondFiss = smesh.Mesh(pipeFondFiss)
+ putName(meshFondFiss, "pipeFondFiss", i_pref=nro_cas)
+
algo2d = meshFondFiss.Quadrangle(algo=smeshBuilder.QUADRANGLE)
algo3d = meshFondFiss.Prism()
- putName(algo3d.GetSubMesh(), "pipe")
- putName(algo3d, "algo3d_pipe")
- putName(algo2d, "algo2d_pipe")
+ putName(algo3d.GetSubMesh(), "pipe", i_pref=nro_cas)
+ putName(algo3d, "algo3d_pipe", i_pref=nro_cas)
+ putName(algo2d, "algo2d_pipe", i_pref=nro_cas)
- for i, face in enumerate(disques):
+ for i_aux, face in enumerate(disques):
algo2d = meshFondFiss.Quadrangle(algo=smeshBuilder.RADIAL_QUAD,geom=face)
- putName(algo2d.GetSubMesh(), "disque", i)
- putName(algo2d, "algo2d_disque", i)
+ putName(algo2d.GetSubMesh(), "disque", i_aux, nro_cas)
+ putName(algo2d, "algo2d_disque", i_aux, nro_cas)
- for i, edge in enumerate(rayons):
+ for i_aux, edge in enumerate(rayons):
algo1d = meshFondFiss.Segment(geom=edge)
hypo1d = algo1d.NumberOfSegments(4)
- putName(algo1d.GetSubMesh(), "rayon", i)
- putName(algo1d, "algo1d_rayon", i)
- putName(hypo1d, "hypo1d_rayon", i)
+ putName(algo1d.GetSubMesh(), "rayon", i_aux, nro_cas)
+ putName(algo1d, "algo1d_rayon", i_aux, nro_cas)
+ putName(hypo1d, "hypo1d_rayon", i_aux, nro_cas)
- for i, edge in enumerate(demiCercles):
+ for i_aux, edge in enumerate(demiCercles):
algo1d = meshFondFiss.Segment(geom=edge)
hypo1d = algo1d.NumberOfSegments(6)
- putName(algo1d.GetSubMesh(), "demiCercle", i)
- putName(algo1d, "algo1d_demiCercle", i)
- putName(hypo1d, "hypo1d_demiCercle", i)
+ putName(algo1d.GetSubMesh(), "demiCercle", i_aux, nro_cas)
+ putName(algo1d, "algo1d_demiCercle", i_aux, nro_cas)
+ putName(hypo1d, "hypo1d_demiCercle", i_aux, nro_cas)
generSorted, minlg, maxlg = sortEdges(generatrices)
nbSegGenLong = int(math.sqrt(3.0)*maxlg/(profondeur - rayonPipe)) # on veut 2 triangles equilateraux dans la largeur de la face
nbSegGenBout = 6
logging.info("min %s, max %s, nombre de segments %s, nombre de generatrices %s", minlg, maxlg, nbSegGenLong, len(generSorted))
- for i, edge in enumerate(generSorted):
+ for i_aux, edge in enumerate(generSorted):
algo1d = meshFondFiss.Segment(geom=edge)
- if i < 6:
+ if i_aux < 6:
hypo1d = algo1d.NumberOfSegments(nbSegGenBout)
else:
hypo1d = algo1d.NumberOfSegments(nbSegGenLong)
- putName(algo1d.GetSubMesh(), "generatrice", i)
- putName(algo1d, "algo1d_generatrice", i)
- putName(hypo1d, "hypo1d_generatrice", i)
+ putName(algo1d.GetSubMesh(), "generatrice", i_aux, nro_cas)
+ putName(algo1d, "algo1d_generatrice", i_aux, nro_cas)
+ putName(hypo1d, "hypo1d_generatrice", i_aux, nro_cas)
disks = list()
- for i, face in enumerate(disques[:4]):
- name = "disk%d"%i
+ for i_aux, face in enumerate(disques[:4]):
+ name = "disk{}".format(i_aux)
disks.append(meshFondFiss.GroupOnGeom(face, name, SMESH.FACE))
_ = meshFondFiss.GetMesh().UnionListOfGroups( disks, 'PEAUEXT' )
groups_demiCercles = list()
groupnodes_demiCercles = list()
- for i, group in enumerate(groupsDemiCerclesPipe):
- name = "Cercle%d"%i
+ for i_aux, group in enumerate(groupsDemiCerclesPipe):
+ name = "Cercle{}".format(i_aux)
groups_demiCercles.append(meshFondFiss.GroupOnGeom(group, name, SMESH.EDGE))
- name = "nCercle%d"%i
+ name = "nCercle{}".format(i_aux)
groupnodes_demiCercles.append(meshFondFiss.GroupOnGeom(group, name, SMESH.NODE))
group_generFiss = meshFondFiss.GroupOnGeom(groupGenerFiss, "GenFiss", SMESH.EDGE)
groupnode_generFiss = meshFondFiss.GroupOnGeom(groupGenerFiss, "GenFiss", SMESH.NODE)
minDist = 100000
minCoord = None
imin = -1
- for i, edge in enumerate(demiCerclesPeau):
+ for i_aux, edge in enumerate(demiCerclesPeau):
discoord = geompy.MinDistanceComponents(vertex, edge)
if discoord[0] <minDist:
minDist = discoord[0]
minCoord = discoord[1:]
- imin = i
+ imin = i_aux
if imin >= 0 and minDist > 1.E-6:
logging.debug("node id moved : %s distance=%s", idNode, minDist)
meshFondFiss.MoveNode(idNode, coordMesh[0] + minCoord[0], coordMesh[1] + minCoord[1], coordMesh[2] + minCoord[2])
def insereFissureLongue_d (facePeau, edgePeauFiss, groupEdgesBordPeau, bordsLibres, \
groupsDemiCerclesPeau, groups_demiCercles, verticesOutCercles, \
nbSegGenLong, nbSegGenBout, profondeur, \
- mailleur="MeshGems"):
+ mailleur="MeshGems", nro_cas=-1):
"""maillage face de peau"""
logging.info('start')
+ logging.info("Maillage avec %s pour le cas n°%d", mailleur, nro_cas)
meshFacePeau = smesh.Mesh(facePeau)
- logging.info("Maillage avec %s", mailleur)
+ putName(meshFacePeau, "facePeau", i_pref=nro_cas)
+
if ( mailleur == "MeshGems"):
algo2d = meshFacePeau.Triangle(algo=smeshBuilder.MG_CADSurf)
hypo2d = algo2d.Parameters()
hypo2d.SetFineness( 2 )
hypo2d.SetMinSize( 2 )
hypo2d.SetQuadAllowed( 0 )
- putName(algo2d.GetSubMesh(), "facePeau")
- putName(algo2d, "algo2d_facePeau")
- putName(hypo2d, "hypo2d_facePeau")
+ putName(algo2d.GetSubMesh(), "facePeau", i_pref=nro_cas)
+ putName(algo2d, "algo2d_facePeau", i_pref=nro_cas)
+ putName(hypo2d, "hypo2d_facePeau", i_pref=nro_cas)
#
lenEdgePeauFiss = geompy.BasicProperties(edgePeauFiss)[0]
frac = profondeur/lenEdgePeauFiss
hypo1d.SetDistrType( 2 )
hypo1d.SetConversionMode( 1 )
hypo1d.SetTableFunction( [ 0, ratio, frac, 1, (1.-frac), 1, 1, ratio ] )
- putName(algo1d.GetSubMesh(), "edgePeauFiss")
- putName(algo1d, "algo1d_edgePeauFiss")
- putName(hypo1d, "hypo1d_edgePeauFiss")
+ putName(algo1d.GetSubMesh(), "edgePeauFiss", i_pref=nro_cas)
+ putName(algo1d, "algo1d_edgePeauFiss", i_pref=nro_cas)
+ putName(hypo1d, "hypo1d_edgePeauFiss", i_pref=nro_cas)
#
algo1d = meshFacePeau.UseExisting1DElements(geom=groupEdgesBordPeau)
hypo1d = algo1d.SourceEdges([ bordsLibres ],0,0)
- putName(algo1d.GetSubMesh(), "bordsLibres")
- putName(algo1d, "algo1d_bordsLibres")
- putName(hypo1d, "hypo1d_bordsLibres")
+ putName(algo1d.GetSubMesh(), "bordsLibres", i_pref=nro_cas)
+ putName(algo1d, "algo1d_bordsLibres", i_pref=nro_cas)
+ putName(hypo1d, "hypo1d_bordsLibres", i_pref=nro_cas)
#
- for i in range(2):
- algo1d = meshFacePeau.UseExisting1DElements(geom=groupsDemiCerclesPeau[i])
- hypo1d = algo1d.SourceEdges([ groups_demiCercles[i] ],0,0)
- putName(algo1d.GetSubMesh(), "DemiCercles", i)
- putName(algo1d, "algo1d_groupDemiCercles", i)
- putName(hypo1d, "hypo1d_groupDemiCercles", i)
+ for i_aux in range(2):
+ algo1d = meshFacePeau.UseExisting1DElements(geom=groupsDemiCerclesPeau[i_aux])
+ hypo1d = algo1d.SourceEdges([ groups_demiCercles[i_aux] ],0,0)
+ putName(algo1d.GetSubMesh(), "DemiCercles", i_aux, nro_cas)
+ putName(algo1d, "algo1d_groupDemiCercles", i_aux, nro_cas)
+ putName(hypo1d, "hypo1d_groupDemiCercles", i_aux, nro_cas)
_ = meshFacePeau.GroupOnGeom(verticesOutCercles[0], "THOR", SMESH.NODE)
_ = meshFacePeau.GroupOnGeom(verticesOutCercles[1], "THEX", SMESH.NODE)
def insereFissureLongue_e (faceFiss, edgePeauFiss, groupEdgesPeauFiss, group_generFiss, groupEdgesFaceFissPipe, \
profondeur, rayonPipe, \
- mailleur="MeshGems"):
+ mailleur="MeshGems", nro_cas=-1):
"""maillage face de fissure"""
logging.info('start')
+ logging.info("Maillage avec %s pour le cas n°%d", mailleur, nro_cas)
meshFaceFiss = smesh.Mesh(faceFiss)
- mesh_size = (profondeur - rayonPipe)/math.sqrt(3.0) # pour avoir deux couches de triangles equilateraux partout sur la fissure
- logging.info("Maillage avec %s", mailleur)
+ putName(meshFaceFiss, "faceFiss", i_pref=nro_cas)
+
+ mesh_size = (profondeur - rayonPipe)/math.sqrt(3.0) # pour avoir deux couches de triangles équilatéraux partout sur la fissure
if ( mailleur == "MeshGems"):
algo2d = meshFaceFiss.Triangle(algo=smeshBuilder.MG_CADSurf)
hypo2d = algo2d.Parameters()
hypo2d.SetFineness( 2 )
hypo2d.SetMinSize( 2 )
hypo2d.SetQuadAllowed( 0 )
- putName(algo2d.GetSubMesh(), "faceFiss")
- putName(algo2d, "algo2d_faceFiss")
- putName(hypo2d, "hypo2d_faceFiss")
+ putName(algo2d.GetSubMesh(), "faceFiss", i_pref=nro_cas)
+ putName(algo2d, "algo2d_faceFiss", i_pref=nro_cas)
+ putName(hypo2d, "hypo2d_faceFiss", i_pref=nro_cas)
#
algo1d = meshFaceFiss.UseExisting1DElements(geom=edgePeauFiss)
hypo1d = algo1d.SourceEdges([ groupEdgesPeauFiss ],0,0)
- putName(algo1d.GetSubMesh(), "edgeFissPeau")
- putName(algo1d, "algo1d_edgeFissPeau")
- putName(hypo1d, "hypo1d_edgeFissPeau")
+ putName(algo1d.GetSubMesh(), "edgeFissPeau", i_pref=nro_cas)
+ putName(algo1d, "algo1d_edgeFissPeau", i_pref=nro_cas)
+ putName(hypo1d, "hypo1d_edgeFissPeau", i_pref=nro_cas)
#
algo1d = meshFaceFiss.UseExisting1DElements(geom=groupEdgesFaceFissPipe)
hypo1d = algo1d.SourceEdges([ group_generFiss ],0,0)
- putName(algo1d.GetSubMesh(), "edgeFissPeau")
- putName(algo1d, "algo1d_edgeFissPeau")
- putName(hypo1d, "hypo1d_edgeFissPeau")
+ putName(algo1d.GetSubMesh(), "edgeFissPeau", i_pref=nro_cas)
+ putName(algo1d, "algo1d_edgeFissPeau", i_pref=nro_cas)
+ putName(hypo1d, "hypo1d_edgeFissPeau", i_pref=nro_cas)
_ = meshFaceFiss.GroupOnGeom(faceFiss, "fisOutPi", SMESH.FACE)
from .putName import putName
def insereFissureLongue_f (internalBoundary, meshFondFiss, meshFacePeau, meshFaceFiss, \
- mailleur="MeshGems"):
+ mailleur="MeshGems", nro_cas=-1):
"""maillage meshBoiteDefaut"""
logging.info('start')
- logging.info("insereFissureLongue_f (%s)", mailleur)
+ logging.info("Usage du mailleur %s pour le cas n°%d", mailleur, nro_cas)
meshBoiteDefaut = smesh.Concatenate( [internalBoundary.GetMesh(), \
meshFondFiss.GetMesh(), \
meshFacePeau.GetMesh(), \
meshFaceFiss.GetMesh()], \
- 1, 1, 1e-05,False)
+ 1, 1, 1e-05,False )
# pour aider l'algo hexa-tetra a ne pas mettre de pyramides a l'exterieur des volumes replies sur eux-memes
# on designe les faces de peau en quadrangles par le groupe "skinFaces"
group_faceFissOutPipe = None
hypo3d.SetVerboseLevel( 0 )
hypo3d.SetStandardOutputLog( 0 )
hypo3d.SetRemoveLogOnSuccess( 1 )
- putName(algo3d.GetSubMesh(), "boiteDefaut")
- putName(algo3d, "algo3d_boiteDefaut")
- putName(meshBoiteDefaut, "boiteDefaut")
+ putName(algo3d.GetSubMesh(), "boiteDefaut", i_pref=nro_cas)
+ putName(algo3d, "algo3d_boiteDefaut", i_pref=nro_cas)
+ putName(meshBoiteDefaut, "boiteDefaut", i_pref=nro_cas)
is_done = meshBoiteDefaut.Compute()
text = "meshBoiteDefaut.Compute"
def insereFissureLongue_g(nomFicFissure, fichierMaillageFissure, nomFicSain, maillageSain, \
meshBoiteDefaut, facePorteFissure, \
group_faceFissInPipe, group_faceFissOutPipe, \
- zoneDefaut, zoneDefaut_skin, zoneDefaut_internalEdges, zoneDefaut_internalFaces):
+ zoneDefaut, zoneDefaut_skin, zoneDefaut_internalEdges, zoneDefaut_internalFaces, \
+ nro_cas=-1):
"""Les groupes de la fissure longue"""
logging.info('start')
+ logging.info("Pour le cas n°%d", mailleur, nro_cas)
O, _, _, _ = triedreBase()
_ = meshBoiteDefaut.GetMesh().UnionListOfGroups( [ group_faceFissOutPipe, group_faceFissInPipe ], 'FACE1' )
maillageSain = enleveDefaut(maillageSain, zoneDefaut, zoneDefaut_skin, zoneDefaut_internalFaces, zoneDefaut_internalEdges)
- putName(maillageSain, nomFicSain+"_coupe")
+ putName(maillageSain, nomFicSain+"_coupe", i_pref=nro_cas)
extrusionFaceFissure, normfiss = shapeSurFissure(facePorteFissure)
maillageComplet = RegroupeSainEtDefaut(maillageSain, meshBoiteDefaut, extrusionFaceFissure, facePorteFissure, 'COUDE')
from .putName import putName
-def mailleAretesEtJonction(internalBoundary, aretesVivesCoupees, lgAretesVives):
+def mailleAretesEtJonction (internalBoundary, aretesVivesCoupees, lgAretesVives, \
+ nro_cas=-1):
"""edges de bord, faces défaut à respecter"""
logging.info('start')
+ logging.info("Pour le cas n°%d", nro_cas)
_ = smesh.CreateFilterManager()
_, internalBoundary, _NoneGroup = internalBoundary.MakeBoundaryElements( SMESH.BND_1DFROM2D, '', '', 0, [ ])
criteres.append(unCritere)
filtre = smesh.GetFilterFromCriteria(criteres)
bordsLibres = internalBoundary.MakeGroupByFilter( 'bords', filtre )
- smesh.SetName(bordsLibres, 'bordsLibres')
+ putName(bordsLibres, 'bordsLibres', i_pref=nro_cas)
# --- pour aider l'algo hexa-tetra à ne pas mettre de pyramides à l'exterieur des volumes repliés sur eux-mêmes
# on désigne les faces de peau en quadrangles par le groupe "skinFaces"
meshAretesVives = smesh.Mesh(aretesVivesC)
algo1d = meshAretesVives.Segment()
hypo1d = algo1d.LocalLength(lgAretesVives,[],1e-07)
- putName(algo1d.GetSubMesh(), "aretesVives")
- putName(algo1d, "algo1d_aretesVives")
- putName(hypo1d, "hypo1d_aretesVives")
+ putName(algo1d.GetSubMesh(), "aretesVives", i_pref=nro_cas)
+ putName(algo1d, "algo1d_aretesVives", i_pref=nro_cas)
+ putName(hypo1d, "hypo1d_aretesVives", i_pref=nro_cas)
is_done = meshAretesVives.Compute()
text = "meshAretesVives.Compute"
def mailleFacesFissure(faceFissureExterne, \
edgesPipeFissureExterneC, edgesPeauFissureExterneC, \
meshPipeGroups, areteFaceFissure, rayonPipe, nbsegRad, \
- mailleur="MeshGems"):
+ mailleur="MeshGems", nro_cas=-1):
"""maillage faces de fissure"""
logging.info('start')
+ logging.info("Maillage avec %s pour le cas n°%d", mailleur, nro_cas)
meshFaceFiss = smesh.Mesh(faceFissureExterne)
logging.info("Maillage avec %s", mailleur)
hypo2d.SetFineness( 2 )
hypo2d.SetMinSize( rayonPipe/float(nbsegRad) )
hypo2d.SetQuadAllowed( 0 )
- putName(algo2d.GetSubMesh(), "faceFiss")
- putName(algo2d, "algo2d_faceFiss")
- putName(hypo2d, "hypo2d_faceFiss")
+ putName(algo2d.GetSubMesh(), "faceFiss", i_pref=nro_cas)
+ putName(algo2d, "algo2d_faceFiss", i_pref=nro_cas)
+ putName(hypo2d, "hypo2d_faceFiss", i_pref=nro_cas)
texte = "Récupération des arêtes de '{}'".format(edgesPipeFissureExterneC.GetName())
logging.info(texte)
algo1d = meshFaceFiss.UseExisting1DElements(geom=edgesPipeFissureExterneC)
hypo1d = algo1d.SourceEdges([ meshPipeGroups['edgeFaceFissGroup'] ],0,0)
- putName(algo1d.GetSubMesh(), "edgeFissPeau")
- putName(algo1d, "algo1d_edgeFissPeau")
- putName(hypo1d, "hypo1d_edgeFissPeau")
+ putName(algo1d.GetSubMesh(), "edgeFissPeau", i_pref=nro_cas)
+ putName(algo1d, "algo1d_edgeFissPeau", i_pref=nro_cas)
+ putName(hypo1d, "hypo1d_edgeFissPeau", i_pref=nro_cas)
grpFaceFissureExterne = meshFaceFiss.GroupOnGeom(faceFissureExterne, "fisOutPi", SMESH.FACE)
grpEdgesPeauFissureExterne = meshFaceFiss.GroupOnGeom(edgesPeauFissureExterneC,'edgesPeauFissureExterne',SMESH.EDGE)
mailleur="MeshGems", nro_cas=-1):
"""maillage faces de peau"""
logging.info('start')
- logging.info(mailleur+" pour le cas n° %d"%nro_cas)
+ logging.info("Maillage avec %s pour le cas n°%d", mailleur, nro_cas)
+
nbFacesFilling = len(partitionsPeauFissFond)
boutFromIfil = [None for _ in range(nbFacesFilling)]
if idFillingFromBout[0] != idFillingFromBout[1]: # repérage des extremites du pipe quand elles débouchent sur des faces différentes
gencnt, facefissoutore, edgeext, facesExternes, facesExtBloc, facesExtElli, \
aretesInternes, internalBoundary, ellipsoidep, sharedFaces, sharedEdges, edgesBords, \
nbsegExt, nbsegGen, nbsegRad, scaleRad, reverses, reverext, nbsegCercle, nbsegFis, dmoyen, lensegEllipsoide, \
- mailleur="MeshGems"):
+ mailleur="MeshGems", nro_cas=-1):
"""Maillage du bloc partitionné"""
logging.info('start')
+ logging.info("Maillage avec %s pour le cas n°%d", mailleur, nro_cas)
# --- edges de bord à respecter
criteres.append(unCritere)
filtre = smesh.GetFilterFromCriteria(criteres)
bordsLibres = internalBoundary.MakeGroupByFilter( 'bords', filtre )
- smesh.SetName(bordsLibres, 'bordsLibres')
+ putName(bordsLibres, 'bordsLibres', i_pref=nro_cas)
# --- maillage bloc
hypo2d.SetLocalLength(lensegEllipsoide)
hypo2d.LengthFromEdges()
hypo2d.SetAllowQuadrangles(0)
- putName(algo2d.GetSubMesh(), "sharedFaces", i_aux)
- putName(algo2d, "algo2d_sharedFaces", i_aux)
- putName(hypo2d, "hypo2d_sharedFaces", i_aux)
+ putName(algo2d.GetSubMesh(), "sharedFaces", i_aux, nro_cas)
+ putName(algo2d, "algo2d_sharedFaces", i_aux, nro_cas)
+ putName(hypo2d, "hypo2d_sharedFaces", i_aux, nro_cas)
for i_aux, sharedEdges_i in enumerate(sharedEdges):
algo1d = bloc1.Segment(geom=sharedEdges_i)
hypo1d = algo1d.LocalLength(lensegEllipsoide)
- putName(algo1d.GetSubMesh(), "sharedEdges", i_aux)
- putName(algo1d, "algo1d_sharedEdges", i_aux)
- putName(hypo1d, "hypo1d_sharedEdges", i_aux)
+ putName(algo1d.GetSubMesh(), "sharedEdges", i_aux, nro_cas)
+ putName(algo1d, "algo1d_sharedEdges", i_aux, nro_cas)
+ putName(hypo1d, "hypo1d_sharedEdges", i_aux, nro_cas)
declareAlgoEllipsoideFirst = False
if declareAlgoEllipsoideFirst:
algo3d = bloc1.Tetrahedron(algo=smeshBuilder.NETGEN,geom=ellipsoidep)
hypo3d = algo3d.MaxElementVolume(1000.0)
- putName(algo3d.GetSubMesh(), "ellipsoide")
- putName(algo3d, "algo3d_ellipsoide")
- putName(hypo3d, "hypo3d_ellipsoide")
+ putName(algo3d.GetSubMesh(), "ellipsoide", i_pref=nro_cas)
+ putName(algo3d, "algo3d_ellipsoide", i_pref=nro_cas)
+ putName(hypo3d, "hypo3d_ellipsoide", i_pref=nro_cas)
algo3d = bloc1.Prism(geom=tore)
algo2d = bloc1.Quadrangle(geom=tore)
algo1d = bloc1.Segment(geom=tore)
hypo1d = algo1d.NumberOfSegments(nbsegGen)
- putName(algo3d.GetSubMesh(), "tore")
- putName(algo3d, "algo3d_tore")
- putName(algo2d, "algo2d_tore")
- putName(algo1d, "algo1d_tore")
- putName(hypo1d, "hypo1d_tore")
+ putName(algo3d.GetSubMesh(), "tore", i_pref=nro_cas)
+ putName(algo3d, "algo3d_tore", i_pref=nro_cas)
+ putName(algo2d, "algo2d_tore", i_pref=nro_cas)
+ putName(algo1d, "algo1d_tore", i_pref=nro_cas)
+ putName(hypo1d, "hypo1d_tore", i_pref=nro_cas)
for i_aux, faces_i in enumerate(faces):
algo2d = bloc1.Quadrangle(geom=faces_i)
hypo2d.SetTriaVertex( geompy.GetSubShapeID(blocPartition,centres[i_aux]) )
hypo2d.SetQuadType( StdMeshersBuilder.QUAD_STANDARD )
_ = bloc1.AddHypothesis(hypo2d,faces_i)
- putName(algo2d.GetSubMesh(), "faces", i_aux)
- putName(algo2d, "algo2d_faces", i_aux)
- putName(hypo2d, "hypo2d_faces", i_aux)
+ putName(algo2d.GetSubMesh(), "faces", i_aux, nro_cas)
+ putName(algo2d, "algo2d_faces", i_aux, nro_cas)
+ putName(hypo2d, "hypo2d_faces", i_aux, nro_cas)
for i_aux, edges_i in enumerate(edges):
algo1d = bloc1.Segment(geom=edges_i)
hypo1d = algo1d.NumberOfSegments(nbsegRad, scaleRad,[ geompy.GetSubShapeID(blocPartition,edges_i) ])
else:
hypo1d = algo1d.NumberOfSegments(nbsegRad, scaleRad,[ ])
- putName(algo1d.GetSubMesh(), "edges", i_aux)
- putName(algo1d, "algo1d_edges", i_aux)
- putName(hypo1d, "hypo1d_edges", i_aux)
+ putName(algo1d.GetSubMesh(), "edges", i_aux, nro_cas)
+ putName(algo1d, "algo1d_edges", i_aux, nro_cas)
+ putName(hypo1d, "hypo1d_edges", i_aux, nro_cas)
for i_aux, circles_i in enumerate(circles):
algo1d = bloc1.Segment(geom=circles_i)
hypo1d = algo1d.NumberOfSegments(nbsegCercle)
- putName(algo1d.GetSubMesh(), "circles", i_aux)
- putName(algo1d, "algo1d_circles", i_aux)
- putName(hypo1d, "hypo1d_circles", i_aux)
+ putName(algo1d.GetSubMesh(), "circles", i_aux, nro_cas)
+ putName(algo1d, "algo1d_circles", i_aux, nro_cas)
+ putName(hypo1d, "hypo1d_circles", i_aux, nro_cas)
if len(edgeext) == 1:
densite = int(round(nbsegFis/2))
hypo1d.SetDistrType( 2 )
hypo1d.SetConversionMode( 1 )
hypo1d.SetTableFunction( [ 0, densite, 0.4, 1, 0.6, 1, 1, densite ] )
- putName(algo1d.GetSubMesh(), "edgeext")
- putName(algo1d, "algo1d_edgeext")
- putName(hypo1d, "hypo1d_edgeext")
+ putName(algo1d.GetSubMesh(), "edgeext", i_pref=nro_cas)
+ putName(algo1d, "algo1d_edgeext", i_pref=nro_cas)
+ putName(hypo1d, "hypo1d_edgeext", i_pref=nro_cas)
else:
longTotal = 0
longEdgeExts = list()
hypo1d.SetTableFunction( [ 0, densite, 0.8, 1, 1, 1 ] )
if reverext[i_aux]:
hypo1d.SetReversedEdges([ geompy.GetSubShapeID(blocPartition, edgeext_i) ])
- putName(algo1d.GetSubMesh(), "edgeext", i_aux)
- putName(algo1d, "algo1d_edgeext", i_aux)
- putName(hypo1d, "hypo1d_edgeext", i_aux)
+ putName(algo1d.GetSubMesh(), "edgeext", i_aux, nro_cas)
+ putName(algo1d, "algo1d_edgeext", i_aux, nro_cas)
+ putName(hypo1d, "hypo1d_edgeext", i_aux, nro_cas)
algo2d = bloc1.Triangle(algo=smeshBuilder.NETGEN_2D, geom=facefissoutore)
hypo2d = algo2d.LengthFromEdges()
- putName(algo2d.GetSubMesh(), "facefissoutore")
- putName(algo2d, "algo2d_facefissoutore")
- putName(hypo2d, "hypo2d_facefissoutore")
+ putName(algo2d.GetSubMesh(), "facefissoutore", i_pref=nro_cas)
+ putName(algo2d, "algo2d_facefissoutore", i_pref=nro_cas)
+ putName(hypo2d, "hypo2d_facefissoutore", i_pref=nro_cas)
maxElemArea = 0.5*dmoyen*dmoyen
if edgesBords is None:
algo1d = bloc1.Segment(geom=facesExternes_i)
hypo1d = algo1d.NumberOfSegments(1)
- putName(algo2d.GetSubMesh(), "facesExternes", i_aux)
- putName(algo2d, "algo2d_facesExternes", i_aux)
- putName(hypo2d, "hypo2d_facesExternes", i_aux)
+ putName(algo2d.GetSubMesh(), "facesExternes", i_aux, nro_cas)
+ putName(algo2d, "algo2d_facesExternes", i_aux, nro_cas)
+ putName(hypo2d, "hypo2d_facesExternes", i_aux, nro_cas)
if edgesBords is None:
- putName(algo1d, "algo1d_facesExternes", i_aux)
- putName(hypo1d, "hypo1d_facesExternes", i_aux)
+ putName(algo1d, "algo1d_facesExternes", i_aux, nro_cas)
+ putName(hypo1d, "hypo1d_facesExternes", i_aux, nro_cas)
for i_aux, aretesInternes_i in enumerate(aretesInternes):
algo1d = bloc1.Segment(geom=aretesInternes_i)
hypo1d = algo1d.NumberOfSegments(nbsegExt)
- putName(algo1d.GetSubMesh(), "aretesInternes", i_aux)
- putName(algo1d, "algo1d_aretesInternes", i_aux)
- putName(hypo1d, "hypo1d_aretesInternes", i_aux)
+ putName(algo1d.GetSubMesh(), "aretesInternes", i_aux, nro_cas)
+ putName(algo1d, "algo1d_aretesInternes", i_aux, nro_cas)
+ putName(hypo1d, "hypo1d_aretesInternes", i_aux, nro_cas)
if edgesBords is not None:
algo1d = bloc1.UseExisting1DElements(geom=edgesBords)
hypo1d = algo1d.SourceEdges([ bordsLibres ],0,0)
- putName(algo1d.GetSubMesh(), "bordsLibres")
- putName(algo1d, "algo1d_bordsLibres")
- putName(hypo1d, "hypo1d_bordsLibres")
+ putName(algo1d.GetSubMesh(), "bordsLibres", i_pref=nro_cas)
+ putName(algo1d, "algo1d_bordsLibres", i_pref=nro_cas)
+ putName(hypo1d, "hypo1d_bordsLibres", i_pref=nro_cas)
if not declareAlgoEllipsoideFirst:
algo3d = bloc1.Tetrahedron(algo=smeshBuilder.NETGEN,geom=ellipsoidep)
hypo3d = algo3d.MaxElementVolume(1000.0)
- putName(algo3d.GetSubMesh(), "ellipsoide")
- putName(algo3d, "algo3d_ellipsoide")
- putName(hypo3d, "hypo3d_ellipsoide")
+ putName(algo3d.GetSubMesh(), "ellipsoide", i_pref=nro_cas)
+ putName(algo3d, "algo3d_ellipsoide", i_pref=nro_cas)
+ putName(hypo3d, "hypo3d_ellipsoide", i_pref=nro_cas)
_ = bloc1.GroupOnGeom(faceFissure,'FACE1',SMESH.FACE)
_ = bloc1.GroupOnGeom(gencnt,'nfondfis',SMESH.NODE)
algo3d = blocMesh.Tetrahedron(algo=smeshBuilder.NETGEN)
hypo3d = algo3d.MaxElementVolume(1000.0)
- putName(algo3d.GetSubMesh(), "bloc")
- putName(algo3d, "algo3d_bloc")
- putName(hypo3d, "hypo3d_bloc")
+ putName(algo3d.GetSubMesh(), "bloc", i_pref=nro_cas)
+ putName(algo3d, "algo3d_bloc", i_pref=nro_cas)
+ putName(hypo3d, "hypo3d_bloc", i_pref=nro_cas)
is_done = blocMesh.Compute()
text = "blocMesh.Compute"
from .fissError import fissError
from .listOfExtraFunctions import lookForCorner
from .fusionMaillageAttributionDefaut import fusionMaillageDefaut
+from .putName import putName
-def peauInterne(fichierMaillage, shapeDefaut, nomZones):
+def peauInterne(fichierMaillage, shapeDefaut, nomZones, \
+ nro_cas=-1):
"""Retrouve les groupes de défaut dans le maillage sain modifié par CreateHoleSkin (CreeZoneDefautMaillage)
On récupère le volume et la peau de la zone de défaut, les éventuelles faces et arêtes internes de cette zone.
internalBoundary = smesh.CopyMesh( internal, 'internalBoundary', 0, 0)
maillageDefautCible = smesh.CopyMesh(zoneDefaut_skin, 'maillageCible', 0, 0)
+ putName(maillageDefautCible, "maillageCible", i_pref=nro_cas)
listOfCorner = lookForCorner(maillageDefautCible)
texte = "listOfCorner = {}".format(listOfCorner)
logging.debug(texte)
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-
"""Nommage des objets mesh (algorithme, hypothèse, subMesh)"""
+#import logging
from .geomsmesh import smesh
def putName (objmesh, name, i_suff=-1, i_pref=-1):
@i_pref un éventuel préfixe
"""
+ #logging.info("putName pour %s - i_suff=%d, i_pref=%d", name, i_suff, i_pref)
# suffixe éventuel :
if i_suff >= 0:
suffixe = "_{}".format(i_suff)
if i_pref >= 0:
prefixe = "Cas{:02d}_".format(i_pref)
name = prefixe + name
+ #logging.info("Au final : %s", name)
smesh.SetName(objmesh, name)
