From: GERALD NICOLAS Date: Thu, 25 Mar 2021 08:08:23 +0000 (+0100) Subject: Merge branch 'master' into gni/evolution X-Git-Tag: V9_7_0a1~13^2~3 X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=commitdiff_plain;h=b24a2d1b7692bdb21cf037b026e0273ba547cef4;hp=24825596b3595ab0c0b1988368a886864d1080ef Merge branch 'master' into gni/evolution --- diff --git a/src/Tools/blocFissure/AREextradosLauncher.py b/src/Tools/blocFissure/AREextradosLauncher.py index 41bd5a770..03822c612 100644 --- a/src/Tools/blocFissure/AREextradosLauncher.py +++ b/src/Tools/blocFissure/AREextradosLauncher.py @@ -38,8 +38,8 @@ crack = 'fissureExtrados.brep' dicoParams = dict(nomCas = 'fissTuyau', maillageSain = '/local00/home/I48174/Documents/soudure/essaiFissure/{0}'.format(mesh), - brepFaceFissure = '/local00/home/I48174/Documents/soudure/essaiFissure/{0}'.format(crack), - edgeFissIds = [4], + CAOFaceFissure = '/local00/home/I48174/Documents/soudure/essaiFissure/{0}'.format(crack), + edgeFiss = [4], lgInfluence = 12, meshBrep = (0.05, 2.0), rayonPipe = 1.0, diff --git a/src/Tools/blocFissure/AREintradosLauncher.py b/src/Tools/blocFissure/AREintradosLauncher.py index 01d865f73..8fd028a26 100644 --- a/src/Tools/blocFissure/AREintradosLauncher.py +++ b/src/Tools/blocFissure/AREintradosLauncher.py @@ -38,8 +38,8 @@ crack = 'fissureIntrados.brep' dicoParams = dict(nomCas = 'fissTuyau', maillageSain = '/local00/home/I48174/Documents/soudure/essaiFissure/{0}'.format(mesh), - brepFaceFissure = '/local00/home/I48174/Documents/soudure/essaiFissure/{0}'.format(crack), - edgeFissIds = [4], + CAOFaceFissure = '/local00/home/I48174/Documents/soudure/essaiFissure/{0}'.format(crack), + edgeFiss = [4], lgInfluence = 14, meshBrep = (0.05, 2.0), rayonPipe = 1.0, diff --git a/src/Tools/blocFissure/CasTests/CMakeLists.txt b/src/Tools/blocFissure/CasTests/CMakeLists.txt index 26e9bf5fc..768955a58 100644 --- a/src/Tools/blocFissure/CasTests/CMakeLists.txt +++ b/src/Tools/blocFissure/CasTests/CMakeLists.txt @@ -51,6 +51,7 @@ SET(plugin_SCRIPTS fissureCoude_9.py fissure_Coude.py vis_1.py + tube.py ) # --- rules --- diff --git a/src/Tools/blocFissure/CasTests/cubeAngle.py b/src/Tools/blocFissure/CasTests/cubeAngle.py index c7cac0bc7..236b7ea46 100644 --- a/src/Tools/blocFissure/CasTests/cubeAngle.py +++ b/src/Tools/blocFissure/CasTests/cubeAngle.py @@ -18,41 +18,37 @@ # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # -import os -from blocFissure import gmu -from blocFissure.gmu.geomsmesh import geompy, smesh +"""problème de fissure plane coupant 2 faces (angle), débouches normaux, objet plan""" -import math -import GEOM -import SALOMEDS -import SMESH -#import StdMeshers -#import GHS3DPlugin -#import NETGENPlugin +import os import logging +from blocFissure import gmu +from blocFissure.gmu.geomsmesh import geompy, smesh from blocFissure.gmu.fissureGenerique import fissureGenerique - -from blocFissure.gmu.triedreBase import triedreBase from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale -O, OX, OY, OZ = triedreBase() +import GEOM +import SALOMEDS +import SMESH class cubeAngle(fissureGenerique): - """ - problème de fissure plane coupant 2 faces (angle), débouches normaux, objet plan - """ + """problème de fissure plane coupant 2 faces (angle), débouches normaux, objet plan""" nomProbleme = "cubeAngle" + shapeFissureParams = dict() + maillageFissureParams = dict() + referencesMaillageFissure = dict() # --------------------------------------------------------------------------- def genereMaillageSain(self, geometriesSaines, meshParams): - logging.info("genereMaillageSain %s", self.nomCas) + texte = "genereMaillageSain pour '{}'".format(self.nomCas) + logging.info(texte) - ([objetSain], status) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, 'materielCasTests/CubeAngle.med')) - smesh.SetName(objetSain.GetMesh(), 'objetSain') + ([objetSain], _) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests", "CubeAngle.med")) + smesh.SetName(objetSain.GetMesh(), "{}_objetSain".format(self.nomProbleme)) return [objetSain, True] # True : maillage hexa @@ -63,33 +59,40 @@ class cubeAngle(fissureGenerique): lgInfluence : distance autour de la shape de fissure a remailler (A ajuster selon le maillage) rayonPipe : le rayon du pile maillé en hexa autour du fond de fissure """ - logging.info("setParamShapeFissure %s", self.nomCas) + texte = "genereMaillageSain pour '{}'".format(self.nomCas) + logging.info(texte) self.shapeFissureParams = dict(lgInfluence = 20, rayonPipe = 10) # --------------------------------------------------------------------------- - def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams): - logging.info("genereShapeFissure %s", self.nomCas) + def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams, \ + mailleur="MeshGems"): + """Importe la géométrie de la fissure""" + texte = "genereShapeFissure pour '{}'".format(self.nomCas) + logging.info(texte) lgInfluence = shapeFissureParams['lgInfluence'] - shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests/CubeAngleFiss.brep")) + shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests", "CubeAngleFiss.brep")) fondFiss = geompy.CreateGroup(shellFiss, geompy.ShapeType["EDGE"]) geompy.UnionIDs(fondFiss, [3]) geompy.addToStudy( shellFiss, 'shellFiss' ) geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' ) - - coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,10) + mailleur = self.mailleur2d3d() + coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,10, mailleur) centre = None + return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss] # --------------------------------------------------------------------------- def setParamMaillageFissure(self): - self.maillageFissureParams = dict(nomRep = '.', + texte = "setParamMaillageFissure pour '{}'".format(self.nomCas) + logging.info(texte) + self.maillageFissureParams = dict(nomRep = os.curdir, nomFicSain = self.nomCas, - nomFicFissure = 'fissure_' + self.nomCas, + nomFicFissure = self.nomCas + "_fissure", nbsegRad = 5, nbsegCercle = 8, areteFaceFissure = 10) @@ -100,22 +103,28 @@ class cubeAngle(fissureGenerique): return elementsDefaut # --------------------------------------------------------------------------- - def genereMaillageFissure(self, geometriesSaines, maillagesSains, - shapesFissure, shapeFissureParams, - maillageFissureParams, elementsDefaut, step): - maillageFissure = construitFissureGenerale(maillagesSains, - shapesFissure, shapeFissureParams, - maillageFissureParams, elementsDefaut, step) + def genereMaillageFissure(self, geometriesSaines, maillagesSains, \ + shapesFissure, shapeFissureParams, \ + maillageFissureParams, elementsDefaut, step, \ + mailleur="MeshGems"): + texte = "genereMaillageFissure pour '{}'".format(self.nomCas) + logging.info(texte) + + mailleur = self.mailleur2d3d() + maillageFissure = construitFissureGenerale(shapesFissure, shapeFissureParams, \ + maillageFissureParams, elementsDefaut, \ + step, mailleur) return maillageFissure # --------------------------------------------------------------------------- def setReferencesMaillageFissure(self): - self.referencesMaillageFissure = dict(Entity_Quad_Pyramid = 204, - Entity_Quad_Triangle = 336, - Entity_Quad_Edge = 278, - Entity_Quad_Penta = 96, - Entity_Quad_Hexa = 3651, - Entity_Node = 20490, - Entity_Quad_Tetra = 1877, - Entity_Quad_Quadrangle = 1702) - + self.referencesMaillageFissure = dict( \ + Entity_Quad_Quadrangle = 1630, \ + Entity_Quad_Hexa = 3523, \ + Entity_Node = 18874, \ + Entity_Quad_Edge = 261, \ + Entity_Quad_Triangle = 190, \ + Entity_Quad_Tetra = 1322, \ + Entity_Quad_Pyramid = 172, \ + Entity_Quad_Penta = 64 \ + ) diff --git a/src/Tools/blocFissure/CasTests/cubeAngle2.py b/src/Tools/blocFissure/CasTests/cubeAngle2.py index 31d398a2e..aa35b6225 100644 --- a/src/Tools/blocFissure/CasTests/cubeAngle2.py +++ b/src/Tools/blocFissure/CasTests/cubeAngle2.py @@ -17,21 +17,24 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""problème de fissure plane coupant 2 faces (angle)""" + +import os from .cubeAngle import cubeAngle class cubeAngle2(cubeAngle): - """ - problème de fissure plane coupant 2 faces (angle), débouches normaux, objet plan - detection d'un probleme de tolerance sur les edges de jonction pipe et face fissure externe + """problème de fissure plane coupant 2 faces (angle), débouches normaux, objet plan + + detection d'un probleme de tolerance sur les edges de jonction pipe et face fissure externe """ nomProbleme = "cubeAngle2" # --------------------------------------------------------------------------- def setParamShapeFissure(self): - """ - paramètres de la fissure pour méthode construitFissureGenerale + """paramètres de la fissure pour méthode construitFissureGenerale + lgInfluence : distance autour de la shape de fissure a remailler (A ajuster selon le maillage) rayonPipe : le rayon du pile maillé en hexa autour du fond de fissure """ @@ -40,21 +43,22 @@ class cubeAngle2(cubeAngle): # --------------------------------------------------------------------------- def setParamMaillageFissure(self): - self.maillageFissureParams = dict(nomRep = '.', + self.maillageFissureParams = dict(nomRep = os.curdir, nomFicSain = self.nomCas, - nomFicFissure = 'fissure_' + self.nomCas, + nomFicFissure = self.nomCas + "_fissure", nbsegRad = 5, nbsegCercle = 32, areteFaceFissure = 5) # --------------------------------------------------------------------------- def setReferencesMaillageFissure(self): - self.referencesMaillageFissure = dict(Entity_Quad_Pyramid = 748, - Entity_Quad_Triangle = 1228, - Entity_Quad_Edge = 351, - Entity_Quad_Penta = 640, - Entity_Quad_Hexa = 5827, - Entity_Node = 42865, - Entity_Quad_Tetra = 9216, - Entity_Quad_Quadrangle = 2518) - + self.referencesMaillageFissure = dict( \ + Entity_Quad_Quadrangle = 2350, \ + Entity_Quad_Hexa = 5315, \ + Entity_Node = 38196, \ + Entity_Quad_Edge = 345, \ + Entity_Quad_Triangle = 1214, \ + Entity_Quad_Tetra = 7772, \ + Entity_Quad_Pyramid = 620, \ + Entity_Quad_Penta = 512 \ + ) diff --git a/src/Tools/blocFissure/CasTests/cubeCoin.py b/src/Tools/blocFissure/CasTests/cubeCoin.py index 3626ef439..e6221be87 100644 --- a/src/Tools/blocFissure/CasTests/cubeCoin.py +++ b/src/Tools/blocFissure/CasTests/cubeCoin.py @@ -18,13 +18,15 @@ # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""problème de fissure plane coupant le cube dans un coin""" + import os from blocFissure import gmu -dicoParams = dict(nomCas = 'cubeCoin', - maillageSain = os.path.join(gmu.pathBloc, 'materielCasTests/cubeFin.med'), - brepFaceFissure = os.path.join(gmu.pathBloc, "materielCasTests/cubeFin_Coin.brep"), - edgeFissIds = [6], +dicoParams = dict(nomCas = "cubeCoin", + maillageSain = os.path.join(gmu.pathBloc, "materielCasTests", "cubeFin.med"), + CAOFaceFissure = os.path.join(gmu.pathBloc, "materielCasTests", "cubeFin_Coin.brep"), + edgeFiss = [3], lgInfluence = 50, meshBrep = (5,10), rayonPipe = 10, @@ -35,12 +37,13 @@ dicoParams = dict(nomCas = 'cubeCoin', # --------------------------------------------------------------------------- -referencesMaillageFissure = dict(Entity_Quad_Pyramid = 0, - Entity_Quad_Triangle = 0, - Entity_Quad_Edge = 0, - Entity_Quad_Penta = 0, - Entity_Quad_Hexa = 0, - Entity_Node = 0, - Entity_Quad_Tetra = 0, - Entity_Quad_Quadrangle = 0) - +referencesMaillageFissure = dict( \ + Entity_Quad_Quadrangle = 2740, \ + Entity_Quad_Hexa = 7420, \ + Entity_Node = 46394, \ + Entity_Quad_Edge = 323, \ + Entity_Quad_Triangle = 486, \ + Entity_Quad_Tetra = 8512, \ + Entity_Quad_Pyramid = 460, \ + Entity_Quad_Penta = 80 \ + ) diff --git a/src/Tools/blocFissure/CasTests/cubeMilieu.py b/src/Tools/blocFissure/CasTests/cubeMilieu.py index d287618f3..96d069e35 100644 --- a/src/Tools/blocFissure/CasTests/cubeMilieu.py +++ b/src/Tools/blocFissure/CasTests/cubeMilieu.py @@ -18,13 +18,15 @@ # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""problème de fissure plane coupant le cube au milieu""" + import os from blocFissure import gmu -dicoParams = dict(nomCas = 'cubeMilieu', - maillageSain = os.path.join(gmu.pathBloc, 'materielCasTests/cubeFin.med'), - brepFaceFissure = os.path.join(gmu.pathBloc, "materielCasTests/cubeFin_Milieu.brep"), - edgeFissIds = [6], +dicoParams = dict(nomCas = "cubeMilieu", + maillageSain = os.path.join(gmu.pathBloc, "materielCasTests", "cubeFin.med"), + CAOFaceFissure = os.path.join(gmu.pathBloc, "materielCasTests", "cubeFin_Milieu.brep"), + edgeFiss = [3], lgInfluence = 50, meshBrep = (5,10), rayonPipe = 10, @@ -35,12 +37,13 @@ dicoParams = dict(nomCas = 'cubeMilieu', # --------------------------------------------------------------------------- -referencesMaillageFissure = dict(Entity_Quad_Pyramid = 0, - Entity_Quad_Triangle = 0, - Entity_Quad_Edge = 0, - Entity_Quad_Penta = 0, - Entity_Quad_Hexa = 0, - Entity_Node = 0, - Entity_Quad_Tetra = 0, - Entity_Quad_Quadrangle = 0) - +referencesMaillageFissure = dict( \ + Entity_Quad_Quadrangle = 3140, \ + Entity_Quad_Hexa = 7120, \ + Entity_Node = 61414, \ + Entity_Quad_Edge = 346, \ + Entity_Quad_Triangle = 818, \ + Entity_Quad_Tetra = 19117, \ + Entity_Quad_Pyramid = 990, \ + Entity_Quad_Penta = 230 \ + ) diff --git a/src/Tools/blocFissure/CasTests/cubeTransverse.py b/src/Tools/blocFissure/CasTests/cubeTransverse.py index 875906df7..bc05c37a4 100644 --- a/src/Tools/blocFissure/CasTests/cubeTransverse.py +++ b/src/Tools/blocFissure/CasTests/cubeTransverse.py @@ -18,13 +18,15 @@ # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""problème de fissure plane coupant le cube au milieu""" + import os from blocFissure import gmu -dicoParams = dict(nomCas = 'cubeTransverse', - maillageSain = os.path.join(gmu.pathBloc, 'materielCasTests/cubeFin.med'), - brepFaceFissure = os.path.join(gmu.pathBloc, "materielCasTests/cubeFin_Transverse.brep"), - edgeFissIds = [6], +dicoParams = dict(nomCas = "cubeTransverse", + maillageSain = os.path.join(gmu.pathBloc, "materielCasTests", "cubeFin.med"), + CAOFaceFissure = os.path.join(gmu.pathBloc, "materielCasTests", "cubeFin_Transverse.brep"), + edgeFiss = [6], lgInfluence = 50, meshBrep = (5,10), rayonPipe = 10, @@ -35,12 +37,13 @@ dicoParams = dict(nomCas = 'cubeTransverse', # --------------------------------------------------------------------------- -referencesMaillageFissure = dict(Entity_Quad_Pyramid = 0, - Entity_Quad_Triangle = 0, - Entity_Quad_Edge = 0, - Entity_Quad_Penta = 0, - Entity_Quad_Hexa = 0, - Entity_Node = 0, - Entity_Quad_Tetra = 0, - Entity_Quad_Quadrangle = 0) - +referencesMaillageFissure = dict( \ + Entity_Quad_Quadrangle = 2900, \ + Entity_Quad_Hexa = 7000, \ + Entity_Node = 58430, \ + Entity_Quad_Edge = 390, \ + Entity_Quad_Triangle = 1228, \ + Entity_Quad_Tetra = 17567, \ + Entity_Quad_Pyramid = 780, \ + Entity_Quad_Penta = 200 \ + ) diff --git a/src/Tools/blocFissure/CasTests/cylindre.py b/src/Tools/blocFissure/CasTests/cylindre.py index 129d7633e..4da916166 100644 --- a/src/Tools/blocFissure/CasTests/cylindre.py +++ b/src/Tools/blocFissure/CasTests/cylindre.py @@ -18,34 +18,29 @@ # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # -import os -from blocFissure import gmu -from blocFissure.gmu.geomsmesh import geompy, smesh +"""problème de fissure plane sur cylindre, grand fond de fissure en arc de cercle""" -import math -import GEOM -import SALOMEDS -import SMESH -#import StdMeshers -#import GHS3DPlugin -#import NETGENPlugin +import os import logging +from blocFissure import gmu +from blocFissure.gmu.geomsmesh import geompy, smesh from blocFissure.gmu.fissureGenerique import fissureGenerique - -from blocFissure.gmu.triedreBase import triedreBase from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale -O, OX, OY, OZ = triedreBase() +import GEOM +import SALOMEDS +import SMESH class cylindre(fissureGenerique): - """ - problème de fissure plane sur cylindre, grand fond de fissure en arc de cercle - """ + """problème de fissure plane sur cylindre, grand fond de fissure en arc de cercle""" nomProbleme = "cylindre" + shapeFissureParams = dict() + maillageFissureParams = dict() + referencesMaillageFissure = dict() # --------------------------------------------------------------------------- def genereMaillageSain(self, geometriesSaines, meshParams): @@ -55,7 +50,7 @@ class cylindre(fissureGenerique): """ logging.info("genereMaillageSain %s", self.nomCas) - ([objetSain], status) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests/CylindreSain.med")) + ([objetSain], _) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests", "CylindreSain.med")) smesh.SetName(objetSain.GetMesh(), 'objetSain') return [objetSain, True] # True : maillage hexa @@ -72,28 +67,29 @@ class cylindre(fissureGenerique): rayonPipe = 5) # --------------------------------------------------------------------------- - def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams): + def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams, \ + mailleur="MeshGems"): logging.info("genereShapeFissure %s", self.nomCas) lgInfluence = shapeFissureParams['lgInfluence'] - shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests/FissInCylindre2.brep")) + shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests", "FissInCylindre2.brep")) fondFiss = geompy.CreateGroup(shellFiss, geompy.ShapeType["EDGE"]) geompy.UnionIDs(fondFiss, [6]) geompy.addToStudy( shellFiss, 'shellFiss' ) geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' ) - - coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,15) + mailleur = self.mailleur2d3d() + coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,15, mailleur) centre = None return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss] # --------------------------------------------------------------------------- def setParamMaillageFissure(self): - self.maillageFissureParams = dict(nomRep = '.', + self.maillageFissureParams = dict(nomRep = os.curdir, nomFicSain = self.nomCas, - nomFicFissure = 'fissure_' + self.nomCas, + nomFicFissure = self.nomCas + "_fissure", nbsegRad = 5, nbsegCercle = 8, areteFaceFissure = 20) @@ -104,22 +100,26 @@ class cylindre(fissureGenerique): return elementsDefaut # --------------------------------------------------------------------------- - def genereMaillageFissure(self, geometriesSaines, maillagesSains, - shapesFissure, shapeFissureParams, - maillageFissureParams, elementsDefaut, step): - maillageFissure = construitFissureGenerale(maillagesSains, - shapesFissure, shapeFissureParams, - maillageFissureParams, elementsDefaut, step) + def genereMaillageFissure(self, geometriesSaines, maillagesSains, \ + shapesFissure, shapeFissureParams, \ + maillageFissureParams, elementsDefaut, step, \ + mailleur="MeshGems"): + + mailleur = self.mailleur2d3d() + maillageFissure = construitFissureGenerale(shapesFissure, shapeFissureParams, \ + maillageFissureParams, elementsDefaut, \ + step, mailleur) return maillageFissure # --------------------------------------------------------------------------- def setReferencesMaillageFissure(self): - self.referencesMaillageFissure = dict(Entity_Quad_Pyramid = 1270, - Entity_Quad_Triangle = 1260, - Entity_Quad_Edge = 758, - Entity_Quad_Penta = 496, - Entity_Quad_Hexa = 18814, - Entity_Node = 113313, - Entity_Quad_Tetra = 20469, - Entity_Quad_Quadrangle = 7280) - + self.referencesMaillageFissure = dict( \ + Entity_Quad_Quadrangle = 6920, \ + Entity_Quad_Hexa = 18174, \ + Entity_Node = 104349, \ + Entity_Quad_Edge = 718, \ + Entity_Quad_Triangle = 952, \ + Entity_Quad_Tetra = 16691, \ + Entity_Quad_Pyramid = 1110, \ + Entity_Quad_Penta = 336 \ + ) diff --git a/src/Tools/blocFissure/CasTests/cylindre_2.py b/src/Tools/blocFissure/CasTests/cylindre_2.py index a5129a480..f02e01a8f 100644 --- a/src/Tools/blocFissure/CasTests/cylindre_2.py +++ b/src/Tools/blocFissure/CasTests/cylindre_2.py @@ -18,57 +18,54 @@ # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""problème de fissure plane sur cylindre hexa, fond de fissure complexe : polyline""" + import os +import logging + from blocFissure import gmu from blocFissure.gmu.geomsmesh import geompy, smesh +from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut -import math import GEOM import SALOMEDS import SMESH -import logging from .cylindre import cylindre -from blocFissure.gmu.triedreBase import triedreBase -from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut -from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain -from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale - -O, OX, OY, OZ = triedreBase() - class cylindre_2(cylindre): - """ - problème de fissure plane sur cylindre hexa, fond de fissure complexe : polyline - """ + """problème de fissure plane sur cylindre hexa, fond de fissure complexe : polyline""" + nomProbleme = "cylindre2" # --------------------------------------------------------------------------- - def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams): + def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams, \ + mailleur="MeshGems"): logging.info("genereShapeFissure %s", self.nomCas) lgInfluence = shapeFissureParams['lgInfluence'] - shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests/FissInCylindre.brep")) + shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests", "FissInCylindre.brep")) fondFiss = geompy.CreateGroup(shellFiss, geompy.ShapeType["EDGE"]) - geompy.UnionIDs(fondFiss, [3]) + geompy.UnionIDs(fondFiss, [6]) geompy.addToStudy( shellFiss, 'shellFiss' ) geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' ) - - coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,15) + mailleur = self.mailleur2d3d() + coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,15, mailleur) centre = None return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss] # --------------------------------------------------------------------------- def setReferencesMaillageFissure(self): - self.referencesMaillageFissure = dict(Entity_Quad_Pyramid = 1334, - Entity_Quad_Triangle = 1432, - Entity_Quad_Edge = 785, - Entity_Quad_Penta = 560, - Entity_Quad_Hexa = 19070, - Entity_Node = 114290, - Entity_Quad_Tetra = 19978, - Entity_Quad_Quadrangle = 7424) - + self.referencesMaillageFissure = dict( \ + Entity_Quad_Quadrangle = 7028, \ + Entity_Quad_Hexa = 18366, \ + Entity_Node = 105035, \ + Entity_Quad_Edge = 735, \ + Entity_Quad_Triangle = 1056, \ + Entity_Quad_Tetra = 16305, \ + Entity_Quad_Pyramid = 1158, \ + Entity_Quad_Penta = 384 \ + ) diff --git a/src/Tools/blocFissure/CasTests/disquePerce.py b/src/Tools/blocFissure/CasTests/disquePerce.py index 8ed28cbdc..7cb18872f 100644 --- a/src/Tools/blocFissure/CasTests/disquePerce.py +++ b/src/Tools/blocFissure/CasTests/disquePerce.py @@ -18,13 +18,15 @@ # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""disque percé""" + import os from blocFissure import gmu dicoParams = dict(nomCas = 'disque', - maillageSain = os.path.join(gmu.pathBloc, 'materielCasTests/disque.med'), - brepFaceFissure = os.path.join(gmu.pathBloc, "materielCasTests/ellipse_disque.brep"), - edgeFissIds = [3], + maillageSain = os.path.join(gmu.pathBloc, "materielCasTests", "disque.med"), + CAOFaceFissure = os.path.join(gmu.pathBloc, "materielCasTests", "ellipse_disque.brep"), + edgeFiss = [3], lgInfluence = 10, meshBrep = (0.5,2.5), rayonPipe = 1.0, @@ -35,12 +37,13 @@ dicoParams = dict(nomCas = 'disque', # --------------------------------------------------------------------------- -referencesMaillageFissure = dict(Entity_Quad_Pyramid = 610, - Entity_Quad_Triangle = 1284, - Entity_Quad_Edge = 393, - Entity_Quad_Penta = 592, - Entity_Quad_Hexa = 6952, - Entity_Node = 51119, - Entity_Quad_Tetra = 11672, - Entity_Quad_Quadrangle = 3000) - +referencesMaillageFissure = dict ( \ + Entity_Quad_Quadrangle = 2748, \ + Entity_Quad_Hexa = 6232, \ + Entity_Node = 43889, \ + Entity_Quad_Edge = 376, \ + Entity_Quad_Triangle = 1366, \ + Entity_Quad_Tetra = 9112, \ + Entity_Quad_Pyramid = 466, \ + Entity_Quad_Penta = 448 \ + ) diff --git a/src/Tools/blocFissure/CasTests/ellipse_1.py b/src/Tools/blocFissure/CasTests/ellipse_1.py index 67b046f7e..7ca10b8c1 100644 --- a/src/Tools/blocFissure/CasTests/ellipse_1.py +++ b/src/Tools/blocFissure/CasTests/ellipse_1.py @@ -18,34 +18,29 @@ # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # -import os -from blocFissure import gmu -from blocFissure.gmu.geomsmesh import geompy, smesh +"""problème de fissure non plane, débouchante non normale""" -import math -import GEOM -import SALOMEDS -import SMESH -#import StdMeshers -#import GHS3DPlugin -#import NETGENPlugin +import os import logging +from blocFissure import gmu +from blocFissure.gmu.geomsmesh import geompy, smesh from blocFissure.gmu.fissureGenerique import fissureGenerique - -from blocFissure.gmu.triedreBase import triedreBase from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale -O, OX, OY, OZ = triedreBase() +import GEOM +import SALOMEDS +import SMESH class ellipse_1(fissureGenerique): - """ - problème de fissure non plane, débouchante non normale - """ + """problème de fissure non plane, débouchante non normale""" nomProbleme = "ellipse1" + shapeFissureParams = dict() + maillageFissureParams = dict() + referencesMaillageFissure = dict() # # --------------------------------------------------------------------------- # def genereGeometrieSaine(self, geomParams): @@ -55,10 +50,11 @@ class ellipse_1(fissureGenerique): # --------------------------------------------------------------------------- def genereMaillageSain(self, geometriesSaines, meshParams): - logging.info("genereMaillageSain %s", self.nomCas) + texte = "genereMaillageSain pour '{}'".format(self.nomCas) + logging.info(texte) - ([objetSain], status) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests/boiteSaine.med")) - smesh.SetName(objetSain.GetMesh(), 'objetSain') + ([objetSain], _) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests", "boiteSaine.med")) + smesh.SetName(objetSain.GetMesh(), "{}_objetSain".format(self.nomProbleme)) return [objetSain, True] # True : maillage hexa @@ -71,33 +67,40 @@ class ellipse_1(fissureGenerique): convexe : optionnel, True : la face est convexe (vue de l'exterieur) sert si on ne donne pas de point interne pointIn_x : optionnel, coordonnée x d'un point dans le solide sain (pour orienter la face) """ - logging.info("setParamShapeFissure %s", self.nomCas) + texte = "genereMaillageSain pour '{}'".format(self.nomCas) + logging.info(texte) self.shapeFissureParams = dict(lgInfluence = 50, rayonPipe = 20) # --------------------------------------------------------------------------- - def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams): - logging.info("genereShapeFissure %s", self.nomCas) + def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams, \ + mailleur="MeshGems"): + """Importe la géométrie de la fissure""" + texte = "genereShapeFissure pour '{}'".format(self.nomCas) + logging.info(texte) lgInfluence = shapeFissureParams['lgInfluence'] - shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests/ellipse1.brep")) + shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests", "ellipse1.brep")) fondFiss = geompy.CreateGroup(shellFiss, geompy.ShapeType["EDGE"]) geompy.UnionIDs(fondFiss, [3]) geompy.addToStudy( shellFiss, 'shellFiss' ) geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' ) - - coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,25) + mailleur = self.mailleur2d3d() + coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,25, mailleur) centre = None + return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss] # --------------------------------------------------------------------------- def setParamMaillageFissure(self): - self.maillageFissureParams = dict(nomRep = '.', + texte = "setParamMaillageFissure pour '{}'".format(self.nomCas) + logging.info(texte) + self.maillageFissureParams = dict(nomRep = os.curdir, nomFicSain = self.nomCas, - nomFicFissure = 'fissure_' + self.nomCas, + nomFicFissure = self.nomCas + "_fissure", nbsegRad = 5, nbsegCercle = 8, areteFaceFissure = 1000) @@ -108,22 +111,29 @@ class ellipse_1(fissureGenerique): return elementsDefaut # --------------------------------------------------------------------------- - def genereMaillageFissure(self, geometriesSaines, maillagesSains, - shapesFissure, shapeFissureParams, - maillageFissureParams, elementsDefaut, step): - maillageFissure = construitFissureGenerale(maillagesSains, - shapesFissure, shapeFissureParams, - maillageFissureParams, elementsDefaut, step) + def genereMaillageFissure(self, geometriesSaines, maillagesSains, \ + shapesFissure, shapeFissureParams, \ + maillageFissureParams, elementsDefaut, step, \ + mailleur="MeshGems"): + + texte = "genereMaillageFissure pour '{}'".format(self.nomCas) + logging.info(texte) + + mailleur = self.mailleur2d3d() + maillageFissure = construitFissureGenerale(shapesFissure, shapeFissureParams, \ + maillageFissureParams, elementsDefaut, \ + step, mailleur) return maillageFissure # --------------------------------------------------------------------------- def setReferencesMaillageFissure(self): - self.referencesMaillageFissure = dict(Entity_Quad_Pyramid = 175, - Entity_Quad_Triangle = 298, - Entity_Quad_Edge = 248, - Entity_Quad_Penta = 96, - Entity_Quad_Hexa = 3699, - Entity_Node = 20741, - Entity_Quad_Tetra = 1979, - Entity_Quad_Quadrangle = 1694) - + self.referencesMaillageFissure = dict( \ + Entity_Quad_Quadrangle = 1748, \ + Entity_Quad_Hexa = 3795, \ + Entity_Node = 21939, \ + Entity_Quad_Edge = 256, \ + Entity_Quad_Triangle = 360, \ + Entity_Quad_Tetra = 2425, \ + Entity_Quad_Pyramid = 199, \ + Entity_Quad_Penta = 120 \ + ) diff --git a/src/Tools/blocFissure/CasTests/ellipse_2.py b/src/Tools/blocFissure/CasTests/ellipse_2.py index 1edd2cc43..65ee36266 100644 --- a/src/Tools/blocFissure/CasTests/ellipse_2.py +++ b/src/Tools/blocFissure/CasTests/ellipse_2.py @@ -18,60 +18,57 @@ # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""problème de fissure non plane, débouchante non normale""" + import os +import logging + from blocFissure import gmu from blocFissure.gmu.geomsmesh import geompy, smesh +from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut -import math import GEOM import SALOMEDS import SMESH -#import StdMeshers -#import GHS3DPlugin -#import NETGENPlugin -import logging from .ellipse_1 import ellipse_1 -from blocFissure.gmu.triedreBase import triedreBase -from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut -from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain -from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale - -O, OX, OY, OZ = triedreBase() - class ellipse_2(ellipse_1): - """ - problème de fissure non plane, débouchante non normale - """ + """problème de fissure non plane, débouchante non normale""" nomProbleme = "ellipse2" # --------------------------------------------------------------------------- - def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams): - logging.info("genereShapeFissure %s", self.nomCas) + def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams, \ + mailleur="MeshGems"): + """Importe la géométrie de la fissure""" + texte = "genereShapeFissure pour '{}'".format(self.nomCas) + logging.info(texte) lgInfluence = shapeFissureParams['lgInfluence'] - shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests/ellipse1_pb.brep")) + shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests", "ellipse1_pb.brep")) fondFiss = geompy.CreateGroup(shellFiss, geompy.ShapeType["EDGE"]) geompy.UnionIDs(fondFiss, [3]) geompy.addToStudy( shellFiss, 'shellFiss' ) geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' ) - - coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,25) + mailleur = self.mailleur2d3d() + coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,25, mailleur) centre = None + return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss] # --------------------------------------------------------------------------- def setReferencesMaillageFissure(self): - self.referencesMaillageFissure = dict(Entity_Quad_Pyramid = 159, - Entity_Quad_Triangle = 438, - Entity_Quad_Edge = 249, - Entity_Quad_Penta = 80, - Entity_Quad_Hexa = 3635, - Entity_Node = 20519, - Entity_Quad_Tetra = 1973, - Entity_Quad_Quadrangle = 1658) + self.referencesMaillageFissure = dict( \ + Entity_Quad_Quadrangle = 1748, \ + Entity_Quad_Hexa = 3795, \ + Entity_Node = 22219, \ + Entity_Quad_Edge = 258, \ + Entity_Quad_Triangle = 434, \ + Entity_Quad_Tetra = 2574, \ + Entity_Quad_Pyramid = 199, \ + Entity_Quad_Penta = 120 \ + ) diff --git a/src/Tools/blocFissure/CasTests/eprouvetteCourbe.py b/src/Tools/blocFissure/CasTests/eprouvetteCourbe.py index 2526fbe72..d3110d863 100644 --- a/src/Tools/blocFissure/CasTests/eprouvetteCourbe.py +++ b/src/Tools/blocFissure/CasTests/eprouvetteCourbe.py @@ -18,40 +18,36 @@ # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # -import os -from blocFissure import gmu -from blocFissure.gmu.geomsmesh import geompy, smesh +"""problème de fissure plane coupant 3 faces (éprouvette), faces au débouché non planes, incidence presque normale""" -import math -import GEOM -import SALOMEDS -import SMESH -#import StdMeshers -#import GHS3DPlugin -#import NETGENPlugin +import os import logging +from blocFissure import gmu +from blocFissure.gmu.geomsmesh import geompy, smesh from blocFissure.gmu.fissureGenerique import fissureGenerique - -from blocFissure.gmu.triedreBase import triedreBase from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale -O, OX, OY, OZ = triedreBase() +import GEOM +import SALOMEDS +import SMESH class eprouvetteCourbe(fissureGenerique): - """ - problème de fissure plane coupant 3 faces (éprouvette), faces au débouché non planes, incidence presque normale - """ + """problème de fissure plane coupant 3 faces (éprouvette), faces au débouché non planes, incidence presque normale""" nomProbleme = "eprouvetteCourbe" + shapeFissureParams = dict() + maillageFissureParams = dict() + referencesMaillageFissure = dict() # --------------------------------------------------------------------------- def genereMaillageSain(self, geometriesSaines, meshParams): - logging.info("genereMaillageSain %s", self.nomCas) + texte = "genereMaillageSain pour '{}'".format(self.nomCas) + logging.info(texte) - ([objetSain], status) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests/EprouvetteCourbe.med")) + ([objetSain], _) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests", "EprouvetteCourbe.med")) smesh.SetName(objetSain.GetMesh(), 'objetSain') return [objetSain, True] # True : maillage hexa @@ -65,33 +61,40 @@ class eprouvetteCourbe(fissureGenerique): convexe : optionnel True : la face est convexe (vue de l'exterieur) sert si on ne donne pas de point interne pointIn_x : optionnel coordonnée x d'un point dans le solide sain (pour orienter la face) """ - logging.info("setParamShapeFissure %s", self.nomCas) + texte = "genereMaillageSain pour '{}'".format(self.nomCas) + logging.info(texte) self.shapeFissureParams = dict(lgInfluence = 30, rayonPipe = 10) # --------------------------------------------------------------------------- - def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams): - logging.info("genereShapeFissure %s", self.nomCas) + def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams, \ + mailleur="MeshGems"): + """Importe la géométrie de la fissure""" + texte = "genereShapeFissure pour '{}'".format(self.nomCas) + logging.info(texte) lgInfluence = shapeFissureParams['lgInfluence'] - shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests/EprouvetteCourbeFiss.brep")) + shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests", "EprouvetteCourbeFiss.brep")) fondFiss = geompy.CreateGroup(shellFiss, geompy.ShapeType["EDGE"]) geompy.UnionIDs(fondFiss, [8]) geompy.addToStudy( shellFiss, 'shellFiss' ) geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' ) - - coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,10) + mailleur = self.mailleur2d3d() + coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,10, mailleur) centre = None + return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss] # --------------------------------------------------------------------------- def setParamMaillageFissure(self): - self.maillageFissureParams = dict(nomRep = '.', + texte = "setParamMaillageFissure pour '{}'".format(self.nomCas) + logging.info(texte) + self.maillageFissureParams = dict(nomRep = os.curdir, nomFicSain = self.nomCas, - nomFicFissure = 'fissure_' + self.nomCas, + nomFicFissure = self.nomCas + "_fissure", nbsegRad = 5, nbsegCercle = 8, areteFaceFissure = 15) @@ -102,22 +105,29 @@ class eprouvetteCourbe(fissureGenerique): return elementsDefaut # --------------------------------------------------------------------------- - def genereMaillageFissure(self, geometriesSaines, maillagesSains, - shapesFissure, shapeFissureParams, - maillageFissureParams, elementsDefaut, step): - maillageFissure = construitFissureGenerale(maillagesSains, - shapesFissure, shapeFissureParams, - maillageFissureParams, elementsDefaut, step) + def genereMaillageFissure(self, geometriesSaines, maillagesSains, \ + shapesFissure, shapeFissureParams, \ + maillageFissureParams, elementsDefaut, step, \ + mailleur="MeshGems"): + + texte = "genereMaillageFissure pour '{}'".format(self.nomCas) + logging.info(texte) + + mailleur = self.mailleur2d3d() + maillageFissure = construitFissureGenerale(shapesFissure, shapeFissureParams, \ + maillageFissureParams, elementsDefaut, \ + step, mailleur) return maillageFissure # --------------------------------------------------------------------------- def setReferencesMaillageFissure(self): - self.referencesMaillageFissure = dict(Entity_Quad_Pyramid = 618, - Entity_Quad_Triangle = 1224, - Entity_Quad_Edge = 578, - Entity_Quad_Penta = 168, - Entity_Quad_Hexa = 18342, - Entity_Node = 98170, - Entity_Quad_Tetra = 10809, - Entity_Quad_Quadrangle = 5408) - + self.referencesMaillageFissure = dict( \ + Entity_Quad_Quadrangle = 5318, \ + Entity_Quad_Hexa = 18182, \ + Entity_Node = 94472, \ + Entity_Quad_Edge = 539, \ + Entity_Quad_Triangle = 828, \ + Entity_Quad_Tetra = 9024, \ + Entity_Quad_Pyramid = 578, \ + Entity_Quad_Penta = 128 \ + ) diff --git a/src/Tools/blocFissure/CasTests/eprouvetteDroite.py b/src/Tools/blocFissure/CasTests/eprouvetteDroite.py index 48757f32d..8122f01a9 100644 --- a/src/Tools/blocFissure/CasTests/eprouvetteDroite.py +++ b/src/Tools/blocFissure/CasTests/eprouvetteDroite.py @@ -17,13 +17,12 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""problème de fissure plane coupant 3 faces (éprouvette), débouches normaux, objet plan""" import os from blocFissure import gmu from blocFissure.gmu.geomsmesh import geompy, smesh -import os -import math import GEOM import SALOMEDS import SMESH @@ -42,17 +41,18 @@ from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale O, OX, OY, OZ = triedreBase() class eprouvetteDroite(fissureGenerique): - """ - problème de fissure plane coupant 3 faces (éprouvette), débouches normaux, objet plan - """ + """problème de fissure plane coupant 3 faces (éprouvette), débouches normaux, objet plan""" nomProbleme = "eprouvetteDroite" + shapeFissureParams = dict() + maillageFissureParams = dict() + referencesMaillageFissure = dict() # --------------------------------------------------------------------------- def genereMaillageSain(self, geometriesSaines, meshParams): logging.info("genereMaillageSain %s", self.nomCas) - ([objetSain], status) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests/eprouvetteDroite.med")) + ([objetSain], _) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests", "eprouvetteDroite.med")) smesh.SetName(objetSain.GetMesh(), 'objetSain') return [objetSain, True] # True : maillage hexa @@ -72,28 +72,29 @@ class eprouvetteDroite(fissureGenerique): lenSegPipe = 6) # --------------------------------------------------------------------------- - def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams): + def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams, \ + mailleur="MeshGems"): logging.info("genereShapeFissure %s", self.nomCas) lgInfluence = shapeFissureParams['lgInfluence'] - shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests/EprouvetteDroiteFiss_1.brep")) + shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests", "EprouvetteDroiteFiss_1.brep")) fondFiss = geompy.CreateGroup(shellFiss, geompy.ShapeType["EDGE"]) geompy.UnionIDs(fondFiss, [8]) geompy.addToStudy( shellFiss, 'shellFiss' ) geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' ) - - coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,10) + mailleur = self.mailleur2d3d() + coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,10, mailleur) centre = None return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss] # --------------------------------------------------------------------------- def setParamMaillageFissure(self): - self.maillageFissureParams = dict(nomRep = '.', + self.maillageFissureParams = dict(nomRep = os.curdir, nomFicSain = self.nomCas, - nomFicFissure = 'fissure_' + self.nomCas, + nomFicFissure = self.nomCas + "_fissure", nbsegRad = 5, nbsegCercle = 8, areteFaceFissure = 15) @@ -104,22 +105,26 @@ class eprouvetteDroite(fissureGenerique): return elementsDefaut # --------------------------------------------------------------------------- - def genereMaillageFissure(self, geometriesSaines, maillagesSains, - shapesFissure, shapeFissureParams, - maillageFissureParams, elementsDefaut, step): - maillageFissure = construitFissureGenerale(maillagesSains, - shapesFissure, shapeFissureParams, - maillageFissureParams, elementsDefaut, step) + def genereMaillageFissure(self, geometriesSaines, maillagesSains, \ + shapesFissure, shapeFissureParams, \ + maillageFissureParams, elementsDefaut, step, \ + mailleur="MeshGems"): + + mailleur = self.mailleur2d3d() + maillageFissure = construitFissureGenerale(shapesFissure, shapeFissureParams, \ + maillageFissureParams, elementsDefaut, \ + step, mailleur) return maillageFissure # --------------------------------------------------------------------------- def setReferencesMaillageFissure(self): - self.referencesMaillageFissure = dict(Entity_Quad_Pyramid = 368, - Entity_Quad_Triangle = 798, - Entity_Quad_Edge = 491, - Entity_Quad_Penta = 88, - Entity_Quad_Hexa = 9692, - Entity_Node = 52652, - Entity_Quad_Tetra = 5093, - Entity_Quad_Quadrangle = 3750) - + self.referencesMaillageFissure = dict( \ + Entity_Quad_Quadrangle = 3768, \ + Entity_Quad_Hexa = 9724, \ + Entity_Node = 52337, \ + Entity_Quad_Edge = 457, \ + Entity_Quad_Triangle = 570, \ + Entity_Quad_Tetra = 4919, \ + Entity_Quad_Pyramid = 376, \ + Entity_Quad_Penta = 96 \ + ) diff --git a/src/Tools/blocFissure/CasTests/eprouvetteDroite_2.py b/src/Tools/blocFissure/CasTests/eprouvetteDroite_2.py index f6f21553f..243ae704b 100644 --- a/src/Tools/blocFissure/CasTests/eprouvetteDroite_2.py +++ b/src/Tools/blocFissure/CasTests/eprouvetteDroite_2.py @@ -17,62 +17,54 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""problème de fissure plane coupant 3 faces (éprouvette), débouches non normaux, objet plan""" import os from blocFissure import gmu from blocFissure.gmu.geomsmesh import geompy, smesh -import math import GEOM import SALOMEDS import SMESH -#import StdMeshers -#import GHS3DPlugin -#import NETGENPlugin import logging from .eprouvetteDroite import eprouvetteDroite -from blocFissure.gmu.triedreBase import triedreBase from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut -from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain -from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale - -O, OX, OY, OZ = triedreBase() class eprouvetteDroite_2(eprouvetteDroite): - """ - problème de fissure plane coupant 3 faces (éprouvette), débouches non normaux, objet plan - """ + """problème de fissure plane coupant 3 faces (éprouvette), débouches non normaux, objet plan""" - nomProbleme = "eprouvetteDroite2" + nomProbleme = "eprouvetteDroite_2" # --------------------------------------------------------------------------- - def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams): + def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams, \ + mailleur="MeshGems"): logging.info("genereShapeFissure %s", self.nomCas) lgInfluence = shapeFissureParams['lgInfluence'] - shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests/EprouvetteDroiteFiss_2.brep")) + shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests", "EprouvetteDroiteFiss_2.brep")) fondFiss = geompy.CreateGroup(shellFiss, geompy.ShapeType["EDGE"]) geompy.UnionIDs(fondFiss, [10]) geompy.addToStudy( shellFiss, 'shellFiss' ) geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' ) - - coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,10) + mailleur = self.mailleur2d3d() + coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,10, mailleur) centre = None return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss] # --------------------------------------------------------------------------- def setReferencesMaillageFissure(self): - self.referencesMaillageFissure = dict(Entity_Quad_Pyramid = 396, - Entity_Quad_Triangle = 1084, - Entity_Quad_Edge = 510, - Entity_Quad_Penta = 96, - Entity_Quad_Hexa = 9504, - Entity_Node = 55482, - Entity_Quad_Tetra = 7545, - Entity_Quad_Quadrangle = 3724) - + self.referencesMaillageFissure = dict( \ + Entity_Quad_Quadrangle = 3724, \ + Entity_Quad_Hexa = 9504, \ + Entity_Node = 54049, \ + Entity_Quad_Edge = 478, \ + Entity_Quad_Triangle = 724, \ + Entity_Quad_Tetra = 6766, \ + Entity_Quad_Pyramid = 396, \ + Entity_Quad_Penta = 96 \ + ) diff --git a/src/Tools/blocFissure/CasTests/execution_Cas.py b/src/Tools/blocFissure/CasTests/execution_Cas.py index adef4c24e..971405d1d 100644 --- a/src/Tools/blocFissure/CasTests/execution_Cas.py +++ b/src/Tools/blocFissure/CasTests/execution_Cas.py @@ -17,152 +17,308 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Lancement des cas-tests de blocFissure""" -import sys, traceback +import traceback import logging from blocFissure import gmu from blocFissure.gmu import initLog +from blocFissure.gmu import geomsmesh +from blocFissure.gmu.casStandard import casStandard # ----------------------------------------------------------------------------------------------- #initLog.setDebug() -initLog.setVerbose() +#initLog.setVerbose() #initLog.setRelease() #initLog.setPerfTests() -# ---tous les cas en sequence, ou les cas selectionnés ... -runall = True -if runall: - torun = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] -else: #prob 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29 - torun = [ 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +# ---tous les cas en séquence, ou les cas sélectionnés ... +TORUNOK = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0] # OK +# 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28 +#RUNALL = False +RUNALL = True +if RUNALL: + TORUN = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] +# 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28 +else: + TORUNPB = list() + for IAUX in TORUNOK: + TORUNPB.append((IAUX+1)%2) + print ("TORUN = {} # OK".format(TORUNOK)) + print ("TORUN = {} # PB".format(TORUNPB)) +# genereMateriel + TORUN = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0] # aucun + TORUN = [ 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] # cubeAngle + TORUN = [ 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] # cubeFin + TORUN = [ 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] # decoupeCylindre + TORUN = [ 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] # disque_perce + ellipse_disque + TORUN = [ 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] # ellipse + fissureGauche2 + TORUN = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] # ellipse_probleme + fissureGauche2 + TORUN = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] # eprouvetteCourbe + TORUN = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] # eprouvetteDroite + TORUN = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] # fissureGauche + fissureGauche2 + TORUN = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0] # vis + TORUN = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1] # tube +# 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28 + TORUN = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0] # OK # ----------------------------------------------------------------------------------------------- -from blocFissure.gmu import geomsmesh -from blocFissure.gmu.casStandard import casStandard - -problemes = list() - -cas=0 -from blocFissure.CasTests.cubeAngle import cubeAngle -problemes.append(cubeAngle(cas)) - -cas+=1 -from blocFissure.CasTests.cubeAngle2 import cubeAngle2 -problemes.append(cubeAngle2(cas)) - -cas+=1 -from blocFissure.CasTests import cubeCoin -problemes.append(casStandard(cubeCoin.dicoParams, cubeCoin.referencesMaillageFissure, cas)) - -cas+=1 -from blocFissure.CasTests import cubeMilieu -problemes.append(casStandard(cubeMilieu.dicoParams, cubeMilieu.referencesMaillageFissure, cas)) - -cas+=1 -from blocFissure.CasTests import cubeTransverse -problemes.append(casStandard(cubeTransverse.dicoParams, cubeTransverse.referencesMaillageFissure, cas)) - -cas+=1 -from blocFissure.CasTests.cylindre import cylindre -problemes.append(cylindre(cas)) - -cas+=1 -from blocFissure.CasTests.cylindre_2 import cylindre_2 -problemes.append(cylindre_2(cas)) - -cas+=1 -from blocFissure.CasTests import disquePerce -problemes.append(casStandard(disquePerce.dicoParams, disquePerce.referencesMaillageFissure, cas)) - -cas+=1 -from blocFissure.CasTests.ellipse_1 import ellipse_1 -problemes.append(ellipse_1(cas)) - -cas+=1 -from blocFissure.CasTests.ellipse_2 import ellipse_2 -problemes.append(ellipse_2(cas)) - -cas+=1 -from blocFissure.CasTests.eprouvetteCourbe import eprouvetteCourbe -problemes.append(eprouvetteCourbe(cas)) - -cas+=1 -from blocFissure.CasTests.eprouvetteDroite import eprouvetteDroite -problemes.append(eprouvetteDroite(cas)) - -cas+=1 -from blocFissure.CasTests.eprouvetteDroite_2 import eprouvetteDroite_2 -problemes.append(eprouvetteDroite_2(cas)) - -cas+=1 -from blocFissure.CasTests.faceGauche import faceGauche -problemes.append(faceGauche(cas)) - -cas+=1 -from blocFissure.CasTests.faceGauche_2 import faceGauche_2 -problemes.append(faceGauche_2(cas)) - -cas+=1 -from blocFissure.CasTests.fissure_Coude import fissure_Coude -problemes.append(fissure_Coude(cas)) - -cas+=1 -from blocFissure.CasTests.fissure_Coude_4 import fissure_Coude_4 -problemes.append(fissure_Coude_4(cas)) - -cas+=1 -from blocFissure.CasTests.fissureCoude_1 import fissureCoude_1 -problemes.append(fissureCoude_1(cas)) - -cas+=1 -from blocFissure.CasTests.fissureCoude_2 import fissureCoude_2 -problemes.append(fissureCoude_2(cas)) - -cas+=1 -from blocFissure.CasTests.fissureCoude_3 import fissureCoude_3 -problemes.append(fissureCoude_3(cas)) - -cas+=1 -from blocFissure.CasTests.fissure_Coude_4 import fissure_Coude_4 -problemes.append(fissure_Coude_4(cas)) - -cas+=1 -from blocFissure.CasTests.fissureCoude_4 import fissureCoude_4 -problemes.append(fissureCoude_4(cas)) - -cas+=1 -from blocFissure.CasTests.fissureCoude_5 import fissureCoude_5 -problemes.append(fissureCoude_5(cas)) - -cas+=1 -from blocFissure.CasTests.fissureCoude_6 import fissureCoude_6 -problemes.append(fissureCoude_6(cas)) - -cas+=1 -from blocFissure.CasTests.fissureCoude_7 import fissureCoude_7 -problemes.append(fissureCoude_7(cas)) - -cas+=1 -from blocFissure.CasTests.fissureCoude_8 import fissureCoude_8 -problemes.append(fissureCoude_8(cas)) - -cas+=1 -from blocFissure.CasTests.fissureCoude_9 import fissureCoude_9 -problemes.append(fissureCoude_9(cas)) - -cas+=1 -from blocFissure.CasTests.fissureCoude_10 import fissureCoude_10 -problemes.append(fissureCoude_10(cas)) - -cas+=1 -from blocFissure.CasTests.vis_1 import vis_1 -problemes.append(vis_1(cas)) - -for iaux, cas in enumerate(problemes): - if torun[iaux]: - logging.critical("=== Execution cas {}".format(iaux)) - try: - cas.executeProbleme() - except: - traceback.print_exc() - print("---------------------------------------------------------------------") +def caract_l_problemes (): + """Caractérisation des problèmes""" + d_aux = dict() + l_problemes = list() + + n_cas = 0 + # genereMateriel : cubeAngle + from blocFissure.CasTests.cubeAngle import cubeAngle + l_problemes.append(cubeAngle(n_cas)) + + n_cas = 1 + # genereMateriel : cubeAngle + from blocFissure.CasTests.cubeAngle2 import cubeAngle2 + l_problemes.append(cubeAngle2(n_cas)) + + n_cas = 2 + # genereMateriel : cubeFin + from blocFissure.CasTests import cubeCoin + l_problemes.append(casStandard(cubeCoin.dicoParams, cubeCoin.referencesMaillageFissure, n_cas)) + d_aux[n_cas] = "cubeCoin" + + n_cas = 3 + # genereMateriel : cubeFin + from blocFissure.CasTests import cubeMilieu + l_problemes.append(casStandard(cubeMilieu.dicoParams, cubeMilieu.referencesMaillageFissure, n_cas)) + d_aux[n_cas] = "cubeMilieu" + + n_cas = 4 + # genereMateriel : cubeFin + from blocFissure.CasTests import cubeTransverse + l_problemes.append(casStandard(cubeTransverse.dicoParams, cubeTransverse.referencesMaillageFissure, n_cas)) + d_aux[n_cas] = "cubeTransverse" + + n_cas = 5 + # genereMateriel : decoupeCylindre + from blocFissure.CasTests.cylindre import cylindre + l_problemes.append(cylindre(n_cas)) + + n_cas = 6 + # genereMateriel : decoupeCylindre + from blocFissure.CasTests.cylindre_2 import cylindre_2 + l_problemes.append(cylindre_2(n_cas)) + + n_cas = 7 + # genereMateriel : disque_perce + # genereMateriel : ellipse_disque + from blocFissure.CasTests import disquePerce + l_problemes.append(casStandard(disquePerce.dicoParams, disquePerce.referencesMaillageFissure, n_cas)) + d_aux[n_cas] = "disquePerce" + + n_cas = 8 + # genereMateriel: ellipse + # genereMateriel : fissureGauche2 + from blocFissure.CasTests.ellipse_1 import ellipse_1 + l_problemes.append(ellipse_1(n_cas)) + + n_cas = 9 + # genereMateriel: ellipse_probleme + # genereMateriel : fissureGauche2 + from blocFissure.CasTests.ellipse_2 import ellipse_2 + l_problemes.append(ellipse_2(n_cas)) + + n_cas = 10 + # genereMateriel : eprouvetteCourbe + from blocFissure.CasTests.eprouvetteCourbe import eprouvetteCourbe + l_problemes.append(eprouvetteCourbe(n_cas)) + + n_cas = 11 + # genereMateriel : eprouvetteDroite + from blocFissure.CasTests.eprouvetteDroite import eprouvetteDroite + l_problemes.append(eprouvetteDroite(n_cas)) + + n_cas = 12 + # genereMateriel : eprouvetteDroite + from blocFissure.CasTests.eprouvetteDroite_2 import eprouvetteDroite_2 + l_problemes.append(eprouvetteDroite_2(n_cas)) + + n_cas = 13 + # genereMateriel : fissureGauche + # genereMateriel : fissureGauche2 + from blocFissure.CasTests.faceGauche import faceGauche + l_problemes.append(faceGauche(n_cas)) + + n_cas = 14 + # genereMateriel : aucun + from blocFissure.CasTests.faceGauche_2 import faceGauche_2 + l_problemes.append(faceGauche_2(n_cas)) + #"boiteDefaut" has not been computed: + #- "algo3d_boiteDefaut" failed. Error: Algorithm failed. Presumably, the surface mesh is not compatible with the domain being processed (warning). + #An edge is unique (i.e., bounds a hole in the surface). + #The surface mesh includes at least one hole. The domain is not well defined. + #See /tmp/GHS3D_18605_10269264.log for more information + #Traceback (most recent call last): + #File "/home/D68518/salome-dev/DEV_package/appli_DEV_package/lib/python3.6/site-packages/salome/blocFissure/CasTests/execution_Cas.py", line 222, in + #ok_maillage = cas.executeProbleme() + #File "/home/D68518/salome-dev/DEV_package/appli_DEV_package/lib/python3.6/site-packages/salome/blocFissure/gmu/fissureGenerique.py", line 122, in executeProbleme + #self.maillageFissureParams, elementsDefaut, step) + #File "/home/D68518/salome-dev/DEV_package/appli_DEV_package/lib/python3.6/site-packages/salome/blocFissure/CasTests/faceGauche_2.py", line 108, in genereMaillageFissure + #maillageFissureParams, elementsDefaut, step) + #File "/home/D68518/salome-dev/DEV_package/appli_DEV_package/lib/python3.6/site-packages/salome/blocFissure/gmu/construitFissureGenerale.py", line 330, in construitFissureGenerale + #raise Exception(text) + #Exception: Erreur au calcul du maillage. + + n_cas = 15 + # genereMateriel : aucun + from blocFissure.CasTests.fissureCoude_1 import fissureCoude_1 + l_problemes.append(fissureCoude_1(n_cas)) + + n_cas = 16 + # genereMateriel : aucun + from blocFissure.CasTests.fissureCoude_2 import fissureCoude_2 + l_problemes.append(fissureCoude_2(n_cas)) + + n_cas = 17 + # genereMateriel : aucun + from blocFissure.CasTests.fissureCoude_3 import fissureCoude_3 + l_problemes.append(fissureCoude_3(n_cas)) + + n_cas = 18 + # genereMateriel : aucun + from blocFissure.CasTests.fissureCoude_4 import fissureCoude_4 + l_problemes.append(fissureCoude_4(n_cas)) + + n_cas = 19 + # genereMateriel : aucun + from blocFissure.CasTests.fissureCoude_5 import fissureCoude_5 + l_problemes.append(fissureCoude_5(n_cas)) + + n_cas = 20 + # genereMateriel : aucun + from blocFissure.CasTests.fissureCoude_6 import fissureCoude_6 + l_problemes.append(fissureCoude_6(n_cas)) + + n_cas = 21 + # genereMateriel : aucun + from blocFissure.CasTests.fissureCoude_7 import fissureCoude_7 + l_problemes.append(fissureCoude_7(n_cas)) + + n_cas = 22 + # genereMateriel : aucun + from blocFissure.CasTests.fissureCoude_8 import fissureCoude_8 + l_problemes.append(fissureCoude_8(n_cas)) + + n_cas = 23 + # genereMateriel : aucun + from blocFissure.CasTests.fissureCoude_9 import fissureCoude_9 + l_problemes.append(fissureCoude_9(n_cas)) + + n_cas = 24 + # genereMateriel : aucun + from blocFissure.CasTests.fissureCoude_10 import fissureCoude_10 + l_problemes.append(fissureCoude_10(n_cas)) + + n_cas = 25 + # genereMateriel : aucun + from blocFissure.CasTests.fissure_Coude import fissure_Coude + l_problemes.append(fissure_Coude(n_cas)) + + n_cas = 26 + # genereMateriel : aucun + from blocFissure.CasTests.fissure_Coude_4 import fissure_Coude_4 + l_problemes.append(fissure_Coude_4(n_cas)) + + n_cas = 27 + # genereMateriel : vis + from blocFissure.CasTests.vis_1 import vis_1 + l_problemes.append(vis_1(n_cas)) + #"Mesh_22" has not been computed: + #- "algo2d_faceFiss" failed on FACE #2. Error: Algorithm failed. NgException at Surface meshing: Problem in Surface mesh generation + #- "algo1d_edgeFissPeau" failed on EDGE #9. Error: Algorithm failed. Source elements don't cover totally the geometrical edge + #Traceback (most recent call last): + #File "/home/D68518/salome-dev/DEV_package/appli_DEV_package/lib/python3.6/site-packages/salome/blocFissure/CasTests/execution_Cas.py", line 233, in + #ok_maillage = cas.executeProbleme() + #File "/home/D68518/salome-dev/DEV_package/appli_DEV_package/lib/python3.6/site-packages/salome/blocFissure/gmu/fissureGenerique.py", line 122, in executeProbleme + #self.maillageFissureParams, elementsDefaut, step) + #File "/home/D68518/salome-dev/DEV_package/appli_DEV_package/lib/python3.6/site-packages/salome/blocFissure/CasTests/vis_1.py", line 116, in genereMaillageFissure + #maillageFissureParams, elementsDefaut, step) + #File "/home/D68518/salome-dev/DEV_package/appli_DEV_package/lib/python3.6/site-packages/salome/blocFissure/gmu/construitFissureGenerale.py", line 282, in construitFissureGenerale + #meshPipeGroups, areteFaceFissure, rayonPipe, nbsegRad) + #File "/home/D68518/salome-dev/DEV_package/appli_DEV_package/lib/python3.6/site-packages/salome/blocFissure/gmu/mailleFacesFissure.py", line 69, in mailleFacesFissure + #raise Exception(text) + #Exception: Erreur au calcul du maillage. + + n_cas = 28 + # genereMateriel : tube + from blocFissure.CasTests.tube import tube + l_problemes.append(tube(n_cas)) + #"Mesh_13" has not been computed: + #- "algo2d_facePeau_0" failed on "FACE_12 to mesh". Error: Algorithm failed. NgException at Surface meshing: Problem in Surface mesh generation + #- "algo1d_cercle1_0" failed on EDGE #20. Error: Algorithm failed. Source elements don't cover totally the geometrical edge + #- "algo1d_cercle1_0" failed on EDGE #17. Error: Algorithm failed. Source elements don't cover totally the geometrical edge + #- "algo1d_cercle1_0" failed on EDGE #15. Error: Algorithm failed. Source elements don't cover totally the geometrical edge + #- "algo1d_cercle1_0" failed on EDGE #12. Error: Algorithm failed. Source elements don't cover totally the geometrical edge + + return l_problemes, d_aux +#============================================================= +def calcul_cas (n_cas, cas, d_aux, ligne): + """Calcul d'un cas""" + texte = "" + if n_cas in d_aux: + nom = d_aux[n_cas] + else: + nom = cas.nomProbleme + texte_a = "\n=== Exécution du cas n° {}, '{}'".format(n_cas,nom) + logging.critical(ligne+texte_a) + try: + ok_maillage = cas.executeProbleme() + except: + traceback.print_exc() + texte = "Problème avec le cas n° {}, '{}'\n".format(n_cas,nom) + ok_maillage = False + print(ligne) + return ok_maillage, texte +#============================================================= +def calcul_tout (l_problemes, d_aux): + """Calcul de tous les cas""" + + ligne = "---------------------------------------------------------------------" + texte = "" + nb_cas_ok = 0 + nb_cas_nook = 0 + for n_cas, cas in enumerate(l_problemes): + #print ("Cas n° {}, '{}'".format(n_cas,cas.nomProbleme)) + if TORUN[n_cas]: + ok_maillage, texte_a = calcul_cas (n_cas, cas, d_aux, ligne) + texte += texte_a + if ok_maillage: + nb_cas_ok += 1 + else: + nb_cas_nook += 1 + print(ligne) + + nb_cas = nb_cas_nook + nb_cas_ok + if ( nb_cas > 1): + if nb_cas_nook: + texte += ". Nombre de cas_tests OK : {}\n".format(nb_cas_ok) + texte += ". Nombre de cas_tests NOOK : {}\n".format(nb_cas_nook) + else: + texte += "Les {} tests se sont bien passés.\n".format(nb_cas) + print (texte+ligne) + + return +#============================================================= +#============================================================= + +while True: + + L_PROBLEMES, D_AUX = caract_l_problemes() + + if ( len(L_PROBLEMES) != len(TORUN) ): + TEXTE = "\nNombre de problèmes définis : {}\n".format(len(L_PROBLEMES)) + TEXTE += "Longueur de la liste 'TORUN' : {}\n".format(len(TORUN)) + TEXTE += "\t==> Incohérence de programmation à corriger dans {}".format(__name__) + print (TEXTE) + break + + calcul_tout (L_PROBLEMES, D_AUX) + + break diff --git a/src/Tools/blocFissure/CasTests/faceGauche.py b/src/Tools/blocFissure/CasTests/faceGauche.py index 8d047377c..1427d943c 100644 --- a/src/Tools/blocFissure/CasTests/faceGauche.py +++ b/src/Tools/blocFissure/CasTests/faceGauche.py @@ -17,6 +17,7 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""problème de fissure non plane, débouchante non normale""" import os from blocFissure import gmu @@ -26,9 +27,7 @@ import math import GEOM import SALOMEDS import SMESH -#import StdMeshers -#import GHS3DPlugin -#import NETGENPlugin + import logging from blocFissure.gmu.fissureGenerique import fissureGenerique @@ -41,17 +40,18 @@ from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale O, OX, OY, OZ = triedreBase() class faceGauche(fissureGenerique): - """ - problème de fissure non plane, débouchante non normale - """ + """problème de fissure non plane, débouchante non normale""" nomProbleme = "faceGauche" + shapeFissureParams = dict() + maillageFissureParams = dict() + referencesMaillageFissure = dict() # --------------------------------------------------------------------------- def genereMaillageSain(self, geometriesSaines, meshParams): logging.info("genereMaillageSain %s", self.nomCas) - ([objetSain], status) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests/faceGaucheSain.med")) + ([objetSain], _) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests", "faceGaucheSain.med")) smesh.SetName(objetSain.GetMesh(), 'objetSain') return [objetSain, True] # True : maillage hexa @@ -70,28 +70,29 @@ class faceGauche(fissureGenerique): rayonPipe = 20) # --------------------------------------------------------------------------- - def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams): + def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams, \ + mailleur="MeshGems"): logging.info("genereShapeFissure %s", self.nomCas) lgInfluence = shapeFissureParams['lgInfluence'] - shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests/faceGaucheFiss.brep")) + shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests", "faceGaucheFiss.brep")) fondFiss = geompy.CreateGroup(shellFiss, geompy.ShapeType["EDGE"]) geompy.UnionIDs(fondFiss, [6]) geompy.addToStudy( shellFiss, 'shellFiss' ) geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' ) - - coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,50) + mailleur = self.mailleur2d3d() + coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,50, mailleur) centre = None return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss] # --------------------------------------------------------------------------- def setParamMaillageFissure(self): - self.maillageFissureParams = dict(nomRep = '.', + self.maillageFissureParams = dict(nomRep = os.curdir, nomFicSain = self.nomCas, - nomFicFissure = 'fissure_' + self.nomCas, + nomFicFissure = self.nomCas + "_fissure", nbsegRad = 5, nbsegCercle = 8, areteFaceFissure = 1000) @@ -102,22 +103,26 @@ class faceGauche(fissureGenerique): return elementsDefaut # --------------------------------------------------------------------------- - def genereMaillageFissure(self, geometriesSaines, maillagesSains, - shapesFissure, shapeFissureParams, - maillageFissureParams, elementsDefaut, step): - maillageFissure = construitFissureGenerale(maillagesSains, - shapesFissure, shapeFissureParams, - maillageFissureParams, elementsDefaut, step) + def genereMaillageFissure(self, geometriesSaines, maillagesSains, \ + shapesFissure, shapeFissureParams, \ + maillageFissureParams, elementsDefaut, step, \ + mailleur="MeshGems"): + + mailleur = self.mailleur2d3d() + maillageFissure = construitFissureGenerale(shapesFissure, shapeFissureParams, \ + maillageFissureParams, elementsDefaut, \ + step, mailleur) return maillageFissure # --------------------------------------------------------------------------- def setReferencesMaillageFissure(self): - self.referencesMaillageFissure = dict(Entity_Quad_Pyramid = 1284, - Entity_Quad_Triangle = 2336, - Entity_Quad_Edge = 758, - Entity_Quad_Penta = 984, - Entity_Quad_Hexa = 6416, - Entity_Node = 85673, - Entity_Quad_Tetra = 35990, - Entity_Quad_Quadrangle = 4285) - + self.referencesMaillageFissure = dict( \ + Entity_Quad_Quadrangle = 3997, \ + Entity_Quad_Hexa = 5904, \ + Entity_Node = 77735, \ + Entity_Quad_Edge = 725, \ + Entity_Quad_Triangle = 2176, \ + Entity_Quad_Tetra = 32320, \ + Entity_Quad_Pyramid = 1156, \ + Entity_Quad_Penta = 856 \ + ) diff --git a/src/Tools/blocFissure/CasTests/faceGauche_2.py b/src/Tools/blocFissure/CasTests/faceGauche_2.py index 79661c471..e3863efc5 100644 --- a/src/Tools/blocFissure/CasTests/faceGauche_2.py +++ b/src/Tools/blocFissure/CasTests/faceGauche_2.py @@ -17,12 +17,12 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""problème de fissure non plane, débouchante non normale""" import os from blocFissure import gmu from blocFissure.gmu.geomsmesh import geompy, smesh -import math import GEOM import SALOMEDS import SMESH @@ -42,25 +42,26 @@ from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale O, OX, OY, OZ = triedreBase() class faceGauche_2(fissureGenerique): - """ - problème de fissure non plane, débouchante non normale - """ + """problème de fissure non plane, débouchante non normale""" - nomProbleme = "faceGauche2" + nomProbleme = "faceGauche_2" + shapeFissureParams = dict() + maillageFissureParams = dict() + referencesMaillageFissure = dict() # --------------------------------------------------------------------------- def genereMaillageSain(self, geometriesSaines, meshParams): logging.info("genereMaillageSain %s", self.nomCas) - ([objetSain], status) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests/boiteSaine.med")) + ([objetSain], _) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests", "boiteSaine.med")) smesh.SetName(objetSain.GetMesh(), 'objetSain') return [objetSain, True] # True : maillage hexa # --------------------------------------------------------------------------- def setParamShapeFissure(self): - """ - paramètres de la fissure pour méthode construitFissureGenerale + """paramètres de la fissure pour méthode construitFissureGenerale + lgInfluence : distance autour de la shape de fissure a remailler (A ajuster selon le maillage) rayonPipe : le rayon du pile maillé en hexa autour du fond de fissure convexe : optionnel True : la face est convexe (vue de l'exterieur) sert si on ne donne pas de point interne @@ -71,28 +72,29 @@ class faceGauche_2(fissureGenerique): rayonPipe = 20) # --------------------------------------------------------------------------- - def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams): + def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams, \ + mailleur="MeshGems"): logging.info("genereShapeFissure %s", self.nomCas) lgInfluence = shapeFissureParams['lgInfluence'] - shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests/faceGauche2FissCoupe.brep")) + shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests", "faceGauche2FissCoupe.brep")) fondFiss = geompy.CreateGroup(shellFiss, geompy.ShapeType["EDGE"]) - geompy.UnionIDs(fondFiss, [14, 9]) + geompy.UnionIDs(fondFiss, [4, 12]) geompy.addToStudy( shellFiss, 'shellFiss' ) geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' ) - - coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,25) + mailleur = self.mailleur2d3d() + coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,25, mailleur) centre = None return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss] # --------------------------------------------------------------------------- def setParamMaillageFissure(self): - self.maillageFissureParams = dict(nomRep = '.', + self.maillageFissureParams = dict(nomRep = os.curdir, nomFicSain = self.nomCas, - nomFicFissure = 'fissure_' + self.nomCas, + nomFicFissure = self.nomCas + "_fissure", nbsegRad = 5, nbsegCercle = 8, areteFaceFissure = 1000) @@ -103,22 +105,26 @@ class faceGauche_2(fissureGenerique): return elementsDefaut # --------------------------------------------------------------------------- - def genereMaillageFissure(self, geometriesSaines, maillagesSains, - shapesFissure, shapeFissureParams, - maillageFissureParams, elementsDefaut, step): - maillageFissure = construitFissureGenerale(maillagesSains, - shapesFissure, shapeFissureParams, - maillageFissureParams, elementsDefaut, step) + def genereMaillageFissure(self, geometriesSaines, maillagesSains, \ + shapesFissure, shapeFissureParams, \ + maillageFissureParams, elementsDefaut, step, \ + mailleur="MeshGems"): + + mailleur = self.mailleur2d3d() + maillageFissure = construitFissureGenerale(shapesFissure, shapeFissureParams, \ + maillageFissureParams, elementsDefaut, \ + step, mailleur) return maillageFissure # --------------------------------------------------------------------------- def setReferencesMaillageFissure(self): - self.referencesMaillageFissure = dict(Entity_Quad_Pyramid = 859, - Entity_Quad_Triangle = 634, - Entity_Quad_Edge = 323, - Entity_Quad_Penta = 288, - Entity_Quad_Hexa = 3435, - Entity_Node = 44095, - Entity_Quad_Tetra = 18400, - Entity_Quad_Quadrangle = 2542) - + self.referencesMaillageFissure = dict( \ + Entity_Quad_Quadrangle = 2542, \ + Entity_Quad_Hexa = 3435, \ + Entity_Node = 44095, \ + Entity_Quad_Edge = 323, \ + Entity_Quad_Triangle = 634, \ + Entity_Quad_Tetra = 18400, \ + Entity_Quad_Pyramid = 859, \ + Entity_Quad_Penta = 288 \ + ) diff --git a/src/Tools/blocFissure/CasTests/fissureCoude_1.py b/src/Tools/blocFissure/CasTests/fissureCoude_1.py index 27a8a879d..f26031baf 100644 --- a/src/Tools/blocFissure/CasTests/fissureCoude_1.py +++ b/src/Tools/blocFissure/CasTests/fissureCoude_1.py @@ -17,14 +17,21 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Fissure dans un coude""" + +import os from blocFissure.gmu.fissureCoude import fissureCoude class fissureCoude_1(fissureCoude): - """ - problème de fissure du Coude : - adaptation maillage - """ + """problème de fissure du Coude : adaptation maillage""" + + nomProbleme = "fissureCoude_1" + geomParams = dict() + meshParams = dict() + shapeFissureParams = dict() + maillageFissureParams = dict() + referencesMaillageFissure = dict() # --------------------------------------------------------------------------- def setParamGeometrieSaine(self): @@ -89,21 +96,22 @@ class fissureCoude_1(fissureCoude): nbSegCercle = nombre de secteurs areteFaceFissure = taille cible de l'arête des triangles en face de fissure. """ - self.maillageFissureParams = dict(nomRep = '.', + self.maillageFissureParams = dict(nomRep = os.curdir, nomFicSain = self.nomCas, - nomFicFissure = 'fissure_' + self.nomCas, + nomFicFissure = self.nomCas + "_fissure", nbsegRad = 5, nbsegCercle = 6, areteFaceFissure = 5) # --------------------------------------------------------------------------- def setReferencesMaillageFissure(self): - self.referencesMaillageFissure = dict(Entity_Node = 77917, - Entity_Quad_Edge = 975, - Entity_Quad_Triangle = 2182, - Entity_Quad_Quadrangle = 6842, - Entity_Quad_Tetra = 20135, - Entity_Quad_Hexa = 8994, - Entity_Quad_Penta = 972, - Entity_Quad_Pyramid = 1038) - + self.referencesMaillageFissure = dict( \ + Entity_Quad_Quadrangle = 6042, \ + Entity_Quad_Hexa = 7794, \ + Entity_Node = 65337, \ + Entity_Quad_Edge = 874, \ + Entity_Quad_Triangle = 2058, \ + Entity_Quad_Tetra = 16037, \ + Entity_Quad_Pyramid = 738, \ + Entity_Quad_Penta = 672 \ + ) diff --git a/src/Tools/blocFissure/CasTests/fissureCoude_10.py b/src/Tools/blocFissure/CasTests/fissureCoude_10.py index 7fcfaf88b..b135dfcb7 100644 --- a/src/Tools/blocFissure/CasTests/fissureCoude_10.py +++ b/src/Tools/blocFissure/CasTests/fissureCoude_10.py @@ -17,17 +17,26 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Fissure dans un coude - cas test ASCOU17""" + +import os from blocFissure.gmu.fissureCoude import fissureCoude class fissureCoude_10(fissureCoude): - # cas test ASCOU17 + """Fissure dans un coude - cas test ASCOU17""" + nomProbleme = "fissureCoude_10" + geomParams = dict() + meshParams = dict() + shapeFissureParams = dict() + maillageFissureParams = dict() + referencesMaillageFissure = dict() # --------------------------------------------------------------------------- def setParamGeometrieSaine(self): """ - Paramètres géométriques du tuyau coudé sain: + Paramètres géométriques du tuyau coudé sain angleCoude r_cintr l_tube_p1 @@ -80,7 +89,7 @@ class fissureCoude_10(fissureCoude): externe = False) # --------------------------------------------------------------------------- - + def setParamMaillageFissure(self): """ Paramètres du maillage de la fissure pour le tuyau coudé @@ -89,21 +98,22 @@ class fissureCoude_10(fissureCoude): nbSegCercle = nombre de secteurs areteFaceFissure = taille cible de l'arête des triangles en face de fissure. """ - self.maillageFissureParams = dict(nomRep = '.', + self.maillageFissureParams = dict(nomRep = os.curdir, nomFicSain = self.nomCas, - nomFicFissure = 'fissure_' + self.nomCas, + nomFicFissure = self.nomCas + "_fissure", nbsegRad = 3, nbsegCercle = 8, areteFaceFissure = 2.5) - + # --------------------------------------------------------------------------- def setReferencesMaillageFissure(self): - self.referencesMaillageFissure = dict(Entity_Node = 93352, - Entity_Quad_Edge = 1456, - Entity_Quad_Triangle = 8934, - Entity_Quad_Quadrangle = 6978, - Entity_Quad_Tetra = 31147, - Entity_Quad_Hexa = 6972, - Entity_Quad_Penta = 1600, - Entity_Quad_Pyramid = 1696) - + self.referencesMaillageFissure = dict ( \ + Entity_Quad_Quadrangle = 6160, \ + Entity_Quad_Hexa = 5864, \ + Entity_Node = 78012, \ + Entity_Quad_Edge = 1346, \ + Entity_Quad_Triangle = 9022, \ + Entity_Quad_Tetra = 24341, \ + Entity_Quad_Pyramid = 1232, \ + Entity_Quad_Penta = 1136 \ + ) diff --git a/src/Tools/blocFissure/CasTests/fissureCoude_2.py b/src/Tools/blocFissure/CasTests/fissureCoude_2.py index 68519575e..1282b122b 100644 --- a/src/Tools/blocFissure/CasTests/fissureCoude_2.py +++ b/src/Tools/blocFissure/CasTests/fissureCoude_2.py @@ -17,14 +17,21 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Fissure dans un coude""" + +import os from blocFissure.gmu.fissureCoude import fissureCoude class fissureCoude_2(fissureCoude): - """ - problème de fissure du Coude : - adaptation maillage - """ + """problème de fissure du Coude : adaptation maillage""" + + nomProbleme = "fissureCoude_2" + geomParams = dict() + meshParams = dict() + shapeFissureParams = dict() + maillageFissureParams = dict() + referencesMaillageFissure = dict() # --------------------------------------------------------------------------- def setParamGeometrieSaine(self): @@ -89,21 +96,22 @@ class fissureCoude_2(fissureCoude): nbSegCercle = nombre de secteurs areteFaceFissure = taille cible de l'arête des triangles en face de fissure. """ - self.maillageFissureParams = dict(nomRep = '.', + self.maillageFissureParams = dict(nomRep = os.curdir, nomFicSain = self.nomCas, - nomFicFissure = 'fissure_' + self.nomCas, + nomFicFissure = self.nomCas + "_fissure", nbsegRad = 5, nbsegCercle = 6, areteFaceFissure = 5) # --------------------------------------------------------------------------- def setReferencesMaillageFissure(self): - self.referencesMaillageFissure = dict(Entity_Node = 132120, - Entity_Quad_Edge = 1411, - Entity_Quad_Triangle = 5342, - Entity_Quad_Quadrangle = 9524, - Entity_Quad_Tetra = 40902, - Entity_Quad_Hexa = 12981, - Entity_Quad_Penta = 1980, - Entity_Quad_Pyramid = 2064) - + self.referencesMaillageFissure = dict( \ + Entity_Quad_Quadrangle = 7828, \ + Entity_Quad_Hexa = 10437, \ + Entity_Node = 101695, \ + Entity_Quad_Edge = 1199, \ + Entity_Quad_Triangle = 4230, \ + Entity_Quad_Tetra = 30013, \ + Entity_Quad_Pyramid = 1428, \ + Entity_Quad_Penta = 1344 \ + ) diff --git a/src/Tools/blocFissure/CasTests/fissureCoude_3.py b/src/Tools/blocFissure/CasTests/fissureCoude_3.py index ab9682076..9adc4f5b4 100644 --- a/src/Tools/blocFissure/CasTests/fissureCoude_3.py +++ b/src/Tools/blocFissure/CasTests/fissureCoude_3.py @@ -17,14 +17,21 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Fissure dans un coude""" + +import os from blocFissure.gmu.fissureCoude import fissureCoude class fissureCoude_3(fissureCoude): - """ - problème de fissure du Coude - adaptation maillage - """ + """problème de fissure du Coude - adaptation maillage""" + + nomProbleme = "fissureCoude_3" + geomParams = dict() + meshParams = dict() + shapeFissureParams = dict() + maillageFissureParams = dict() + referencesMaillageFissure = dict() # --------------------------------------------------------------------------- def setParamGeometrieSaine(self): @@ -89,21 +96,22 @@ class fissureCoude_3(fissureCoude): nbSegCercle = nombre de secteurs areteFaceFissure = taille cible de l'arête des triangles en face de fissure. """ - self.maillageFissureParams = dict(nomRep = '.', + self.maillageFissureParams = dict(nomRep = os.curdir, nomFicSain = self.nomCas, - nomFicFissure = 'fissure_' + self.nomCas, + nomFicFissure = self.nomCas + "_fissure", nbsegRad = 5, nbsegCercle = 6, areteFaceFissure = 5) # --------------------------------------------------------------------------- def setReferencesMaillageFissure(self): - self.referencesMaillageFissure = dict(Entity_Node = 98643, - Entity_Quad_Edge = 1130, - Entity_Quad_Triangle = 1476, - Entity_Quad_Quadrangle = 11100, - Entity_Quad_Tetra = 15993, - Entity_Quad_Hexa = 14508, - Entity_Quad_Penta = 624, - Entity_Quad_Pyramid = 788) - + self.referencesMaillageFissure = dict( \ + Entity_Quad_Quadrangle = 10604, \ + Entity_Quad_Hexa = 13764, \ + Entity_Node = 89087, \ + Entity_Quad_Edge = 1065, \ + Entity_Quad_Triangle = 1326, \ + Entity_Quad_Tetra = 12185, \ + Entity_Quad_Pyramid = 602, \ + Entity_Quad_Penta = 438 \ + ) diff --git a/src/Tools/blocFissure/CasTests/fissureCoude_4.py b/src/Tools/blocFissure/CasTests/fissureCoude_4.py index da8f58e21..b897d5d2a 100644 --- a/src/Tools/blocFissure/CasTests/fissureCoude_4.py +++ b/src/Tools/blocFissure/CasTests/fissureCoude_4.py @@ -17,14 +17,21 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Fissure dans un coude - ASCOU09A""" + +import os from blocFissure.gmu.fissureCoude import fissureCoude class fissureCoude_4(fissureCoude): - """ - problème de fissure du Coude : ASCOU09A - adaptation maillage - """ + """problème de fissure du Coude : ASCOU09A - adaptation maillage""" + + nomProbleme = "fissureCoude_4" + geomParams = dict() + meshParams = dict() + shapeFissureParams = dict() + maillageFissureParams = dict() + referencesMaillageFissure = dict() # --------------------------------------------------------------------------- def setParamGeometrieSaine(self): @@ -89,21 +96,22 @@ class fissureCoude_4(fissureCoude): nbSegCercle = nombre de secteurs areteFaceFissure = taille cible de l'arête des triangles en face de fissure. """ - self.maillageFissureParams = dict(nomRep = '.', + self.maillageFissureParams = dict(nomRep = os.curdir, nomFicSain = self.nomCas, - nomFicFissure = 'fissure_' + self.nomCas, + nomFicFissure = self.nomCas + "_fissure", nbsegRad = 5, nbsegCercle = 6, areteFaceFissure = 5) # --------------------------------------------------------------------------- def setReferencesMaillageFissure(self): - self.referencesMaillageFissure = dict(Entity_Node = 133832, - Entity_Quad_Edge = 1133, - Entity_Quad_Triangle = 1498, - Entity_Quad_Quadrangle = 11892, - Entity_Quad_Tetra = 18401, - Entity_Quad_Hexa = 22412, - Entity_Quad_Penta = 600, - Entity_Quad_Pyramid = 816) - + self.referencesMaillageFissure = dict( \ + Entity_Quad_Quadrangle = 11428, \ + Entity_Quad_Hexa = 21716, \ + Entity_Node = 124663, \ + Entity_Quad_Edge = 1073, \ + Entity_Quad_Triangle = 1330, \ + Entity_Quad_Tetra = 14665, \ + Entity_Quad_Pyramid = 642, \ + Entity_Quad_Penta = 426 \ + ) diff --git a/src/Tools/blocFissure/CasTests/fissureCoude_5.py b/src/Tools/blocFissure/CasTests/fissureCoude_5.py index 84b6ec8f5..e5865ce7e 100644 --- a/src/Tools/blocFissure/CasTests/fissureCoude_5.py +++ b/src/Tools/blocFissure/CasTests/fissureCoude_5.py @@ -17,14 +17,21 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Fissure dans un coude""" + +import os from blocFissure.gmu.fissureCoude import fissureCoude class fissureCoude_5(fissureCoude): - """ - problème de fissure du Coude : - adaptation maillage - """ + """problème de fissure du Coude : - adaptation maillage""" + + nomProbleme = "fissureCoude_5" + geomParams = dict() + meshParams = dict() + shapeFissureParams = dict() + maillageFissureParams = dict() + referencesMaillageFissure = dict() # --------------------------------------------------------------------------- def setParamGeometrieSaine(self): @@ -89,21 +96,22 @@ class fissureCoude_5(fissureCoude): nbSegCercle = nombre de secteurs areteFaceFissure = taille cible de l'arête des triangles en face de fissure. """ - self.maillageFissureParams = dict(nomRep = '.', + self.maillageFissureParams = dict(nomRep = os.curdir, nomFicSain = self.nomCas, - nomFicFissure = 'fissure_' + self.nomCas, + nomFicFissure = self.nomCas + "_fissure", nbsegRad = 5, nbsegCercle = 8, areteFaceFissure = 5) # --------------------------------------------------------------------------- def setReferencesMaillageFissure(self): - self.referencesMaillageFissure = dict(Entity_Node = 55217, - Entity_Quad_Edge = 762, - Entity_Quad_Triangle = 1586, - Entity_Quad_Quadrangle = 5610, - Entity_Quad_Tetra = 11468, - Entity_Quad_Hexa = 7200, - Entity_Quad_Penta = 516, - Entity_Quad_Pyramid = 552) - + self.referencesMaillageFissure = dict( \ + Entity_Quad_Quadrangle = 5366, \ + Entity_Quad_Hexa = 7120, \ + Entity_Node = 54832, \ + Entity_Quad_Edge = 722, \ + Entity_Quad_Triangle = 1570, \ + Entity_Quad_Tetra = 11747, \ + Entity_Quad_Pyramid = 532, \ + Entity_Quad_Penta = 496 \ + ) diff --git a/src/Tools/blocFissure/CasTests/fissureCoude_6.py b/src/Tools/blocFissure/CasTests/fissureCoude_6.py index cc8086f96..4cdba6d83 100644 --- a/src/Tools/blocFissure/CasTests/fissureCoude_6.py +++ b/src/Tools/blocFissure/CasTests/fissureCoude_6.py @@ -17,11 +17,21 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Fissure dans un coude - ASCOU08""" + +import os from blocFissure.gmu.fissureCoude import fissureCoude class fissureCoude_6(fissureCoude): -# --- cas ASCOU08 + """ASCOU08""" + + nomProbleme = "fissureCoude_6" + geomParams = dict() + meshParams = dict() + shapeFissureParams = dict() + maillageFissureParams = dict() + referencesMaillageFissure = dict() # --------------------------------------------------------------------------- def setParamGeometrieSaine(self): @@ -78,7 +88,7 @@ class fissureCoude_6(fissureCoude): externe = True) # --------------------------------------------------------------------------- - + def setParamMaillageFissure(self): """ Paramètres du maillage de la fissure pour le tuyau coudé @@ -87,22 +97,22 @@ class fissureCoude_6(fissureCoude): nbSegCercle = nombre de secteurs areteFaceFissure = taille cible de l'arête des triangles en face de fissure. """ - self.maillageFissureParams = dict(nomRep = '.', + self.maillageFissureParams = dict(nomRep = os.curdir, nomFicSain = self.nomCas, - nomFicFissure = 'fissure_' + self.nomCas, + nomFicFissure = self.nomCas + "_fissure", nbsegRad = 5, nbsegCercle = 12, - areteFaceFissure = 5) + areteFaceFissure = 5) # --------------------------------------------------------------------------- def setReferencesMaillageFissure(self): - self.referencesMaillageFissure = dict(Entity_Node = 63783, - Entity_Quad_Edge = 831, - Entity_Quad_Triangle = 742, - Entity_Quad_Quadrangle = 7480, - Entity_Quad_Tetra = 8084, - Entity_Quad_Hexa = 10080, - Entity_Quad_Penta = 456, - Entity_Quad_Pyramid = 500) - - + self.referencesMaillageFissure = dict( \ + Entity_Quad_Quadrangle = 7392, \ + Entity_Quad_Hexa = 9888, \ + Entity_Node = 62571, \ + Entity_Quad_Edge = 833, \ + Entity_Quad_Triangle = 1048, \ + Entity_Quad_Tetra = 7723, \ + Entity_Quad_Pyramid = 452, \ + Entity_Quad_Penta = 408 \ + ) diff --git a/src/Tools/blocFissure/CasTests/fissureCoude_7.py b/src/Tools/blocFissure/CasTests/fissureCoude_7.py index 95870120e..86bfbfb01 100644 --- a/src/Tools/blocFissure/CasTests/fissureCoude_7.py +++ b/src/Tools/blocFissure/CasTests/fissureCoude_7.py @@ -17,11 +17,21 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Fissure dans un coude""" + +import os from blocFissure.gmu.fissureCoude import fissureCoude class fissureCoude_7(fissureCoude): + """fissure dans un coude""" + nomProbleme = "fissureCoude_7" + geomParams = dict() + meshParams = dict() + shapeFissureParams = dict() + maillageFissureParams = dict() + referencesMaillageFissure = dict() # --------------------------------------------------------------------------- def setParamGeometrieSaine(self): @@ -79,7 +89,7 @@ class fissureCoude_7(fissureCoude): externe = True) # --------------------------------------------------------------------------- - + def setParamMaillageFissure(self): """ Paramètres du maillage de la fissure pour le tuyau coudé @@ -88,21 +98,22 @@ class fissureCoude_7(fissureCoude): nbSegCercle = nombre de secteurs areteFaceFissure = taille cible de l'arête des triangles en face de fissure. """ - self.maillageFissureParams = dict(nomRep = '.', + self.maillageFissureParams = dict(nomRep = os.curdir, nomFicSain = self.nomCas, - nomFicFissure = 'fissure_' + self.nomCas, + nomFicFissure = self.nomCas + "_fissure", nbsegRad = 5, nbsegCercle = 12, - areteFaceFissure = 5) + areteFaceFissure = 5) # --------------------------------------------------------------------------- def setReferencesMaillageFissure(self): - self.referencesMaillageFissure = dict(Entity_Node = 75580, - Entity_Quad_Edge = 899, - Entity_Quad_Triangle = 1158, - Entity_Quad_Quadrangle = 8022, - Entity_Quad_Tetra = 13162, - Entity_Quad_Hexa = 11272, - Entity_Quad_Penta = 756, - Entity_Quad_Pyramid = 812) - + self.referencesMaillageFissure = dict( \ + Entity_Quad_Quadrangle = 7758, \ + Entity_Quad_Hexa = 10696, \ + Entity_Node = 71535, \ + Entity_Quad_Edge = 882, \ + Entity_Quad_Triangle = 1378, \ + Entity_Quad_Tetra = 10847, \ + Entity_Quad_Pyramid = 668, \ + Entity_Quad_Penta = 612 \ + ) diff --git a/src/Tools/blocFissure/CasTests/fissureCoude_8.py b/src/Tools/blocFissure/CasTests/fissureCoude_8.py index 6aba8ec93..7ca8505d8 100644 --- a/src/Tools/blocFissure/CasTests/fissureCoude_8.py +++ b/src/Tools/blocFissure/CasTests/fissureCoude_8.py @@ -17,12 +17,21 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Fissure dans un coude - ASCOU16""" + +import os from blocFissure.gmu.fissureCoude import fissureCoude class fissureCoude_8(fissureCoude): - # cas test ASCOU15 + """cas test ASCOU16""" + nomProbleme = "fissureCoude_8" + geomParams = dict() + meshParams = dict() + shapeFissureParams = dict() + maillageFissureParams = dict() + referencesMaillageFissure = dict() # --------------------------------------------------------------------------- def setParamGeometrieSaine(self): @@ -80,7 +89,7 @@ class fissureCoude_8(fissureCoude): externe = False) # --------------------------------------------------------------------------- - + def setParamMaillageFissure(self): """ Paramètres du maillage de la fissure pour le tuyau coudé @@ -89,21 +98,22 @@ class fissureCoude_8(fissureCoude): nbSegCercle = nombre de secteurs areteFaceFissure = taille cible de l'arête des triangles en face de fissure. """ - self.maillageFissureParams = dict(nomRep = '.', + self.maillageFissureParams = dict(nomRep = os.curdir, nomFicSain = self.nomCas, - nomFicFissure = 'fissure_' + self.nomCas, + nomFicFissure = self.nomCas + "_fissure", nbsegRad = 4, nbsegCercle = 16, areteFaceFissure = 5) - + # --------------------------------------------------------------------------- def setReferencesMaillageFissure(self): - self.referencesMaillageFissure = dict(Entity_Node = 50627, - Entity_Quad_Edge = 666, - Entity_Quad_Triangle = 1498, - Entity_Quad_Quadrangle = 4747, - Entity_Quad_Tetra = 13225, - Entity_Quad_Hexa = 5464, - Entity_Quad_Penta = 864, - Entity_Quad_Pyramid = 880) - + self.referencesMaillageFissure = dict( \ + Entity_Quad_Quadrangle = 4572, \ + Entity_Quad_Hexa = 5128, \ + Entity_Node = 45641, \ + Entity_Quad_Edge = 648, \ + Entity_Quad_Triangle = 1282, \ + Entity_Quad_Tetra = 11122, \ + Entity_Quad_Pyramid = 768, \ + Entity_Quad_Penta = 752 \ + ) diff --git a/src/Tools/blocFissure/CasTests/fissureCoude_9.py b/src/Tools/blocFissure/CasTests/fissureCoude_9.py index d4d827658..c20ce91ed 100644 --- a/src/Tools/blocFissure/CasTests/fissureCoude_9.py +++ b/src/Tools/blocFissure/CasTests/fissureCoude_9.py @@ -17,12 +17,21 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Fissure dans un coude - ASCOU19""" + +import os from blocFissure.gmu.fissureCoude import fissureCoude class fissureCoude_9(fissureCoude): - # cas test ASCOU19 + """cas test ASCOU19""" + nomProbleme = "fissureCoude_9" + geomParams = dict() + meshParams = dict() + shapeFissureParams = dict() + maillageFissureParams = dict() + referencesMaillageFissure = dict() # --------------------------------------------------------------------------- def setParamGeometrieSaine(self): @@ -87,21 +96,22 @@ class fissureCoude_9(fissureCoude): nbSegCercle = nombre de secteurs areteFaceFissure = taille cible de l'arête des triangles en face de fissure. """ - self.maillageFissureParams = dict(nomRep = '.', + self.maillageFissureParams = dict(nomRep = os.curdir, nomFicSain = self.nomCas, - nomFicFissure = 'fissure_' + self.nomCas, + nomFicFissure = self.nomCas + "_fissure", nbsegRad = 6, nbsegCercle = 20, areteFaceFissure = 2.5) # --------------------------------------------------------------------------- def setReferencesMaillageFissure(self): - self.referencesMaillageFissure = dict(Entity_Node = 162936, - Entity_Quad_Edge = 1254, - Entity_Quad_Triangle = 3238, - Entity_Quad_Quadrangle = 15088, - Entity_Quad_Tetra = 19305, - Entity_Quad_Hexa = 27472, - Entity_Quad_Penta = 920, - Entity_Quad_Pyramid = 1056) - + self.referencesMaillageFissure = dict( \ + Entity_Quad_Quadrangle = 14864, \ + Entity_Quad_Hexa = 26772, \ + Entity_Node = 156163, \ + Entity_Quad_Edge = 1237, \ + Entity_Quad_Triangle = 3178, \ + Entity_Quad_Tetra = 16952, \ + Entity_Quad_Pyramid = 916, \ + Entity_Quad_Penta = 780 \ + ) diff --git a/src/Tools/blocFissure/CasTests/fissure_Coude.py b/src/Tools/blocFissure/CasTests/fissure_Coude.py index cabe7cef8..e5705002a 100644 --- a/src/Tools/blocFissure/CasTests/fissure_Coude.py +++ b/src/Tools/blocFissure/CasTests/fissure_Coude.py @@ -17,6 +17,9 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Fissure dans un coude""" + +import os from blocFissure import gmu from blocFissure.gmu.geomsmesh import geompy, smesh @@ -40,12 +43,19 @@ from blocFissure.gmu.insereFissureLongue import insereFissureLongue O, OX, OY, OZ = triedreBase() class fissure_Coude(fissureGenerique): - """ - problème de fissure du Coude : version de base + """problème de fissure du Coude : version de base + maillage hexa """ - nomProbleme = "tuyau_Coude" + nomProbleme = "fissure_Coude" + geomParams = dict() + meshParams = dict() + shapeFissureParams = dict() + maillageFissureParams = dict() + referencesMaillageFissure = dict() + circonferentielle = False + longitudinale = False # --------------------------------------------------------------------------- def setParamGeometrieSaine(self): @@ -256,16 +266,16 @@ class fissure_Coude(fissureGenerique): smesh.SetName(algo1d_long_p2, "algo1d_long_p2") smesh.SetName(hypo1d_long_p2, "hypo1d_long_p2") - isDone = maillageSain.Compute() + _ = maillageSain.GroupOnGeom(P1,'P1',SMESH.NODE) + _ = maillageSain.GroupOnGeom(P2,'P2',SMESH.NODE) + _ = maillageSain.GroupOnGeom(EXTUBE,'EXTUBE',SMESH.FACE) + _ = maillageSain.GroupOnGeom(BORDTU,'BORDTU',SMESH.EDGE) + _ = maillageSain.GroupOnGeom(CLGV,'CLGV',SMESH.FACE) + _ = maillageSain.GroupOnGeom(PEAUINT,'PEAUINT',SMESH.FACE) + _ = maillageSain.GroupOnGeom(PEAUEXT,'PEAUEXT',SMESH.FACE) + _ = maillageSain.GroupOnGeom(COUDE,'COUDSAIN',SMESH.VOLUME) - mp1 = maillageSain.GroupOnGeom(P1,'P1',SMESH.NODE) - mp2 = maillageSain.GroupOnGeom(P2,'P2',SMESH.NODE) - ext = maillageSain.GroupOnGeom(EXTUBE,'EXTUBE',SMESH.FACE) - btu = maillageSain.GroupOnGeom(BORDTU,'BORDTU',SMESH.EDGE) - clg = maillageSain.GroupOnGeom(CLGV,'CLGV',SMESH.FACE) - pei = maillageSain.GroupOnGeom(PEAUINT,'PEAUINT',SMESH.FACE) - pex = maillageSain.GroupOnGeom(PEAUEXT,'PEAUEXT',SMESH.FACE) - cou = maillageSain.GroupOnGeom(COUDE,'COUDSAIN',SMESH.VOLUME) + _ = maillageSain.Compute() return [maillageSain, True] # True : maillage hexa @@ -292,14 +302,15 @@ class fissure_Coude(fissureGenerique): externe = True) # --------------------------------------------------------------------------- - def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams): + def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams, \ + mailleur="MeshGems"): logging.info("genereShapeFissure %s", self.nomCas) logging.info("shapeFissureParams %s", shapeFissureParams) - angleCoude = geomParams['angleCoude'] + #angleCoude = geomParams['angleCoude'] r_cintr = geomParams['r_cintr'] l_tube_p1 = geomParams['l_tube_p1'] - l_tube_p2 = geomParams['l_tube_p2'] + #l_tube_p2 = geomParams['l_tube_p2'] epais = geomParams['epais'] de = geomParams['de'] @@ -317,13 +328,8 @@ class fissure_Coude(fissureGenerique): if not lgInfluence: lgInfluence = profondeur - if longueur > 2*profondeur: - self.fissureLongue=True - else: - self.fissureLongue=False + self.fissureLongue = bool(longueur > 2*profondeur) - self.circonferentielle = False - self.longitudinale = False if self.fissureLongue and (abs(orientation) < 45) : self.longitudinale = True elif self.fissureLongue: @@ -471,15 +477,16 @@ class fissure_Coude(fissureGenerique): else: pass - coordsNoeudsFissure = genereMeshCalculZoneDefaut(facefiss, 5 ,10) + mailleur = self.mailleur2d3d() + coordsNoeudsFissure = genereMeshCalculZoneDefaut(facefiss, 5 ,10, mailleur) return [facefiss, centre, lgInfluence, coordsNoeudsFissure, wiretube, facetubel, facetuber, planfiss, pipefiss] # --------------------------------------------------------------------------- def setParamMaillageFissure(self): - self.maillageFissureParams = dict(nomRep = '.', + self.maillageFissureParams = dict(nomRep = os.curdir, nomFicSain = self.nomCas, - nomFicFissure = 'fissure_' + self.nomCas, + nomFicFissure = self.nomCas + "_fissure", nbsegExt = 5, nbsegGen = 25, nbsegRad = 5, @@ -495,21 +502,26 @@ class fissure_Coude(fissureGenerique): # --------------------------------------------------------------------------- def genereMaillageFissure(self, geometriesSaines, maillagesSains, - shapesFissure, shapeFissureParams, - maillageFissureParams, elementsDefaut, step): - maillageFissure = insereFissureLongue(geometriesSaines, maillagesSains, - shapesFissure, shapeFissureParams, - maillageFissureParams, elementsDefaut, step) + shapesFissure, shapeFissureParams, \ + maillageFissureParams, elementsDefaut, step, \ + mailleur="MeshGems"): + + mailleur = self.mailleur2d3d() + maillageFissure = insereFissureLongue(geometriesSaines, \ + shapesFissure, shapeFissureParams, \ + maillageFissureParams, elementsDefaut, \ + step, mailleur) return maillageFissure # --------------------------------------------------------------------------- def setReferencesMaillageFissure(self): - self.referencesMaillageFissure = dict(Entity_Node = 77491, - Entity_Quad_Edge = 1006, - Entity_Quad_Triangle = 2412, - Entity_Quad_Quadrangle = 6710, - Entity_Quad_Tetra = 20853, - Entity_Quad_Hexa = 8656, - Entity_Quad_Penta = 1176, - Entity_Quad_Pyramid = 1232) - + self.referencesMaillageFissure = dict( \ + Entity_Quad_Quadrangle = 6710, \ + Entity_Quad_Hexa = 8656, \ + Entity_Node = 76807, \ + Entity_Quad_Edge = 1006, \ + Entity_Quad_Triangle = 2342, \ + Entity_Quad_Tetra = 20392, \ + Entity_Quad_Pyramid = 1232, \ + Entity_Quad_Penta = 1176 \ + ) diff --git a/src/Tools/blocFissure/CasTests/fissure_Coude_4.py b/src/Tools/blocFissure/CasTests/fissure_Coude_4.py index 55a9a1e7d..c697198bb 100644 --- a/src/Tools/blocFissure/CasTests/fissure_Coude_4.py +++ b/src/Tools/blocFissure/CasTests/fissure_Coude_4.py @@ -17,15 +17,25 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""Fissure dans un coude - ASCOU09A""" + +import os from .fissure_Coude import fissure_Coude class fissure_Coude_4(fissure_Coude): - """ - probleme de fissure du Coude : ASCOU09A + """probleme de fissure du Coude : ASCOU09A + adaptation maillage """ + nomProbleme = "fissure_Coude_4" + geomParams = dict() + meshParams = dict() + shapeFissureParams = dict() + maillageFissureParams = dict() + referencesMaillageFissure = dict() + # --------------------------------------------------------------------------- def setParamGeometrieSaine(self): """ @@ -64,10 +74,9 @@ class fissure_Coude_4(fissure_Coude): orientation : 0° : longitudinale, 90° : circonférentielle, autre : uniquement fissures elliptiques externe : True : fissure face externe, False : fissure face interne """ - print("setParamShapeFissure", self.nomCas) - self.shapeFissureParams = dict(nomRep = '.', + self.shapeFissureParams = dict(nomRep = os.curdir, nomFicSain = self.nomCas, - nomFicFissure = 'fissure_' + self.nomCas, + nomFicFissure = self.nomCas + "_fissure", profondeur = 10, azimut = 90, alpha = 20, @@ -80,12 +89,13 @@ class fissure_Coude_4(fissure_Coude): # --------------------------------------------------------------------------- def setReferencesMaillageFissure(self): - self.referencesMaillageFissure = dict(Entity_Quad_Pyramid = 948, - Entity_Quad_Triangle = 1562, - Entity_Quad_Edge = 1192, - Entity_Quad_Penta = 732, - Entity_Quad_Hexa = 22208, - Entity_Node = 133418, - Entity_Quad_Tetra = 18759, - Entity_Quad_Quadrangle = 11852) - + self.referencesMaillageFissure = dict( \ + Entity_Quad_Quadrangle = 11852, \ + Entity_Quad_Hexa = 22208, \ + Entity_Node = 133418, \ + Entity_Quad_Edge = 1192, \ + Entity_Quad_Triangle = 1562, \ + Entity_Quad_Tetra = 18759, \ + Entity_Quad_Pyramid = 948, \ + Entity_Quad_Penta = 732, \ + ) diff --git a/src/Tools/blocFissure/CasTests/tube.py b/src/Tools/blocFissure/CasTests/tube.py new file mode 100644 index 000000000..3653c9ac3 --- /dev/null +++ b/src/Tools/blocFissure/CasTests/tube.py @@ -0,0 +1,135 @@ +# -*- coding: utf-8 -*- +# Copyright (C) 2014-2020 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 +# + +"""problème de fissure plane dans un tube ; passage par fichier xao""" + +import os +import logging + +from blocFissure import gmu +from blocFissure.gmu.geomsmesh import geompy, smesh +from blocFissure.gmu.fissureGenerique import fissureGenerique +from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut +from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain +from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale + +import GEOM +import SALOMEDS +import SMESH + +class tube(fissureGenerique): + """problème de fissure plane dans un tube""" + + nomProbleme = "tube" + shapeFissureParams = dict() + maillageFissureParams = dict() + referencesMaillageFissure = dict() + + # --------------------------------------------------------------------------- + def genereMaillageSain(self, geometriesSaines, meshParams): + texte = "genereMaillageSain pour '{}'".format(self.nomCas) + logging.info(texte) + + ([objetSain], _) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests", "Tube.med")) + smesh.SetName(objetSain.GetMesh(), "{}_objetSain".format(self.nomProbleme)) + + return [objetSain, True] # True : maillage hexa + + # --------------------------------------------------------------------------- + def setParamShapeFissure(self): + """ + paramètres de la fissure pour méthode construitFissureGenerale + lgInfluence : distance autour de la shape de fissure a remailler (A ajuster selon le maillage) + rayonPipe : le rayon du pile maillé en hexa autour du fond de fissure + """ + texte = "genereMaillageSain pour '{}'".format(self.nomCas) + logging.info(texte) + self.shapeFissureParams = dict(lgInfluence = 0.4, + rayonPipe = 0.05) + + # --------------------------------------------------------------------------- + def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams, \ + mailleur="MeshGems"): + """Importe la géométrie de la fissure""" + texte = "genereShapeFissure pour '{}'".format(self.nomCas) + logging.info(texte) + + lgInfluence = shapeFissureParams['lgInfluence'] + + (_, shellFiss, _, l_groups, _) = geompy.ImportXAO(os.path.join(gmu.pathBloc, "materielCasTests", "TubeFiss.xao")) + l_aux = list() + for group in l_groups: + if ( group.GetName() in ("Group_1","Group_2","Group_3") ): + l_aux.append(group) + fondFiss = geompy.CreateGroup(shellFiss, geompy.ShapeType["EDGE"]) + geompy.UnionList(fondFiss, l_aux ) + geompy.addToStudy( shellFiss, 'shellFiss' ) + geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' ) + + mailleur = self.mailleur2d3d() + coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 0.025, 0.1, mailleur) + + centre = None + + return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss] + + # --------------------------------------------------------------------------- + def setParamMaillageFissure(self): + texte = "setParamMaillageFissure pour '{}'".format(self.nomCas) + logging.info(texte) + self.maillageFissureParams = dict(nomRep = os.curdir, + nomFicSain = self.nomCas, + nomFicFissure = self.nomCas + "_fissure", + nbsegRad = 5, + nbsegCercle = 8, + areteFaceFissure = 0.5) + + # --------------------------------------------------------------------------- + def genereZoneDefaut(self, geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams): + elementsDefaut = creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams) + return elementsDefaut + + # --------------------------------------------------------------------------- + def genereMaillageFissure(self, geometriesSaines, maillagesSains, \ + shapesFissure, shapeFissureParams, \ + maillageFissureParams, elementsDefaut, step, \ + mailleur="MeshGems"): + + texte = "genereMaillageFissure pour '{}'".format(self.nomCas) + logging.info(texte) + + mailleur = self.mailleur2d3d() + maillageFissure = construitFissureGenerale(shapesFissure, shapeFissureParams, \ + maillageFissureParams, elementsDefaut, \ + step, mailleur) + return maillageFissure + + # --------------------------------------------------------------------------- + def setReferencesMaillageFissure(self): + self.referencesMaillageFissure = dict( \ + Entity_Quad_Quadrangle = 1630, \ + Entity_Quad_Hexa = 3523, \ + Entity_Node = 18874, \ + Entity_Quad_Edge = 261, \ + Entity_Quad_Triangle = 190, \ + Entity_Quad_Tetra = 1322, \ + Entity_Quad_Pyramid = 172, \ + Entity_Quad_Penta = 64 \ + ) diff --git a/src/Tools/blocFissure/CasTests/vis_1.py b/src/Tools/blocFissure/CasTests/vis_1.py index 7e6e52702..f7b07a0b5 100644 --- a/src/Tools/blocFissure/CasTests/vis_1.py +++ b/src/Tools/blocFissure/CasTests/vis_1.py @@ -17,18 +17,15 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # +"""problème de fissure non plane, débouchante non normale""" import os from blocFissure import gmu from blocFissure.gmu.geomsmesh import geompy, smesh -import math import GEOM import SALOMEDS import SMESH -#import StdMeshers -#import GHS3DPlugin -#import NETGENPlugin import logging from blocFissure.gmu.fissureGenerique import fissureGenerique @@ -41,57 +38,66 @@ from blocFissure.gmu.construitFissureGenerale import construitFissureGenerale O, OX, OY, OZ = triedreBase() class vis_1(fissureGenerique): - """ - problème de fissure non plane, débouchante non normale - """ + """problème de fissure non plane, débouchante non normale""" nomProbleme = "vis_1" + shapeFissureParams = dict() + maillageFissureParams = dict() + referencesMaillageFissure = dict() # --------------------------------------------------------------------------- def genereMaillageSain(self, geometriesSaines, meshParams): - logging.info("genereMaillageSain %s", self.nomCas) + texte = "genereMaillageSain pour '{}'".format(self.nomCas) + logging.info(texte) - ([objetSain], status) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests/visSain.med")) - smesh.SetName(objetSain.GetMesh(), 'objetSain') + ([objetSain], _) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests", "visSain.med")) + smesh.SetName(objetSain.GetMesh(), "{}_objetSain".format(self.nomProbleme)) return [objetSain, True] # True : maillage hexa # --------------------------------------------------------------------------- def setParamShapeFissure(self): - """ - paramètres de la fissure pour méthode construitFissureGenerale + """paramètres de la fissure pour méthode construitFissureGenerale + lgInfluence : distance autour de la shape de fissure a remailler (A ajuster selon le maillage) rayonPipe : le rayon du pile maillé en hexa autour du fond de fissure convexe : optionnel True : la face est convexe (vue de l'exterieur) sert si on ne donne pas de point interne pointIn_x : optionnel coordonnée x d'un point dans le solide sain (pour orienter la face) """ - logging.info("setParamShapeFissure %s", self.nomCas) + texte = "setParamShapeFissure pour '{}'".format(self.nomCas) + logging.info(texte) self.shapeFissureParams = dict(lgInfluence = 0.6, rayonPipe = 0.1) # --------------------------------------------------------------------------- - def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams): - logging.info("genereShapeFissure %s", self.nomCas) + def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams, \ + mailleur="MeshGems"): + """Importe la géométrie de la fissure et crée le groupe du fond de la fissure""" + texte = "genereShapeFissure pour '{}'".format(self.nomCas) + logging.info(texte) lgInfluence = shapeFissureParams['lgInfluence'] - shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests/visFiss.brep")) + shellFiss = geompy.ImportBREP(os.path.join(gmu.pathBloc, "materielCasTests", "visFiss.brep")) fondFiss = geompy.CreateGroup(shellFiss, geompy.ShapeType["EDGE"]) - geompy.UnionIDs(fondFiss, [6, 8]) + geompy.UnionIDs(fondFiss, [6, 8, 3]) geompy.addToStudy( shellFiss, 'shellFiss' ) geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' ) - - coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 0.1 ,0.2) + mailleur = self.mailleur2d3d() + coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 0.1 ,0.2, mailleur) centre = None + return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss] # --------------------------------------------------------------------------- def setParamMaillageFissure(self): - self.maillageFissureParams = dict(nomRep = '.', + texte = "setParamMaillageFissure pour '{}'".format(self.nomCas) + logging.info(texte) + self.maillageFissureParams = dict(nomRep = os.curdir, nomFicSain = self.nomCas, - nomFicFissure = 'fissure_' + self.nomCas, + nomFicFissure = self.nomCas + "_fissure", nbsegRad = 5, nbsegCercle = 32, areteFaceFissure = 0.1) @@ -102,22 +108,29 @@ class vis_1(fissureGenerique): return elementsDefaut # --------------------------------------------------------------------------- - def genereMaillageFissure(self, geometriesSaines, maillagesSains, - shapesFissure, shapeFissureParams, - maillageFissureParams, elementsDefaut, step): - maillageFissure = construitFissureGenerale(maillagesSains, - shapesFissure, shapeFissureParams, - maillageFissureParams, elementsDefaut, step) + def genereMaillageFissure(self, geometriesSaines, maillagesSains, \ + shapesFissure, shapeFissureParams, \ + maillageFissureParams, elementsDefaut, step, \ + mailleur="MeshGems"): + + texte = "genereMaillageFissure pour '{}'".format(self.nomCas) + logging.info(texte) + + mailleur = self.mailleur2d3d() + maillageFissure = construitFissureGenerale(shapesFissure, shapeFissureParams, \ + maillageFissureParams, elementsDefaut, \ + step, mailleur) return maillageFissure # --------------------------------------------------------------------------- def setReferencesMaillageFissure(self): - self.referencesMaillageFissure = dict(Entity_Quad_Pyramid = 1284, - Entity_Quad_Triangle = 2336, - Entity_Quad_Edge = 758, - Entity_Quad_Penta = 984, - Entity_Quad_Hexa = 6416, - Entity_Node = 85673, - Entity_Quad_Tetra = 35990, - Entity_Quad_Quadrangle = 4285) - + self.referencesMaillageFissure = dict( \ + Entity_Quad_Quadrangle = 4285 ,\ + Entity_Quad_Hexa = 6416, \ + Entity_Node = 85673, \ + Entity_Quad_Edge = 758, \ + Entity_Quad_Triangle = 2336, \ + Entity_Quad_Tetra = 35990, \ + Entity_Quad_Pyramid = 1284, \ + Entity_Quad_Penta = 984 \ + ) diff --git a/src/Tools/blocFissure/doc/gui.rst b/src/Tools/blocFissure/doc/gui.rst index af0815088..4d633588e 100644 --- a/src/Tools/blocFissure/doc/gui.rst +++ b/src/Tools/blocFissure/doc/gui.rst @@ -6,23 +6,30 @@ With GUI To make the use of « Bloc Fissure » easier, a Graphical User Interface (GUI) was developed. Inputs are similar to those of :ref:`script mode