diff --git a/src/Tools/blocFissure/CasTests/cubeAngle.py b/src/Tools/blocFissure/CasTests/cubeAngle.py index ba5392e5a..1d8b4ab4d 100644 --- a/src/Tools/blocFissure/CasTests/cubeAngle.py +++ b/src/Tools/blocFissure/CasTests/cubeAngle.py @@ -80,7 +80,7 @@ class cubeAngle(fissureGenerique): geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' ) mailleur = self.mailleur2d3d() - coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,10, mailleur) + coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,10, mailleur, self.numeroCas) centre = None @@ -99,7 +99,8 @@ class cubeAngle(fissureGenerique): # --------------------------------------------------------------------------- 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 # --------------------------------------------------------------------------- diff --git a/src/Tools/blocFissure/CasTests/cylindre.py b/src/Tools/blocFissure/CasTests/cylindre.py index 2e01fb91b..7ea732a38 100644 --- a/src/Tools/blocFissure/CasTests/cylindre.py +++ b/src/Tools/blocFissure/CasTests/cylindre.py @@ -51,7 +51,7 @@ class cylindre(fissureGenerique): 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 @@ -80,7 +80,7 @@ class cylindre(fissureGenerique): 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] @@ -96,7 +96,8 @@ class cylindre(fissureGenerique): # --------------------------------------------------------------------------- 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 # --------------------------------------------------------------------------- diff --git a/src/Tools/blocFissure/CasTests/cylindre_2.py b/src/Tools/blocFissure/CasTests/cylindre_2.py index f02e01a8f..329ed3491 100644 --- a/src/Tools/blocFissure/CasTests/cylindre_2.py +++ b/src/Tools/blocFissure/CasTests/cylindre_2.py @@ -52,7 +52,7 @@ class cylindre_2(cylindre): 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] diff --git a/src/Tools/blocFissure/CasTests/ellipse_1.py b/src/Tools/blocFissure/CasTests/ellipse_1.py index 08c8187db..4c39444dc 100644 --- a/src/Tools/blocFissure/CasTests/ellipse_1.py +++ b/src/Tools/blocFissure/CasTests/ellipse_1.py @@ -88,7 +88,7 @@ class ellipse_1(fissureGenerique): geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' ) mailleur = self.mailleur2d3d() - coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,25, mailleur) + coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,25, mailleur, self.numeroCas) centre = None @@ -107,7 +107,8 @@ class ellipse_1(fissureGenerique): # --------------------------------------------------------------------------- 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 # --------------------------------------------------------------------------- diff --git a/src/Tools/blocFissure/CasTests/ellipse_2.py b/src/Tools/blocFissure/CasTests/ellipse_2.py index 65ee36266..19eebe03a 100644 --- a/src/Tools/blocFissure/CasTests/ellipse_2.py +++ b/src/Tools/blocFissure/CasTests/ellipse_2.py @@ -54,7 +54,7 @@ class ellipse_2(ellipse_1): geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' ) mailleur = self.mailleur2d3d() - coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,25, mailleur) + coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,25, mailleur, self.numeroCas) centre = None diff --git a/src/Tools/blocFissure/CasTests/eprouvetteCourbe.py b/src/Tools/blocFissure/CasTests/eprouvetteCourbe.py index 30e0a2ac7..38937cb6e 100644 --- a/src/Tools/blocFissure/CasTests/eprouvetteCourbe.py +++ b/src/Tools/blocFissure/CasTests/eprouvetteCourbe.py @@ -48,7 +48,7 @@ class eprouvetteCourbe(fissureGenerique): 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 @@ -82,7 +82,7 @@ class eprouvetteCourbe(fissureGenerique): geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' ) mailleur = self.mailleur2d3d() - coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,10, mailleur) + coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,10, mailleur, self.numeroCas) centre = None @@ -101,7 +101,8 @@ class eprouvetteCourbe(fissureGenerique): # --------------------------------------------------------------------------- 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 # --------------------------------------------------------------------------- diff --git a/src/Tools/blocFissure/CasTests/eprouvetteDroite.py b/src/Tools/blocFissure/CasTests/eprouvetteDroite.py index 150dc5c62..21a6c815a 100644 --- a/src/Tools/blocFissure/CasTests/eprouvetteDroite.py +++ b/src/Tools/blocFissure/CasTests/eprouvetteDroite.py @@ -53,7 +53,7 @@ class eprouvetteDroite(fissureGenerique): 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 @@ -85,7 +85,7 @@ class eprouvetteDroite(fissureGenerique): 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] @@ -101,7 +101,8 @@ class eprouvetteDroite(fissureGenerique): # --------------------------------------------------------------------------- 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 # --------------------------------------------------------------------------- diff --git a/src/Tools/blocFissure/CasTests/eprouvetteDroite_2.py b/src/Tools/blocFissure/CasTests/eprouvetteDroite_2.py index 243ae704b..ffe43c6cc 100644 --- a/src/Tools/blocFissure/CasTests/eprouvetteDroite_2.py +++ b/src/Tools/blocFissure/CasTests/eprouvetteDroite_2.py @@ -51,7 +51,7 @@ class eprouvetteDroite_2(eprouvetteDroite): 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] diff --git a/src/Tools/blocFissure/CasTests/faceGauche.py b/src/Tools/blocFissure/CasTests/faceGauche.py index 739f74eb1..ed9347157 100644 --- a/src/Tools/blocFissure/CasTests/faceGauche.py +++ b/src/Tools/blocFissure/CasTests/faceGauche.py @@ -52,7 +52,7 @@ class faceGauche(fissureGenerique): 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 @@ -83,7 +83,7 @@ class faceGauche(fissureGenerique): 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] @@ -99,7 +99,8 @@ class faceGauche(fissureGenerique): # --------------------------------------------------------------------------- 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 # --------------------------------------------------------------------------- diff --git a/src/Tools/blocFissure/CasTests/faceGauche_2.py b/src/Tools/blocFissure/CasTests/faceGauche_2.py index f624f8764..04787d61a 100644 --- a/src/Tools/blocFissure/CasTests/faceGauche_2.py +++ b/src/Tools/blocFissure/CasTests/faceGauche_2.py @@ -54,7 +54,7 @@ class faceGauche_2(fissureGenerique): 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 @@ -85,7 +85,7 @@ class faceGauche_2(fissureGenerique): 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] @@ -101,7 +101,8 @@ class faceGauche_2(fissureGenerique): # --------------------------------------------------------------------------- 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 # --------------------------------------------------------------------------- diff --git a/src/Tools/blocFissure/CasTests/fissure_Coude.py b/src/Tools/blocFissure/CasTests/fissure_Coude.py index e5705002a..6b1e42977 100644 --- a/src/Tools/blocFissure/CasTests/fissure_Coude.py +++ b/src/Tools/blocFissure/CasTests/fissure_Coude.py @@ -39,6 +39,7 @@ from blocFissure.gmu.triedreBase import triedreBase 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() @@ -233,38 +234,38 @@ class fissure_Coude(fissureGenerique): 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) @@ -478,7 +479,7 @@ class fissure_Coude(fissureGenerique): 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] @@ -497,7 +498,8 @@ class fissure_Coude(fissureGenerique): # --------------------------------------------------------------------------- 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 # --------------------------------------------------------------------------- @@ -510,7 +512,7 @@ class fissure_Coude(fissureGenerique): maillageFissure = insereFissureLongue(geometriesSaines, \ shapesFissure, shapeFissureParams, \ maillageFissureParams, elementsDefaut, \ - step, mailleur) + step, mailleur, self.numeroCas) return maillageFissure # --------------------------------------------------------------------------- diff --git a/src/Tools/blocFissure/CasTests/tube.py b/src/Tools/blocFissure/CasTests/tube.py index c579b384d..4e4460130 100644 --- a/src/Tools/blocFissure/CasTests/tube.py +++ b/src/Tools/blocFissure/CasTests/tube.py @@ -84,7 +84,7 @@ class tube(fissureGenerique): 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 @@ -103,7 +103,8 @@ class tube(fissureGenerique): # --------------------------------------------------------------------------- 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 # --------------------------------------------------------------------------- diff --git a/src/Tools/blocFissure/CasTests/vis_1.py b/src/Tools/blocFissure/CasTests/vis_1.py index b1f2dde7c..3f5793030 100644 --- a/src/Tools/blocFissure/CasTests/vis_1.py +++ b/src/Tools/blocFissure/CasTests/vis_1.py @@ -85,7 +85,7 @@ class vis_1(fissureGenerique): 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 @@ -104,7 +104,8 @@ class vis_1(fissureGenerique): # --------------------------------------------------------------------------- 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 # --------------------------------------------------------------------------- diff --git a/src/Tools/blocFissure/gmu/CMakeLists.txt b/src/Tools/blocFissure/gmu/CMakeLists.txt index d23bf8884..8fdcb3a6d 100644 --- a/src/Tools/blocFissure/gmu/CMakeLists.txt +++ b/src/Tools/blocFissure/gmu/CMakeLists.txt @@ -89,7 +89,6 @@ SET(plugin_SCRIPTS initEtude.py initLog.py insereFissureElliptique.py - insereFissureGenerale.py insereFissureLongue_a.py insereFissureLongue_b.py insereFissureLongue_c.py diff --git a/src/Tools/blocFissure/gmu/calculePointsAxiauxPipe.py b/src/Tools/blocFissure/gmu/calculePointsAxiauxPipe.py index 79e3215a7..370d416df 100644 --- a/src/Tools/blocFissure/gmu/calculePointsAxiauxPipe.py +++ b/src/Tools/blocFissure/gmu/calculePointsAxiauxPipe.py @@ -25,9 +25,12 @@ import math 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 @@ -37,6 +40,7 @@ def calculePointsAxiauxPipe(edgesFondFiss, edgesIdByOrientation, facesDefaut, """ 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 @@ -60,7 +64,10 @@ def calculePointsAxiauxPipe(edgesFondFiss, edgesIdByOrientation, facesDefaut, 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" diff --git a/src/Tools/blocFissure/gmu/casStandard.py b/src/Tools/blocFissure/gmu/casStandard.py index ecce71672..5e433531d 100644 --- a/src/Tools/blocFissure/gmu/casStandard.py +++ b/src/Tools/blocFissure/gmu/casStandard.py @@ -39,6 +39,7 @@ from .triedreBase import triedreBase from .genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut from .creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain from .construitFissureGenerale import construitFissureGenerale +from .putName import putName O, OX, OY, OZ = triedreBase() @@ -47,7 +48,7 @@ class casStandard(fissureGenerique): - 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 @@ -90,7 +91,7 @@ class casStandard(fissureGenerique): 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 @@ -149,7 +150,7 @@ class casStandard(fissureGenerique): coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, self.dicoParams['meshBrep'][0] ,self.dicoParams['meshBrep'][1], \ - mailleur) + mailleur, self.numeroCas) centre = None return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss] @@ -166,7 +167,8 @@ class casStandard(fissureGenerique): # --------------------------------------------------------------------------- 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 # --------------------------------------------------------------------------- diff --git a/src/Tools/blocFissure/gmu/construitFissureGenerale.py b/src/Tools/blocFissure/gmu/construitFissureGenerale.py index 7500a5440..365aeea5e 100644 --- a/src/Tools/blocFissure/gmu/construitFissureGenerale.py +++ b/src/Tools/blocFissure/gmu/construitFissureGenerale.py @@ -59,8 +59,7 @@ def construitFissureGenerale(shapesFissure, shapeFissureParams, \ 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 @@ -150,9 +149,10 @@ def construitFissureGenerale(shapesFissure, shapeFissureParams, \ # - 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 @@ -179,11 +179,14 @@ def construitFissureGenerale(shapesFissure, shapeFissureParams, \ # --- 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 @@ -191,7 +194,7 @@ def construitFissureGenerale(shapesFissure, shapeFissureParams, \ mailleFacesFissure(faceFissureExterne, \ edgesPipeFissureExterneC, edgesPeauFissureExterneC, \ meshPipeGroups, areteFaceFissure, rayonPipe, nbsegRad, \ - mailleur) + mailleur, nro_cas) # --- maillage faces de peau @@ -214,7 +217,7 @@ def construitFissureGenerale(shapesFissure, shapeFissureParams, \ zoneDefaut, zoneDefaut_skin, zoneDefaut_internalFaces, zoneDefaut_internalEdges, \ facesPortFissure, \ maillageFissureParams, \ - mailleur ) + mailleur, nro_cas ) if salome.sg.hasDesktop(): salome.sg.updateObjBrowser() diff --git a/src/Tools/blocFissure/gmu/construitFissureGenerale_c.py b/src/Tools/blocFissure/gmu/construitFissureGenerale_c.py index 767862f81..c718ddf7f 100644 --- a/src/Tools/blocFissure/gmu/construitFissureGenerale_c.py +++ b/src/Tools/blocFissure/gmu/construitFissureGenerale_c.py @@ -43,10 +43,10 @@ def construitFissureGenerale_c(maillageSain, meshBoiteDefaut, \ 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'] @@ -77,9 +77,9 @@ def construitFissureGenerale_c(maillageSain, meshBoiteDefaut, \ 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" @@ -94,7 +94,7 @@ def construitFissureGenerale_c(maillageSain, meshBoiteDefaut, \ '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) diff --git a/src/Tools/blocFissure/gmu/creeZoneDefautDansObjetSain.py b/src/Tools/blocFissure/gmu/creeZoneDefautDansObjetSain.py index d14f26ee2..00d516027 100644 --- a/src/Tools/blocFissure/gmu/creeZoneDefautDansObjetSain.py +++ b/src/Tools/blocFissure/gmu/creeZoneDefautDansObjetSain.py @@ -35,7 +35,8 @@ from .creeZoneDefautGeom import creeZoneDefautGeom from .getCentreFondFiss import getCentreFondFiss def creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure, \ - shapeFissureParams, maillageFissureParams): + shapeFissureParams, maillageFissureParams, \ + nro_cas=-1): """ #TODO: a compléter """ @@ -78,7 +79,8 @@ def creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure, 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() diff --git a/src/Tools/blocFissure/gmu/eliminateDoubles.py b/src/Tools/blocFissure/gmu/eliminateDoubles.py index f037a790e..86c56b3a2 100644 --- a/src/Tools/blocFissure/gmu/eliminateDoubles.py +++ b/src/Tools/blocFissure/gmu/eliminateDoubles.py @@ -22,9 +22,6 @@ import logging from .geomsmesh import geompy -# ----------------------------------------------------------------------------- -# --- - def eliminateDoubles(obj, subshapes): """éliminer les doublons d'une liste de subshapes""" @@ -37,7 +34,7 @@ def eliminateDoubles(obj, 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) diff --git a/src/Tools/blocFissure/gmu/fissureCoude.py b/src/Tools/blocFissure/gmu/fissureCoude.py index 48892cd62..7f55036a1 100644 --- a/src/Tools/blocFissure/gmu/fissureCoude.py +++ b/src/Tools/blocFissure/gmu/fissureCoude.py @@ -40,6 +40,7 @@ from .genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut from .creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain from .construitFissureGenerale import construitFissureGenerale from .sortEdges import sortEdges +from .putName import putName O, OX, OY, OZ = triedreBase() @@ -262,38 +263,38 @@ class fissureCoude(fissureGenerique): 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" @@ -648,7 +649,7 @@ class fissureCoude(fissureGenerique): geomPublish(initLog.debug, centre, 'centrefissPlace' ) coordsNoeudsFissure = genereMeshCalculZoneDefaut(facefiss, profondeur/2. ,profondeur, \ - mailleur) + mailleur, self.numeroCas) return [facefiss, centre, lgInfluence, coordsNoeudsFissure, wiretube, edgetube] @@ -670,7 +671,8 @@ class fissureCoude(fissureGenerique): # --------------------------------------------------------------------------- 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 # --------------------------------------------------------------------------- diff --git a/src/Tools/blocFissure/gmu/fusionMaillageAttributionDefaut.py b/src/Tools/blocFissure/gmu/fusionMaillageAttributionDefaut.py index a509c0350..c4aedf818 100644 --- a/src/Tools/blocFissure/gmu/fusionMaillageAttributionDefaut.py +++ b/src/Tools/blocFissure/gmu/fusionMaillageAttributionDefaut.py @@ -33,11 +33,15 @@ from .geomsmesh import smesh 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() @@ -96,6 +100,6 @@ def fusionMaillageDefaut(maillageSain, maillageDefautCible, maillageInterneCible 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 diff --git a/src/Tools/blocFissure/gmu/genereElemsFissureElliptique.py b/src/Tools/blocFissure/gmu/genereElemsFissureElliptique.py index a5bd42b36..58467bc18 100644 --- a/src/Tools/blocFissure/gmu/genereElemsFissureElliptique.py +++ b/src/Tools/blocFissure/gmu/genereElemsFissureElliptique.py @@ -32,7 +32,7 @@ from .rotTrans import rotTrans 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') @@ -70,6 +70,6 @@ def genereElemsFissureElliptique(shapeFissureParams, \ 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 diff --git a/src/Tools/blocFissure/gmu/genereMeshCalculZoneDefaut.py b/src/Tools/blocFissure/gmu/genereMeshCalculZoneDefaut.py index ceff2c22f..ea42ef905 100644 --- a/src/Tools/blocFissure/gmu/genereMeshCalculZoneDefaut.py +++ b/src/Tools/blocFissure/gmu/genereMeshCalculZoneDefaut.py @@ -25,8 +25,10 @@ from salome.smesh import smeshBuilder 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 : @@ -50,9 +52,12 @@ def genereMeshCalculZoneDefaut(facefiss, minSize, maxSize, \ """ 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) @@ -71,8 +76,8 @@ def genereMeshCalculZoneDefaut(facefiss, minSize, maxSize, \ 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" diff --git a/src/Tools/blocFissure/gmu/insereFissureElliptique.py b/src/Tools/blocFissure/gmu/insereFissureElliptique.py index 3f1a60e07..aa0e945f7 100644 --- a/src/Tools/blocFissure/gmu/insereFissureElliptique.py +++ b/src/Tools/blocFissure/gmu/insereFissureElliptique.py @@ -95,116 +95,122 @@ def insereFissureElliptique(geometriesSaines, maillagesSains, \ 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() diff --git a/src/Tools/blocFissure/gmu/insereFissureGenerale.py b/src/Tools/blocFissure/gmu/insereFissureGenerale.py deleted file mode 100644 index 26caa4069..000000000 --- a/src/Tools/blocFissure/gmu/insereFissureGenerale.py +++ /dev/null @@ -1,1447 +0,0 @@ -# -*- 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 diff --git a/src/Tools/blocFissure/gmu/insereFissureLongue.py b/src/Tools/blocFissure/gmu/insereFissureLongue.py index 62bf50258..de4245186 100644 --- a/src/Tools/blocFissure/gmu/insereFissureLongue.py +++ b/src/Tools/blocFissure/gmu/insereFissureLongue.py @@ -42,10 +42,10 @@ from .insereFissureLongue_g import insereFissureLongue_g 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 @@ -114,7 +114,8 @@ def insereFissureLongue(geometriesSaines, \ planfiss, planBord1, planBord2, \ facePeau, verticesOutCercles, verticesEdgePeauFiss, \ fillingFaceExterne, rayonPipe, \ - internalBoundary) + internalBoundary, \ + nro_cas) # --- maillage pipe fond fissure @@ -122,7 +123,8 @@ def insereFissureLongue(geometriesSaines, \ insereFissureLongue_c (pipeFondFiss, disques, rayons, demiCercles, demiCerclesPeau, generatrices, \ VerticesEndPipeFiss, verticesEdgePeauFiss, \ groupFaceFissInPipe, groupEdgeFondFiss, groupsDemiCerclesPipe, groupGenerFiss, \ - profondeur, rayonPipe) + profondeur, rayonPipe, \ + nro_cas) # --- maillage face de peau @@ -130,20 +132,20 @@ def insereFissureLongue(geometriesSaines, \ 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 @@ -151,7 +153,8 @@ def insereFissureLongue(geometriesSaines, \ 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(): diff --git a/src/Tools/blocFissure/gmu/insereFissureLongue_a.py b/src/Tools/blocFissure/gmu/insereFissureLongue_a.py index 5b31e0b6e..1816d9e49 100644 --- a/src/Tools/blocFissure/gmu/insereFissureLongue_a.py +++ b/src/Tools/blocFissure/gmu/insereFissureLongue_a.py @@ -128,29 +128,29 @@ def insereFissureLongue_a(facePorteFissure, WirePorteFondFissure, \ 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) diff --git a/src/Tools/blocFissure/gmu/insereFissureLongue_b.py b/src/Tools/blocFissure/gmu/insereFissureLongue_b.py index 38c94ead4..946cb9bf7 100644 --- a/src/Tools/blocFissure/gmu/insereFissureLongue_b.py +++ b/src/Tools/blocFissure/gmu/insereFissureLongue_b.py @@ -37,16 +37,19 @@ from .sortEdges import sortEdges 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 @@ -214,12 +217,13 @@ def insereFissureLongue_b(edgesInside, centreFondFiss, tangentFondFiss, \ _ = 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" diff --git a/src/Tools/blocFissure/gmu/insereFissureLongue_c.py b/src/Tools/blocFissure/gmu/insereFissureLongue_c.py index ce6d0b25b..9efc75232 100644 --- a/src/Tools/blocFissure/gmu/insereFissureLongue_c.py +++ b/src/Tools/blocFissure/gmu/insereFissureLongue_c.py @@ -36,53 +36,57 @@ from .distance2 import distance2 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' ) @@ -95,10 +99,10 @@ def insereFissureLongue_c (pipeFondFiss, disques, rayons, demiCercles, demiCercl 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) @@ -134,12 +138,12 @@ def insereFissureLongue_c (pipeFondFiss, disques, rayons, demiCercles, demiCercl 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] = 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]) diff --git a/src/Tools/blocFissure/gmu/insereFissureLongue_d.py b/src/Tools/blocFissure/gmu/insereFissureLongue_d.py index 35a63dd72..c52577f67 100644 --- a/src/Tools/blocFissure/gmu/insereFissureLongue_d.py +++ b/src/Tools/blocFissure/gmu/insereFissureLongue_d.py @@ -33,12 +33,14 @@ from .putName import putName 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() @@ -55,9 +57,9 @@ def insereFissureLongue_d (facePeau, edgePeauFiss, groupEdgesBordPeau, bordsLibr 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 @@ -70,22 +72,22 @@ def insereFissureLongue_d (facePeau, edgePeauFiss, groupEdgesBordPeau, bordsLibr 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) diff --git a/src/Tools/blocFissure/gmu/insereFissureLongue_e.py b/src/Tools/blocFissure/gmu/insereFissureLongue_e.py index b0e81dba7..c82f13286 100644 --- a/src/Tools/blocFissure/gmu/insereFissureLongue_e.py +++ b/src/Tools/blocFissure/gmu/insereFissureLongue_e.py @@ -32,13 +32,15 @@ from .putName import putName 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() @@ -55,21 +57,21 @@ def insereFissureLongue_e (faceFiss, edgePeauFiss, groupEdgesPeauFiss, group_gen 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) diff --git a/src/Tools/blocFissure/gmu/insereFissureLongue_f.py b/src/Tools/blocFissure/gmu/insereFissureLongue_f.py index 8804e9ca3..dfe14539f 100644 --- a/src/Tools/blocFissure/gmu/insereFissureLongue_f.py +++ b/src/Tools/blocFissure/gmu/insereFissureLongue_f.py @@ -30,16 +30,16 @@ from .geomsmesh import smesh 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 @@ -65,9 +65,9 @@ def insereFissureLongue_f (internalBoundary, meshFondFiss, meshFacePeau, meshFac 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" diff --git a/src/Tools/blocFissure/gmu/insereFissureLongue_g.py b/src/Tools/blocFissure/gmu/insereFissureLongue_g.py index dfd98627f..5d9ddeedb 100644 --- a/src/Tools/blocFissure/gmu/insereFissureLongue_g.py +++ b/src/Tools/blocFissure/gmu/insereFissureLongue_g.py @@ -37,9 +37,11 @@ from .triedreBase import triedreBase 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() @@ -52,7 +54,7 @@ def insereFissureLongue_g(nomFicFissure, fichierMaillageFissure, nomFicSain, mai _ = 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') diff --git a/src/Tools/blocFissure/gmu/mailleAretesEtJonction.py b/src/Tools/blocFissure/gmu/mailleAretesEtJonction.py index b39f899aa..e35e5af3e 100644 --- a/src/Tools/blocFissure/gmu/mailleAretesEtJonction.py +++ b/src/Tools/blocFissure/gmu/mailleAretesEtJonction.py @@ -28,9 +28,11 @@ from .geomsmesh import smesh 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, [ ]) @@ -39,7 +41,7 @@ def mailleAretesEtJonction(internalBoundary, aretesVivesCoupees, lgAretesVives): 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" @@ -56,9 +58,9 @@ def mailleAretesEtJonction(internalBoundary, aretesVivesCoupees, lgAretesVives): 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" diff --git a/src/Tools/blocFissure/gmu/mailleFacesFissure.py b/src/Tools/blocFissure/gmu/mailleFacesFissure.py index 605b0752b..74e0f3773 100644 --- a/src/Tools/blocFissure/gmu/mailleFacesFissure.py +++ b/src/Tools/blocFissure/gmu/mailleFacesFissure.py @@ -31,9 +31,10 @@ from .putName import putName 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) @@ -54,17 +55,17 @@ def mailleFacesFissure(faceFissureExterne, \ 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) diff --git a/src/Tools/blocFissure/gmu/mailleFacesPeau.py b/src/Tools/blocFissure/gmu/mailleFacesPeau.py index 5566ccac2..cdb8ac14b 100644 --- a/src/Tools/blocFissure/gmu/mailleFacesPeau.py +++ b/src/Tools/blocFissure/gmu/mailleFacesPeau.py @@ -40,7 +40,8 @@ def mailleFacesPeau(partitionsPeauFissFond, idFillingFromBout, facesDefaut, \ 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 diff --git a/src/Tools/blocFissure/gmu/meshBlocPart.py b/src/Tools/blocFissure/gmu/meshBlocPart.py index 4693f307f..6f49c0fc6 100644 --- a/src/Tools/blocFissure/gmu/meshBlocPart.py +++ b/src/Tools/blocFissure/gmu/meshBlocPart.py @@ -36,9 +36,10 @@ def meshBlocPart(blocPartition, faceFissure, tore, centres, edges, diams, circle 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 @@ -49,7 +50,7 @@ def meshBlocPart(blocPartition, faceFissure, tore, centres, edges, diams, circle 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 @@ -61,34 +62,34 @@ def meshBlocPart(blocPartition, faceFissure, tore, centres, edges, diams, circle 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) @@ -96,9 +97,9 @@ def meshBlocPart(blocPartition, faceFissure, tore, centres, edges, diams, circle 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) @@ -106,16 +107,16 @@ def meshBlocPart(blocPartition, faceFissure, tore, centres, edges, diams, circle 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)) @@ -124,9 +125,9 @@ def meshBlocPart(blocPartition, faceFissure, tore, centres, edges, diams, circle 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() @@ -144,15 +145,15 @@ def meshBlocPart(blocPartition, faceFissure, tore, centres, edges, diams, circle 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 @@ -164,33 +165,33 @@ def meshBlocPart(blocPartition, faceFissure, tore, centres, edges, diams, circle 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) @@ -230,9 +231,9 @@ def meshBlocPart(blocPartition, faceFissure, tore, centres, edges, diams, circle 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" diff --git a/src/Tools/blocFissure/gmu/peauInterne.py b/src/Tools/blocFissure/gmu/peauInterne.py index 6c241a75c..d2087d84a 100644 --- a/src/Tools/blocFissure/gmu/peauInterne.py +++ b/src/Tools/blocFissure/gmu/peauInterne.py @@ -29,8 +29,10 @@ from .geomsmesh import smesh 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. @@ -97,6 +99,7 @@ def peauInterne(fichierMaillage, shapeDefaut, nomZones): 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) diff --git a/src/Tools/blocFissure/gmu/putName.py b/src/Tools/blocFissure/gmu/putName.py index af556e622..dadd6f22f 100644 --- a/src/Tools/blocFissure/gmu/putName.py +++ b/src/Tools/blocFissure/gmu/putName.py @@ -17,9 +17,9 @@ # # 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): @@ -31,6 +31,7 @@ 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) @@ -40,5 +41,6 @@ def putName (objmesh, name, i_suff=-1, i_pref=-1): if i_pref >= 0: prefixe = "Cas{:02d}_".format(i_pref) name = prefixe + name + #logging.info("Au final : %s", name) smesh.SetName(objmesh, name)