#include "SMESH_TryCatch.hxx" // include after OCCT headers!
#include "Utils_ExceptHandlers.hxx"
-
+#ifndef WIN32
#include <boost/thread/thread.hpp>
#include <boost/bind.hpp>
+#else
+#include <pthread.h>
+#endif
using namespace std;
namespace
{
- void deleteMeshDS(SMESHDS_Mesh* meshDS)
+#ifndef WIN32
+ void deleteMeshDS(SMESHDS_Mesh* meshDS)
{
//cout << "deleteMeshDS( " << meshDS << endl;
delete meshDS;
}
+#else
+ static void* deleteMeshDS(void* meshDS)
+ {
+ //cout << "deleteMeshDS( " << meshDS << endl;
+ SMESHDS_Mesh* m = (SMESHDS_Mesh*)meshDS;
+ if(m) {
+ delete m;
+ }
+ return 0;
+ }
+#endif
}
//=============================================================================
_myDocument->RemoveMesh( _id );
_myDocument = 0;
- if ( _myMeshDS )
- // delete _myMeshDS, in a thread in order not to block closing a study with large meshes
+ if ( _myMeshDS ) {
+ // delete _myMeshDS, in a thread in order not to block closing a study with large meshes
+#ifndef WIN32
boost::thread aThread(boost::bind( & deleteMeshDS, _myMeshDS ));
+#else
+ pthread_t thread;
+ int result=pthread_create(&thread, NULL, deleteMeshDS, (void*)_myMeshDS);
+#endif
+ }
}
//================================================================================
QLabel * nbNodesName = new QLabel(tr("SMESH_MESHINFO_NODES"), this );
QLabel * nbElemsName = new QLabel(tr("SMESH_MESHINFO_ELEMENTS"), this );
- QLabel * freeRAMName = new QLabel(tr("SMESH_FREERAM"), this );
nbNodesLabel = new QLabel("0", this );
nbElemsLabel = new QLabel("0", this );
+#ifndef WIN32
+ QLabel * freeRAMName = new QLabel(tr("SMESH_FREERAM"), this );
freeRAMLabel = new QLabel("", this );
+#endif
progressBar = new QProgressBar(this);
progressBar->setMinimum( 0 );
progressBar->setMaximum( 1000 );
ADD_SUBDIRECTORY(MeshCut)
ADD_SUBDIRECTORY(padder)
ADD_SUBDIRECTORY(Verima)
+ADD_SUBDIRECTORY(blocFissure)
IF(SALOME_BUILD_GUI)
ADD_SUBDIRECTORY(MGCleanerPlug)
--- /dev/null
+# Copyright (C) 2012-2013 CEA/DEN, EDF R&D, OPEN CASCADE
+#
+# 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.
+#
+# 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
+#
+
+ADD_SUBDIRECTORY(CasTests)
+ADD_SUBDIRECTORY(gmu)
+ADD_SUBDIRECTORY(materielCasTests)
+
+IF(SALOME_BUILD_GUI)
+ ADD_SUBDIRECTORY(ihm)
+ENDIF(SALOME_BUILD_GUI)
+
+# --- scripts ---
+
+# scripts / static
+SET(plugin_SCRIPTS
+ __init__.py
+ casStandard.py
+ exemple.py
+ exemple2.py
+)
+
+# --- rules ---
+
+SALOME_INSTALL_SCRIPTS("${plugin_SCRIPTS}" ${SALOME_SMESH_INSTALL_PLUGINS}/blocFissure)
--- /dev/null
+# Copyright (C) 2012-2013 CEA/DEN, EDF R&D, OPEN CASCADE
+#
+# 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.
+#
+# 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
+#
+
+# --- scripts ---
+
+# scripts / static
+SET(plugin_SCRIPTS
+ __init__.py
+ cubeAngle2.py
+ cubeAngle.py
+ cylindre_2.py
+ cylindre.py
+ disquePerce.py
+ ellipse_1.py
+ ellipse_2.py
+ eprouvetteCourbe.py
+ eprouvetteDroite_2.py
+ eprouvetteDroite.py
+ execution_Cas.py
+ faceGauche_2.py
+ faceGauche.py
+ fissureCoude_10.py
+ fissureCoude_1.py
+ fissureCoude_2.py
+ fissureCoude_3.py
+ fissure_Coude_4.py
+ fissureCoude_4.py
+ fissureCoude_5.py
+ fissureCoude_6.py
+ fissureCoude_7.py
+ fissureCoude_8.py
+ fissureCoude_9.py
+ fissure_Coude.py
+ vis_1.py
+)
+
+# --- rules ---
+
+SALOME_INSTALL_SCRIPTS("${plugin_SCRIPTS}" ${SALOME_SMESH_INSTALL_PLUGINS}/blocFissure/CasTests)
--- /dev/null
+# -*- coding: utf-8 -*-
+
+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
+
+from blocFissure.gmu.triedreBase import triedreBase
+from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
+from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
+from blocFissure.gmu.insereFissureGenerale import insereFissureGenerale
+
+O, OX, OY, OZ = triedreBase()
+
+class cubeAngle(fissureGenerique):
+ """
+ problème de fissure plane coupant 2 faces (angle), débouches normaux, objet plan
+ """
+
+ nomProbleme = "cubeAngle"
+
+ # ---------------------------------------------------------------------------
+ def genereMaillageSain(self, geometriesSaines, meshParams):
+ logging.info("genereMaillageSain %s", self.nomCas)
+
+ ([objetSain], status) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, 'materielCasTests/CubeAngle.med'))
+ smesh.SetName(objetSain.GetMesh(), 'objetSain')
+
+ return [objetSain, True] # True : maillage hexa
+
+ # ---------------------------------------------------------------------------
+ def setParamShapeFissure(self):
+ """
+ paramètres de la fissure pour méthode insereFissureGenerale
+ 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)
+ self.shapeFissureParams = dict(lgInfluence = 20,
+ rayonPipe = 10)
+
+ # ---------------------------------------------------------------------------
+ def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams):
+ logging.info("genereShapeFissure %s", self.nomCas)
+
+ lgInfluence = shapeFissureParams['lgInfluence']
+
+ shellFiss = geompy.ImportFile(os.path.join(gmu.pathBloc, "materielCasTests/CubeAngleFiss.brep"), "BREP")
+ fondFiss = geompy.CreateGroup(shellFiss, geompy.ShapeType["EDGE"])
+ geompy.UnionIDs(fondFiss, [4])
+ geompy.addToStudy( shellFiss, 'shellFiss' )
+ geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' )
+
+
+ coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,10)
+
+ centre = None
+ return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss]
+
+ # ---------------------------------------------------------------------------
+ def setParamMaillageFissure(self):
+ self.maillageFissureParams = dict(nomRep = '.',
+ nomFicSain = self.nomCas,
+ nomFicFissure = 'fissure_' + self.nomCas,
+ nbsegRad = 5,
+ nbsegCercle = 8,
+ areteFaceFissure = 10)
+
+ # ---------------------------------------------------------------------------
+ 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):
+ maillageFissure = insereFissureGenerale(maillagesSains,
+ shapesFissure, shapeFissureParams,
+ maillageFissureParams, elementsDefaut, step)
+ 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)
+
--- /dev/null
+# -*- coding: utf-8 -*-
+
+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
+ """
+
+ nomProbleme = "cubeAngle2"
+
+ # ---------------------------------------------------------------------------
+ def setParamShapeFissure(self):
+ """
+ paramètres de la fissure pour méthode insereFissureGenerale
+ 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
+ """
+ self.shapeFissureParams = dict(lgInfluence = 20,
+ rayonPipe = 5)
+
+ # ---------------------------------------------------------------------------
+ def setParamMaillageFissure(self):
+ self.maillageFissureParams = dict(nomRep = '.',
+ nomFicSain = self.nomCas,
+ nomFicFissure = 'fissure_' + self.nomCas,
+ 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)
+
--- /dev/null
+# -*- coding: utf-8 -*-
+
+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
+
+from blocFissure.gmu.triedreBase import triedreBase
+from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
+from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
+from blocFissure.gmu.insereFissureGenerale import insereFissureGenerale
+
+O, OX, OY, OZ = triedreBase()
+
+class cylindre(fissureGenerique):
+ """
+ problème de fissure plane sur cylindre, grand fond de fissure en arc de cercle
+ """
+
+ nomProbleme = "cylindre"
+
+ # ---------------------------------------------------------------------------
+ def genereMaillageSain(self, geometriesSaines, meshParams):
+ """
+ génère le maillage de l'objet sain, par chargement d'un fichier med
+ ici, les paramètres de géométrie et de maillage ne sont pas utiles
+ """
+ logging.info("genereMaillageSain %s", self.nomCas)
+
+ ([objetSain], status) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests/CylindreSain.med"))
+ smesh.SetName(objetSain.GetMesh(), 'objetSain')
+
+ return [objetSain, True] # True : maillage hexa
+
+ # ---------------------------------------------------------------------------
+ def setParamShapeFissure(self):
+ """
+ paramètres de la fissure pour méthode insereFissureGenerale
+ 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)
+ self.shapeFissureParams = dict(lgInfluence = 20,
+ rayonPipe = 5)
+
+ # ---------------------------------------------------------------------------
+ def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams):
+ logging.info("genereShapeFissure %s", self.nomCas)
+
+ lgInfluence = shapeFissureParams['lgInfluence']
+
+ shellFiss = geompy.ImportFile(os.path.join(gmu.pathBloc, "materielCasTests/FissInCylindre2.brep"), "BREP")
+ fondFiss = geompy.CreateGroup(shellFiss, geompy.ShapeType["EDGE"])
+ geompy.UnionIDs(fondFiss, [7])
+ geompy.addToStudy( shellFiss, 'shellFiss' )
+ geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' )
+
+
+ coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,15)
+
+ centre = None
+ return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss]
+
+ # ---------------------------------------------------------------------------
+ def setParamMaillageFissure(self):
+ self.maillageFissureParams = dict(nomRep = '.',
+ nomFicSain = self.nomCas,
+ nomFicFissure = 'fissure_' + self.nomCas,
+ nbsegRad = 5,
+ nbsegCercle = 8,
+ areteFaceFissure = 20)
+
+ # ---------------------------------------------------------------------------
+ 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):
+ maillageFissure = insereFissureGenerale(maillagesSains,
+ shapesFissure, shapeFissureParams,
+ maillageFissureParams, elementsDefaut, step)
+ 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)
+
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import os
+from blocFissure import gmu
+from blocFissure.gmu.geomsmesh import geompy, smesh
+
+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.insereFissureGenerale import insereFissureGenerale
+
+O, OX, OY, OZ = triedreBase()
+
+class cylindre_2(cylindre):
+ """
+ problème de fissure plane sur cylindre hexa, fond de fissure complexe : polyline
+ """
+ nomProbleme = "cylindre2"
+
+ # ---------------------------------------------------------------------------
+ def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams):
+ logging.info("genereShapeFissure %s", self.nomCas)
+
+ lgInfluence = shapeFissureParams['lgInfluence']
+
+ shellFiss = geompy.ImportFile(os.path.join(gmu.pathBloc, "materielCasTests/FissInCylindre.brep"), "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 ,15)
+
+ 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)
+
--- /dev/null
+# -*- coding: utf-8 -*-
+
+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 = [4],
+ lgInfluence = 10,
+ meshBrep = (0.5,2.5),
+ rayonPipe = 1.0,
+ lenSegPipe = 1.5,
+ nbSegRad = 6,
+ nbSegCercle = 16,
+ areteFaceFissure = 2.5)
+
+ # ---------------------------------------------------------------------------
+
+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)
+
--- /dev/null
+# -*- coding: utf-8 -*-
+
+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
+
+from blocFissure.gmu.triedreBase import triedreBase
+from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
+from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
+from blocFissure.gmu.insereFissureGenerale import insereFissureGenerale
+
+O, OX, OY, OZ = triedreBase()
+
+class ellipse_1(fissureGenerique):
+ """
+ problème de fissure non plane, débouchante non normale
+ """
+
+ nomProbleme = "ellipse1"
+
+# # ---------------------------------------------------------------------------
+# def genereGeometrieSaine(self, geomParams):
+# logging.info("genereGeometrieSaine %s", self.nomCas)
+# box = geompy.MakeBox(0, -500, 0, 400, 500, 800, "boiteSaine")
+# return [box]
+
+ # ---------------------------------------------------------------------------
+ def genereMaillageSain(self, geometriesSaines, meshParams):
+ logging.info("genereMaillageSain %s", self.nomCas)
+
+ ([objetSain], status) = 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 insereFissureGenerale
+ 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)
+ self.shapeFissureParams = dict(lgInfluence = 50,
+ rayonPipe = 20)
+
+ # ---------------------------------------------------------------------------
+ def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams):
+ logging.info("genereShapeFissure %s", self.nomCas)
+
+ lgInfluence = shapeFissureParams['lgInfluence']
+
+ shellFiss = geompy.ImportFile(os.path.join(gmu.pathBloc, "materielCasTests/ellipse1.brep"), "BREP")
+ fondFiss = geompy.CreateGroup(shellFiss, geompy.ShapeType["EDGE"])
+ geompy.UnionIDs(fondFiss, [4])
+ geompy.addToStudy( shellFiss, 'shellFiss' )
+ geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' )
+
+
+ coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,25)
+
+ centre = None
+ return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss]
+
+ # ---------------------------------------------------------------------------
+ def setParamMaillageFissure(self):
+ self.maillageFissureParams = dict(nomRep = '.',
+ nomFicSain = self.nomCas,
+ nomFicFissure = 'fissure_' + self.nomCas,
+ nbsegRad = 5,
+ nbsegCercle = 8,
+ areteFaceFissure = 1000)
+
+ # ---------------------------------------------------------------------------
+ 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):
+ maillageFissure = insereFissureGenerale(maillagesSains,
+ shapesFissure, shapeFissureParams,
+ maillageFissureParams, elementsDefaut, step)
+ 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)
+
--- /dev/null
+# -*- coding: utf-8 -*-
+
+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 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.insereFissureGenerale import insereFissureGenerale
+
+O, OX, OY, OZ = triedreBase()
+
+class ellipse_2(ellipse_1):
+ """
+ problème de fissure non plane, débouchante non normale
+ """
+
+ nomProbleme = "ellipse2"
+
+ # ---------------------------------------------------------------------------
+ def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams):
+ logging.info("genereShapeFissure %s", self.nomCas)
+
+ lgInfluence = shapeFissureParams['lgInfluence']
+
+ shellFiss = geompy.ImportFile(os.path.join(gmu.pathBloc, "materielCasTests/ellipse1_pb.brep"), "BREP")
+ fondFiss = geompy.CreateGroup(shellFiss, geompy.ShapeType["EDGE"])
+ geompy.UnionIDs(fondFiss, [4])
+ geompy.addToStudy( shellFiss, 'shellFiss' )
+ geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' )
+
+
+ coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,25)
+
+ 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)
--- /dev/null
+# -*- coding: utf-8 -*-
+
+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
+
+from blocFissure.gmu.triedreBase import triedreBase
+from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
+from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
+from blocFissure.gmu.insereFissureGenerale import insereFissureGenerale
+
+O, OX, OY, OZ = triedreBase()
+
+class eprouvetteCourbe(fissureGenerique):
+ """
+ problème de fissure plane coupant 3 faces (éprouvette), faces au débouché non planes, incidence presque normale
+ """
+
+ nomProbleme = "eprouvetteCourbe"
+
+ # ---------------------------------------------------------------------------
+ def genereMaillageSain(self, geometriesSaines, meshParams):
+ logging.info("genereMaillageSain %s", self.nomCas)
+
+ ([objetSain], status) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests/EprouvetteCourbe.med"))
+ smesh.SetName(objetSain.GetMesh(), 'objetSain')
+
+ return [objetSain, True] # True : maillage hexa
+
+ # ---------------------------------------------------------------------------
+ def setParamShapeFissure(self):
+ """
+ paramètres de la fissure pour méthode insereFissureGenerale
+ 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)
+ self.shapeFissureParams = dict(lgInfluence = 30,
+ rayonPipe = 10)
+
+ # ---------------------------------------------------------------------------
+ def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams):
+ logging.info("genereShapeFissure %s", self.nomCas)
+
+ lgInfluence = shapeFissureParams['lgInfluence']
+
+ shellFiss = geompy.ImportFile(os.path.join(gmu.pathBloc, "materielCasTests/EprouvetteCourbeFiss.brep"), "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)
+
+ centre = None
+ return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss]
+
+ # ---------------------------------------------------------------------------
+ def setParamMaillageFissure(self):
+ self.maillageFissureParams = dict(nomRep = '.',
+ nomFicSain = self.nomCas,
+ nomFicFissure = 'fissure_' + self.nomCas,
+ nbsegRad = 5,
+ nbsegCercle = 8,
+ areteFaceFissure = 15)
+
+ # ---------------------------------------------------------------------------
+ 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):
+ maillageFissure = insereFissureGenerale(maillagesSains,
+ shapesFissure, shapeFissureParams,
+ maillageFissureParams, elementsDefaut, step)
+ 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)
+
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import os
+from blocFissure import gmu
+from blocFissure.gmu.geomsmesh import geompy, smesh
+
+import os
+import math
+import GEOM
+import SALOMEDS
+import SMESH
+#import StdMeshers
+#import GHS3DPlugin
+#import NETGENPlugin
+import logging
+
+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.insereFissureGenerale import insereFissureGenerale
+
+O, OX, OY, OZ = triedreBase()
+
+class eprouvetteDroite(fissureGenerique):
+ """
+ problème de fissure plane coupant 3 faces (éprouvette), débouches normaux, objet plan
+ """
+
+ nomProbleme = "eprouvetteDroite"
+
+ # ---------------------------------------------------------------------------
+ def genereMaillageSain(self, geometriesSaines, meshParams):
+ logging.info("genereMaillageSain %s", self.nomCas)
+
+ ([objetSain], status) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests/eprouvetteDroite.med"))
+ smesh.SetName(objetSain.GetMesh(), 'objetSain')
+
+ return [objetSain, True] # True : maillage hexa
+
+ # ---------------------------------------------------------------------------
+ def setParamShapeFissure(self):
+ """
+ paramètres de la fissure pour méthode insereFissureGenerale
+ 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)
+ self.shapeFissureParams = dict(lgInfluence = 30,
+ rayonPipe = 10,
+ lenSegPipe = 6)
+
+ # ---------------------------------------------------------------------------
+ def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams):
+ logging.info("genereShapeFissure %s", self.nomCas)
+
+ lgInfluence = shapeFissureParams['lgInfluence']
+
+ shellFiss = geompy.ImportFile(os.path.join(gmu.pathBloc, "materielCasTests/EprouvetteDroiteFiss_1.brep"), "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)
+
+ centre = None
+ return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss]
+
+ # ---------------------------------------------------------------------------
+ def setParamMaillageFissure(self):
+ self.maillageFissureParams = dict(nomRep = '.',
+ nomFicSain = self.nomCas,
+ nomFicFissure = 'fissure_' + self.nomCas,
+ nbsegRad = 5,
+ nbsegCercle = 8,
+ areteFaceFissure = 15)
+
+ # ---------------------------------------------------------------------------
+ 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):
+ maillageFissure = insereFissureGenerale(maillagesSains,
+ shapesFissure, shapeFissureParams,
+ maillageFissureParams, elementsDefaut, step)
+ 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)
+
--- /dev/null
+# -*- coding: utf-8 -*-
+
+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.insereFissureGenerale import insereFissureGenerale
+
+O, OX, OY, OZ = triedreBase()
+
+class eprouvetteDroite_2(eprouvetteDroite):
+ """
+ problème de fissure plane coupant 3 faces (éprouvette), débouches non normaux, objet plan
+ """
+
+ nomProbleme = "eprouvetteDroite2"
+
+ # ---------------------------------------------------------------------------
+ def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams):
+ logging.info("genereShapeFissure %s", self.nomCas)
+
+ lgInfluence = shapeFissureParams['lgInfluence']
+
+ shellFiss = geompy.ImportFile(os.path.join(gmu.pathBloc, "materielCasTests/EprouvetteDroiteFiss_2.brep"), "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)
+
+ 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)
+
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import sys, traceback
+from blocFissure import gmu
+from blocFissure.gmu import initLog
+#initLog.setDebug()
+initLog.setVerbose()
+
+from blocFissure.gmu import geomsmesh
+from blocFissure.casStandard import casStandard
+
+problemes = []
+
+cas=0
+from blocFissure.CasTests.fissure_Coude import fissure_Coude
+problemes.append(fissure_Coude(cas))
+
+cas=1
+from blocFissure.CasTests.faceGauche import faceGauche
+problemes.append(faceGauche(cas))
+
+cas=2
+from blocFissure.CasTests.faceGauche_2 import faceGauche_2
+problemes.append(faceGauche_2(cas))
+
+cas=3
+from blocFissure.CasTests.ellipse_1 import ellipse_1
+problemes.append(ellipse_1(cas))
+
+cas=4
+from blocFissure.CasTests.fissure_Coude_4 import fissure_Coude_4
+problemes.append(fissure_Coude_4(cas))
+
+cas=5
+from blocFissure.CasTests.cylindre import cylindre
+problemes.append(cylindre(cas))
+
+cas=6
+from blocFissure.CasTests.cylindre_2 import cylindre_2
+problemes.append(cylindre_2(cas))
+
+cas=7
+from blocFissure.CasTests.eprouvetteCourbe import eprouvetteCourbe
+problemes.append(eprouvetteCourbe(cas))
+
+cas=8
+from blocFissure.CasTests.eprouvetteDroite import eprouvetteDroite
+problemes.append(eprouvetteDroite(cas))
+
+cas=9
+from blocFissure.CasTests.eprouvetteDroite_2 import eprouvetteDroite_2
+problemes.append(eprouvetteDroite_2(cas))
+
+cas=10
+from blocFissure.CasTests.cubeAngle import cubeAngle
+problemes.append(cubeAngle(cas))
+
+cas=11
+from blocFissure.CasTests.fissureCoude_1 import fissureCoude_1
+problemes.append(fissureCoude_1(cas))
+
+cas=12
+from blocFissure.CasTests.fissureCoude_2 import fissureCoude_2
+problemes.append(fissureCoude_2(cas))
+
+cas=13
+from blocFissure.CasTests.fissureCoude_3 import fissureCoude_3
+problemes.append(fissureCoude_3(cas))
+
+cas=14
+from blocFissure.CasTests.fissureCoude_4 import fissureCoude_4
+problemes.append(fissureCoude_4(cas))
+
+cas=15
+from blocFissure.CasTests.fissureCoude_5 import fissureCoude_5
+problemes.append(fissureCoude_5(cas))
+
+cas=16
+from blocFissure.CasTests.ellipse_2 import ellipse_2
+problemes.append(ellipse_2(cas))
+
+cas=17
+from blocFissure.CasTests.cubeAngle2 import cubeAngle2
+problemes.append(cubeAngle2(cas))
+
+cas=18
+from blocFissure.CasTests import disquePerce
+problemes.append(casStandard(disquePerce.dicoParams, disquePerce.referencesMaillageFissure, cas))
+
+cas=19
+from blocFissure.CasTests.fissureCoude_6 import fissureCoude_6
+problemes.append(fissureCoude_6(cas))
+
+cas=20
+from blocFissure.CasTests.fissureCoude_7 import fissureCoude_7
+problemes.append(fissureCoude_7(cas))
+
+cas=21
+from blocFissure.CasTests.fissureCoude_8 import fissureCoude_8
+problemes.append(fissureCoude_8(cas))
+
+cas=22
+from blocFissure.CasTests.fissureCoude_9 import fissureCoude_9
+problemes.append(fissureCoude_9(cas))
+
+cas=23
+from blocFissure.CasTests.fissureCoude_10 import fissureCoude_10
+problemes.append(fissureCoude_10(cas))
+
+cas=24
+from blocFissure.CasTests.vis_1 import vis_1
+problemes.append(vis_1(cas))
+
+# ---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,]
+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
+ 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,]
+
+for i in range(len(problemes)):
+ if torun[i]:
+ try:
+ problemes[i].executeProbleme()
+ except:
+ traceback.print_exc()
+ print "---------------------------------------------------------------------"
--- /dev/null
+# -*- coding: utf-8 -*-
+
+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
+
+from blocFissure.gmu.triedreBase import triedreBase
+from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
+from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
+from blocFissure.gmu.insereFissureGenerale import insereFissureGenerale
+
+O, OX, OY, OZ = triedreBase()
+
+class faceGauche(fissureGenerique):
+ """
+ problème de fissure non plane, débouchante non normale
+ """
+
+ nomProbleme = "faceGauche"
+
+ # ---------------------------------------------------------------------------
+ def genereMaillageSain(self, geometriesSaines, meshParams):
+ logging.info("genereMaillageSain %s", self.nomCas)
+
+ ([objetSain], status) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests/faceGaucheSain.med"))
+ smesh.SetName(objetSain.GetMesh(), 'objetSain')
+
+ return [objetSain, True] # True : maillage hexa
+
+ # ---------------------------------------------------------------------------
+ def setParamShapeFissure(self):
+ """
+ paramètres de la fissure pour méthode insereFissureGenerale
+ 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)
+ self.shapeFissureParams = dict(lgInfluence = 300,
+ rayonPipe = 20)
+
+ # ---------------------------------------------------------------------------
+ def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams):
+ logging.info("genereShapeFissure %s", self.nomCas)
+
+ lgInfluence = shapeFissureParams['lgInfluence']
+
+ shellFiss = geompy.ImportFile(os.path.join(gmu.pathBloc, "materielCasTests/faceGaucheFiss.brep"), "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)
+
+ centre = None
+ return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss]
+
+ # ---------------------------------------------------------------------------
+ def setParamMaillageFissure(self):
+ self.maillageFissureParams = dict(nomRep = '.',
+ nomFicSain = self.nomCas,
+ nomFicFissure = 'fissure_' + self.nomCas,
+ nbsegRad = 5,
+ nbsegCercle = 8,
+ areteFaceFissure = 1000)
+
+ # ---------------------------------------------------------------------------
+ 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):
+ maillageFissure = insereFissureGenerale(maillagesSains,
+ shapesFissure, shapeFissureParams,
+ maillageFissureParams, elementsDefaut, step)
+ 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)
+
--- /dev/null
+# -*- coding: utf-8 -*-
+
+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
+
+
+from blocFissure.gmu.triedreBase import triedreBase
+from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
+from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
+from blocFissure.gmu.insereFissureGenerale import insereFissureGenerale
+
+O, OX, OY, OZ = triedreBase()
+
+class faceGauche_2(fissureGenerique):
+ """
+ problème de fissure non plane, débouchante non normale
+ """
+
+ nomProbleme = "faceGauche2"
+
+ # ---------------------------------------------------------------------------
+ def genereMaillageSain(self, geometriesSaines, meshParams):
+ logging.info("genereMaillageSain %s", self.nomCas)
+
+ ([objetSain], status) = 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 insereFissureGenerale
+ 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)
+ self.shapeFissureParams = dict(lgInfluence = 100,
+ rayonPipe = 20)
+
+ # ---------------------------------------------------------------------------
+ def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams):
+ logging.info("genereShapeFissure %s", self.nomCas)
+
+ lgInfluence = shapeFissureParams['lgInfluence']
+
+ shellFiss = geompy.ImportFile(os.path.join(gmu.pathBloc, "materielCasTests/faceGauche2FissCoupe.brep"), "BREP")
+ fondFiss = geompy.CreateGroup(shellFiss, geompy.ShapeType["EDGE"])
+ geompy.UnionIDs(fondFiss, [12, 4])
+ geompy.addToStudy( shellFiss, 'shellFiss' )
+ geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' )
+
+
+ coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 5 ,25)
+
+ centre = None
+ return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss]
+
+ # ---------------------------------------------------------------------------
+ def setParamMaillageFissure(self):
+ self.maillageFissureParams = dict(nomRep = '.',
+ nomFicSain = self.nomCas,
+ nomFicFissure = 'fissure_' + self.nomCas,
+ nbsegRad = 5,
+ nbsegCercle = 8,
+ areteFaceFissure = 1000)
+
+ # ---------------------------------------------------------------------------
+ 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):
+ maillageFissure = insereFissureGenerale(maillagesSains,
+ shapesFissure, shapeFissureParams,
+ maillageFissureParams, elementsDefaut, step)
+ 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)
+
--- /dev/null
+# -*- coding: utf-8 -*-
+
+from blocFissure.gmu.fissureCoude import fissureCoude
+
+class fissureCoude_1(fissureCoude):
+ """
+ problème de fissure du Coude :
+ adaptation maillage
+ """
+
+# ---------------------------------------------------------------------------
+ def setParamGeometrieSaine(self):
+ """
+ Paramètres géométriques du tuyau coudé sain:
+ angleCoude
+ r_cintr
+ l_tube_p1
+ l_tube_p2
+ epais
+ de
+ """
+ self.geomParams = dict(angleCoude = 60,
+ r_cintr = 1200,
+ l_tube_p1 = 1600,
+ l_tube_p2 = 1200,
+ epais = 40,
+ de = 760)
+
+ # ---------------------------------------------------------------------------
+ def setParamMaillageSain(self):
+ self.meshParams = dict(n_long_p1 = 16,
+ n_ep = 3,
+ n_long_coude = 15,
+ n_circ_g = 20,
+ n_circ_d = 20,
+ n_long_p2 = 12)
+
+# ---------------------------------------------------------------------------
+ def setParamShapeFissure(self):
+ """
+ paramètres de la fissure pour le tuyau coude
+ profondeur : 0 < profondeur <= épaisseur
+ rayonPipe : rayon du pipe correspondant au maillage rayonnant
+ lenSegPipe : longueur des mailles rayonnantes le long du fond de fissure (= rayonPipe par défaut)
+ azimut : entre 0 et 360°
+ alpha : 0 < alpha < angleCoude
+ longueur : <=2*profondeur ==> force une fissure elliptique (longueur/profondeur = grand axe/petit axe).
+ orientation : 0° : longitudinale, 90° : circonférentielle, autre : uniquement fissures elliptiques
+ lgInfluence : distance autour de la shape de fissure a remailler (si 0, pris égal à profondeur. A ajuster selon le maillage)
+ elliptique : True : fissure elliptique (longueur/profondeur = grand axe/petit axe); False : fissure longue (fond de fissure de profondeur constante, demi-cercles aux extrémites)
+ pointIn_x : optionnel coordonnées x d'un point dans le solide, pas trop loin du centre du fond de fissure (idem y,z)
+ externe : True : fissure face externe, False : fissure face interne
+ """
+ print "setParamShapeFissure", self.nomCas
+ self.shapeFissureParams = dict(profondeur = 10,
+ rayonPipe = 2.5,
+ lenSegPipe = 2.5,
+ azimut = 160,
+ alpha = 20,
+ longueur = 400,
+ orientation = 90,
+ lgInfluence = 50,
+ elliptique = False,
+ externe = True)
+
+# ---------------------------------------------------------------------------
+ def setParamMaillageFissure(self):
+ """
+ Paramètres du maillage de la fissure pour le tuyau coudé
+ Voir également setParamShapeFissure, paramètres rayonPipe et lenSegPipe.
+ nbSegRad = nombre de couronnes
+ nbSegCercle = nombre de secteurs
+ areteFaceFissure = taille cible de l'arête des triangles en face de fissure.
+ """
+ self.maillageFissureParams = dict(nomRep = '.',
+ nomFicSain = self.nomCas,
+ nomFicFissure = 'fissure_' + self.nomCas,
+ 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)
+
--- /dev/null
+# -*- coding: utf-8 -*-
+
+from blocFissure.gmu.fissureCoude import fissureCoude
+
+class fissureCoude_10(fissureCoude):
+ # cas test ASCOU17
+
+
+# ---------------------------------------------------------------------------
+ def setParamGeometrieSaine(self):
+ """
+ Paramètres géométriques du tuyau coudé sain:
+ angleCoude
+ r_cintr
+ l_tube_p1
+ l_tube_p2
+ epais
+ de
+ """
+ self.geomParams = dict(angleCoude = 90,
+ r_cintr = 1143,
+ l_tube_p1 = 3200,
+ l_tube_p2 = 3200,
+ epais = 35,
+ de = 762)
+
+ # ---------------------------------------------------------------------------
+ def setParamMaillageSain(self):
+ self.meshParams = dict(n_long_p1 = 13,
+ n_ep = 2,
+ n_long_coude = 20,
+ n_circ_g = 20,
+ n_circ_d = 20,
+ n_long_p2 = 13)
+
+ # ---------------------------------------------------------------------------
+
+ def setParamShapeFissure(self):
+ """
+ paramètres de la fissure pour le tuyau coude
+ profondeur : 0 < profondeur <= épaisseur
+ rayonPipe : rayon du pipe correspondant au maillage rayonnant
+ lenSegPipe : longueur des mailles rayonnantes le long du fond de fissure (= rayonPipe par défaut)
+ azimut : entre 0 et 360°
+ alpha : 0 < alpha < angleCoude
+ longueur : <=2*profondeur ==> force une fissure elliptique (longueur/profondeur = grand axe/petit axe).
+ orientation : 0° : longitudinale, 90° : circonférentielle, autre : uniquement fissures elliptiques
+ lgInfluence : distance autour de la shape de fissure a remailler (si 0, pris égal à profondeur. A ajuster selon le maillage)
+ elliptique : True : fissure elliptique (longueur/profondeur = grand axe/petit axe); False : fissure longue (fond de fissure de profondeur constante, demi-cercles aux extrémites)
+ pointIn_x : optionnel coordonnées x d'un point dans le solide, pas trop loin du centre du fond de fissure (idem y,z)
+ externe : True : fissure face externe, False : fissure face interne
+ """
+# logging.info("setParamShapeFissure %s", self.nomCas)
+ self.shapeFissureParams = dict(profondeur = 2.5,
+ rayonPipe = 1.5,
+ lenSegPipe = 6,
+ azimut = 180,
+ alpha = 45,
+ longueur = 1196,
+ orientation = 0,
+ lgInfluence = 30,
+ elliptique = False,
+ externe = False)
+
+ # ---------------------------------------------------------------------------
+
+ def setParamMaillageFissure(self):
+ """
+ Paramètres du maillage de la fissure pour le tuyau coudé
+ Voir également setParamShapeFissure, paramètres rayonPipe et lenSegPipe.
+ nbSegRad = nombre de couronnes
+ nbSegCercle = nombre de secteurs
+ areteFaceFissure = taille cible de l'arête des triangles en face de fissure.
+ """
+ self.maillageFissureParams = dict(nomRep = '.',
+ nomFicSain = self.nomCas,
+ nomFicFissure = 'fissure_' + self.nomCas,
+ 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)
+
--- /dev/null
+# -*- coding: utf-8 -*-
+
+from blocFissure.gmu.fissureCoude import fissureCoude
+
+class fissureCoude_2(fissureCoude):
+ """
+ problème de fissure du Coude :
+ adaptation maillage
+ """
+
+# ---------------------------------------------------------------------------
+ def setParamGeometrieSaine(self):
+ """
+ Paramètres géométriques du tuyau coudé sain:
+ angleCoude
+ r_cintr
+ l_tube_p1
+ l_tube_p2
+ epais
+ de
+ """
+ self.geomParams = dict(angleCoude = 90,
+ r_cintr = 1200,
+ l_tube_p1 = 1600,
+ l_tube_p2 = 1200,
+ epais = 40,
+ de = 760)
+
+ # ---------------------------------------------------------------------------
+ def setParamMaillageSain(self):
+ self.meshParams = dict(n_long_p1 = 16,
+ n_ep = 3,
+ n_long_coude = 15,
+ n_circ_g = 20,
+ n_circ_d = 20,
+ n_long_p2 = 12)
+
+# ---------------------------------------------------------------------------
+ def setParamShapeFissure(self):
+ """
+ paramètres de la fissure pour le tuyau coude
+ profondeur : 0 < profondeur <= épaisseur
+ rayonPipe : rayon du pipe correspondant au maillage rayonnant
+ lenSegPipe : longueur des mailles rayonnantes le long du fond de fissure (= rayonPipe par défaut)
+ azimut : entre 0 et 360°
+ alpha : 0 < alpha < angleCoude
+ longueur : <=2*profondeur ==> force une fissure elliptique (longueur/profondeur = grand axe/petit axe).
+ orientation : 0° : longitudinale, 90° : circonférentielle, autre : uniquement fissures elliptiques
+ lgInfluence : distance autour de la shape de fissure a remailler (si 0, pris égal à profondeur. A ajuster selon le maillage)
+ elliptique : True : fissure elliptique (longueur/profondeur = grand axe/petit axe); False : fissure longue (fond de fissure de profondeur constante, demi-cercles aux extrémites)
+ pointIn_x : optionnel coordonnées x d'un point dans le solide, pas trop loin du centre du fond de fissure (idem y,z)
+ externe : True : fissure face externe, False : fissure face interne
+ """
+ print "setParamShapeFissure", self.nomCas
+ self.shapeFissureParams = dict(profondeur = 10,
+ rayonPipe = 2.5,
+ lenSegPipe = 2.5,
+ azimut = 200,
+ alpha = 40,
+ longueur = 800,
+ orientation = 0,
+ lgInfluence = 50,
+ elliptique = False,
+ externe = True)
+
+ # ---------------------------------------------------------------------------
+ def setParamMaillageFissure(self):
+ """
+ Paramètres du maillage de la fissure pour le tuyau coudé
+ Voir également setParamShapeFissure, paramètres rayonPipe et lenSegPipe.
+ nbSegRad = nombre de couronnes
+ nbSegCercle = nombre de secteurs
+ areteFaceFissure = taille cible de l'arête des triangles en face de fissure.
+ """
+ self.maillageFissureParams = dict(nomRep = '.',
+ nomFicSain = self.nomCas,
+ nomFicFissure = 'fissure_' + self.nomCas,
+ 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)
+
--- /dev/null
+# -*- coding: utf-8 -*-
+
+from blocFissure.gmu.fissureCoude import fissureCoude
+
+class fissureCoude_3(fissureCoude):
+ """
+ problème de fissure du Coude
+ adaptation maillage
+ """
+
+# ---------------------------------------------------------------------------
+ def setParamGeometrieSaine(self):
+ """
+ Paramètres géométriques du tuyau coudé sain:
+ angleCoude
+ r_cintr
+ l_tube_p1
+ l_tube_p2
+ epais
+ de
+ """
+ self.geomParams = dict(angleCoude = 40,
+ r_cintr = 654,
+ l_tube_p1 = 1700,
+ l_tube_p2 = 1700,
+ epais = 62.5,
+ de = 912.4)
+
+ # ---------------------------------------------------------------------------
+ def setParamMaillageSain(self):
+ self.meshParams = dict(n_long_p1 = 16,
+ n_ep = 3,
+ n_long_coude = 30,
+ n_circ_g = 50,
+ n_circ_d = 20,
+ n_long_p2 = 12)
+
+# ---------------------------------------------------------------------------
+ def setParamShapeFissure(self):
+ """
+ paramètres de la fissure pour le tuyau coude
+ profondeur : 0 < profondeur <= épaisseur
+ rayonPipe : rayon du pipe correspondant au maillage rayonnant
+ lenSegPipe : longueur des mailles rayonnantes le long du fond de fissure (= rayonPipe par défaut)
+ azimut : entre 0 et 360°
+ alpha : 0 < alpha < angleCoude
+ longueur : <=2*profondeur ==> force une fissure elliptique (longueur/profondeur = grand axe/petit axe).
+ orientation : 0° : longitudinale, 90° : circonférentielle, autre : uniquement fissures elliptiques
+ lgInfluence : distance autour de la shape de fissure a remailler (si 0, pris égal à profondeur. A ajuster selon le maillage)
+ elliptique : True : fissure elliptique (longueur/profondeur = grand axe/petit axe); False : fissure longue (fond de fissure de profondeur constante, demi-cercles aux extrémites)
+ pointIn_x : optionnel coordonnées x d'un point dans le solide, pas trop loin du centre du fond de fissure (idem y,z)
+ externe : True : fissure face externe, False : fissure face interne
+ """
+ print "setParamShapeFissure", self.nomCas
+ self.shapeFissureParams = dict(profondeur = 10,
+ rayonPipe = 2.5,
+ lenSegPipe = 2.5,
+ azimut = 90,
+ alpha = 20,
+ longueur = 240,
+ orientation = 90,
+ lgInfluence = 30,
+ elliptique = False,
+ externe = False)
+
+ # ---------------------------------------------------------------------------
+ def setParamMaillageFissure(self):
+ """
+ Paramètres du maillage de la fissure pour le tuyau coudé
+ Voir également setParamShapeFissure, paramètres rayonPipe et lenSegPipe.
+ nbSegRad = nombre de couronnes
+ nbSegCercle = nombre de secteurs
+ areteFaceFissure = taille cible de l'arête des triangles en face de fissure.
+ """
+ self.maillageFissureParams = dict(nomRep = '.',
+ nomFicSain = self.nomCas,
+ nomFicFissure = 'fissure_' + self.nomCas,
+ 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)
+
--- /dev/null
+# -*- coding: utf-8 -*-
+
+from blocFissure.gmu.fissureCoude import fissureCoude
+
+class fissureCoude_4(fissureCoude):
+ """
+ problème de fissure du Coude : ASCOU09A
+ adaptation maillage
+ """
+
+# ---------------------------------------------------------------------------
+ def setParamGeometrieSaine(self):
+ """
+ Paramètres géométriques du tuyau coudé sain:
+ angleCoude
+ r_cintr
+ l_tube_p1
+ l_tube_p2
+ epais
+ de
+ """
+ self.geomParams = dict(angleCoude = 40,
+ r_cintr = 654,
+ l_tube_p1 = 1700,
+ l_tube_p2 = 1700,
+ epais = 62.5,
+ de = 912.4)
+
+ # ---------------------------------------------------------------------------
+ def setParamMaillageSain(self):
+ self.meshParams = dict(n_long_p1 = 16,
+ n_ep = 5,
+ n_long_coude = 30,
+ n_circ_g = 50,
+ n_circ_d = 20,
+ n_long_p2 = 12)
+
+# ---------------------------------------------------------------------------
+ def setParamShapeFissure(self):
+ """
+ paramètres de la fissure pour le tuyau coude
+ profondeur : 0 < profondeur <= épaisseur
+ rayonPipe : rayon du pipe correspondant au maillage rayonnant
+ lenSegPipe : longueur des mailles rayonnantes le long du fond de fissure (= rayonPipe par défaut)
+ azimut : entre 0 et 360°
+ alpha : 0 < alpha < angleCoude
+ longueur : <=2*profondeur ==> force une fissure elliptique (longueur/profondeur = grand axe/petit axe).
+ orientation : 0° : longitudinale, 90° : circonférentielle, autre : uniquement fissures elliptiques
+ lgInfluence : distance autour de la shape de fissure a remailler (si 0, pris égal à profondeur. A ajuster selon le maillage)
+ elliptique : True : fissure elliptique (longueur/profondeur = grand axe/petit axe); False : fissure longue (fond de fissure de profondeur constante, demi-cercles aux extrémites)
+ pointIn_x : optionnel coordonnées x d'un point dans le solide, pas trop loin du centre du fond de fissure (idem y,z)
+ externe : True : fissure face externe, False : fissure face interne
+ """
+ print "setParamShapeFissure", self.nomCas
+ self.shapeFissureParams = dict(profondeur = 10,
+ rayonPipe = 2.5,
+ lenSegPipe =2.5,
+ azimut = 90,
+ alpha = 20,
+ longueur = 240,
+ orientation = 90,
+ lgInfluence = 30,
+ elliptique = False,
+ externe = True)
+
+ # ---------------------------------------------------------------------------
+ def setParamMaillageFissure(self):
+ """
+ Paramètres du maillage de la fissure pour le tuyau coudé
+ Voir également setParamShapeFissure, paramètres rayonPipe et lenSegPipe.
+ nbSegRad = nombre de couronnes
+ nbSegCercle = nombre de secteurs
+ areteFaceFissure = taille cible de l'arête des triangles en face de fissure.
+ """
+ self.maillageFissureParams = dict(nomRep = '.',
+ nomFicSain = self.nomCas,
+ nomFicFissure = 'fissure_' + self.nomCas,
+ 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)
+
--- /dev/null
+# -*- coding: utf-8 -*-
+
+from blocFissure.gmu.fissureCoude import fissureCoude
+
+class fissureCoude_5(fissureCoude):
+ """
+ problème de fissure du Coude :
+ adaptation maillage
+ """
+
+# ---------------------------------------------------------------------------
+ def setParamGeometrieSaine(self):
+ """
+ Paramètres géométriques du tuyau coudé sain:
+ angleCoude
+ r_cintr
+ l_tube_p1
+ l_tube_p2
+ epais
+ de
+ """
+ self.geomParams = dict(angleCoude = 90,
+ r_cintr = 1200,
+ l_tube_p1 = 1600,
+ l_tube_p2 = 1200,
+ epais = 40,
+ de = 760)
+
+ # ---------------------------------------------------------------------------
+ def setParamMaillageSain(self):
+ self.meshParams = dict(n_long_p1 = 16,
+ n_ep = 3,
+ n_long_coude = 15,
+ n_circ_g = 20,
+ n_circ_d = 20,
+ n_long_p2 = 12)
+
+# ---------------------------------------------------------------------------
+ def setParamShapeFissure(self):
+ """
+ paramètres de la fissure pour le tuyau coude
+ profondeur : 0 < profondeur <= épaisseur
+ rayonPipe : rayon du pipe correspondant au maillage rayonnant
+ lenSegPipe : longueur des mailles rayonnantes le long du fond de fissure (= rayonPipe par défaut)
+ azimut : entre 0 et 360°
+ alpha : 0 < alpha < angleCoude
+ longueur : <=2*profondeur ==> force une fissure elliptique (longueur/profondeur = grand axe/petit axe).
+ orientation : 0° : longitudinale, 90° : circonférentielle, autre : uniquement fissures elliptiques
+ lgInfluence : distance autour de la shape de fissure a remailler (si 0, pris égal à profondeur. A ajuster selon le maillage)
+ elliptique : True : fissure elliptique (longueur/profondeur = grand axe/petit axe); False : fissure longue (fond de fissure de profondeur constante, demi-cercles aux extrémites)
+ pointIn_x : optionnel coordonnées x d'un point dans le solide, pas trop loin du centre du fond de fissure (idem y,z)
+ externe : True : fissure face externe, False : fissure face interne
+ """
+ print "setParamShapeFissure", self.nomCas
+ self.shapeFissureParams = dict(profondeur = 10,
+ rayonPipe = 2.5,
+ lenSegPipe = 2.5,
+ azimut = 180,
+ alpha = 40,
+ longueur = 200,
+ orientation = 0,
+ lgInfluence = 50,
+ elliptique = False,
+ externe = False)
+
+ # ---------------------------------------------------------------------------
+ def setParamMaillageFissure(self):
+ """
+ Paramètres du maillage de la fissure pour le tuyau coudé
+ Voir également setParamShapeFissure, paramètres rayonPipe et lenSegPipe.
+ nbSegRad = nombre de couronnes
+ nbSegCercle = nombre de secteurs
+ areteFaceFissure = taille cible de l'arête des triangles en face de fissure.
+ """
+ self.maillageFissureParams = dict(nomRep = '.',
+ nomFicSain = self.nomCas,
+ nomFicFissure = 'fissure_' + self.nomCas,
+ nbsegRad = 5,
+ nbsegCercle = 6,
+ 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)
+
--- /dev/null
+# -*- coding: utf-8 -*-
+
+from blocFissure.gmu.fissureCoude import fissureCoude
+
+class fissureCoude_6(fissureCoude):
+# --- cas ASCOU08
+
+# ---------------------------------------------------------------------------
+ def setParamGeometrieSaine(self):
+ """
+ Paramètres géométriques du tuyau coudé sain:
+ angleCoude
+ r_cintr
+ l_tube_p1
+ l_tube_p2
+ epais
+ de
+ """
+ self.geomParams = dict(angleCoude = 40,
+ r_cintr = 854,
+ l_tube_p1 = 1700,
+ l_tube_p2 = 1700,
+ epais = 62.5,
+ de = 912.4)
+
+ # ---------------------------------------------------------------------------
+ def setParamMaillageSain(self):
+ self.meshParams = dict(n_long_p1 = 15,
+ n_ep = 3,
+ n_long_coude = 16,
+ n_circ_g = 30,
+ n_circ_d = 30,
+ n_long_p2 = 15)
+
+# ---------------------------------------------------------------------------
+ def setParamShapeFissure(self):
+ """
+ paramètres de la fissure pour le tuyau coude
+ profondeur : 0 < profondeur <= épaisseur
+ rayonPipe : rayon du pipe correspondant au maillage rayonnant
+ lenSegPipe : longueur des mailles rayonnantes le long du fond de fissure (= rayonPipe par défaut)
+ azimut : entre 0 et 360°
+ alpha : 0 < alpha < angleCoude
+ longueur : <=2*profondeur ==> force une fissure elliptique (longueur/profondeur = grand axe/petit axe).
+ orientation : 0° : longitudinale, 90° : circonférentielle, autre : uniquement fissures elliptiques
+ lgInfluence : distance autour de la shape de fissure a remailler (si 0, pris égal à profondeur. A ajuster selon le maillage)
+ elliptique : True : fissure elliptique (longueur/profondeur = grand axe/petit axe); False : fissure longue (fond de fissure de profondeur constante, demi-cercles aux extrémites)
+ pointIn_x : optionnel coordonnées x d'un point dans le solide, pas trop loin du centre du fond de fissure (idem y,z)
+ externe : True : fissure face externe, False : fissure face interne
+ """
+ print "setParamShapeFissure", self.nomCas
+ self.shapeFissureParams = dict(profondeur = 10,
+ rayonPipe = 4,
+ lenSegPipe = 4,
+ azimut = 90,
+ alpha = 20,
+ longueur = 133,
+ orientation = 0,
+ lgInfluence = 30,
+ elliptique = False,
+ externe = True)
+
+ # ---------------------------------------------------------------------------
+
+ def setParamMaillageFissure(self):
+ """
+ Paramètres du maillage de la fissure pour le tuyau coudé
+ Voir également setParamShapeFissure, paramètres rayonPipe et lenSegPipe.
+ nbSegRad = nombre de couronnes
+ nbSegCercle = nombre de secteurs
+ areteFaceFissure = taille cible de l'arête des triangles en face de fissure.
+ """
+ self.maillageFissureParams = dict(nomRep = '.',
+ nomFicSain = self.nomCas,
+ nomFicFissure = 'fissure_' + self.nomCas,
+ nbsegRad = 5,
+ nbsegCercle = 12,
+ 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)
+
+
--- /dev/null
+# -*- coding: utf-8 -*-
+
+from blocFissure.gmu.fissureCoude import fissureCoude
+
+class fissureCoude_7(fissureCoude):
+
+
+# ---------------------------------------------------------------------------
+ def setParamGeometrieSaine(self):
+ """
+ Paramètres géométriques du tuyau coudé sain:
+ angleCoude
+ r_cintr
+ l_tube_p1
+ l_tube_p2
+ epais
+ de
+ """
+ self.geomParams = dict(angleCoude = 40,
+ r_cintr = 654,
+ l_tube_p1 = 1700,
+ l_tube_p2 = 1700,
+ epais = 62.5,
+ de = 912.4)
+
+ # ---------------------------------------------------------------------------
+ def setParamMaillageSain(self):
+ self.meshParams = dict(n_long_p1 = 15,
+ n_ep = 3,
+ n_long_coude = 16,
+ n_circ_g = 30,
+ n_circ_d = 30,
+ n_long_p2 = 15)
+
+ # ---------------------------------------------------------------------------
+
+ def setParamShapeFissure(self):
+ """
+ paramètres de la fissure pour le tuyau coude
+ profondeur : 0 < profondeur <= épaisseur
+ rayonPipe : rayon du pipe correspondant au maillage rayonnant
+ lenSegPipe : longueur des mailles rayonnantes le long du fond de fissure (= rayonPipe par défaut)
+ azimut : entre 0 et 360°
+ alpha : 0 < alpha < angleCoude
+ longueur : <=2*profondeur ==> force une fissure elliptique (longueur/profondeur = grand axe/petit axe).
+ orientation : 0° : longitudinale, 90° : circonférentielle, autre : uniquement fissures elliptiques
+ lgInfluence : distance autour de la shape de fissure a remailler (si 0, pris égal à profondeur. A ajuster selon le maillage)
+ elliptique : True : fissure elliptique (longueur/profondeur = grand axe/petit axe); False : fissure longue (fond de fissure de profondeur constante, demi-cercles aux extrémites)
+ pointIn_x : optionnel coordonnées x d'un point dans le solide, pas trop loin du centre du fond de fissure (idem y,z)
+ externe : True : fissure face externe, False : fissure face interne
+ """
+# logging.info("setParamShapeFissure %s", self.nomCas)
+ self.shapeFissureParams = dict(profondeur = 10,
+ rayonPipe = 4,
+ lenSegPipe = 4,
+ azimut = 0,
+ alpha = 20,
+ longueur = 240,
+ orientation = 0,
+ lgInfluence = 30,
+ elliptique = False,
+ externe = True)
+
+ # ---------------------------------------------------------------------------
+
+ def setParamMaillageFissure(self):
+ """
+ Paramètres du maillage de la fissure pour le tuyau coudé
+ Voir également setParamShapeFissure, paramètres rayonPipe et lenSegPipe.
+ nbSegRad = nombre de couronnes
+ nbSegCercle = nombre de secteurs
+ areteFaceFissure = taille cible de l'arête des triangles en face de fissure.
+ """
+ self.maillageFissureParams = dict(nomRep = '.',
+ nomFicSain = self.nomCas,
+ nomFicFissure = 'fissure_' + self.nomCas,
+ nbsegRad = 5,
+ nbsegCercle = 12,
+ 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)
+
--- /dev/null
+# -*- coding: utf-8 -*-
+
+from blocFissure.gmu.fissureCoude import fissureCoude
+
+class fissureCoude_8(fissureCoude):
+ # cas test ASCOU15
+
+
+# ---------------------------------------------------------------------------
+ def setParamGeometrieSaine(self):
+ """
+ Paramètres géométriques du tuyau coudé sain:
+ angleCoude
+ r_cintr
+ l_tube_p1
+ l_tube_p2
+ epais
+ de
+ """
+ self.geomParams = dict(angleCoude = 90,
+ r_cintr = 2290,
+ l_tube_p1 = 3200,
+ l_tube_p2 = 3200,
+ epais = 30.5,
+ de = 762)
+
+ # ---------------------------------------------------------------------------
+ def setParamMaillageSain(self):
+ self.meshParams = dict(n_long_p1 = 8,
+ n_ep = 2,
+ n_long_coude = 20,
+ n_circ_g = 20,
+ n_circ_d = 20,
+ n_long_p2 = 8)
+
+ # ---------------------------------------------------------------------------
+
+ def setParamShapeFissure(self):
+ """
+ paramètres de la fissure pour le tuyau coude
+ profondeur : 0 < profondeur <= épaisseur
+ rayonPipe : rayon du pipe correspondant au maillage rayonnant
+ lenSegPipe : longueur des mailles rayonnantes le long du fond de fissure (= rayonPipe par défaut)
+ azimut : entre 0 et 360°
+ alpha : 0 < alpha < angleCoude
+ longueur : <=2*profondeur ==> force une fissure elliptique (longueur/profondeur = grand axe/petit axe).
+ orientation : 0° : longitudinale, 90° : circonférentielle, autre : uniquement fissures elliptiques
+ lgInfluence : distance autour de la shape de fissure a remailler (si 0, pris égal à profondeur. A ajuster selon le maillage)
+ elliptique : True : fissure elliptique (longueur/profondeur = grand axe/petit axe); False : fissure longue (fond de fissure de profondeur constante, demi-cercles aux extrémites)
+ pointIn_x : optionnel coordonnées x d'un point dans le solide, pas trop loin du centre du fond de fissure (idem y,z)
+ externe : True : fissure face externe, False : fissure face interne
+ """
+# logging.info("setParamShapeFissure %s", self.nomCas)
+ self.shapeFissureParams = dict(profondeur = 8,
+ rayonPipe = 1,
+ lenSegPipe = 1.5,
+ azimut = 180,
+ alpha = 45,
+ longueur = 48,
+ orientation = 0,
+ lgInfluence = 30,
+ elliptique = True,
+ externe = False)
+
+ # ---------------------------------------------------------------------------
+
+ def setParamMaillageFissure(self):
+ """
+ Paramètres du maillage de la fissure pour le tuyau coudé
+ Voir également setParamShapeFissure, paramètres rayonPipe et lenSegPipe.
+ nbSegRad = nombre de couronnes
+ nbSegCercle = nombre de secteurs
+ areteFaceFissure = taille cible de l'arête des triangles en face de fissure.
+ """
+ self.maillageFissureParams = dict(nomRep = '.',
+ nomFicSain = self.nomCas,
+ nomFicFissure = 'fissure_' + self.nomCas,
+ 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)
+
--- /dev/null
+# -*- coding: utf-8 -*-
+
+from blocFissure.gmu.fissureCoude import fissureCoude
+
+class fissureCoude_9(fissureCoude):
+ # cas test ASCOU19
+
+
+# ---------------------------------------------------------------------------
+ def setParamGeometrieSaine(self):
+ """
+ Paramètres géométriques du tuyau coudé sain:
+ angleCoude
+ r_cintr
+ l_tube_p1
+ l_tube_p2
+ epais
+ de
+ """
+ self.geomParams = dict(angleCoude = 90,
+ r_cintr = 1144,
+ l_tube_p1 = 1651,
+ l_tube_p2 = 1651,
+ epais = 39,
+ de = 762)
+
+ # ---------------------------------------------------------------------------
+ def setParamMaillageSain(self):
+ self.meshParams = dict(n_long_p1 = 16,
+ n_ep = 4,
+ n_long_coude = 40,
+ n_circ_g = 40,
+ n_circ_d = 40,
+ n_long_p2 = 16)
+
+# ---------------------------------------------------------------------------
+ def setParamShapeFissure(self):
+ """
+ paramètres de la fissure pour le tuyau coude
+ profondeur : 0 < profondeur <= épaisseur
+ rayonPipe : rayon du pipe correspondant au maillage rayonnant
+ lenSegPipe : longueur des mailles rayonnantes le long du fond de fissure (= rayonPipe par défaut)
+ azimut : entre 0 et 360°
+ alpha : 0 < alpha < angleCoude
+ longueur : <=2*profondeur ==> force une fissure elliptique (longueur/profondeur = grand axe/petit axe).
+ orientation : 0° : longitudinale, 90° : circonférentielle, autre : uniquement fissures elliptiques
+ lgInfluence : distance autour de la shape de fissure a remailler (si 0, pris égal à profondeur. A ajuster selon le maillage)
+ elliptique : True : fissure elliptique (longueur/profondeur = grand axe/petit axe); False : fissure longue (fond de fissure de profondeur constante, demi-cercles aux extrémites)
+ pointIn_x : optionnel coordonnées x d'un point dans le solide, pas trop loin du centre du fond de fissure (idem y,z)
+ externe : True : fissure face externe, False : fissure face interne
+ """
+ print "setParamShapeFissure", self.nomCas
+ self.shapeFissureParams = dict(profondeur = 10,
+ rayonPipe = 2,
+ lenSegPipe = 6,
+ azimut = 0,
+ alpha = 30.8456,
+ longueur = 240,
+ orientation = 90,
+ lgInfluence = 50,
+ elliptique = False,
+ externe = False)
+
+# ---------------------------------------------------------------------------
+ def setParamMaillageFissure(self):
+ """
+ Paramètres du maillage de la fissure pour le tuyau coudé
+ Voir également setParamShapeFissure, paramètres rayonPipe et lenSegPipe.
+ nbSegRad = nombre de couronnes
+ nbSegCercle = nombre de secteurs
+ areteFaceFissure = taille cible de l'arête des triangles en face de fissure.
+ """
+ self.maillageFissureParams = dict(nomRep = '.',
+ nomFicSain = self.nomCas,
+ nomFicFissure = 'fissure_' + self.nomCas,
+ 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)
+
--- /dev/null
+# -*- coding: utf-8 -*-
+
+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
+
+from blocFissure.gmu.triedreBase import triedreBase
+from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
+from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
+from blocFissure.gmu.insereFissureLongue import insereFissureLongue
+
+O, OX, OY, OZ = triedreBase()
+
+class fissure_Coude(fissureGenerique):
+ """
+ problème de fissure du Coude : version de base
+ maillage hexa
+ """
+
+ nomProbleme = "tuyau_Coude"
+
+ # ---------------------------------------------------------------------------
+ def setParamGeometrieSaine(self):
+ """
+ Paramètres géométriques du tuyau coudé sain:
+ angleCoude
+ r_cintr
+ l_tube_p1
+ l_tube_p2
+ epais
+ de
+ """
+ self.geomParams = dict(angleCoude = 60,
+ r_cintr = 1200,
+ l_tube_p1 = 1600,
+ l_tube_p2 = 1200,
+ epais = 40,
+ de = 760)
+
+ # ---------------------------------------------------------------------------
+ def genereGeometrieSaine(self, geomParams):
+ logging.info("genereGeometrieSaine %s", self.nomCas)
+
+ angleCoude = geomParams['angleCoude']
+ r_cintr = geomParams['r_cintr']
+ l_tube_p1 = geomParams['l_tube_p1']
+ l_tube_p2 = geomParams['l_tube_p2']
+ epais = geomParams['epais']
+ de = geomParams['de']
+
+ centre = geompy.MakeVertex(0, 0, -l_tube_p1)
+ Disk_1 = geompy.MakeDiskPntVecR(centre, OZ, de/2.)
+ Disk_2 = geompy.MakeDiskPntVecR(centre, OZ, de/2. -epais)
+ Cut_1 = geompy.MakeCut(Disk_1, Disk_2)
+ Extrusion_1 = geompy.MakePrismVecH(Cut_1, OZ, l_tube_p1)
+ axe = geompy.MakeTranslation(OY, -r_cintr, 0, -l_tube_p1)
+ Revolution_1 = geompy.MakeRevolution(Cut_1, axe, angleCoude*math.pi/180.0)
+ Rotation_1 = geompy.MakeRotation(Cut_1, axe, angleCoude*math.pi/180.0)
+ Rotation_2 = geompy.MakeRotation(OZ, OY, angleCoude*math.pi/180.0)
+ Extrusion_2 = geompy.MakePrismVecH(Rotation_1, Rotation_2, -l_tube_p2)
+ Plane_1 = geompy.MakePlaneLCS(None, 100000, 3)
+ geompy.addToStudy( Plane_1, "Plane_1" )
+ geompy.addToStudy( Extrusion_1, "Extrusion_1" )
+ geompy.addToStudy( Revolution_1, "Revolution_1" )
+ geompy.addToStudy( Extrusion_2, "Extrusion_2" )
+
+ P1 = O
+ geompy.addToStudy( P1, "P1" )
+ op2 = geompy.MakeVertex(0, 0, -l_tube_p1)
+ P2 = geompy.MakeRotation(op2, axe, angleCoude*math.pi/180.0)
+ P2 = geompy.MakeTranslationVectorDistance(P2, Rotation_2, -l_tube_p2)
+ geompy.addToStudy( P2, "P2" )
+
+ # --- tube coude sain
+
+ geometrieSaine = geompy.MakePartition([Extrusion_1, Revolution_1, Extrusion_2, P1, P2], [Plane_1], [], [], geompy.ShapeType["SOLID"], 0, [], 1)
+ geompy.addToStudy( geometrieSaine, self.nomCas )
+ [P1, P2] = geompy.RestoreGivenSubShapes(geometrieSaine, [P1, P2], GEOM.FSM_GetInPlaceByHistory, False, True)
+
+ [ep, circ_g, circ_d, long_p2, long_coude, long_p1] = geompy.Propagate(geometrieSaine)
+ geompy.addToStudyInFather( geometrieSaine, long_p1, 'long_p1' )
+ geompy.addToStudyInFather( geometrieSaine, ep, 'ep' )
+ geompy.addToStudyInFather( geometrieSaine, long_coude, 'long_coude' )
+ geompy.addToStudyInFather( geometrieSaine, circ_g, 'circ_g' )
+ geompy.addToStudyInFather( geometrieSaine, circ_d, 'circ_d' )
+ geompy.addToStudyInFather( geometrieSaine, long_p2, 'long_p2' )
+
+ # --- face extremite tube (EXTUBE)
+
+ facesIds = geompy.GetShapesOnPlaneIDs(geometrieSaine, geompy.ShapeType["FACE"], OZ, GEOM.ST_ON)
+ EXTUBE = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["FACE"])
+ geompy.UnionIDs(EXTUBE, facesIds)
+ geompy.addToStudyInFather( geometrieSaine, EXTUBE, 'EXTUBE' )
+
+ # --- edge bord extremite tube (BORDTU)
+
+ edge1Ids = geompy.GetShapesOnPlaneIDs(geometrieSaine, geompy.ShapeType["EDGE"], OZ, GEOM.ST_ON)
+ edge2Ids = geompy.GetShapesOnCylinderIDs(geometrieSaine, geompy.ShapeType["EDGE"], OZ, de/2., GEOM.ST_ON)
+ edgesIds = []
+ for edge in edge1Ids:
+ if edge in edge2Ids:
+ edgesIds.append(edge)
+ BORDTU = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["EDGE"])
+ geompy.UnionIDs(BORDTU, edgesIds)
+ geompy.addToStudyInFather( geometrieSaine, BORDTU, 'BORDTU' )
+
+ # --- face origine tube (CLGV)
+
+ pp2 = geompy.MakeTranslationVectorDistance(P2, Rotation_2, 10)
+ vec2 = geompy.MakeVector(P2, pp2)
+ #geompy.addToStudy(vec2, 'vec2')
+ facesIds = geompy.GetShapesOnPlaneIDs(geometrieSaine, geompy.ShapeType["FACE"], vec2, GEOM.ST_ON)
+ CLGV = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["FACE"])
+ geompy.UnionIDs(CLGV, facesIds)
+ geompy.addToStudyInFather( geometrieSaine, CLGV, 'CLGV' )
+
+ # --- peau tube interieur (PEAUINT)
+
+ extru1 = geompy.MakePrismVecH(Disk_2, OZ, l_tube_p1)
+ revol1 = geompy.MakeRevolution(Disk_2, axe, angleCoude*math.pi/180.0)
+ rot1 = geompy.MakeRotation(Disk_2, axe, angleCoude*math.pi/180.0)
+ extru2 = geompy.MakePrismVecH(rot1, Rotation_2, -l_tube_p2)
+ interne = geompy.MakeFuse(extru1, revol1)
+ interne = geompy.MakeFuse(extru2, interne)
+ geompy.addToStudy(interne, 'interne')
+ facesIds = geompy.GetShapesOnShapeIDs(interne, geometrieSaine, geompy.ShapeType["FACE"], GEOM.ST_ONIN)
+ PEAUINT = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["FACE"])
+ geompy.UnionIDs(PEAUINT, facesIds)
+ geompy.addToStudyInFather( geometrieSaine, PEAUINT, 'PEAUINT' )
+
+ # --- peau tube exterieur (PEAUEXT)
+
+ cercle1 = geompy.MakeCircle(centre, OZ, de/2.)
+ extru1 = geompy.MakePrismVecH(cercle1, OZ, l_tube_p1)
+ revol1 = geompy.MakeRevolution(cercle1, axe, angleCoude*math.pi/180.0)
+ rot1 = geompy.MakeRotation(cercle1, axe, angleCoude*math.pi/180.0)
+ extru2 = geompy.MakePrismVecH(rot1, Rotation_2, -l_tube_p2)
+ externe = geompy.MakeFuse(extru1, revol1)
+ externe = geompy.MakeFuse(extru2, externe)
+ geompy.addToStudy(externe, 'externe')
+ facesIds = geompy.GetShapesOnShapeIDs(externe, geometrieSaine, geompy.ShapeType["FACE"], GEOM.ST_ON)
+ PEAUEXT = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["FACE"])
+ geompy.UnionIDs(PEAUEXT, facesIds)
+ geompy.addToStudyInFather( geometrieSaine, PEAUEXT, 'PEAUEXT' )
+
+ # --- solide sain
+
+ volIds = geompy.SubShapeAllIDs(geometrieSaine, geompy.ShapeType["SOLID"])
+ COUDE = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["SOLID"])
+ geompy.UnionIDs(COUDE, volIds)
+ geompy.addToStudyInFather( geometrieSaine, COUDE, 'COUDSAIN' )
+
+ geometriesSaines = [geometrieSaine, long_p1, ep, long_coude, circ_g, circ_d, long_p2, P1, P2, EXTUBE, BORDTU, CLGV, PEAUINT, PEAUEXT, COUDE]
+
+ return geometriesSaines
+
+ # ---------------------------------------------------------------------------
+ def setParamMaillageSain(self):
+ self.meshParams = dict(n_long_p1 = 16,
+ n_ep = 3,
+ n_long_coude = 15,
+ n_circ_g = 20,
+ n_circ_d = 20,
+ n_long_p2 = 12)
+
+ # ---------------------------------------------------------------------------
+ def genereMaillageSain(self, geometriesSaines, meshParams):
+ logging.info("genereMaillageSain %s", self.nomCas)
+
+ geometrieSaine = geometriesSaines[0]
+ long_p1 = geometriesSaines[1]
+ ep = geometriesSaines[2]
+ long_coude = geometriesSaines[3]
+ circ_g = geometriesSaines[4]
+ circ_d = geometriesSaines[5]
+ long_p2 = geometriesSaines[6]
+ P1 = geometriesSaines[7]
+ P2 = geometriesSaines[8]
+ EXTUBE = geometriesSaines[9]
+ BORDTU = geometriesSaines[10]
+ CLGV = geometriesSaines[11]
+ PEAUINT = geometriesSaines[12]
+ PEAUEXT = geometriesSaines[13]
+ COUDE = geometriesSaines[14]
+
+ n_long_p1 = meshParams['n_long_p1']
+ n_ep = meshParams['n_ep']
+ n_long_coude = meshParams['n_long_coude']
+ n_circ_g = meshParams['n_circ_g']
+ n_circ_d = meshParams['n_circ_d']
+ n_long_p2 = meshParams['n_long_p2']
+
+ maillageSain = smesh.Mesh(geometrieSaine)
+
+ algo3d = maillageSain.Hexahedron()
+ algo2d = maillageSain.Quadrangle()
+ smesh.SetName(algo3d, "algo3d_maillageSain")
+ smesh.SetName(algo2d, "algo2d_maillageSain")
+
+ algo1d_long_p1 = maillageSain.Segment(geom=long_p1)
+ hypo1d_long_p1 = algo1d_long_p1.NumberOfSegments(n_long_p1)
+ smesh.SetName(algo1d_long_p1, "algo1d_long_p1")
+ smesh.SetName(hypo1d_long_p1, "hypo1d_long_p1")
+
+ algo1d_ep = maillageSain.Segment(geom=ep)
+ hypo1d_ep = algo1d_ep.NumberOfSegments(n_ep)
+ smesh.SetName(algo1d_ep, "algo1d_ep")
+ smesh.SetName(hypo1d_ep, "hypo1d_ep")
+
+ algo1d_long_coude = maillageSain.Segment(geom=long_coude)
+ hypo1d_long_coude = algo1d_long_coude.NumberOfSegments(n_long_coude)
+ smesh.SetName(algo1d_long_coude, "algo1d_long_coude")
+ smesh.SetName(hypo1d_long_coude, "hypo1d_long_coude")
+
+ algo1d_circ_g = maillageSain.Segment(geom=circ_g)
+ hypo1d_circ_g = algo1d_circ_g.NumberOfSegments(n_circ_g)
+ smesh.SetName(algo1d_circ_g, "algo1d_circ_g")
+ smesh.SetName(hypo1d_circ_g, "hypo1d_circ_g")
+
+ algo1d_circ_d = maillageSain.Segment(geom=circ_d)
+ hypo1d_circ_d = algo1d_circ_d.NumberOfSegments(n_circ_d)
+ smesh.SetName(algo1d_circ_d, "algo1d_circ_d")
+ smesh.SetName(hypo1d_circ_d, "hypo1d_circ_d")
+
+ algo1d_long_p2 = maillageSain.Segment(geom=long_p2)
+ hypo1d_long_p2 = algo1d_long_p2.NumberOfSegments(n_long_p2)
+ smesh.SetName(algo1d_long_p2, "algo1d_long_p2")
+ smesh.SetName(hypo1d_long_p2, "hypo1d_long_p2")
+
+ isDone = maillageSain.Compute()
+
+ 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)
+
+ return [maillageSain, True] # True : maillage hexa
+
+ # ---------------------------------------------------------------------------
+ def setParamShapeFissure(self):
+ """
+ paramètres de la fissure
+ profondeur : 0 < profondeur <= épaisseur
+ azimut : entre 0 et 360°
+ alpha : 0 < alpha < angleCoude
+ longueur : <=2*profondeur ==> ellipse, >2*profondeur = fissure longue
+ lgInfluence : distance autour de la shape de fissure a remailler (si 0, pris égal à profondeur. A ajuster selon le maillage)
+ orientation : 0° : longitudinale, 90° : circonférentielle, autre : uniquement fissures elliptiques
+ externe : True : fissure face externe, False : fissure face interne
+ """
+ logging.info("setParamShapeFissure %s", self.nomCas)
+ self.shapeFissureParams = dict(profondeur = 10,
+ azimut = 160,
+ alpha = 20,
+ longueur = 400,
+ orientation = 90,
+ lgInfluence = 0,
+ elliptique = False,
+ externe = True)
+
+ # ---------------------------------------------------------------------------
+ def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams):
+ logging.info("genereShapeFissure %s", self.nomCas)
+ logging.info("shapeFissureParams %s", shapeFissureParams)
+
+ angleCoude = geomParams['angleCoude']
+ r_cintr = geomParams['r_cintr']
+ l_tube_p1 = geomParams['l_tube_p1']
+ l_tube_p2 = geomParams['l_tube_p2']
+ epais = geomParams['epais']
+ de = geomParams['de']
+
+ profondeur = shapeFissureParams['profondeur']
+ azimut = shapeFissureParams['azimut']
+ alpha = shapeFissureParams['alpha']
+ longueur = shapeFissureParams['longueur']
+ orientation = shapeFissureParams['orientation']
+ externe = shapeFissureParams['externe']
+ lgInfluence = shapeFissureParams['lgInfluence']
+
+ azimut = -azimut # axe inverse / ASCOUF
+ axe = geompy.MakeTranslation(OY, -r_cintr, 0, -l_tube_p1)
+
+ if not lgInfluence:
+ lgInfluence = profondeur
+
+ if longueur > 2*profondeur:
+ self.fissureLongue=True
+ else:
+ self.fissureLongue=False
+
+ self.circonferentielle = False
+ self.longitudinale = False
+ if self.fissureLongue and (abs(orientation) < 45) :
+ self.longitudinale = True
+ elif self.fissureLongue:
+ self.circonferentielle = True
+
+ if self.circonferentielle:
+ if externe:
+ raybor = de/2.
+ rayint = raybor - profondeur
+ rayext = raybor + profondeur
+ else:
+ rayext = de/2. - epais
+ rayint = raybor + profondeur
+ rayext = raybor - profondeur
+ lgfond = longueur -2*profondeur
+ angle = lgfond/(2*raybor)
+ pb = geompy.MakeVertex(raybor, 0, 0)
+ pi = geompy.MakeVertex(rayint, 0, 0)
+ pe = geompy.MakeVertex(rayext, 0, 0)
+ pl = geompy.MakeVertex(raybor, profondeur, 0)
+ pr = geompy.MakeVertex(raybor, -profondeur, 0)
+ pil = geompy.MakeRotation(pi, OZ, angle)
+ pll = geompy.MakeRotation(pl, OZ, angle)
+ pel = geompy.MakeRotation(pe, OZ, angle)
+ pir = geompy.MakeRotation(pi, OZ, -angle)
+ prr = geompy.MakeRotation(pr, OZ, -angle)
+ per = geompy.MakeRotation(pe, OZ, -angle)
+ arcl = geompy.MakeArc(pil, pll, pel)
+ arcr = geompy.MakeArc(pir, prr, per)
+ arci = geompy.MakeArc(pil, pi, pir)
+ arce = geompy.MakeArc(pel, pe, per)
+ wire0 = geompy.MakeWire([arcr, arci, arcl])
+ cercle0 = geompy.MakeCircle(O, OY, profondeur/4.0)
+ cercle0 = geompy.MakeRotation(cercle0, OY, math.pi/2.0)
+ cercle0 = geompy.MakeTranslationTwoPoints(cercle0, O, pi)
+ facetube0 = geompy.MakeFaceWires([cercle0], 1)
+ facetubel = geompy.MakeRotation(facetube0, OZ, angle)
+ facetuber = geompy.MakeRotation(facetube0, OZ, -angle)
+ face0 = geompy.MakeFaceWires([arcl,arci, arce, arcr], 1)
+ plan0 = geompy.MakePlane(O, OZ, 10000)
+ geompy.addToStudy( face0, 'facefissOrig' )
+ face1 = geompy.MakeRotation(face0, OZ, azimut*math.pi/180.)
+ face2 = geompy.MakeTranslation(face1, 0, 0, -l_tube_p1)
+ facefiss = geompy.MakeRotation(face2, axe, alpha*math.pi/180.)
+ geompy.addToStudy( facefiss, 'facefissPlace' )
+ centre = geompy.MakeRotation(pb, OZ, azimut*math.pi/180.)
+ centre = geompy.MakeTranslation(centre, 0, 0, -l_tube_p1)
+ centre = geompy.MakeRotation(centre, axe, alpha*math.pi/180.)
+ geompy.addToStudy( centre, 'centrefissPlace' )
+ arcr = geompy.MakeRotation(arcr, OZ, azimut*math.pi/180.)
+ arcr = geompy.MakeTranslation(arcr, 0, 0, -l_tube_p1)
+ arcr = geompy.MakeRotation(arcr, axe, alpha*math.pi/180.)
+ arci = geompy.MakeRotation(arci, OZ, azimut*math.pi/180.)
+ arci = geompy.MakeTranslation(arci, 0, 0, -l_tube_p1)
+ arci = geompy.MakeRotation(arci, axe, alpha*math.pi/180.)
+ arcl = geompy.MakeRotation(arcl, OZ, azimut*math.pi/180.)
+ arcl = geompy.MakeTranslation(arcl, 0, 0, -l_tube_p1)
+ arcl = geompy.MakeRotation(arcl, axe, alpha*math.pi/180.)
+ wiretube = geompy.MakeRotation(wire0, OZ, azimut*math.pi/180.)
+ wiretube = geompy.MakeTranslation(wiretube, 0, 0, -l_tube_p1)
+ wiretube = geompy.MakeRotation(wiretube, axe, alpha*math.pi/180.)
+ geompy.addToStudy(wiretube, 'wiretubePlace' )
+ facetubel = geompy.MakeRotation(facetubel, OZ, azimut*math.pi/180.)
+ facetubel = geompy.MakeTranslation(facetubel, 0, 0, -l_tube_p1)
+ facetubel = geompy.MakeRotation(facetubel, axe, alpha*math.pi/180.)
+ geompy.addToStudy(facetubel, 'facetubeGauche' )
+ facetuber = geompy.MakeRotation(facetuber, OZ, azimut*math.pi/180.)
+ facetuber = geompy.MakeTranslation(facetuber, 0, 0, -l_tube_p1)
+ facetuber = geompy.MakeRotation(facetuber, axe, alpha*math.pi/180.)
+ geompy.addToStudy(facetuber, 'facetubeDroit' )
+ planfiss = geompy.MakeRotation(plan0, OZ, azimut*math.pi/180.)
+ planfiss = geompy.MakeTranslation(planfiss, 0, 0, -l_tube_p1)
+ planfiss = geompy.MakeRotation(planfiss, axe, alpha*math.pi/180.)
+ geompy.addToStudy(planfiss, 'planfissPlace' )
+ pipefissl = geompy.MakePipe(facetubel, arcl)
+ pipefissi = geompy.MakePipe(facetubel, arci)
+ pipefissr = geompy.MakePipe(facetuber, arcr)
+ pipefiss = geompy.MakePartition([pipefissl, pipefissi, pipefissr], [planfiss, wiretube], [], [], geompy.ShapeType["SOLID"], 0, [], 0)
+ geompy.addToStudy(pipefiss, 'pipefissPlace' )
+
+
+ elif self.longitudinale:
+ if externe:
+ raybor = r_cintr + de/2.
+ rayint = raybor - profondeur
+ rayext = raybor + profondeur
+ else:
+ rayext = r_cintr + de/2. - epais
+ rayint = raybor + profondeur
+ rayext = raybor - profondeur
+ lgfond = longueur -2*profondeur
+ angle = lgfond/(2*raybor)
+ pb = geompy.MakeVertex(-raybor, 0, 0)
+ pi = geompy.MakeVertex(-rayint, 0, 0)
+ pe = geompy.MakeVertex(-rayext, 0, 0)
+ pl = geompy.MakeVertex(-raybor, 0, -profondeur)
+ pr = geompy.MakeVertex(-raybor, 0, profondeur)
+ pil = geompy.MakeRotation(pi, OY, -angle)
+ pll = geompy.MakeRotation(pl, OY, -angle)
+ pel = geompy.MakeRotation(pe, OY, -angle)
+ pir = geompy.MakeRotation(pi, OY, angle)
+ prr = geompy.MakeRotation(pr, OY, angle)
+ per = geompy.MakeRotation(pe, OY, angle)
+ arcl = geompy.MakeArc(pil, pll, pel)
+ arcr = geompy.MakeArc(pir, prr, per)
+ arci = geompy.MakeArc(pil, pi, pir)
+ arce = geompy.MakeArc(pel, pe, per)
+ geompy.addToStudy( arcl, 'arcl' )
+ geompy.addToStudy( arcr, 'arcr' )
+ geompy.addToStudy( arci, 'arci' )
+ geompy.addToStudy( arce, 'arce' )
+ wire0 = geompy.MakeWire([arcr, arci, arcl])
+ cercle0 = geompy.MakeCircle(O, OZ, profondeur/4.0)
+ #cercle0 = geompy.MakeRotation(cercle0, OZ, math.pi/2.0)
+ cercle0 = geompy.MakeTranslationTwoPoints(cercle0, O, pi)
+ geompy.addToStudy( cercle0, 'cercle0' )
+ facetube0 = geompy.MakeFaceWires([cercle0], 1)
+ facetubel = geompy.MakeRotation(facetube0, OY, -angle)
+ facetuber = geompy.MakeRotation(facetube0, OY, angle)
+ geompy.addToStudy(facetubel , 'facetubel' )
+ geompy.addToStudy( facetuber, 'facetuber' )
+ face0 = geompy.MakeFaceWires([arcl,arci, arce, arcr], 1)
+ plan0 = geompy.MakePlane(O, OY, 10000)
+ geompy.addToStudy( face0, 'facefissOrig' )
+ facefiss = geompy.MakeRotation(face0, OY, alpha*math.pi/180.)
+ geompy.addToStudy( facefiss, 'facefissPlace' )
+ centre = geompy.MakeRotation(pb, OY, alpha*math.pi/180.)
+ geompy.addToStudy( centre, 'centrefissPlace' )
+ arcr = geompy.MakeRotation(arcr, OY, alpha*math.pi/180.)
+ arci = geompy.MakeRotation(arci, OY, alpha*math.pi/180.)
+ arcl = geompy.MakeRotation(arcl, OY, alpha*math.pi/180.)
+ wiretube = geompy.MakeRotation(wire0, OY, alpha*math.pi/180.)
+ geompy.addToStudy(wiretube, 'wiretubePlace' )
+ facetubel = geompy.MakeRotation(facetubel, OY, alpha*math.pi/180.)
+ geompy.addToStudy(facetubel, 'facetubeGauche' )
+ facetuber = geompy.MakeRotation(facetuber, OY, alpha*math.pi/180.)
+ geompy.addToStudy(facetubel, 'facetubeDroit' )
+ planfiss = geompy.MakeRotation(plan0, OY, alpha*math.pi/180.)
+ geompy.addToStudy(planfiss, 'planfissPlace' )
+ pipefissl = geompy.MakePipe(facetubel, arcl)
+ pipefissi = geompy.MakePipe(facetubel, arci)
+ pipefissr = geompy.MakePipe(facetuber, arcr)
+ pipefiss = geompy.MakePartition([pipefissl, pipefissi, pipefissr], [planfiss, wiretube], [], [], geompy.ShapeType["SOLID"], 0, [], 0)
+ geompy.addToStudy(pipefiss, 'pipefissPlace' )
+ else:
+ pass
+
+ coordsNoeudsFissure = genereMeshCalculZoneDefaut(facefiss, 5 ,10)
+
+ return [facefiss, centre, lgInfluence, coordsNoeudsFissure, wiretube, facetubel, facetuber, planfiss, pipefiss]
+
+ # ---------------------------------------------------------------------------
+ def setParamMaillageFissure(self):
+ self.maillageFissureParams = dict(nomRep = '.',
+ nomFicSain = self.nomCas,
+ nomFicFissure = 'fissure_' + self.nomCas,
+ nbsegExt = 5,
+ nbsegGen = 25,
+ nbsegRad = 5,
+ scaleRad = 4,
+ nbsegCercle = 6,
+ nbsegFis = 20,
+ lensegEllipso = 1.0)
+
+ # ---------------------------------------------------------------------------
+ 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):
+ maillageFissure = insereFissureLongue(geometriesSaines, maillagesSains,
+ shapesFissure, shapeFissureParams,
+ maillageFissureParams, elementsDefaut, step)
+ 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)
+
--- /dev/null
+# -*- coding: utf-8 -*-
+
+from fissure_Coude import fissure_Coude
+
+class fissure_Coude_4(fissure_Coude):
+ """
+ probleme de fissure du Coude : ASCOU09A
+ adaptation maillage
+ """
+
+# ---------------------------------------------------------------------------
+ def setParamGeometrieSaine(self):
+ """
+ Paramètres géométriques du tuyau coudé sain:
+ angleCoude
+ r_cintr
+ l_tube_p1
+ l_tube_p2
+ epais
+ de
+ """
+ self.geomParams = dict(angleCoude = 40,
+ r_cintr = 654,
+ l_tube_p1 = 1700,
+ l_tube_p2 = 1700,
+ epais = 62.5,
+ de = 912.4)
+
+ # ---------------------------------------------------------------------------
+ def setParamMaillageSain(self):
+ self.meshParams = dict(n_long_p1 = 16,
+ n_ep = 5,
+ n_long_coude = 30,
+ n_circ_g = 50,
+ n_circ_d = 20,
+ n_long_p2 = 12)
+
+# ---------------------------------------------------------------------------
+ def setParamShapeFissure(self):
+ """
+ paramètres de la fissure
+ profondeur : 0 < profondeur <= épaisseur
+ azimut : entre 0 et 360°
+ alpha : 0 < alpha < angleCoude
+ longueur : <=2*profondeur ==> ellipse, >2*profondeur = fissure longue
+ 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 = '.',
+ nomFicSain = self.nomCas,
+ nomFicFissure = 'fissure_' + self.nomCas,
+ profondeur = 10,
+ azimut = 90,
+ alpha = 20,
+ longueur = 240,
+ orientation = 90,
+ lgInfluence = 30,
+ elliptique = False,
+ convexe = True,
+ externe = True)
+
+ # ---------------------------------------------------------------------------
+ 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)
+
--- /dev/null
+# -*- coding: utf-8 -*-
+
+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
+
+from blocFissure.gmu.triedreBase import triedreBase
+from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
+from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
+from blocFissure.gmu.insereFissureGenerale import insereFissureGenerale
+
+O, OX, OY, OZ = triedreBase()
+
+class vis_1(fissureGenerique):
+ """
+ problème de fissure non plane, débouchante non normale
+ """
+
+ nomProbleme = "vis_1"
+
+ # ---------------------------------------------------------------------------
+ def genereMaillageSain(self, geometriesSaines, meshParams):
+ logging.info("genereMaillageSain %s", self.nomCas)
+
+ ([objetSain], status) = smesh.CreateMeshesFromMED(os.path.join(gmu.pathBloc, "materielCasTests/visSain.med"))
+ smesh.SetName(objetSain.GetMesh(), 'objetSain')
+
+ return [objetSain, True] # True : maillage hexa
+
+ # ---------------------------------------------------------------------------
+ def setParamShapeFissure(self):
+ """
+ paramètres de la fissure pour méthode insereFissureGenerale
+ 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)
+ self.shapeFissureParams = dict(lgInfluence = 0.6,
+ rayonPipe = 0.1)
+
+ # ---------------------------------------------------------------------------
+ def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams):
+ logging.info("genereShapeFissure %s", self.nomCas)
+
+ lgInfluence = shapeFissureParams['lgInfluence']
+
+ shellFiss = geompy.ImportFile(os.path.join(gmu.pathBloc, "materielCasTests/visFiss.brep"), "BREP")
+ fondFiss = geompy.CreateGroup(shellFiss, geompy.ShapeType["EDGE"])
+ geompy.UnionIDs(fondFiss, [4, 7, 9])
+ geompy.addToStudy( shellFiss, 'shellFiss' )
+ geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' )
+
+
+ coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, 0.1 ,0.2)
+
+ centre = None
+ return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss]
+
+ # ---------------------------------------------------------------------------
+ def setParamMaillageFissure(self):
+ self.maillageFissureParams = dict(nomRep = '.',
+ nomFicSain = self.nomCas,
+ nomFicFissure = 'fissure_' + self.nomCas,
+ nbsegRad = 5,
+ nbsegCercle = 32,
+ areteFaceFissure = 0.1)
+
+ # ---------------------------------------------------------------------------
+ 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):
+ maillageFissure = insereFissureGenerale(maillagesSains,
+ shapesFissure, shapeFissureParams,
+ maillageFissureParams, elementsDefaut, step)
+ 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)
+
--- /dev/null
+
+Exécution des exemples et cas tests :
+------------------------------------
+
+- lancer salome
+- exécuter les instructions suivantes dans la console Python embarquée, ou dans une console Python avec l'environnement SALOME
+ # les shapes et fichiers med nécessaires aux tests sont créés dans ${SMESH_ROOT_DIR}/share/salome/plugins/smesh/blocFissure/CasTests
+ # les maillages fissurés sont écrits dans le répertoire d'exécution.
+
+
+# preparation des shapes et fichiers MED
+
+import sys, os
+sys.path.append(os.path.join(os.environ["SMESH_ROOT_DIR"], "share", "salome", "plugins", "smesh"))
+from blocFissure.materielCasTests import genereMateriel
+
+# execution exemples
+
+from blocFissure import exemple
+from blocFissure import exemple
+
+# execution des cas tests
+
+from blocFissure.CasTests import execution_Cas
+
--- /dev/null
+# -*- coding: utf-8 -*-
+
+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
+
+from blocFissure.gmu.initEtude import initEtude
+from blocFissure.gmu.triedreBase import triedreBase
+from blocFissure.gmu.genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
+from blocFissure.gmu.creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
+from blocFissure.gmu.insereFissureGenerale import insereFissureGenerale
+
+O, OX, OY, OZ = triedreBase()
+
+class casStandard(fissureGenerique):
+ """
+ problème de fissure standard, défini par :
+ - un maillage sain (hexaèdres),
+ - une face géométrique de fissure, qui doit légèrement dépasser hors du volume maillé
+ - les numéros d'arêtes (edges géométriques) correspondant au fond de fissure
+ - les paramètres de maillage de la fissure
+ """
+
+ # ---------------------------------------------------------------------------
+ def __init__ (self, dicoParams, references = None, numeroCas = 0):
+ initEtude()
+ self.references = references
+ self.dicoParams = dicoParams
+ if self.dicoParams.has_key('nomCas'):
+ self.nomCas = self.dicoParams['nomCas']
+ else:
+ self.nomCas = 'casStandard'
+ self.numeroCas = numeroCas
+ if self.numeroCas != 0:
+ self.nomCas = self.nomProbleme +"_%d"%(self.numeroCas)
+ else:
+ self.nomProbleme = self.nomCas
+ if self.dicoParams.has_key('lenSegPipe'):
+ self.lenSegPipe = self.dicoParams['lenSegPipe']
+ else:
+ self.lenSegPipe =self.dicoParams['rayonPipe']
+ if self.dicoParams.has_key('step'):
+ step = self.dicoParams['step']
+ else:
+ step = -1 # exécuter toutes les étapes
+ if self.numeroCas == 0: # valeur par défaut : exécution immédiate, sinon execution différée dans le cas d'une liste de problèmes
+ self.executeProbleme(step)
+
+ # ---------------------------------------------------------------------------
+ def genereMaillageSain(self, geometriesSaines, meshParams):
+ logging.info("genereMaillageSain %s", self.nomCas)
+
+ ([objetSain], status) = smesh.CreateMeshesFromMED(self.dicoParams['maillageSain'])
+ smesh.SetName(objetSain.GetMesh(), 'objetSain')
+
+ return [objetSain, True] # True : maillage hexa
+
+ # ---------------------------------------------------------------------------
+ def setParamShapeFissure(self):
+ """
+ paramètres de la fissure pour méthode insereFissureGenerale
+ 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 : 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 - idem avec y,z)
+ """
+ logging.info("setParamShapeFissure %s", self.nomCas)
+ if self.dicoParams.has_key('pointInterieur'):
+ self.shapeFissureParams = dict(lgInfluence = self.dicoParams['lgInfluence'],
+ rayonPipe = self.dicoParams['rayonPipe'],
+ lenSegPipe = self.lenSegPipe,
+ pointIn_x = self.dicoParams['pointInterieur'][0],
+ pointIn_y = self.dicoParams['pointInterieur'][1],
+ pointIn_z = self.dicoParams['pointInterieur'][2])
+ else:
+ self.shapeFissureParams = dict(lgInfluence = self.dicoParams['lgInfluence'],
+ rayonPipe = self.dicoParams['rayonPipe'],
+ lenSegPipe = self.lenSegPipe)
+
+ # ---------------------------------------------------------------------------
+ def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams):
+ logging.info("genereShapeFissure %s", self.nomCas)
+
+ lgInfluence = shapeFissureParams['lgInfluence']
+
+ shellFiss = geompy.ImportFile( self.dicoParams['brepFaceFissure'], "BREP")
+ fondFiss = geompy.CreateGroup(shellFiss, geompy.ShapeType["EDGE"])
+ geompy.UnionIDs(fondFiss, self.dicoParams['edgeFissIds'] )
+ geompy.addToStudy( shellFiss, 'shellFiss' )
+ geompy.addToStudyInFather( shellFiss, fondFiss, 'fondFiss' )
+
+
+ coordsNoeudsFissure = genereMeshCalculZoneDefaut(shellFiss, self.dicoParams['meshBrep'][0] ,self.dicoParams['meshBrep'][1])
+
+ centre = None
+ return [shellFiss, centre, lgInfluence, coordsNoeudsFissure, fondFiss]
+
+ # ---------------------------------------------------------------------------
+ def setParamMaillageFissure(self):
+ self.maillageFissureParams = dict(nomRep = '.',
+ nomFicSain = self.nomCas,
+ nomFicFissure = 'fissure_' + self.nomCas,
+ nbsegRad = self.dicoParams['nbSegRad'],
+ nbsegCercle = self.dicoParams['nbSegCercle'],
+ areteFaceFissure = self.dicoParams['areteFaceFissure'])
+
+ # ---------------------------------------------------------------------------
+ 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):
+ maillageFissure = insereFissureGenerale(maillagesSains,
+ shapesFissure, shapeFissureParams,
+ maillageFissureParams, elementsDefaut, step)
+ return maillageFissure
+
+ # ---------------------------------------------------------------------------
+ def setReferencesMaillageFissure(self):
+ if self.references is not None:
+ self.referencesMaillageFissure = self.references
+ else:
+ self.referencesMaillageFissure = dict(Entity_Quad_Pyramid = 0,
+ Entity_Quad_Triangle = 0,
+ Entity_Quad_Edge = 0,
+ Entity_Quad_Penta = 0,
+ Entity_Quad_Hexa = 0,
+ Entity_Node = 0,
+ Entity_Quad_Tetra = 0,
+ Entity_Quad_Quadrangle = 0)
+
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import os
+from blocFissure import gmu
+from blocFissure.gmu import initLog
+initLog.setDebug()
+#initLog.setVerbose()
+
+from blocFissure.casStandard import casStandard
+
+dicoParams = dict(nomCas = 'angleCube',
+ maillageSain = os.path.join(gmu.pathBloc, 'materielCasTests/CubeAngle.med'),
+ brepFaceFissure = os.path.join(gmu.pathBloc, "materielCasTests/CubeAngleFiss.brep"),
+ edgeFissIds = [4],
+ lgInfluence = 20,
+ meshBrep = (5,10),
+ rayonPipe = 5,
+ lenSegPipe = 2.5,
+ nbSegRad = 5,
+ nbSegCercle = 32,
+ areteFaceFissure = 10)
+
+execInstance = casStandard(dicoParams)
--- /dev/null
+# -*- coding: iso-8859-1 -*-
+
+import sys
+import salome
+
+salome.salome_init()
+theStudy = salome.myStudy
+
+import salome_notebook
+notebook = salome_notebook.NoteBook(theStudy)
+
+###
+### GEOM component
+###
+
+import GEOM
+from salome.geom import geomBuilder
+import math
+import SALOMEDS
+
+
+geompy = geomBuilder.New(theStudy)
+
+O = geompy.MakeVertex(0, 0, 0)
+OX = geompy.MakeVectorDXDYDZ(1, 0, 0)
+OY = geompy.MakeVectorDXDYDZ(0, 1, 0)
+OZ = geompy.MakeVectorDXDYDZ(0, 0, 1)
+Box_1 = geompy.MakeBoxDXDYDZ(200, 200, 200)
+Vertex_1 = geompy.MakeVertex(0, 0, 100)
+Disk_1 = geompy.MakeDiskPntVecR(Vertex_1, OZ, 50)
+Rotation_1 = geompy.MakeRotation(Box_1, OZ, 45*math.pi/180.0)
+geompy.TranslateDXDYDZ(Rotation_1, -50, -250, 0)
+Cut_1 = geompy.MakeCut(Disk_1, Rotation_1)
+geompy.Export(Cut_1, "disk.brep", "BREP")
+geompy.addToStudy( O, 'O' )
+geompy.addToStudy( OX, 'OX' )
+geompy.addToStudy( OY, 'OY' )
+geompy.addToStudy( OZ, 'OZ' )
+geompy.addToStudy( Box_1, 'Box_1' )
+geompy.addToStudy( Vertex_1, 'Vertex_1' )
+geompy.addToStudy( Disk_1, 'Disk_1' )
+geompy.addToStudy( Rotation_1, 'Rotation_1' )
+geompy.addToStudy( Cut_1, 'Cut_1' )
+
+###
+### SMESH component
+###
+
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+
+smesh = smeshBuilder.New(theStudy)
+from salome.StdMeshers import StdMeshersBuilder
+boite = smesh.Mesh(Box_1)
+Regular_1D = boite.Segment()
+Nb_Segments_1 = Regular_1D.NumberOfSegments(15)
+Nb_Segments_1.SetDistrType( 0 )
+Quadrangle_2D = boite.Quadrangle(algo=smeshBuilder.QUADRANGLE)
+Hexa_3D = boite.Hexahedron(algo=smeshBuilder.Hexa)
+isDone = boite.Compute()
+smesh.SetName(boite, 'boite')
+boite.ExportMED( r'boite.med', 0, SMESH.MED_V2_2, 1 )
+
+## set object names
+smesh.SetName(boite.GetMesh(), 'boite')
+smesh.SetName(Regular_1D.GetAlgorithm(), 'Regular_1D')
+smesh.SetName(Nb_Segments_1, 'Nb. Segments_1')
+smesh.SetName(Quadrangle_2D.GetAlgorithm(), 'Quadrangle_2D')
+smesh.SetName(Hexa_3D.GetAlgorithm(), 'Hexa_3D')
+
+import os
+from blocFissure import gmu
+from blocFissure.gmu import initLog
+#initLog.setDebug()
+initLog.setVerbose()
+
+from blocFissure.casStandard import casStandard
+
+dicoParams = dict(nomCas = 'angleCube2',
+ maillageSain = 'boite.med',
+ brepFaceFissure = "disk.brep",
+ edgeFissIds = [4],
+ lgInfluence = 20,
+ meshBrep = (5,10),
+ rayonPipe = 10,
+ nbSegRad = 5,
+ nbSegCercle = 8,
+ areteFaceFissure = 10)
+
+execInstance = casStandard(dicoParams)
+
+if salome.sg.hasDesktop():
+ salome.sg.updateObjBrowser(1)
--- /dev/null
+# Copyright (C) 2012-2013 CEA/DEN, EDF R&D, OPEN CASCADE
+#
+# 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.
+#
+# 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
+#
+
+# --- scripts ---
+
+# scripts / static
+SET(plugin_SCRIPTS
+ __init__.py
+ blocDefaut.py
+ checkDecoupePartition.py
+ commonSubShapes.py
+ creeZoneDefautDansObjetSain.py
+ creeZoneDefautFilling.py
+ creeZoneDefautGeom.py
+ creeZoneDefautMaillage.py
+ distance2.py
+ eliminateDoubles.py
+ ellipsoideDefaut.py
+ enleveDefaut.py
+ extractionOrienteeMulti.py
+ extractionOrientee.py
+ facesCirculaires.py
+ facesFissure.py
+ facesToreInBloc.py
+ facesVolumesToriques.py
+ findWireEndVertices.py
+ findWireIntermediateVertices.py
+ fissureCoude.py
+ fissureGenerique.py
+ genereElemsFissureElliptique.py
+ genereMeshCalculZoneDefaut.py
+ geomsmesh.py
+ getCentreFondFiss.py
+ getStatsMaillageFissure.py
+ getSubshapeIds.py
+ initEtude.py
+ initLog.py
+ insereFissureElliptique.py
+ insereFissureGenerale.py
+ insereFissureLongue.py
+ meshBlocPart.py
+ orderEdgesFromWire.py
+ partitionBlocDefaut.py
+ partitionVolumeSain.py
+ peauInterne.py
+ produitMixte.py
+ projettePointSurCourbe.py
+ prolongeVertices.py
+ prolongeWire.py
+ propagateTore.py
+ putName.py
+ quadranglesToShape.py
+ regroupeSainEtDefaut.py
+ rotTrans.py
+ shapesSurFissure.py
+ shapeSurFissure.py
+ sortEdges.py
+ sortFaces.py
+ sortGeneratrices.py
+ sortSolids.py
+ substractSubShapes.py
+ testgmu.py
+ toreFissure.py
+ triedreBase.py
+ whichSideMulti.py
+ whichSide.py
+ whichSideVertex.py
+)
+
+# --- rules ---
+
+SALOME_INSTALL_SCRIPTS("${plugin_SCRIPTS}" ${SALOME_SMESH_INSTALL_PLUGINS}/blocFissure/gmu)
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import os
+import initLog
+#initLog.setDebug()
+#initLog.setVerbose()
+#initLog.setRelease()
+
+# --- calcul path blocFissure
+
+apath = initLog.__file__
+isabs = os.path.isabs(apath)
+pathGmu = os.path.split(apath)[0]
+if isabs:
+ pathBloc = os.path.join(pathGmu, '..')
+else:
+ pathBloc = os.path.join(os.getcwd(), pathGmu, '..')
+pathBloc = os.path.normpath(pathBloc)
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import logging
+from geomsmesh import geompy
+
+# -----------------------------------------------------------------------------
+# --- bloc defaut
+
+def blocDefaut(blocDim):
+ """
+ Le bloc contenant la fissure est un cube construit centre a l'origine, dont on donne la demi arete.
+ @param blocdim : demi arete
+ @return cube (geomObject)
+ """
+ logging.info("start")
+ geomObj_1 = geompy.MakeVertex(-blocDim, -blocDim, -blocDim)
+ geomObj_2 = geompy.MakeVertex( blocDim, blocDim, blocDim)
+ Box = geompy.MakeBoxTwoPnt(geomObj_1, geomObj_2)
+ #geompy.addToStudy( Box_1, 'Box_1' )
+ return Box
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import logging
+from geomsmesh import geompy
+
+# -----------------------------------------------------------------------------
+# --- teste si l'opération de partition a produit une modification
+
+def checkDecoupePartition(shapes, part):
+ """
+ Teste si l'opération de partition a produit une découpe
+ (plus de shapes dans la partition).
+ Résultat non garanti si recouvrement des shapes d'origine.
+ @param shapes : liste des shapes d'origine
+ @param part : résultat de la partition
+ @return True si la partition a découpé les shapes d'origine
+ """
+ logging.info('start')
+ # TODO: ShapeInfo donne des résultats faux (deux faces au lieu de une)
+
+ isPart = False
+ orig = {}
+ for shape in shapes:
+ info = geompy.ShapeInfo(shape)
+ logging.debug("shape info %s", info)
+ for k in ['VERTEX', 'EDGE', 'FACE', 'SOLID']:
+ if k in orig.keys():
+ orig[k] += info[k]
+ else:
+ orig[k] = info[k]
+ logging.debug("original shapes info %s", orig)
+ info = geompy.ShapeInfo(part)
+ logging.debug("partition info %s", info)
+ for k in ['VERTEX', 'EDGE', 'FACE', 'SOLID']:
+ if orig[k] < info[k]:
+ isPart = True
+ break
+ logging.debug("partition modifie l'original %s", isPart)
+
+ return isPart
+
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import logging
+from geomsmesh import geompy
+
+# -----------------------------------------------------------------------------
+# --- subShapes communes à deux listes
+
+def commonSubShapes(obj, sub1, sub2):
+ """
+ liste de subshapes communes
+ """
+ logging.info("start")
+ idsub1 = {}
+ subList = []
+ for s in sub1:
+ idsub1[geompy.GetSubShapeID(obj, s)] = s
+ for s in sub2:
+ idsub = geompy.GetSubShapeID(obj, s)
+ if idsub in idsub1.keys():
+ subList.append(s)
+ logging.debug("subList=%s", subList)
+ return subList
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import logging
+from geomsmesh import smesh
+import SMESH
+import SALOMEDS
+
+from creeZoneDefautMaillage import creeZoneDefautMaillage
+from peauInterne import peauInterne
+from quadranglesToShape import quadranglesToShape
+from creeZoneDefautFilling import creeZoneDefautFilling
+from creeZoneDefautGeom import creeZoneDefautGeom
+from getCentreFondFiss import getCentreFondFiss
+
+# -----------------------------------------------------------------------------
+# ---
+
+def creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure,
+ shapeFissureParams, maillageFissureParams):
+ """
+ TODO: a compléter
+ """
+ logging.info('start')
+
+ #smesh.SetCurrentStudy(salome.myStudy)
+
+ geometrieSaine = geometriesSaines[0]
+ maillageSain = maillagesSains[0]
+ isHexa = maillagesSains[1]
+ shapeDefaut = shapesFissure[0]
+ tailleDefaut = shapesFissure[2]
+ coordsNoeudsFissure = shapesFissure[3]
+
+ isElliptique = False
+ if shapeFissureParams.has_key('elliptique'):
+ isElliptique = shapeFissureParams['elliptique']
+ if isElliptique:
+ if shapeFissureParams.has_key('demiGrandAxe'):
+ demiGrandAxe = shapeFissureParams['demiGrandAxe']
+ else:
+ demiGrandAxe = shapeFissureParams['longueur']
+ lgExtrusion = 2.0*demiGrandAxe
+ else:
+ lgExtrusion = 50.
+
+ nomRep = maillageFissureParams['nomRep']
+ nomFicSain = maillageFissureParams['nomFicSain']
+
+ fichierMaillageSain = nomRep + '/' + nomFicSain + '.med'
+
+ # --- centre de fond de fissure et tangente
+
+ edgeFondExt, centreFondFiss, tgtCentre = getCentreFondFiss(shapesFissure)
+
+
+ # --- zone de défaut
+ nomZones = "zoneDefaut"
+
+ [origShapes, verticesShapes, dmoyen] = \
+ creeZoneDefautMaillage(maillagesSains, shapeDefaut, tailleDefaut, nomZones, coordsNoeudsFissure)
+
+ maillageSain.ExportMED( fichierMaillageSain, 0, SMESH.MED_V2_2, 1 )
+ logging.debug("fichier maillage sain %s", fichierMaillageSain)
+ [maillageSain, internalBoundary, zoneDefaut, zoneDefaut_skin, zoneDefaut_internalFaces, zoneDefaut_internalEdges] = \
+ peauInterne(fichierMaillageSain, nomZones)
+
+ facesDefaut = []
+ centresDefaut = []
+ normalsDefaut =[]
+ extrusionsDefaut = []
+ isPlane = False
+ if isHexa and not isPlane:
+ meshQuad = smesh.CopyMesh( zoneDefaut_skin, 'meshQuad', 0, 0)
+ fillings, noeuds_bords, bordsPartages, fillconts, idFilToCont = quadranglesToShape(meshQuad, shapeFissureParams, centreFondFiss)
+ for filling in fillings:
+ [faceDefaut, centreDefaut, normalDefaut, extrusionDefaut] = \
+ creeZoneDefautFilling(filling, shapeDefaut, lgExtrusion)
+ facesDefaut.append(faceDefaut)
+ centresDefaut.append(centreDefaut)
+ normalsDefaut.append(normalDefaut)
+ extrusionsDefaut.append(extrusionDefaut)
+ else:
+ [facesDefaut, centreDefaut, normalDefaut, extrusionDefaut] = \
+ creeZoneDefautGeom( geometrieSaine, shapeDefaut, origShapes, verticesShapes, dmoyen, lgExtrusion)
+ bordsPartages =[]
+ for face in facesDefaut:
+ bordsPartages.append([None,None]) # TODO : traitement des arêtes vives ?
+ fillconts = facesDefaut
+ idFilToCont = range(len(facesDefaut))
+
+ return [facesDefaut, centresDefaut, normalsDefaut, extrusionsDefaut, dmoyen, bordsPartages, fillconts, idFilToCont,
+ maillageSain, internalBoundary, zoneDefaut, zoneDefaut_skin, zoneDefaut_internalFaces, zoneDefaut_internalEdges,
+ edgeFondExt, centreFondFiss, tgtCentre]
+
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import logging
+from geomsmesh import geompy
+
+# -----------------------------------------------------------------------------
+# --- crée zone géométrique défaut a partir d'un filling
+
+def creeZoneDefautFilling(filling, shapeDefaut, lgExtrusion=50):
+ """
+ Construction CAO de la zone à remailler, quand on utilise un filling,
+ après appel creeZoneDefautMaillage et quadranglesToShape
+ @param filling : la CAO de la peau du défaut reconstituée
+ @param shapeDefaut : objet géométrique représentant la fissure
+ (selon les cas, un point central, ou une shape plus complexe,
+ dont on ne garde que les vertices)
+ @return (facesDefaut = filling, centreDefaut, normalDefaut, extrusionDefaut)
+ """
+ logging.info("start")
+
+ trace = True
+ facesDefaut = filling
+ centreSphere = geompy.MakeCDG(shapeDefaut)
+ geompy.addToStudy(centreSphere, "cdg_defaut")
+ centreDefaut = geompy.MakeProjection(centreSphere, filling)
+ if trace:
+ geompy.addToStudy(centreDefaut, "centreDefaut")
+ normalDefaut = geompy.GetNormal(filling, centreDefaut)
+ if trace:
+ geompy.addToStudy(normalDefaut, "normalDefaut")
+ extrusionDefaut = geompy.MakePrismVecH(filling, normalDefaut, -lgExtrusion)
+ if trace:
+ geompy.addToStudy(extrusionDefaut, "extrusionDefaut")
+
+ return facesDefaut, centreDefaut, normalDefaut, extrusionDefaut
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import logging
+from geomsmesh import geompy
+from prolongeVertices import prolongeVertices
+
+# -----------------------------------------------------------------------------
+# --- zone de defaut, constructions geometrique avec CAO d'origine
+
+def creeZoneDefautGeom(objetSain, shapeDefaut, origShapes, verticesShapes, dmoyen, lgExtrusion=50):
+ """
+ Construction CAO de la zone à remailler, quand on utilise la CAO d'origine,
+ apres appel creeZoneDefautMaillage
+ @param objetSain : la géometrie de l'objet initial
+ @param shapeDefaut : objet géometrique représentant la fissure
+ (selon les cas, un point central, ou une shape plus complexe,
+ dont on ne garde que les vertices)
+ @param origShapes : liste id subShapes
+ @param verticesShapes : listes noeuds de bord
+ @param dmoyen : longueur arete moyenne bord
+ @lgExtrusion : distance d'extrusion de la face du defaut
+ (ne vaut que pour des fissures courtes)
+ @return (facesDefaut, centreDefaut, normalDefaut, extrusionDefaut)
+ """
+ logging.info("start")
+
+ trace = True
+ faces = []
+ curves = []
+ cdgs = []
+ projs = []
+ normals = []
+ extrusions = []
+ partitions = []
+ decoupes = []
+
+ for ishape, vertices in enumerate(verticesShapes):
+ aShape = origShapes[ishape]
+ [face] = geompy.SubShapes(objetSain, [aShape])
+ faces.append(face)
+ curve = geompy.MakePolyline(vertices, False)
+ curves.append(curve)
+ if trace:
+ name="poly_%d"%aShape
+ geompy.addToStudy(curve, name)
+ #
+ cdg = geompy.MakeCDG(curve)
+ cdgs.append(cdg)
+ if trace:
+ name="cdgpoly_%d"%aShape
+ geompy.addToStudy(cdg, name)
+ #
+ projCdg = geompy.MakeProjection(cdg, face)
+ projs.append(projCdg)
+ if trace:
+ name="projCdg_%d"%aShape
+ geompy.addToStudy(projCdg, name)
+ #
+ normal = geompy.GetNormal(face, projCdg)
+ normals.append(normal)
+ if trace:
+ name="normal_%d"%aShape
+ geompy.addToStudy(normal, name)
+ #
+ extrusion = geompy.MakePrismVecH2Ways(curve, normal, 10)
+ extrusions.append(extrusion)
+ if trace:
+ name="extrusion_%d"%aShape
+ geompy.addToStudy(extrusion, name)
+ #
+ verticesProlongees = prolongeVertices(vertices)
+ #
+ curveprol = geompy.MakePolyline(verticesProlongees, False)
+ if trace:
+ name="polyProl_%d"%aShape
+ geompy.addToStudy(curveprol, name)
+ #
+ extruprol = geompy.MakePrismVecH2Ways(curveprol, normal, 10)
+ if trace:
+ name="extruProl_%d"%aShape
+ geompy.addToStudy(extruprol, name)
+ #
+ partition = geompy.MakePartition([face], [extruprol], [], [], geompy.ShapeType["FACE"], 0, [], 0)
+ partitions.append(partition)
+ if trace:
+ name="partition_%d"%aShape
+ geompy.addToStudy(partition, name)
+ pass
+ #
+
+ centreSphere = geompy.MakeCDG(shapeDefaut)
+ geompy.addToStudy(centreSphere, "cdg_defaut")
+ ccurves = geompy.MakeCompound(curves)
+ gravCenter = geompy.MakeCDG(ccurves)
+ geompy.addToStudy(gravCenter, "cdg_curves")
+ for i in range(len(partitions)):
+ if trace:
+ logging.debug(" --- original shape %s", origShapes[i])
+ dists = []
+ facesToSort = []
+ subFaces = geompy.ExtractShapes(partitions[i], geompy.ShapeType["FACE"], True)
+ for aFace in subFaces:
+ cdg = geompy.MakeCDG(aFace)
+ distance = geompy.MinDistance(cdg, centreSphere)
+ dists.append(distance)
+ facesToSort.append(aFace)
+ if trace:
+ logging.debug("distance = %s", distance)
+ pass
+ pass
+ if len(dists) > 0:
+ minDist = min(dists)
+ for j,d in enumerate(dists):
+ if d == minDist:
+ aFace = facesToSort[j]
+ name="decoupe_%d"%origShapes[i]
+ geompy.addToStudy(aFace, name)
+ decoupes.append(aFace)
+ break
+ pass
+ pass
+
+ facesDefaut = decoupes[0]
+ if len(decoupes) > 1:
+ facesDefaut = geompy.MakePartition(decoupes, [], [], [], geompy.ShapeType["FACE"], 0, [], 0)
+ geompy.addToStudy(facesDefaut, "facesDefaut")
+
+ shells=[]
+ if len(decoupes) > 1: # plusieurs faces de defaut
+ subFaces = geompy.ExtractShapes(facesDefaut, geompy.ShapeType["FACE"], True)
+ # --- regroupe les subFaces en shells connectes
+ theFaces = list(subFaces) # copy
+ while len(theFaces) > 0:
+ logging.debug("------- len(theFaces) %s" , len(theFaces))
+ theFace = theFaces[0]
+ logging.debug(" start with face %s",theFaces[0])
+ theFaces[0:1] = []
+ aShell = [theFace]
+ toAdd =[theFace]
+ while len(toAdd) > 0:
+ toAdd = []
+ toRemove = []
+ for i in range(len(theFaces)):
+ logging.debug(" try %s", theFaces[i])
+ for aFace in aShell:
+ logging.debug(" with %s", aFace)
+ try:
+ edge = geompy.GetSharedShapesMulti([aFace, theFaces[i]], geompy.ShapeType["EDGE"])
+ edgeShared = True
+ except:
+ edgeShared = False
+ if edgeShared:
+ if theFaces[i] not in toAdd:
+ toAdd.append(theFaces[i])
+ toRemove.append(i)
+ logging.debug(" --- add %s", theFaces[i])
+ aShell += toAdd
+ for k in sorted(toRemove, reverse=True):
+ theFaces[k:k+1] = []
+ theShell = geompy.MakeShell(aShell)
+ name = "theShell%d"%len(shells)
+ geompy.addToStudy(theShell,name)
+ shells.append(theShell)
+ #
+ distances = []
+ for aShell in shells: # --- trouver le shell en contact avec la fissure
+ distances.append(geompy.MinDistance(aShell, shapeDefaut))
+ minDist = min(distances)
+ for index in range(len(distances)):
+ if distances[index] == minDist:
+ break
+ theShellDefaut = shells[index]
+ #
+ else: # --- une seule face de defaut
+ subFaces = [facesDefaut]
+ theShellDefaut = geompy.MakeShell(subFaces)
+ if trace:
+ geompy.addToStudy(theShellDefaut,"theShellDefaut")
+
+ theFaces = geompy.ExtractShapes(theShellDefaut, geompy.ShapeType["FACE"], True)
+ distances = []
+ for aFace in theFaces:
+ distances.append(geompy.MinDistance(aFace, centreSphere))
+ minDist = min(distances)
+ for index in range(len(distances)):
+ if distances[index] == minDist:
+ break
+
+ centreDefaut = geompy.MakeProjection(centreSphere, theFaces[index])
+ if trace:
+ geompy.addToStudy(centreDefaut, "centreDefaut")
+ normalDefaut = geompy.GetNormal(subFaces[index], centreDefaut)
+ if trace:
+ geompy.addToStudy(normalDefaut, "normalDefaut")
+ extrusionDefaut = geompy.MakePrismVecH(theShellDefaut, normalDefaut, -lgExtrusion)
+ info = geompy.ShapeInfo(extrusionDefaut)
+ logging.debug("shape info %s", info)
+ if (info['SOLID'] > 1) or (info['COMPOUND'] > 0) :
+ solids = geompy.ExtractShapes(extrusionDefaut, geompy.ShapeType["SOLID"], True)
+ solid0 = solids[0]
+ for i in range(1,len(solids)):
+ solid0 = geompy.MakeFuse(solid0, solids[i])
+ extrusionDefaut = solid0
+ if trace:
+ geompy.addToStudy(extrusionDefaut, "extrusionDefaut")
+
+ return facesDefaut, centreDefaut, normalDefaut, extrusionDefaut
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import logging
+from geomsmesh import geompy
+import math
+from distance2 import distance2
+
+# -----------------------------------------------------------------------------
+# --- zone de defaut extraite du maillage
+
+def creeZoneDefautMaillage(maillagesSains, shapeDefaut, tailleDefaut,
+ nomZones, coordsNoeudsFissure):
+ """
+ Identification de la zone à remailler, opérations sur le maillage
+ de l'objet sain
+ La zone à remailler est définie à partir d'un objet géométrique
+ ou à partir d'un jeu de points et d'une distance d'influence.
+ @param maillagesSains : (le maillage de l'objet initial, booleen isHexa)
+ @param shapeDefaut : objet géométrique représentant la fissure
+ (selon les cas, un point central, ou une shape plus complexe,
+ dont on ne garde que les vertices)
+ @param tailleDefaut : distance d'influence définissant la zone à remailler:
+ tous les éléments du maillage initial qui pénètrent dans cette zone
+ sont détectés
+ @param nomZones : préfixe des noms de groupes créés dans le maillage initial. S'il y a un groupe de noeuds
+ @coordsNoeudsFissure : jeu de points donné par une liste (x1,y1,z1, x2,y2,z2, ...)
+ @return (origShapes, verticesShapes, dmoyen) liste id subShapes,
+ listes noeuds de bord, longueur arête moyenne bord
+ """
+ logging.info("start")
+
+ maillageSain = maillagesSains[0]
+ isHexa = maillagesSains[1]
+ lists = maillageSain.CreateHoleSkin(tailleDefaut, shapeDefaut, nomZones, coordsNoeudsFissure)
+
+ logging.debug("lists=%s", lists)
+
+ trace = True
+ origShapes = []
+ verticesShapes = []
+
+ cumul = 0 # somme des distances carrées entre point ordonnés (taille des arêtes)
+ nb = 0 # nombre d'arêtes évaluées
+
+ for aList in lists:
+ aShape = aList[0]
+ origShapes.append(aShape)
+ logging.debug(" shapeId %s", aShape)
+ vertices = []
+ xyz0 = None
+ for inode in range(1, len(aList)):
+ xyz = maillageSain.GetNodeXYZ(aList[inode])
+ if xyz0 is not None:
+ cumul += distance2(xyz, xyz0)
+ nb += 1
+ xyz0 = xyz
+ #logging.debug(" node %s %s", aList[inode], xyz)
+ vertices.append(geompy.MakeVertex(xyz[0], xyz[1], xyz[2]))
+ pass
+ verticesShapes.append(vertices)
+ pass
+
+ dmoyen = math.sqrt(cumul/nb) # ~ taille de l'arête moyenne du maillage global
+ return origShapes, verticesShapes, dmoyen
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import logging
+
+# -----------------------------------------------------------------------------
+# --- calcul de distance carree entre deux points, jeux de coordonnees x,y,z
+
+def distance2(xyz1, xyz2):
+ """
+ carré de la distance entre deux points donnés par des triplets [x,y,z]
+ """
+ #logging.info("start")
+
+ d2 = 0
+ for i in range(3):
+ d2 += (xyz1[i]-xyz2[i])*(xyz1[i]-xyz2[i])
+ logging.debug('d2=%s', d2)
+ return d2
+
+# -----------------------------------------------------------------------------
+# --- test unitaire
+
+import unittest
+class Test_distance2(unittest.TestCase):
+
+ def setUp(self):
+ self.a=[0, 0, 0]
+ self.b=[3, 4, 5]
+ self.c=[-5,-4,-3]
+
+ def test_calcul(self):
+ self.assertEqual(distance2(self.a, self.b), distance2(self.b, self.a))
+ self.assertEqual(distance2(self.a, self.b), distance2(self.a, self.c))
+ self.assertEqual(distance2(self.b, self.b), 0)
+ self.assertEqual(distance2(self.a, self.b), 50)
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import logging
+from geomsmesh import geompy
+
+# -----------------------------------------------------------------------------
+# --- éliminer les doublons d'une liste de subshapes
+
+def eliminateDoubles(obj, subshapes):
+ """
+ éliminer les doublons d'une liste de subshapes
+ """
+ idsubs = {}
+ for sub in subshapes:
+ subid = geompy.GetSubShapeID(obj, sub)
+ if subid in idsubs.keys():
+ idsubs[subid].append(sub)
+ else:
+ idsubs[subid] = [sub]
+ shortList = []
+ for k, v in idsubs.iteritems():
+ shortList.append(v[0])
+ logging.debug("shortList=%s", shortList)
+ return shortList
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import logging
+import math
+from geomsmesh import geompy
+from triedreBase import triedreBase
+O, OX, OY, OZ = triedreBase()
+
+# -----------------------------------------------------------------------------
+# --- ellipsoide defaut
+
+def ellipsoideDefaut(minRad,allonge,rayTore):
+ """
+ Le bloc contenant la fissure est un ellipsoide construit centre a l'origine,
+ contenant le tore elliptique de fissure
+ @param minRad :petit rayon
+ @param allonge :rapport grand rayon / petit rayon
+ @param rayTore :rayon du tore construit autour de la generatrice de l'ellipse
+ @return ellipsoide (geomObject)
+ """
+ logging.info("start")
+ boule = geompy.MakeSphereR(2)
+ bouler = geompy.MakeRotation(boule, OY, math.pi/2.0)
+ face = geompy.MakeFaceHW(100, 100, 3)
+ boulepart = geompy.MakePartition([bouler], [face], [], [], geompy.ShapeType["SOLID"], 0, [], 0)
+ solids = geompy.ExtractShapes(boulepart, geompy.ShapeType["SOLID"], True)
+ solid0 = solids[0]
+ for i in range(1,len(solids)):
+ solid0 = geompy.MakeFuse(solid0, solids[i])
+ ellipsoide = geompy.MakeScaleAlongAxes(solid0, O, minRad, minRad*(allonge+2.0)/2.0, minRad) # on limite l'allongement de l'ellipsoide
+ #geompy.addToStudy( ellipsoide, 'ellipsoide' )
+ return ellipsoide
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import logging
+
+# -----------------------------------------------------------------------------
+# --- maillage sain sans la zone defaut
+
+def enleveDefaut(maillageSain, zoneDefaut, zoneDefaut_skin, zoneDefaut_internalFaces, zoneDefaut_internalEdges):
+ """
+ Maillage sain sans la zone de defaut
+ TODO: a completer
+ """
+ logging.info('start')
+
+ maillageSain.RemoveGroupWithContents(zoneDefaut)
+ if zoneDefaut_skin is not None:
+ maillageSain.RemoveGroupWithContents(zoneDefaut_skin)
+ if zoneDefaut_internalFaces is not None:
+ maillageSain.RemoveGroupWithContents(zoneDefaut_internalFaces)
+ if zoneDefaut_internalEdges is not None:
+ maillageSain.RemoveGroupWithContents(zoneDefaut_internalEdges)
+ nbRemoved = maillageSain.RemoveOrphanNodes()
+ return maillageSain
+
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import logging
+from geomsmesh import geompy
+
+from whichSide import whichSide
+
+# -----------------------------------------------------------------------------
+# --- renvoie l'extraction des shapes d'un objet selon leur position par rapport à la face.
+
+def extractionOrientee(face, obj, ref, shapeType, tol, prefix=""):
+ """
+ renvoie l'extraction des shapes d'un objet selon leur position
+ par rapport à la face.
+ shapeType in ["VERTEX", "EDGE", "FACE",...]
+ """
+ logging.info('start')
+ trace = True
+ sideRef = whichSide(face, ref)
+ logging.debug("ref side %s", sideRef)
+ shapesInside = []
+ shapesOutside = []
+ shapesOnside = []
+ shapes = geompy.ExtractShapes(obj, geompy.ShapeType[shapeType], False)
+ i=0
+ j=0
+ k=0
+ prefix = prefix + shapeType
+ for shape in shapes:
+ side = whichSide(face, shape, tol)
+ if side == sideRef:
+ shapesInside.append(shape)
+ if trace:
+ name = prefix + "_Inside%d"%i
+ geompy.addToStudyInFather(obj, shape, name)
+ i+=1
+ elif side == -sideRef:
+ shapesOutside.append(shape)
+ if trace:
+ name = prefix + "_Outside%d"%j
+ geompy.addToStudyInFather(obj, shape, name)
+ j+=1
+ elif side == 0:
+ shapesOnside.append(shape)
+ if trace:
+ name = prefix + "_Onside%d"%k
+ geompy.addToStudyInFather(obj, shape, name)
+ k+=1
+ logging.debug("--- shape was %s", name)
+ return [shapesInside, shapesOutside, shapesOnside]
+
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import logging
+from geomsmesh import geompy
+
+from whichSideMulti import whichSideMulti
+
+# -----------------------------------------------------------------------------
+# --- renvoie l'extraction des shapes d'un objet selon leur position par rapport à la face.
+
+def extractionOrienteeMulti(faces, ifil, obj, centre, shapeType, tol, prefix=""):
+ """
+ renvoie l'extraction des shapes d'un objet selon leur position
+ par rapport aux faces.
+ shapeType in ["VERTEX", "EDGE", "FACE",...]
+ """
+ logging.info('start')
+ trace = True
+ shapesInside = []
+ shapesOutside = []
+ shapesOnside = []
+ shapes = geompy.ExtractShapes(obj, geompy.ShapeType[shapeType], False)
+ i=0
+ j=0
+ k=0
+ prefix = prefix + shapeType
+ for shape in shapes:
+ side = whichSideMulti(faces, ifil, shape, centre, tol)
+ if side == 1:
+ shapesInside.append(shape)
+ if trace:
+ name = prefix + "_Inside%d"%i
+ geompy.addToStudyInFather(obj, shape, name)
+ i+=1
+ elif side == -1:
+ shapesOutside.append(shape)
+ if trace:
+ name = prefix + "_Outside%d"%j
+ geompy.addToStudyInFather(obj, shape, name)
+ j+=1
+ elif side == 0:
+ shapesOnside.append(shape)
+ if trace:
+ name = prefix + "_Onside%d"%k
+ geompy.addToStudyInFather(obj, shape, name)
+ k+=1
+ logging.debug("--- shape was %s", name)
+ return [shapesInside, shapesOutside, shapesOnside]
+
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import logging
+from geomsmesh import geompy
+
+# -----------------------------------------------------------------------------
+# --- TORE
+## --- faces 1/2 circulaires et leur centre, edges de ces faces dans le plan de fissure
+
+def facesCirculaires(bloc, tore):
+ """
+ Extraction des faces demi circulaires à l'intersection du tore partitionné et de la paroi,
+ de leur centre, les edges de ces faces situees dans le plan de fissure et un booleen par edge,
+ indiquant son sens (normal / reversed).
+ @param bloc : bloc defaut
+ @param tore : le tore partitionné et coupé
+ @return (faces, centres, edges, reverses)
+ """
+ logging.info("start")
+
+ faces = geompy.GetShapesOnShape(bloc, tore, geompy.ShapeType["FACE"], GEOM.ST_ON)
+
+ geompy.addToStudyInFather( tore, faces[0], 'face0' )
+ geompy.addToStudyInFather( tore, faces[1], 'face1' )
+ geompy.addToStudyInFather( tore, faces[2], 'face2' )
+ geompy.addToStudyInFather( tore, faces[3], 'face3' )
+
+ centres = [None, None, None, None]
+ [v1,centres[0],v3] = geompy.ExtractShapes(faces[0], geompy.ShapeType["VERTEX"], True)
+ [v1,centres[1],v3] = geompy.ExtractShapes(faces[1], geompy.ShapeType["VERTEX"], True)
+ [v1,centres[2],v3] = geompy.ExtractShapes(faces[2], geompy.ShapeType["VERTEX"], True)
+ [v1,centres[3],v3] = geompy.ExtractShapes(faces[3], geompy.ShapeType["VERTEX"], True)
+
+ geompy.addToStudyInFather( faces[0], centres[0], 'centre0' )
+ geompy.addToStudyInFather( faces[1], centres[1], 'centre1' )
+ geompy.addToStudyInFather( faces[2], centres[2], 'centre2' )
+ geompy.addToStudyInFather( faces[3], centres[3], 'centre3' )
+
+ alledges = [None, None, None, None]
+ alledges[0] = geompy.ExtractShapes(faces[0], geompy.ShapeType["EDGE"], True)
+ alledges[1] = geompy.ExtractShapes(faces[1], geompy.ShapeType["EDGE"], True)
+ alledges[2] = geompy.ExtractShapes(faces[2], geompy.ShapeType["EDGE"], True)
+ alledges[3] = geompy.ExtractShapes(faces[3], geompy.ShapeType["EDGE"], True)
+
+ dicoedge = {}
+ edges = []
+ reverses = []
+ for i in range(len(alledges)):
+ edgesface = alledges[i]
+ lenef = []
+ for j in range(len(edgesface)):
+ props = geompy.BasicProperties(edgesface[j])
+ lenef.append(props[0])
+ pass
+ maxlen = max(lenef)
+ for j in range(len(edgesface)):
+ if lenef[j] < maxlen:
+ edgid = geompy.GetSubShapeID(tore, edgesface[j])
+ if not (edgid in dicoedge):
+ dicoedge[edgid] = edgesface[j]
+ edges.append(edgesface[j])
+ named = 'edge_' + str(i) + '_' +str(j)
+ geompy.addToStudyInFather( faces[i], edgesface[j], named)
+ vertices = geompy.ExtractShapes(edgesface[j], geompy.ShapeType["VERTEX"], False)
+ #firstVertex = geompy.GetFirstVertex(edgesface[j])
+ if geompy.GetSubShapeID(tore, vertices[0]) != geompy.GetSubShapeID(tore, centres[i]):
+ reverses.append(1)
+ #print 'reversed ' + str(edgid)
+ else:
+ reverses.append(0)
+ #print 'normal' + str(edgid)
+ pass
+ pass
+ pass
+ pass
+
+ return faces, centres, edges, reverses
+
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import logging
+from geomsmesh import geompy
+
+# -----------------------------------------------------------------------------
+# --- faces fissure dans et hors tore, et edges face hors tore
+
+def facesFissure(blocp, faceFissure, extrusionDefaut, genint):
+ """
+ extraction des faces de fissure dans et hors tore, des edges le long du tore et en paroi
+ @param faceFissure : la face de fissure avec la partie dans le tore elliptique et la partie externe
+ @return (facefissintore, facefissoutore, edgeint, edgeext)
+ """
+ logging.info('start')
+
+ [f0,f1] = geompy.ExtractShapes(faceFissure, geompy.ShapeType["FACE"], True)
+ ed0 = geompy.ExtractShapes(f0, geompy.ShapeType["EDGE"], True)
+ ed1 = geompy.ExtractShapes(f1, geompy.ShapeType["EDGE"], True)
+ if len(ed0) > len(ed1):
+ facefissintore = f0
+ facefissoutore = f1
+ else:
+ facefissintore = f1
+ facefissoutore = f0
+
+ geompy.addToStudyInFather(faceFissure, facefissintore,'facefissintore')
+ geompy.addToStudyInFather(faceFissure, facefissoutore,'facefissoutore')
+
+ edgeint = geompy.GetShapesOnShape(extrusionDefaut, facefissoutore, geompy.ShapeType["EDGE"], GEOM.ST_IN)
+ edgeext = geompy.GetShapesOnShape(extrusionDefaut, facefissoutore, geompy.ShapeType["EDGE"], GEOM.ST_ON)
+
+ for i in range(len(edgeint)):
+ name = "edgeint_%d"%i
+ geompy.addToStudyInFather(facefissoutore, edgeint[i],name)
+ for i in range(len(edgeext)):
+ name = "edgeext_%d"%i
+ geompy.addToStudyInFather(facefissoutore, edgeext[i],name)
+
+ reverext = []
+ if len(edgeext) > 1:
+ vertices = geompy.ExtractShapes(genint, geompy.ShapeType["VERTEX"], False)
+ for i in range(len(edgeext)):
+ vertedge = geompy.ExtractShapes(edgeext[i], geompy.ShapeType["VERTEX"], False)
+ if ((geompy.GetSubShapeID(blocp, vertedge[0]) == geompy.GetSubShapeID(blocp, vertices[0])) or
+ (geompy.GetSubShapeID(blocp, vertedge[0]) == geompy.GetSubShapeID(blocp, vertices[1]))):
+ reverext.append(0)
+ else:
+ reverext.append(1)
+
+ return facefissintore, facefissoutore, edgeint, edgeext, reverext
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import logging
+from geomsmesh import geompy
+
+# -----------------------------------------------------------------------------
+# --- identification des faces tore et fissure dans le solide hors tore du bloc partitionné
+
+def facesToreInBloc(blocp, facefissoutore, facetore1, facetore2):
+ """
+ identification des faces tore et fissure dans le bloc partitionné : sous shapes du bloc
+ @param blocp : bloc partitionné
+ @param facefissoutore : la face de fissure externe au tore
+ @param facetore1 : face du tore selon la génératrice
+ @param facetore2 : face du tore selon la génératrice
+ @return (blocFaceFiss, blocFaceTore1, blocFaceTore2) sous shapes reperées
+ """
+ logging.info('start')
+
+ blocFaceFiss = geompy.GetInPlaceByHistory(blocp, facefissoutore)
+ blocFaceTore1 = geompy.GetInPlaceByHistory(blocp, facetore1)
+ blocFaceTore2 = geompy.GetInPlaceByHistory(blocp, facetore2)
+
+ geompy.addToStudyInFather(blocp, blocFaceFiss,'blocFaceFiss')
+ geompy.addToStudyInFather(blocp, blocFaceTore1,'blocFaceTore1')
+ geompy.addToStudyInFather(blocp, blocFaceTore2,'blocFaceTore2')
+
+ return blocFaceFiss, blocFaceTore1, blocFaceTore2
+
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import logging
+from geomsmesh import geompy
+from extractionOrientee import extractionOrientee
+from getSubshapeIds import getSubshapeIds
+
+# -----------------------------------------------------------------------------
+# --- TORE
+# --- faces toriques et volumes du tore
+
+def facesVolumesToriques(tore, plan, facesDefaut):
+ """
+ Extraction des deux faces et volumes du tore partitionné, qui suivent la génératrice elliptique.
+ @param tore : le tore partitionné et coupé.
+ @param plan : le plan de coupe
+ @return (facetore1,facetore2) les 2 faces selon la génératrice
+ """
+ logging.info("start")
+
+ centre = geompy.MakeVertexOnSurface(plan, 0.5, 0.5)
+ normal = geompy.GetNormal(plan, centre)
+ reference = geompy.MakeTranslationVector(centre, normal)
+
+ [facesInPlan, facesOutPlan, facesOnPlan] = extractionOrientee(plan, tore, reference, "FACE", 1.e-2, "faceTorePlan_")
+ [facesInSide, facesOutSide, facesOnSide] = extractionOrientee(facesDefaut, tore, reference, "FACE", 1.e-2, "faceTorePeau_")
+ facesIdInPlan = getSubshapeIds(tore, facesInPlan)
+ facesIdOutPlan = getSubshapeIds(tore, facesOutPlan)
+ facesIdOnSide = getSubshapeIds(tore, facesOnSide)
+ facesIdInSide = getSubshapeIds(tore, facesInSide)
+ facesIdOutSide = getSubshapeIds(tore, facesOutSide)
+ #facesIdInOutSide = facesIdInSide + facesIdOutSide
+ facetore1 = None
+ faceTore2 = None
+ for i, faceId in enumerate(facesIdInPlan):
+ if faceId not in facesIdOnSide:
+ facetore1 = facesInPlan[i]
+ break
+ for i, faceId in enumerate(facesIdOutPlan):
+ if faceId not in facesIdOnSide:
+ facetore2 = facesOutPlan[i]
+ break
+
+ #[facetore1,facetore2] = geompy.GetShapesOnShape(pipe0, tore, geompy.ShapeType["FACE"], GEOM.ST_ON)
+
+ geompy.addToStudyInFather( tore, facetore1, 'facetore1' )
+ geompy.addToStudyInFather( tore, facetore2, 'facetore2' )
+
+ [volumeTore1, volumeTore2] = geompy.ExtractShapes(tore, geompy.ShapeType["SOLID"], True)
+ geompy.addToStudyInFather( tore, volumeTore1, 'volumeTore1' )
+ geompy.addToStudyInFather( tore, volumeTore2, 'volumeTore2' )
+
+ return facetore1, facetore2, volumeTore1, volumeTore2
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import logging
+from geomsmesh import geompy
+
+# -----------------------------------------------------------------------------
+# --- trouver les vertices extremites d'un wire
+
+def findWireEndVertices(aWire, getNormals=False):
+ """
+ trouver les vertices extremites d'un wire
+ calcul optionnel des tangentes. Attention à la tolérance qui peut être élevée (> 0.001)
+ """
+ logging.info("start")
+ if geompy.NumberOfEdges(aWire) > 1:
+ edges = geompy.ExtractShapes(aWire, geompy.ShapeType["EDGE"], False)
+ else:
+ edges = [aWire]
+ vertices = []
+ idsubs = {}
+ shortList = []
+ if getNormals:
+ normals = []
+ idnorm = {}
+ shortNorm = []
+ for edge in edges:
+ vert = geompy.ExtractShapes(edge, geompy.ShapeType["VERTEX"], False)
+ vertices += vert
+ if getNormals:
+ v0 = geompy.MakeVertexOnCurve(edge, 0.0)
+ n0 = geompy.MakeTangentOnCurve(edge, 0.0)
+ v1 = geompy.MakeVertexOnCurve(edge, 1.0)
+ n1 = geompy.MakeTangentOnCurve(edge, 1.0)
+ dist = geompy.MinDistance(v0, vert[0])
+ logging.debug("distance %s", dist)
+ if dist < 1.e-2:
+ normals += [n0, n1]
+ else:
+ normals += [n1, n0]
+ for i, sub in enumerate(vertices):
+ subid = geompy.GetSubShapeID(aWire, sub)
+ if subid in idsubs.keys():
+ idsubs[subid].append(sub)
+ else:
+ idsubs[subid] = [sub]
+ name='vertex%d'%i
+ geompy.addToStudyInFather(aWire, sub, name)
+ if getNormals:
+ idnorm[subid] = normals[i]
+ name='norm%d'%i
+ geompy.addToStudyInFather(aWire, normals[i], name)
+ logging.debug("idsubs: %s", idsubs)
+ for k, v in idsubs.iteritems():
+ if len(v) == 1:
+ shortList.append(v[0])
+ if getNormals:
+ shortNorm.append(idnorm[k])
+ if getNormals:
+ return shortList, shortNorm
+ else:
+ return shortList
+
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import logging
+from geomsmesh import geompy
+
+# -----------------------------------------------------------------------------
+# --- trouver les vertices intermediaires d'un wire
+
+def findWireIntermediateVertices(aWire, getNormals=False):
+ """
+ trouver les vertices d'un wire qui ne sont pas aux extremités
+ calcul optionnel des tangentes. Attention à la tolérance qui peut être élevée (> 0.001)
+ """
+ logging.info("start")
+ edges = geompy.ExtractShapes(aWire, geompy.ShapeType["EDGE"], False)
+ vertices = []
+ idsubs = {}
+ shortList = []
+ if getNormals:
+ normals = []
+ idnorm = {}
+ shortNorm = []
+ for edge in edges:
+ vert = geompy.ExtractShapes(edge, geompy.ShapeType["VERTEX"], False)
+ vertices += vert
+ if getNormals:
+ v0 = geompy.MakeVertexOnCurve(edge, 0.0)
+ n0 = geompy.MakeTangentOnCurve(edge, 0.0)
+ v1 = geompy.MakeVertexOnCurve(edge, 1.0)
+ n1 = geompy.MakeTangentOnCurve(edge, 1.0)
+ dist = geompy.MinDistance(v0, vert[0])
+ logging.debug("distance %s", dist)
+ if dist < 1.e-2:
+ normals += [n0, n1]
+ else:
+ normals += [n1, n0]
+ for i, sub in enumerate(vertices):
+ subid = geompy.GetSubShapeID(aWire, sub)
+ if subid in idsubs.keys():
+ idsubs[subid].append(sub)
+ else:
+ idsubs[subid] = [sub]
+ name='vertex%d'%i
+ geompy.addToStudyInFather(aWire, sub, name)
+ if getNormals:
+ idnorm[subid] = normals[i]
+ name='norm%d'%i
+ geompy.addToStudyInFather(aWire, normals[i], name)
+ for k, v in idsubs.iteritems():
+ if len(v) > 1:
+ shortList.append(v[0])
+ if getNormals:
+ shortNorm.append(idnorm[k])
+ if getNormals:
+ return shortList, shortNorm
+ else:
+ return shortList
+
--- /dev/null
+# -*- coding: utf-8 -*-
+
+from geomsmesh import geompy, smesh
+
+import math
+import GEOM
+import SALOMEDS
+import SMESH
+#import StdMeshers
+#import GHS3DPlugin
+#import NETGENPlugin
+import logging
+
+from fissureGenerique import fissureGenerique
+
+from triedreBase import triedreBase
+from genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
+from creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
+from insereFissureGenerale import insereFissureGenerale
+from sortEdges import sortEdges
+
+O, OX, OY, OZ = triedreBase()
+
+class fissureCoude(fissureGenerique):
+ """
+ problème de fissure du Coude : version de base
+ maillage hexa
+ """
+
+ nomProbleme = "tuyau_Coude"
+
+ # ---------------------------------------------------------------------------
+ def setParamGeometrieSaine(self):
+ """
+ Paramètres géométriques du tuyau coudé sain:
+ angleCoude
+ r_cintr
+ l_tube_p1
+ l_tube_p2
+ epais
+ de
+ """
+ self.geomParams = dict(angleCoude = 60,
+ r_cintr = 1200,
+ l_tube_p1 = 1600,
+ l_tube_p2 = 1200,
+ epais = 40,
+ de = 760)
+
+ # ---------------------------------------------------------------------------
+ def genereGeometrieSaine(self, geomParams):
+ logging.info("genereGeometrieSaine %s", self.nomCas)
+
+ angleCoude = geomParams['angleCoude']
+ r_cintr = geomParams['r_cintr']
+ l_tube_p1 = geomParams['l_tube_p1']
+ l_tube_p2 = geomParams['l_tube_p2']
+ epais = geomParams['epais']
+ de = geomParams['de']
+
+ centre = geompy.MakeVertex(0, 0, -l_tube_p1)
+ diskext = geompy.MakeDiskPntVecR(centre, OZ, de/2.)
+ diskint = geompy.MakeDiskPntVecR(centre, OZ, de/2. -epais)
+ couronne = geompy.MakeCut(diskext, diskint)
+ tube_1 = geompy.MakePrismVecH(couronne, OZ, l_tube_p1)
+ axe = geompy.MakeTranslation(OY, -r_cintr, 0, -l_tube_p1)
+ coude = geompy.MakeRevolution(couronne, axe, angleCoude*math.pi/180.0)
+ Rotation_1 = geompy.MakeRotation(couronne, axe, angleCoude*math.pi/180.0)
+ Rotation_2 = geompy.MakeRotation(OZ, OY, angleCoude*math.pi/180.0)
+ tube_2 = geompy.MakePrismVecH(Rotation_1, Rotation_2, -l_tube_p2)
+ plan_y = geompy.MakePlaneLCS(None, 100000, 3)
+ geompy.addToStudy( plan_y, "plan_y" )
+ geompy.addToStudy( tube_1, "tube_1" )
+ geompy.addToStudy( coude, "coude" )
+ geompy.addToStudy( tube_2, "tube_2" )
+
+ P1 = O
+ geompy.addToStudy( P1, "P1" )
+ op2 = geompy.MakeVertex(0, 0, -l_tube_p1)
+ P2 = geompy.MakeRotation(op2, axe, angleCoude*math.pi/180.0)
+ P2 = geompy.MakeTranslationVectorDistance(P2, Rotation_2, -l_tube_p2)
+ geompy.addToStudy( P2, "P2" )
+
+ # --- tube coude sain
+
+ geometrieSaine = geompy.MakePartition([tube_1, coude, tube_2, P1, P2], [plan_y], [], [], geompy.ShapeType["SOLID"], 0, [], 1)
+ geompy.addToStudy( geometrieSaine, self.nomCas )
+ [P1, P2] = geompy.RestoreGivenSubShapes(geometrieSaine, [P1, P2], GEOM.FSM_GetInPlaceByHistory, False, True)
+
+ xmin = -de -r_cintr -l_tube_p2
+ zmin = -l_tube_p1 -r_cintr -l_tube_p2 -de
+ ymax = de +100.
+ boxypos = geompy.MakeBox(xmin, 0, zmin, ymax, ymax, 100, "boxypos")
+ boxyneg = geompy.MakeBox(xmin, 0, zmin, ymax, -ymax, 100, "boxyneg")
+ edgesypos = geompy.GetShapesOnShape(boxypos, geometrieSaine, geompy.ShapeType["EDGE"], GEOM.ST_IN)
+ edgesyneg = geompy.GetShapesOnShape(boxyneg, geometrieSaine, geompy.ShapeType["EDGE"], GEOM.ST_IN)
+ circ_g = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["EDGE"])
+ geompy.UnionList(circ_g, edgesyneg)
+ circ_d = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["EDGE"])
+ geompy.UnionList(circ_d, edgesypos)
+ edgesy0pos = geompy.GetShapesOnShape(boxypos, geometrieSaine, geompy.ShapeType["EDGE"], GEOM.ST_ONIN)
+ grpedpos = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["EDGE"])
+ geompy.UnionList(grpedpos, edgesy0pos)
+ grpedy0 = geompy.CutGroups(grpedpos, circ_d, "edges_y0")
+ boxtub1 = geompy.MakeBox(-de/2.0 -1, -1, -l_tube_p1, de, de, 0, "boxtub1")
+ edgestub1 = geompy.GetShapesOnShape(boxtub1, geometrieSaine, geompy.ShapeType["EDGE"], GEOM.ST_IN)
+ grped = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["EDGE"])
+ geompy.UnionList(grped, edgestub1)
+ long_p1 = geompy.IntersectGroups(grped, grpedy0)
+ boxtub = geompy.MakeBox(-de/2.0 -1, -1, -l_tube_p1 -l_tube_p2, de, de, -l_tube_p1)
+ boxtub2 = geompy.MakeRotation(boxtub, axe, angleCoude*math.pi/180.0, "boxttub2")
+ edgestub2 = geompy.GetShapesOnShape(boxtub2, geometrieSaine, geompy.ShapeType["EDGE"], GEOM.ST_IN)
+ grped = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["EDGE"])
+ geompy.UnionList(grped, edgestub2)
+ long_p2 = geompy.IntersectGroups(grped, grpedy0)
+ boxtub1t = geompy.MakeTranslationVectorDistance(boxtub1, OZ, -l_tube_p1)
+ facer = geompy.GetShapesOnShape(boxtub1t, boxtub1, geompy.ShapeType["FACE"], GEOM.ST_ONIN, "facer")
+ boxcoud = geompy.MakeRevolution(facer[0], axe, angleCoude*math.pi/180.0, "boxcoud")
+ edgescoud = geompy.GetShapesOnShape(boxcoud, geometrieSaine, geompy.ShapeType["EDGE"], GEOM.ST_IN)
+ grped = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["EDGE"])
+ geompy.UnionList(grped, edgescoud)
+ long_coude = geompy.IntersectGroups(grped, grpedy0)
+ grped = geompy.CutGroups(grpedy0, long_p1)
+ grped = geompy.CutGroups(grped, long_p2)
+ ep = geompy.CutGroups(grped, long_coude)
+ geompy.addToStudyInFather( geometrieSaine, long_p1, 'long_p1' )
+ geompy.addToStudyInFather( geometrieSaine, ep, 'ep' )
+ geompy.addToStudyInFather( geometrieSaine, long_coude, 'long_coude' )
+ geompy.addToStudyInFather( geometrieSaine, circ_g, 'circ_g' )
+ geompy.addToStudyInFather( geometrieSaine, circ_d, 'circ_d' )
+ geompy.addToStudyInFather( geometrieSaine, long_p2, 'long_p2' )
+
+ # --- face extremite tube (EXTUBE)
+
+ facesIds = geompy.GetShapesOnPlaneIDs(geometrieSaine, geompy.ShapeType["FACE"], OZ, GEOM.ST_ON)
+ EXTUBE = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["FACE"])
+ geompy.UnionIDs(EXTUBE, facesIds)
+ geompy.addToStudyInFather( geometrieSaine, EXTUBE, 'EXTUBE' )
+
+ # --- edge bord extremite tube (BORDTU)
+
+ edge1Ids = geompy.GetShapesOnPlaneIDs(geometrieSaine, geompy.ShapeType["EDGE"], OZ, GEOM.ST_ON)
+ edge2Ids = geompy.GetShapesOnCylinderIDs(geometrieSaine, geompy.ShapeType["EDGE"], OZ, de/2. -epais, GEOM.ST_ON)
+ edgesIds = []
+ for edge in edge1Ids:
+ if edge in edge2Ids:
+ edgesIds.append(edge)
+ BORDTU = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["EDGE"])
+ geompy.UnionIDs(BORDTU, edgesIds)
+ geompy.addToStudyInFather( geometrieSaine, BORDTU, 'BORDTU' )
+
+ # --- face origine tube (CLGV)
+
+ pp2 = geompy.MakeTranslationVectorDistance(P2, Rotation_2, 10)
+ vec2 = geompy.MakeVector(P2, pp2)
+ #geompy.addToStudy(vec2, 'vec2')
+ facesIds = geompy.GetShapesOnPlaneIDs(geometrieSaine, geompy.ShapeType["FACE"], vec2, GEOM.ST_ON)
+ CLGV = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["FACE"])
+ geompy.UnionIDs(CLGV, facesIds)
+ geompy.addToStudyInFather( geometrieSaine, CLGV, 'CLGV' )
+
+ # --- peau tube interieur (PEAUINT)
+
+ extru1 = geompy.MakePrismVecH(diskint, OZ, l_tube_p1)
+ revol1 = geompy.MakeRevolution(diskint, axe, angleCoude*math.pi/180.0)
+ rot1 = geompy.MakeRotation(diskint, axe, angleCoude*math.pi/180.0)
+ extru2 = geompy.MakePrismVecH(rot1, Rotation_2, -l_tube_p2)
+ interne = geompy.MakeFuse(extru1, revol1)
+ interne = geompy.MakeFuse(extru2, interne)
+ geompy.addToStudy(interne, 'interne')
+ facesIds = geompy.GetShapesOnShapeIDs(interne, geometrieSaine, geompy.ShapeType["FACE"], GEOM.ST_ONIN)
+ PEAUINT = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["FACE"])
+ geompy.UnionIDs(PEAUINT, facesIds)
+ geompy.addToStudyInFather( geometrieSaine, PEAUINT, 'PEAUINT' )
+
+ # --- peau tube exterieur (PEAUEXT)
+
+ cercle1 = geompy.MakeCircle(centre, OZ, de/2.)
+ extru1 = geompy.MakePrismVecH(cercle1, OZ, l_tube_p1)
+ revol1 = geompy.MakeRevolution(cercle1, axe, angleCoude*math.pi/180.0)
+ rot1 = geompy.MakeRotation(cercle1, axe, angleCoude*math.pi/180.0)
+ extru2 = geompy.MakePrismVecH(rot1, Rotation_2, -l_tube_p2)
+ externe = geompy.MakeFuse(extru1, revol1)
+ externe = geompy.MakeFuse(extru2, externe)
+ geompy.addToStudy(externe, 'externe')
+ facesIds = geompy.GetShapesOnShapeIDs(externe, geometrieSaine, geompy.ShapeType["FACE"], GEOM.ST_ON)
+ PEAUEXT = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["FACE"])
+ geompy.UnionIDs(PEAUEXT, facesIds)
+ geompy.addToStudyInFather( geometrieSaine, PEAUEXT, 'PEAUEXT' )
+
+ # --- solide sain
+
+ volIds = geompy.SubShapeAllIDs(geometrieSaine, geompy.ShapeType["SOLID"])
+ COUDE = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["SOLID"])
+ geompy.UnionIDs(COUDE, volIds)
+ geompy.addToStudyInFather( geometrieSaine, COUDE, 'COUDSAIN' )
+
+ geometriesSaines = [geometrieSaine, long_p1, ep, long_coude, circ_g, circ_d, long_p2, P1, P2, EXTUBE, BORDTU, CLGV, PEAUINT, PEAUEXT, COUDE]
+
+ return geometriesSaines
+
+ # ---------------------------------------------------------------------------
+ def setParamMaillageSain(self):
+ self.meshParams = dict(n_long_p1 = 16,
+ n_ep = 3,
+ n_long_coude = 15,
+ n_circ_g = 20,
+ n_circ_d = 20,
+ n_long_p2 = 12)
+
+ # ---------------------------------------------------------------------------
+ def genereMaillageSain(self, geometriesSaines, meshParams):
+ logging.info("genereMaillageSain %s", self.nomCas)
+
+ geometrieSaine = geometriesSaines[0]
+ long_p1 = geometriesSaines[1]
+ ep = geometriesSaines[2]
+ long_coude = geometriesSaines[3]
+ circ_g = geometriesSaines[4]
+ circ_d = geometriesSaines[5]
+ long_p2 = geometriesSaines[6]
+ P1 = geometriesSaines[7]
+ P2 = geometriesSaines[8]
+ EXTUBE = geometriesSaines[9]
+ BORDTU = geometriesSaines[10]
+ CLGV = geometriesSaines[11]
+ PEAUINT = geometriesSaines[12]
+ PEAUEXT = geometriesSaines[13]
+ COUDE = geometriesSaines[14]
+
+ n_long_p1 = meshParams['n_long_p1']
+ n_ep = meshParams['n_ep']
+ n_long_coude = meshParams['n_long_coude']
+ n_circ_g = meshParams['n_circ_g']
+ n_circ_d = meshParams['n_circ_d']
+ n_long_p2 = meshParams['n_long_p2']
+
+ maillageSain = smesh.Mesh(geometrieSaine)
+
+ algo3d = maillageSain.Hexahedron()
+ algo2d = maillageSain.Quadrangle()
+ smesh.SetName(algo3d, "algo3d_maillageSain")
+ smesh.SetName(algo2d, "algo2d_maillageSain")
+
+ algo1d_long_p1 = maillageSain.Segment(geom=long_p1)
+ hypo1d_long_p1 = algo1d_long_p1.NumberOfSegments(n_long_p1)
+ smesh.SetName(algo1d_long_p1, "algo1d_long_p1")
+ smesh.SetName(hypo1d_long_p1, "hypo1d_long_p1")
+
+ algo1d_ep = maillageSain.Segment(geom=ep)
+ hypo1d_ep = algo1d_ep.NumberOfSegments(n_ep)
+ smesh.SetName(algo1d_ep, "algo1d_ep")
+ smesh.SetName(hypo1d_ep, "hypo1d_ep")
+
+ algo1d_long_coude = maillageSain.Segment(geom=long_coude)
+ hypo1d_long_coude = algo1d_long_coude.NumberOfSegments(n_long_coude)
+ smesh.SetName(algo1d_long_coude, "algo1d_long_coude")
+ smesh.SetName(hypo1d_long_coude, "hypo1d_long_coude")
+
+ algo1d_circ_g = maillageSain.Segment(geom=circ_g)
+ hypo1d_circ_g = algo1d_circ_g.NumberOfSegments(n_circ_g)
+ smesh.SetName(algo1d_circ_g, "algo1d_circ_g")
+ smesh.SetName(hypo1d_circ_g, "hypo1d_circ_g")
+
+ algo1d_circ_d = maillageSain.Segment(geom=circ_d)
+ hypo1d_circ_d = algo1d_circ_d.NumberOfSegments(n_circ_d)
+ smesh.SetName(algo1d_circ_d, "algo1d_circ_d")
+ smesh.SetName(hypo1d_circ_d, "hypo1d_circ_d")
+
+ algo1d_long_p2 = maillageSain.Segment(geom=long_p2)
+ hypo1d_long_p2 = algo1d_long_p2.NumberOfSegments(n_long_p2)
+ smesh.SetName(algo1d_long_p2, "algo1d_long_p2")
+ smesh.SetName(hypo1d_long_p2, "hypo1d_long_p2")
+
+ isDone = maillageSain.Compute()
+
+ 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)
+
+ return [maillageSain, True] # True : maillage hexa
+
+ # ---------------------------------------------------------------------------
+ def setParamShapeFissure(self):
+ """
+ paramètres de la fissure pour le tuyau coude
+ profondeur : 0 < profondeur <= épaisseur
+ rayonPipe : rayon du pipe correspondant au maillage rayonnant
+ lenSegPipe : longueur des mailles rayonnantes le long du fond de fissure (= rayonPipe par défaut)
+ azimut : entre 0 et 360°
+ alpha : 0 < alpha < angleCoude
+ longueur : <=2*profondeur ==> force une fissure elliptique (longueur/profondeur = grand axe/petit axe).
+ orientation : 0° : longitudinale, 90° : circonférentielle, autre : uniquement fissures elliptiques
+ lgInfluence : distance autour de la shape de fissure a remailler (si 0, pris égal à profondeur. A ajuster selon le maillage)
+ elliptique : True : fissure elliptique (longueur/profondeur = grand axe/petit axe); False : fissure longue (fond de fissure de profondeur constante, demi-cercles aux extrémites)
+ pointIn_x : optionnel coordonnées x d'un point dans le solide, pas trop loin du centre du fond de fissure (idem y,z)
+ externe : True : fissure face externe, False : fissure face interne
+ """
+ logging.info("setParamShapeFissure %s", self.nomCas)
+ self.shapeFissureParams = dict(profondeur = 10,
+ rayonPipe = 2.5,
+ lenSegPipe = 2.5,
+ azimut = 160,
+ alpha = 20,
+ longueur = 400,
+ orientation = 90,
+ lgInfluence = 50,
+ elliptique = False,
+ externe = True)
+
+ # ---------------------------------------------------------------------------
+ def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams):
+ logging.info("genereShapeFissure %s", self.nomCas)
+ logging.info("shapeFissureParams %s", shapeFissureParams)
+
+ angleCoude = geomParams['angleCoude']
+ r_cintr = geomParams['r_cintr']
+ l_tube_p1 = geomParams['l_tube_p1']
+ l_tube_p2 = geomParams['l_tube_p2']
+ epais = geomParams['epais']
+ de = geomParams['de']
+
+ profondeur = shapeFissureParams['profondeur']
+ azimut = shapeFissureParams['azimut']
+ alpha = shapeFissureParams['alpha']
+ longueur = shapeFissureParams['longueur']
+ orientation = shapeFissureParams['orientation']
+ externe = shapeFissureParams['externe']
+ lgInfluence = shapeFissureParams['lgInfluence']
+ self.elliptique = False
+ if shapeFissureParams.has_key('elliptique'):
+ self.elliptique = shapeFissureParams['elliptique']
+
+
+
+ azimut = -azimut # axe inverse / ASCOUF
+ axe = geompy.MakeTranslation(OY, -r_cintr, 0, -l_tube_p1)
+ geompy.addToStudy(axe,"axe")
+
+ if not lgInfluence:
+ lgInfluence = profondeur
+
+ if longueur > 2*profondeur:
+ self.fissureLongue=True
+ else:
+ self.fissureLongue=False
+ self.elliptique = True
+
+ self.circonferentielle = False
+ self.longitudinale = False
+ if self.fissureLongue and not self.elliptique:
+ if abs(orientation) < 45 :
+ self.longitudinale = True
+ else:
+ self.circonferentielle = True
+
+ nbp1 = 10
+ if self.circonferentielle:
+ if externe:
+ dp = -1.0
+ raybor = de/2.
+ rayint = raybor - profondeur
+ rayext = raybor + profondeur/5.0
+ else:
+ dp = 1.0
+ raybor = de/2. - epais
+ rayint = raybor + profondeur
+ rayext = raybor - profondeur/5.0
+ lgfond = longueur -2*profondeur
+ angle = lgfond/(2*raybor)
+ pb = geompy.MakeVertex(raybor, 0, 0)
+ pi = geompy.MakeVertex(rayint, 0, 0)
+ pbl = geompy.MakeRotation(pb, OZ, angle)
+ pbr = geompy.MakeRotation(pb, OZ, -angle)
+ geompy.addToStudy(pbl,"pbl")
+ geompy.addToStudy(pbr,"pbr")
+ pal = geompy.MakeTranslationVector(pbl, OZ)
+ par = geompy.MakeTranslationVector(pbr, OZ)
+ axl = geompy.MakeVector(pbl,pal)
+ axr = geompy.MakeVector(pbr,par)
+ pil = geompy.MakeRotation(pi, OZ, angle)
+ pir = geompy.MakeRotation(pi, OZ, -angle)
+ points = []
+ nbp = 3*nbp1
+ for i in range(nbp):
+ angi = dp*(nbp -i)*(2.0*math.pi/3.0)/nbp
+ pt = geompy.MakeRotation(pil, axl, angi)
+ points.append(pt)
+ for i in range(nbp):
+ angi = angle -2.0*i*angle/nbp
+ pt = geompy.MakeRotation(pi, OZ, angi)
+ points.append(pt)
+ for i in range(nbp+1):
+ angi = -dp*i*(2.0*math.pi/3.0)/nbp
+ pt = geompy.MakeRotation(pir, axr, angi)
+ points.append(pt)
+ for i, pt in enumerate(points):
+ pt = geompy.MakeRotation(pt, OZ, azimut*math.pi/180.)
+ pt = geompy.MakeTranslation(pt, 0, 0, -l_tube_p1)
+ pt = geompy.MakeRotation(pt, axe, alpha*math.pi/180.)
+ points[i] = pt
+ wire0 = geompy.MakeInterpol(points[0:nbp+1])
+ wire1 = geompy.MakeInterpol(points[nbp:2*nbp+1])
+ wire2 = geompy.MakeInterpol(points[2*nbp:3*nbp+1])
+ #wiretube = geompy.MakeInterpol(points)
+ wiretube=geompy.MakeWire([wire0,wire1,wire2])
+ geompy.addToStudy(wiretube,"wiretube")
+
+ pe = geompy.MakeVertex(rayext, 0, 0)
+ pe = geompy.MakeRotation(pe, OZ, azimut*math.pi/180.)
+ pe = geompy.MakeTranslation(pe, 0, 0, -l_tube_p1)
+ pe = geompy.MakeRotation(pe, axe, alpha*math.pi/180.)
+
+ arce = geompy.MakeArc(points[0], pe, points[-1])
+ geompy.addToStudy(arce,"arce")
+
+ facefiss = geompy.MakeFaceWires([arce, wiretube], 1)
+ geompy.addToStudy( facefiss, 'facefissPlace' )
+
+ pc = geompy.MakeVertex((raybor + rayint)/2.0, 0, 0)
+ centre = geompy.MakeRotation(pc, OZ, azimut*math.pi/180.)
+ centre = geompy.MakeTranslation(centre, 0, 0, -l_tube_p1)
+ centre = geompy.MakeRotation(centre, axe, alpha*math.pi/180.)
+ geompy.addToStudy( centre, 'centrefissPlace' )
+
+ wiretube = geompy.GetInPlace(facefiss, wiretube)
+ geompy.addToStudy(wiretube, 'wiretubePlace' )
+ try:
+ edgetube = geompy.MakeEdgeWire(wiretube)
+ geompy.addToStudy(edgetube,"edgetube")
+ except:
+ logging.debug("erreur MakeEdgeWire sur fond de fissure, on fait sans")
+ edgetube = None
+
+ # ---------------------------------------------------------
+
+ elif self.longitudinale:
+ if externe:
+ raybor = de/2.
+ dp = -1.0
+ else:
+ raybor = de/2. - epais
+ dp = +1.0
+ prof = dp * profondeur
+ lgfond = longueur -2*profondeur
+ cosaz = math.cos(azimut*math.pi/180.)
+ sinaz = math.sin(azimut*math.pi/180.)
+ alfrd = alpha*math.pi/180.
+ rayxy = r_cintr + raybor*cosaz
+ angle = lgfond/(2.*rayxy)
+ logging.debug("longueur: %s, angle: %s, rayon: %s",lgfond, angle, rayxy)
+ pb = geompy.MakeVertex(raybor*cosaz, raybor*sinaz, -l_tube_p1, "pb")
+ pi = geompy.MakeTranslation(pb, prof*cosaz, prof*sinaz, 0., "pi")
+ pbv = geompy.MakeTranslation(pb, -sinaz, cosaz, 0., "pbv")
+ axb = geompy.MakeVector(pb,pbv, "axb")
+ pbl = geompy.MakeRotation(pb, axe, alfrd -angle, "pbl")
+ pbr = geompy.MakeRotation(pb, axe, alfrd +angle, "pbr")
+ axl = geompy.MakeRotation(axb, axe, alfrd -angle, "axl")
+ axr = geompy.MakeRotation(axb, axe, alfrd +angle, "axr")
+ pil = geompy.MakeRotation(pi, axe, alfrd -angle, "pil")
+ pir = geompy.MakeRotation(pi, axe, alfrd +angle, "pir")
+
+ curves = []
+
+ points = []
+ nbp = 3*nbp1
+ xs = []
+ totx = 0
+ for i in range(nbp+2):
+ x = math.sin(i*math.pi/(nbp+1)) # fonction de répartition des points : distance relative
+ x2 = x*x
+ totx += x2
+ xs.append(totx)
+ logging.debug("x2: %s, totx: %s", x2, totx)
+ for i in range(nbp+1):
+ #posi = nbp -i # répartition équidistante des points sur la courbe
+ posi = nbp*(1 -xs[i]/totx) # points plus resserrés aux extrémités de la courbe
+ angi = -dp*posi*(5.0*math.pi/8.0)/nbp
+ pt = geompy.MakeRotation(pil, axl, angi)
+ points.append(pt)
+ curves.append(geompy.MakeInterpol(points))
+ point0 = points[0]
+ geompy.addToStudy(curves[-1],"curve0")
+# for i, pt in enumerate(points):
+# name = "point%d"%i
+# geompy.addToStudyInFather(curves[-1], pt, name)
+
+ points = []
+ nbp = 3*nbp1
+ xs =[]
+ totx = 0
+ for i in range(nbp+1):
+ x = math.sin(i*math.pi/nbp)
+ #x = 1.0 # répartition équidistante des points sur la courbe
+ x2 = x*x # points plus resserrés aux extrémités de la courbe
+ totx += x2
+ xs.append(totx)
+ logging.debug("x2: %s, totx: %s", x2, totx)
+ for i in range(nbp):
+ angi = alfrd -angle +2.0*angle*xs[i]/totx
+ pt = geompy.MakeRotation(pi, axe, angi)
+ points.append(pt)
+ curves.append(geompy.MakeInterpol(points))
+ geompy.addToStudy(curves[-1],"curve1")
+# for i, pt in enumerate(points):
+# name = "point%d"%i
+# geompy.addToStudyInFather(curves[-1], pt, name)
+
+ points = []
+ nbp = 3*nbp1
+ xs = []
+ totx = 0
+ for i in range(nbp+2):
+ x = math.sin(i*math.pi/(nbp+1))
+ x2 = x*x
+ totx += x2
+ xs.append(totx)
+ logging.debug("x2: %s, totx: %s", x2, totx)
+ for i in range(nbp+1):
+ #posi = nbp -i # répartition équidistante des points sur la courbe
+ posi = nbp*xs[i]/totx # points plus resserrés aux extrémités de la courbe
+ angi = dp*posi*(5.0*math.pi/8.0)/nbp
+ pt = geompy.MakeRotation(pir, axr, angi)
+ points.append(pt)
+ curves.append(geompy.MakeInterpol(points))
+ point1 = points[-1]
+ geompy.addToStudy(curves[-1],"curve2")
+# for i, pt in enumerate(points):
+# name = "point%d"%i
+# geompy.addToStudyInFather(curves[-1], pt, name)
+
+ wiretube = geompy.MakeWire(curves)
+ geompy.addToStudy(wiretube,"wiretube")
+ try:
+ edgetube = geompy.MakeEdgeWire(wiretube)
+ geompy.addToStudy(edgetube,"edgetube")
+ except:
+ logging.debug("erreur MakeEdgeWire sur fond de fissure, on fait sans")
+ edgetube = None
+
+ pts = []
+ pts.append(point0)
+ dpr = prof*math.cos(5.0*math.pi/8.0)
+ pe = geompy.MakeTranslation(pb, dpr*cosaz, dpr*sinaz, 0., "pe")
+ for i in range(nbp):
+ angi = alfrd -angle +2.0*i*angle/nbp
+ pt = geompy.MakeRotation(pe, axe, angi)
+ pts.append(pt)
+ pts.append(point1)
+ arce = geompy.MakeInterpol(pts)
+ geompy.addToStudy(arce,"arce")
+
+ facefiss = geompy.MakeFaceWires([arce, wiretube], 0)
+ geompy.addToStudy( facefiss, 'facefissPlace' )
+
+ pc = geompy.MakeTranslation(pb, 0.5*prof*cosaz, 0.5*prof*sinaz, 0.)
+ centre = geompy.MakeRotation(pc, axe, alfrd)
+ geompy.addToStudy( centre, 'centrefissPlace' )
+
+ edges = geompy.ExtractShapes(facefiss, geompy.ShapeType["EDGE"], True)
+ edgesTriees, minl, maxl = sortEdges(edges)
+ edges = edgesTriees[:-1] # la plus grande correspond à arce, on l'elimine
+ wiretube = geompy.MakeWire(edges)
+ #wiretube = edgesTriees[-1]
+ geompy.addToStudy(wiretube, 'wiretubePlace' )
+
+ # ---------------------------------------------------------
+
+ else: # fissure elliptique, longue ou courte
+ if externe:
+ raybor = de/2.
+ dp = -1.0
+ else:
+ raybor = de/2. - epais
+ dp = +1.0
+ prof = dp * profondeur
+ cosaz = math.cos(azimut*math.pi/180.)
+ sinaz = math.sin(azimut*math.pi/180.)
+ alfrd = alpha*math.pi/180.
+ pb = geompy.MakeVertex(raybor*cosaz, raybor*sinaz, -l_tube_p1, "pb")
+ pi = geompy.MakeTranslation(pb, prof*cosaz, prof*sinaz, 0., "pi")
+ pbv = geompy.MakeTranslation(pb, -profondeur*sinaz, profondeur*cosaz, 0., "pbv")
+ ayb = geompy.MakeVector(pb,pbv, "ayb")
+ pb0 = geompy.MakeRotation(pb, axe, alfrd, "pb0")
+ ay0 = geompy.MakeRotation(ayb, axe, alfrd, "ay0")
+ pi0 = geompy.MakeRotation(pi, axe, alfrd, "pi0")
+ az_ = geompy.MakeVector(pi0, pb0, "az_")
+ az0 = geompy.MakeTranslationVector(az_, az_, "az0") #normale sortante
+ ax0 = geompy.MakeRotation(ay0, az0, -math.pi/2.0, "ax0")
+ ax1 = geompy.MakeRotation(ax0, az0, orientation*math.pi/180., "ax1")
+ ay1 = geompy.MakeRotation(ay0, az0, orientation*math.pi/180., "ay1")
+ originLCS = geompy.MakeMarker(0, 0, 0, 1, 0, 0, 0, 1, 0, "originLCS")
+ coo = geompy.PointCoordinates(pb0)
+ cox = geompy.VectorCoordinates(ax1)
+ coy = geompy.VectorCoordinates(ay1)
+ localLCS = geompy.MakeMarker(coo[0], coo[1], coo[2], cox[0], cox[1], cox[2], coy[0], coy[1], coy[2], "localLCS")
+
+ pco = geompy.MakeVertex(0, 0, -profondeur, "pco")
+ pao = geompy.MakeRotation(pco, OY, 0.6*math.pi, "pao")
+ pbo = geompy.MakeRotation(pco, OY, -0.6*math.pi, "pbo")
+ pce = geompy.MakeVertex(0, 0, 0.1*profondeur,"pce")
+ arcoo = geompy.MakeArc(pao, pco, pbo, "arcoo")
+ linoo = geompy.MakeArc(pao, pce, pbo, "linoo")
+ scalex = longueur/profondeur
+ arco =geompy.MakeScaleAlongAxes(arcoo, O, scalex, 1., 1., "arco")
+ lino =geompy.MakeScaleAlongAxes(linoo, O, scalex, 1., 1., "lino")
+ arci = geompy.MakePosition(arco, originLCS, localLCS, "arci")
+ arce = geompy.MakePosition(lino, originLCS, localLCS, "arce")
+ facefiss = geompy.MakeFaceWires([arce, arci], 0)
+ geompy.addToStudy( facefiss, 'facefissPlace' )
+ edges = geompy.ExtractShapes(facefiss, geompy.ShapeType["EDGE"], True)
+ edgesTriees, minl, maxl = sortEdges(edges)
+ edgetube = edgesTriees[-1] # la plus grande correspond à arci
+ wiretube = edgetube
+
+ pc = geompy.MakeTranslation(pb, 0.5*prof*cosaz, 0.5*prof*sinaz, 0.)
+ centre = geompy.MakeRotation(pc, axe, alfrd)
+ geompy.addToStudy( centre, 'centrefissPlace' )
+
+ coordsNoeudsFissure = genereMeshCalculZoneDefaut(facefiss, profondeur/2. ,profondeur)
+
+ return [facefiss, centre, lgInfluence, coordsNoeudsFissure, wiretube, edgetube]
+
+ # ---------------------------------------------------------------------------
+ def setParamMaillageFissure(self):
+ """
+ Paramètres du maillage de la fissure pour le tuyau coudé
+ Voir également setParamShapeFissure, paramètres rayonPipe et lenSegPipe.
+ nbSegRad = nombre de couronnes
+ nbSegCercle = nombre de secteurs
+ areteFaceFissure = taille cible de l'arête des triangles en face de fissure.
+ """
+ self.maillageFissureParams = dict(nomRep = '.',
+ nomFicSain = self.nomCas,
+ nomFicFissure = 'fissure_' + self.nomCas,
+ nbsegRad = 5,
+ nbsegCercle = 6,
+ areteFaceFissure = 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):
+ maillageFissure = insereFissureGenerale(maillagesSains,
+ shapesFissure, shapeFissureParams,
+ maillageFissureParams, elementsDefaut, step)
+ return maillageFissure
+
+ # ---------------------------------------------------------------------------
+ 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)
+
--- /dev/null
+# -*- coding: utf-8 -*-
+
+from blocFissure import gmu
+from blocFissure.gmu.initEtude import initEtude
+from blocFissure.gmu.getStatsMaillageFissure import getStatsMaillageFissure
+
+class fissureGenerique():
+ """
+ classe générique problème fissure:
+ génération géométrie et maillage sain
+ définition et positionnement d'une fissure
+ génération d'un bloc défaut inséré dans le maillage sain
+ """
+
+ nomProbleme = "generique"
+
+ def __init__(self, numeroCas):
+ initEtude()
+ self.numeroCas = numeroCas
+ self.nomCas = self.nomProbleme +"_%d"%(self.numeroCas)
+ self.fissureLongue = False
+
+ def setParamGeometrieSaine(self):
+ self.geomParams = {}
+
+ def genereGeometrieSaine(self, geomParams):
+ geometriesSaines = [None]
+ return geometriesSaines
+
+ def setParamMaillageSain(self):
+ self.meshParams = {}
+
+ def genereMaillageSain(self, geometriesSaines, meshParams):
+ maillagesSains = [None]
+ return maillagesSains
+
+ def setParamShapeFissure(self):
+ self.shapeFissureParams = {}
+
+ def genereShapeFissure(self, geometriesSaines, geomParams, shapeFissureParams):
+ shapesFissure = [None]
+ return shapesFissure
+
+ def setParamMaillageFissure(self):
+ self.maillageFissureParams = {}
+
+ def genereZoneDefaut(self, geometriesSaines, maillagesSains, shapesFissure, maillageFissureParams):
+ elementsDefaut = [None]
+ return elementsDefaut
+
+ def genereMaillageFissure(self, geometriesSaines, maillagesSains, shapesFissure,
+ maillageFissureParams, elementsDefaut, step):
+ maillageFissure = None
+ return maillageFissure
+
+ def setReferencesMaillageFissure(self):
+ referencesMaillageFissure = {}
+ return referencesMaillageFissure
+
+# ---------------------------------------------------------------------------
+
+ def executeProbleme(self, step=-1):
+ print "executeProbleme", self.nomCas
+ if step == 0:
+ return
+
+ self.setParamGeometrieSaine()
+ geometriesSaines = self.genereGeometrieSaine(self.geomParams)
+ if step == 1:
+ return
+
+ self.setParamMaillageSain()
+ maillagesSains = self.genereMaillageSain(geometriesSaines, self.meshParams)
+ if step == 2:
+ return
+
+ self.setParamShapeFissure()
+ shapesFissure = self.genereShapeFissure(geometriesSaines, self.geomParams, self.shapeFissureParams)
+ if step == 3:
+ return
+
+ self.setParamMaillageFissure()
+ elementsDefaut = self.genereZoneDefaut(geometriesSaines, maillagesSains, shapesFissure, self.shapeFissureParams, self.maillageFissureParams)
+ if step == 4:
+ return
+
+ maillageFissure = self.genereMaillageFissure(geometriesSaines, maillagesSains,
+ shapesFissure, self.shapeFissureParams,
+ self.maillageFissureParams, elementsDefaut, step)
+
+ self.setReferencesMaillageFissure()
+ mesures = getStatsMaillageFissure(maillageFissure, self.referencesMaillageFissure, self.maillageFissureParams)
+
+
+
+
+
+
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import logging
+from geomsmesh import geompy
+
+from toreFissure import toreFissure
+from ellipsoideDefaut import ellipsoideDefaut
+from rotTrans import rotTrans
+from genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
+
+# -----------------------------------------------------------------------------
+# --- création élements géométriques fissure elliptique
+
+def genereElemsFissureElliptique(shapeFissureParams):
+ """
+ TODO: a completer
+ """
+ logging.info('start')
+
+ centreDefaut = shapeFissureParams['centreDefaut']
+ vecteurDefaut = shapeFissureParams['vecteurDefaut']
+ demiGrandAxe = shapeFissureParams['demiGrandAxe']
+ demiPetitAxe = shapeFissureParams['demiPetitAxe']
+ orientation = shapeFissureParams['orientation']
+ tailleDefaut = shapeFissureParams['taille']
+
+ # --- ellipse incomplete : generatrice
+
+ allonge = demiGrandAxe/demiPetitAxe
+ rayonTore = demiPetitAxe/5.0
+ generatrice, FaceGenFiss, Pipe_1, FaceFissure, Plane_1, Pipe1Part = toreFissure(demiPetitAxe, allonge, rayonTore)
+ ellipsoide = ellipsoideDefaut(demiPetitAxe, allonge, rayonTore)
+
+ # --- positionnement sur le bloc defaut de generatrice, tore et plan fissure
+
+ pipe0 = rotTrans(Pipe_1, orientation, centreDefaut, vecteurDefaut)
+ gener1 = rotTrans(generatrice, orientation, centreDefaut, vecteurDefaut)
+ pipe1 = rotTrans(Pipe1Part, orientation, centreDefaut, vecteurDefaut)
+ facefis1 = rotTrans(FaceFissure, orientation, centreDefaut, vecteurDefaut)
+ plane1 = rotTrans(Plane_1, orientation, centreDefaut, vecteurDefaut)
+ ellipsoide1 = rotTrans(ellipsoide, orientation, centreDefaut, vecteurDefaut)
+
+ geompy.addToStudy( pipe0, 'pipe0' )
+ geompy.addToStudy( gener1, 'gener1' )
+ geompy.addToStudy( pipe1, 'pipe1' )
+ geompy.addToStudy( facefis1, 'facefis1' )
+ geompy.addToStudy( plane1, 'plane1' )
+ geompy.addToStudy( ellipsoide1, 'ellipsoide1' )
+
+ shapeDefaut = facefis1
+ xyz_defaut = geompy.PointCoordinates(centreDefaut)
+ coordsNoeudsFissure = genereMeshCalculZoneDefaut(facefis1, demiPetitAxe/10.0, demiPetitAxe/5.0)
+
+ return shapeDefaut, xyz_defaut, tailleDefaut, coordsNoeudsFissure, pipe0, gener1, pipe1, facefis1, plane1, ellipsoide1
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import logging
+from geomsmesh import smesh
+from salome.smesh import smeshBuilder
+
+# -----------------------------------------------------------------------------
+# --- maillage face de fissure pour identification zone de defaut
+
+def genereMeshCalculZoneDefaut(facefiss, minSize, maxSize):
+ """
+ TODO: a completer
+ """
+ logging.info('start')
+
+ meshFissure = smesh.Mesh(facefiss)
+ algo2d = meshFissure.Triangle(algo=smeshBuilder.NETGEN_1D2D)
+ hypo2d = algo2d.Parameters()
+ hypo2d.SetMaxSize( maxSize )
+ hypo2d.SetSecondOrder( 0 )
+ hypo2d.SetOptimize( 1 )
+ hypo2d.SetFineness( 2 )
+ hypo2d.SetMinSize( minSize )
+ hypo2d.SetQuadAllowed( 0 )
+ isDone = meshFissure.Compute()
+ smesh.SetName(algo2d, "algo2d_zoneFiss")
+ smesh.SetName(hypo2d, "hypo1d_zoneFiss")
+
+ coordsNoeudsFissure = []
+ nodeIds = meshFissure.GetNodesId()
+ for id in nodeIds:
+ coords = meshFissure.GetNodeXYZ(id)
+ coordsNoeudsFissure.append(coords[0])
+ coordsNoeudsFissure.append(coords[1])
+ coordsNoeudsFissure.append(coords[2])
+ return coordsNoeudsFissure
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import logging
+logging.info('start')
+
+import salome
+salome.salome_init()
+
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+from salome.smesh import smeshBuilder
+smesh = smeshBuilder.New(salome.myStudy)
+
+logging.debug("initialisation de geompy et smesh OK")
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import logging
+from geomsmesh import geompy
+import bisect
+
+publie = False
+
+def getCentreFondFiss(shapesFissure):
+ """
+ identification du centre de fond de fissure,
+ transformation fond de fissure en edge unique (seulement pour la procédure insereFissureGenerale).
+ On distingue le cas d'utilisation de la procédure insereFissureLongue par le nombre d'éléments de shapesFissure.
+ """
+ global publie
+ logging.debug("start")
+
+ fondFiss = shapesFissure[4] # groupe d'edges de fond de fissure
+ if len(shapesFissure) == 6: # procédure insereFissureGenerale, et edge fond de fissure fournie explicitement
+ edgeFondExt = shapesFissure[5]
+ else:
+ edgeFondExt = None
+
+ if len(shapesFissure) > 6: # procédure insereFissureLongue (fissure plane, plusieurs edges sur le fond de fissure)
+ centreFondFiss = shapesFissure[1]
+ tgtCentre = None
+ else: # procédure insereFissureGenerale, détermination edge unique et milieu de l'edge
+ if geompy.NumberOfEdges(fondFiss) > 1:
+ if geompy.NbShapes(fondFiss, geompy.ShapeType["WIRE"]) > 0: # wire
+ aWire = fondFiss
+ else: # compound
+ edges = geompy.ExtractShapes(fondFiss, geompy.ShapeType["EDGE"], False)
+ aWire = geompy.MakeWire(edges, 1e-07)
+ else:
+ edgeFondExt = fondFiss
+ aWire = geompy.MakeWire([fondFiss], 1e-07)
+ if not publie:
+ geompy.addToStudy(aWire, "wireFondFissExt")
+
+ lgWire = geompy.BasicProperties(aWire)[0]
+ edges = geompy.ExtractShapes(aWire, geompy.ShapeType["EDGE"], True)
+ lgEdges = [geompy.BasicProperties(ed)[0] for ed in edges]
+ lgSumEd =[sum(lgEdges[0:i+1]) for i in range(len(lgEdges))]
+ iedr = bisect.bisect_left(lgSumEd, lgWire/2.0)
+ iedg = iedr -1
+ if iedg < 0:
+ lgOnEdge = lgWire/2.0
+ else:
+ lgOnEdge = lgWire/2.0 - lgSumEd[iedg]
+ logging.debug("lgsumEdges %s", lgSumEd)
+ logging.debug("id edge: %s, lgOnEdge: %s, lgEdge: %s",iedr, lgOnEdge, lgEdges[iedr])
+ if iedr > 0: # il y a une edge avant celle du milieu
+ if geompy.MinDistance(edges[iedr-1], geompy.MakeVertexOnCurve(edges[iedr], 0.0 )) < 1.e-3: # edge orientée croissante
+ centreFondFiss = geompy.MakeVertexOnCurve(edges[iedr], lgOnEdge/lgEdges[iedr])
+ else:
+ centreFondFiss = geompy.MakeVertexOnCurve(edges[iedr], 1.0 - lgOnEdge/lgEdges[iedr])
+ elif iedr < len(edges)-1: # il y a une edge après celle du milieu
+ if geompy.MinDistance(edges[iedr+1], geompy.MakeVertexOnCurve(edges[iedr], 1.0 )) < 1.e-3: # edge orientée croissante
+ centreFondFiss = geompy.MakeVertexOnCurve(edges[iedr], lgOnEdge/lgEdges[iedr])
+ else:
+ centreFondFiss = geompy.MakeVertexOnCurve(edges[iedr], 1.0 - lgOnEdge/lgEdges[iedr])
+ else: # on ne sait pas comment est orientée l'edge unique, mais ça n'a pas d'importance
+ centreFondFiss = geompy.MakeVertexOnCurve(edges[iedr], lgOnEdge/lgEdges[iedr])
+ geompy.addToStudyInFather(aWire, centreFondFiss, "centreFondFiss")
+ tgtCentre = geompy.MakeTangentOnCurve(edges[iedr], lgOnEdge/ lgEdges[iedr])
+
+ if edgeFondExt is None: # fond de fissure non fourni explicitement sous forme d'edge
+ try:
+ edgeFondExt = geompy.MakeEdgeWire(aWire, 0.0005, 1e-07)
+ except:
+ logging.debug("erreur MakeEdgeWire sur fond de fissure, on fait sans")
+ edgeFondExt = None
+ if not publie and edgeFondExt is not None:
+ geompy.addToStudy(edgeFondExt, "edgeFondExt")
+
+ publie = True
+ return edgeFondExt, centreFondFiss, tgtCentre
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import logging
+import SMESH
+
+# -----------------------------------------------------------------------------
+# --- statistiques maillage
+
+def getStatsMaillageFissure(maillage, referencesMaillageFissure, maillageFissureParams):
+ """
+ TODO: a completer
+ """
+ logging.debug('start')
+
+ nomRep = '.'
+ if maillageFissureParams.has_key('nomRep'):
+ nomRep = maillageFissureParams['nomRep']
+
+ nomFicFissure = maillageFissureParams['nomFicFissure']
+ fichierStatMaillageFissure = nomRep + '/' + nomFicFissure + '.res'
+ fichierNewRef = nomRep + '/' + nomFicFissure + '.new'
+ logging.debug("fichierStatMaillageFissure=%s", fichierStatMaillageFissure)
+
+ OK = False
+ if maillage is not None:
+ mesures = maillage.GetMeshInfo()
+ d= {}
+ for key, value in mesures.iteritems():
+ logging.debug( "key: %s value: %s", key, value)
+ d[str(key)] = value
+ logging.debug("dico mesures %s", d)
+
+ f = open(fichierStatMaillageFissure, 'w')
+ f2 = open(fichierNewRef, 'w')
+ OK = True
+ for key in ('Entity_Quad_Pyramid', 'Entity_Quad_Hexa', 'Entity_Quad_Quadrangle'):
+ if d[key] != referencesMaillageFissure[key]:
+ logging.info("Ecart: %s reference: %s calcul: %s", key, referencesMaillageFissure[key], d[key])
+ f.write("Ecart: " + key + " reference: " + str(referencesMaillageFissure[key]) + " calcul: " + str(d[key]) + '\n')
+ OK = False
+ else:
+ logging.info("Valeur_OK: %s reference: %s calcul: %s", key, referencesMaillageFissure[key], d[key])
+ f.write("Valeur_OK: " + key + " reference: " + str(referencesMaillageFissure[key]) + " calcul: " + str(d[key]) + '\n')
+ f2.write(key + " = " + str(d[key]) + ",\n")
+ tolerance = 0.05
+ for key in ('Entity_Quad_Penta', 'Entity_Quad_Tetra', 'Entity_Quad_Triangle', 'Entity_Quad_Edge', 'Entity_Node'):
+ if (d[key] < (1.0 - tolerance)*referencesMaillageFissure[key]) \
+ or (d[key] > (1.0 + tolerance)*referencesMaillageFissure[key]):
+ logging.info("Ecart: %s reference: %s calcul: %s", key, referencesMaillageFissure[key], d[key])
+ f.write("Ecart: " + key + " reference: " + str(referencesMaillageFissure[key]) + " calcul: " + str(d[key]) + '\n')
+ OK = False
+ else:
+ logging.info("Valeur_OK: %s reference: %s calcul: %s", key, referencesMaillageFissure[key], d[key])
+ f.write("Valeur_OK: " + key + " reference: " + str(referencesMaillageFissure[key]) + " calcul: " + str(d[key]) + '\n')
+ f2.write(key + " = " + str(d[key]) + ",\n")
+ f.close()
+ f2.close()
+ return OK
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import logging
+from geomsmesh import geompy
+
+# -----------------------------------------------------------------------------
+# --- transformation d'une liste de subshapes en une liste d'Id
+
+def getSubshapeIds(obj, subshapes):
+ """
+ transformation d'une liste de subshapes en une liste d'Id
+ """
+ logging.debug("start")
+ subshapesId = []
+ for sub in subshapes:
+ subshapesId.append(geompy.GetSubShapeID(obj, sub))
+ logging.debug("subshapesId=%s", subshapesId)
+ return subshapesId
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import logging
+myStudy = None
+
+def initEtude():
+ """
+ creation nouvelle etude salome
+ """
+ import geomsmesh
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import logging
+
+def setDebug():
+ logging.basicConfig(format='%(relativeCreated)d %(funcName)s[%(lineno)d] %(message)s',
+ level=logging.DEBUG)
+ logging.info('start Debug')
+
+def setVerbose():
+ logging.basicConfig(format='%(relativeCreated)d %(funcName)s[%(lineno)d] %(message)s',
+ level=logging.INFO)
+ logging.info('start Verbose')
+
+def setRelease():
+ logging.basicConfig(format='%(funcName)s[%(lineno)d] %(message)s',
+ level=logging.WARNING)
+ logging.warning('start Release')
+
+def setUnitTests():
+ logging.basicConfig(format='%(funcName)s[%(lineno)d] %(message)s',
+ level=logging.CRITICAL)
+ logging.critical('start UnitTests')
+
+ #logging.basicConfig(filename='myapp.log',
+ # format='%(asctime)s %(message)s',
+ # datefmt='%m/%d/%Y %I:%M:%S %p',
+ # level=logging.DEBUG)
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import logging
+import salome
+from geomsmesh import geompy
+from geomsmesh import smesh
+import SMESH
+import math
+
+from partitionBlocDefaut import partitionBlocDefaut
+from facesVolumesToriques import facesVolumesToriques
+from facesCirculaires import facesCirculaires
+from propagateTore import propagateTore
+from sortGeneratrices import sortGeneratrices
+from facesFissure import facesFissure
+from facesToreInBloc import facesToreInBloc
+from shapeSurFissure import shapeSurFissure
+from meshBlocPart import meshBlocPart
+from enleveDefaut import enleveDefaut
+from regroupeSainEtDefaut import RegroupeSainEtDefaut
+from putName import putName
+
+# -----------------------------------------------------------------------------
+# --- procedure complete fissure elliptique
+
+def insereFissureElliptique(geometriesSaines, maillagesSains,
+ shapesFissure, shapeFissureParams,
+ maillageFissureParams, elementsDefaut, step=-1):
+ """
+ TODO: a completer
+ """
+ logging.info('start')
+
+ geometrieSaine = geometriesSaines[0]
+ maillageSain = maillagesSains[0]
+ isHexa = maillagesSains[1]
+ shapeDefaut = shapesFissure[0]
+ tailleDefaut = shapesFissure[2]
+ pipe0 = shapesFissure[4]
+ gener1 = shapesFissure[5]
+ pipe1 = shapesFissure[6]
+ facefis1 = shapesFissure[7]
+ plane1 = shapesFissure[8]
+ ellipsoide1 = shapesFissure[9]
+
+
+ demiGrandAxe = shapeFissureParams['demiGrandAxe']
+ demiPetitAxe = shapeFissureParams['demiPetitAxe']
+ orientation = shapeFissureParams['orientation']
+
+ nomRep = maillageFissureParams['nomRep']
+ nomFicSain = maillageFissureParams['nomFicSain']
+ nomFicFissure = maillageFissureParams['nomFicFissure']
+
+ nbsegExt = maillageFissureParams['nbsegExt'] # 5
+ nbsegGen = maillageFissureParams['nbsegGen'] # 25
+ nbsegRad = maillageFissureParams['nbsegRad'] # 5
+ scaleRad = maillageFissureParams['scaleRad'] # 4
+ nbsegCercle = maillageFissureParams['nbsegCercle'] # 6
+ nbsegFis = maillageFissureParams['nbsegFis'] # 20
+ lensegEllipsoide = maillageFissureParams['lensegEllipso'] # 1.0
+
+ fichierMaillageSain = nomRep + '/' + nomFicSain + '.med'
+ fichierMaillageFissure = nomRep + '/' + nomFicFissure + '.med'
+
+ facesDefaut = elementsDefaut[0]
+ centreDefaut = elementsDefaut[1]
+ normalDefaut = elementsDefaut[2]
+ extrusionDefaut = elementsDefaut[3]
+ dmoyen = elementsDefaut[4]
+ bordsPartages = elementsDefaut[5]
+ fillconts = elementsDefaut[6]
+ idFilToCont = elementsDefaut[7]
+ maillageSain = elementsDefaut[8]
+ internalBoundary = elementsDefaut[9]
+ zoneDefaut = elementsDefaut[10]
+ zoneDefaut_skin = elementsDefaut[11]
+ zoneDefaut_internalFaces = elementsDefaut[12]
+ zoneDefaut_internalEdges = elementsDefaut[13]
+
+ ## --- ellipse incomplete : generatrice
+ #if step == 5:
+ #return None
+
+ #allonge = demiGrandAxe/demiPetitAxe
+ #rayonTore = demiPetitAxe/5.0
+ #generatrice, FaceGenFiss, Pipe_1, FaceFissure, Plane_1, Pipe1Part = self.toreFissure(demiPetitAxe, allonge, rayonTore)
+ #ellipsoide = self.ellipsoideDefaut(demiPetitAxe, allonge, rayonTore)
+
+ ## --- positionnement sur le bloc defaut de generatrice, tore et plan fissure
+ #if step == 6:
+ #return None
+
+ #pipe0 = self.rotTrans(Pipe_1, orientation, centreDefaut, normalDefaut)
+ #gener1 = self.rotTrans(generatrice, orientation, centreDefaut, normalDefaut)
+ #pipe1 = self.rotTrans(Pipe1Part, orientation, centreDefaut, normalDefaut)
+ #facefis1 = self.rotTrans(FaceFissure, orientation, centreDefaut, normalDefaut)
+ #plane1 = self.rotTrans(Plane_1, orientation, centreDefaut, normalDefaut)
+ #ellipsoide1 = self.rotTrans(ellipsoide, orientation, centreDefaut, normalDefaut)
+
+ #geompy.addToStudy( pipe0, 'pipe0' )
+ #geompy.addToStudy( gener1, 'gener1' )
+ #geompy.addToStudy( pipe1, 'pipe1' )
+ #geompy.addToStudy( facefis1, 'facefis1' )
+ #geompy.addToStudy( plane1, 'plane1' )
+ #geompy.addToStudy( ellipsoide1, 'ellipsoide1' )
+
+ # --- partition du bloc défaut par génératrice, tore et plan fissure
+ if step == 7:
+ return None
+
+ [blocPartition, blocp, tore,
+ faceFissure, facesExternes, facesExtBloc, facesExtElli,
+ aretesInternes, ellipsoidep, sharedFaces, sharedEdges, edgesBords] = \
+ partitionBlocDefaut(extrusionDefaut, facesDefaut, gener1, pipe1,
+ facefis1, ellipsoide1)
+ if not isHexa:
+ edgesBords = None # maillage sain hexa ==> filling, et maillage edges Bords imposés du maillage sain
+
+ # --- TORE
+ # --- faces toriques du tore
+ if step == 8:
+ return None
+
+ [facetore1, facetore2, volumeTore1, volumeTore2] = facesVolumesToriques(tore, plane1, facesDefaut)
+
+ # --- faces 1/2 circulaires et edges dans le plan de fissure
+ if step == 9:
+ return None
+
+ [faces, centres, edges, reverses] = facesCirculaires(extrusionDefaut, tore)
+
+ # --- recherche et classement des edges du tore par propagate
+ if step == 10:
+ return None
+
+ [diams, circles, geners] = propagateTore(tore)
+
+ # --- tri par longueur des 3 génératrices
+ if step == 11:
+ return None
+
+ [genext, genint, gencnt] = sortGeneratrices(tore, geners)
+
+ # --- faces fissure dans et hors tore, et edges face hors tore
+ if step == 12:
+ return None
+
+ [facefissintore, facefissoutore, edgeint, edgeext, reverext] = \
+ facesFissure(ellipsoidep, faceFissure, extrusionDefaut, genint)
+
+ # --- identification des faces tore et fissure dans le solide hors tore
+ if step == 13:
+ return None
+
+ [blocFaceFiss, blocFaceTore1, blocFaceTore2] = \
+ facesToreInBloc(ellipsoidep, facefissoutore, facetore1, facetore2)
+
+ # --- identification des shapes modifiées par la duplication des noeuds de la face fissure (d'un coté de la face)
+
+ #shapesAModifier = self.shapesSurFissure(blocPartition, plane1 faceFissure, gencnt)
+ if step == 14:
+ return None
+
+ extrusionFaceFissure, normfiss = shapeSurFissure(plane1)
+
+ # --- maillage du bloc partitionne
+
+ if step == 15:
+ return None
+
+ [bloc1, blocComplet] = \
+ meshBlocPart(blocPartition, faceFissure, tore, centres, edges, diams, circles, faces,
+ gencnt, facefissoutore, edgeext, facesExternes, facesExtBloc, facesExtElli,
+ aretesInternes, internalBoundary, ellipsoidep, sharedFaces, sharedEdges, edgesBords,
+ nbsegExt, nbsegGen, nbsegRad, scaleRad, reverses, reverext, nbsegCercle,
+ nbsegFis, dmoyen, lensegEllipsoide)
+
+ if step == 16:
+ return None
+ maillageSain = enleveDefaut(maillageSain, zoneDefaut, zoneDefaut_skin, zoneDefaut_internalFaces, zoneDefaut_internalEdges)
+
+ if step == 17:
+ return None
+ maillageComplet = RegroupeSainEtDefaut(maillageSain, blocComplet, extrusionFaceFissure, faceFissure, 'VOLUMES')
+
+ if step == 18:
+ return None
+ maillageComplet.ExportMED( fichierMaillageFissure, 0, SMESH.MED_V2_2, 1 )
+ putName(maillageComplet, nomFicFissure)
+ logging.info("fichier maillage fissure : %s", fichierMaillageFissure)
+
+ if salome.sg.hasDesktop():
+ salome.sg.updateObjBrowser(1)
+
+ return maillageComplet
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import logging
+import salome
+from geomsmesh import geompy
+import GEOM
+from geomsmesh import smesh
+from salome.smesh import smeshBuilder
+import SMESH
+import math
+import bisect
+
+from extractionOrientee import extractionOrientee
+from extractionOrienteeMulti import extractionOrienteeMulti
+from sortFaces import sortFaces
+from sortEdges import sortEdges
+from eliminateDoubles import eliminateDoubles
+from substractSubShapes import substractSubShapes
+from produitMixte import produitMixte
+from findWireEndVertices import findWireEndVertices
+from findWireIntermediateVertices import findWireIntermediateVertices
+from orderEdgesFromWire import orderEdgesFromWire
+from getSubshapeIds import getSubshapeIds
+from putName import putName
+from distance2 import distance2
+from enleveDefaut import enleveDefaut
+from shapeSurFissure import shapeSurFissure
+from regroupeSainEtDefaut import RegroupeSainEtDefaut
+from triedreBase import triedreBase
+from checkDecoupePartition import checkDecoupePartition
+from whichSide import whichSide
+from whichSideMulti import whichSideMulti
+from whichSideVertex import whichSideVertex
+from projettePointSurCourbe import projettePointSurCourbe
+from prolongeWire import prolongeWire
+#from getCentreFondFiss import getCentreFondFiss
+
+# -----------------------------------------------------------------------------
+# --- procédure complète fissure générale
+
+def insereFissureGenerale(maillagesSains,
+ shapesFissure, shapeFissureParams,
+ maillageFissureParams, elementsDefaut, step=-1):
+ """
+ TODO: a completer
+ """
+ logging.info('start')
+
+ shapeDefaut = shapesFissure[0] # faces de fissure, débordant
+ fondFiss = shapesFissure[4] # groupe d'edges de fond de fissure
+
+ rayonPipe = shapeFissureParams['rayonPipe']
+ if shapeFissureParams.has_key('lenSegPipe'):
+ lenSegPipe = shapeFissureParams['lenSegPipe']
+ else:
+ lenSegPipe = rayonPipe
+
+ nomRep = maillageFissureParams['nomRep']
+ nomFicSain = maillageFissureParams['nomFicSain']
+ nomFicFissure = maillageFissureParams['nomFicFissure']
+
+ nbsegRad = maillageFissureParams['nbsegRad'] # nombre de couches selon un rayon du pipe
+ nbsegCercle = maillageFissureParams['nbsegCercle'] # nombre de secteur dans un cercle du pipe
+ areteFaceFissure = maillageFissureParams['areteFaceFissure']
+
+ pointIn_x = 0.0
+ pointIn_y = 0.0
+ pointIn_z = 0.0
+ isPointInterne = False
+ if shapeFissureParams.has_key('pointIn_x'):
+ pointIn_x = shapeFissureParams['pointIn_x']
+ isPointInterne = True
+ if shapeFissureParams.has_key('pointIn_y'):
+ pointIn_y = shapeFissureParams['pointIn_y']
+ isPointInterne = True
+ if shapeFissureParams.has_key('pointIn_z'):
+ pointIn_z = shapeFissureParams['pointIn_z']
+ isPointInterne = True
+ if isPointInterne:
+ pointInterne = geompy.MakeVertex(pointIn_x, pointIn_y, pointIn_z)
+
+ #fichierMaillageSain = nomRep + '/' + nomFicSain + '.med'
+ fichierMaillageFissure = nomRep + '/' + nomFicFissure + '.med'
+
+ facesDefaut = elementsDefaut[0] # fillings des faces en peau
+ #centresDefaut = elementsDefaut[1]
+ #normalsDefaut = elementsDefaut[2]
+ #extrusionsDefaut = elementsDefaut[3]
+ dmoyen = elementsDefaut[4]
+ bordsPartages = elementsDefaut[5]
+ fillconts = elementsDefaut[6]
+ idFilToCont = elementsDefaut[7]
+ maillageSain = elementsDefaut[8]
+ internalBoundary = elementsDefaut[9]
+ zoneDefaut = elementsDefaut[10]
+ zoneDefaut_skin = elementsDefaut[11]
+ zoneDefaut_internalFaces = elementsDefaut[12]
+ zoneDefaut_internalEdges = elementsDefaut[13]
+ edgeFondExt = elementsDefaut[14]
+ centreFondFiss = elementsDefaut[15]
+ tgtCentre = elementsDefaut[16]
+
+ # --- restriction de la face de fissure au domaine solide :
+ # partition face fissure étendue par fillings, on garde la plus grande face
+
+ partShapeDefaut = geompy.MakePartition([shapeDefaut], facesDefaut, [], [], geompy.ShapeType["FACE"], 0, [], 0)
+ geompy.addToStudy(partShapeDefaut, 'partShapeDefaut')
+ facesPartShapeDefaut = geompy.ExtractShapes(partShapeDefaut, geompy.ShapeType["FACE"], False)
+ if isPointInterne:
+ distfaces = [(geompy.MinDistance(face,pointInterne), i, face) for i, face in enumerate(facesPartShapeDefaut)]
+ distfaces.sort()
+ logging.debug("selection de la face la plus proche du point interne, distance=%s",distfaces[0][0])
+ facesPortFissure = distfaces[0][2]
+ else:
+ facesPartShapeDefautSorted, minSurf, maxSurf = sortFaces(facesPartShapeDefaut) # la face de fissure dans le volume doit être la plus grande
+ logging.debug("surfaces faces fissure étendue, min %s, max %s", minSurf, maxSurf)
+ facesPortFissure = facesPartShapeDefautSorted[-1]
+
+ geompy.addToStudy(facesPortFissure, "facesPortFissure")
+
+ O, OX, OY, OZ = triedreBase()
+
+ # -----------------------------------------------------------------------------
+ # --- pipe de fond de fissure, prolongé, partition face fissure par pipe
+ # identification des edges communes pipe et face fissure
+
+ if geompy.NumberOfFaces(shapeDefaut) == 1:
+ plan = geompy.MakePlane(centreFondFiss, tgtCentre, 10000)
+ shapeDefaut = geompy.MakePartition([shapeDefaut], [plan], [], [], geompy.ShapeType["FACE"], 0, [], 0)
+ fondFissCoupe = geompy.GetInPlaceByHistory(shapeDefaut, fondFiss)
+ geompy.addToStudy(shapeDefaut, 'shapeDefaut_coupe')
+ geompy.addToStudyInFather(shapeDefaut, fondFissCoupe, 'fondFiss_coupe')
+
+ extrem, norms = findWireEndVertices(fondFiss, True)
+ logging.debug("extrem: %s, norm: %s",extrem, norms)
+ cercle = geompy.MakeCircle(extrem[0], norms[0], rayonPipe)
+ cercle = geompy.MakeRotation(cercle, norms[0], math.pi/3.0 ) # éviter d'avoir l'arête de couture du pipe presque confondue avec la face fissure
+ geompy.addToStudy(cercle, 'cercle')
+ fondFissProlonge = prolongeWire(fondFiss, extrem, norms, 2*rayonPipe)
+ pipeFiss = geompy.MakePipe(cercle, fondFissProlonge)
+ geompy.addToStudy(pipeFiss, 'pipeFiss')
+ partFissPipe = geompy.MakePartition([shapeDefaut, pipeFiss], [], [], [], geompy.ShapeType["FACE"], 0, [], 1)
+ geompy.addToStudy(partFissPipe, 'partFissPipe')
+ fissPipe = geompy.GetInPlaceByHistory(partFissPipe, shapeDefaut)
+ geompy.addToStudy(fissPipe, 'fissPipe')
+ partPipe = geompy.GetInPlaceByHistory(partFissPipe, pipeFiss)
+ geompy.addToStudy(partPipe, 'partPipe')
+
+ edgesPipeFiss = geompy.GetSharedShapesMulti([fissPipe, partPipe], geompy.ShapeType["EDGE"])
+ for i, edge in enumerate(edgesPipeFiss):
+ name = "edgePipe%d"%i
+ geompy.addToStudyInFather(fissPipe, edge, name)
+ try:
+ wirePipeFiss = geompy.MakeWire(edgesPipeFiss)
+ except:
+ wirePipeFiss = geompy.MakeCompound(edgesPipeFiss)
+ logging.debug("wirePipeFiss construit sous forme de compound")
+ geompy.addToStudy(wirePipeFiss, "wirePipeFiss")
+
+ wireFondFiss = geompy.GetInPlace(partFissPipe,fondFiss)
+ edgesFondFiss = geompy.GetSharedShapesMulti([fissPipe, wireFondFiss], geompy.ShapeType["EDGE"])
+ for i, edge in enumerate(edgesFondFiss):
+ name = "edgeFondFiss%d"%i
+ geompy.addToStudyInFather(fissPipe, edge, name)
+ wireFondFiss = geompy.MakeWire(edgesFondFiss)
+ geompy.addToStudy(wireFondFiss,"wireFondFiss")
+
+ # -----------------------------------------------------------------------------
+ # --- peau et face de fissure
+ #
+ # --- partition peau défaut - face de fissure prolongée - wire de fond de fissure prolongée
+ # il peut y avoir plusieurs faces externes, dont certaines sont découpées par la fissure
+ # liste de faces externes : facesDefaut
+ # liste de partitions face externe - fissure : partitionPeauFissFond (None quand pas d'intersection)
+
+ partitionsPeauFissFond = []
+ ipart = 0
+ for filling in facesDefaut:
+ part = geompy.MakePartition([fissPipe, filling], [], [], [], geompy.ShapeType["FACE"], 0, [], 0)
+ isPart = checkDecoupePartition([fissPipe, filling], part)
+ if isPart: # on recrée la partition avec toutes les faces filling en outil pour avoir une face de fissure correcte
+ otherFD = [fd for fd in facesDefaut if fd != filling]
+ if len(otherFD) > 0:
+ fissPipePart = geompy.MakePartition([fissPipe], otherFD, [], [], geompy.ShapeType["FACE"], 0, [], 0)
+ else:
+ fissPipePart = fissPipe
+ part = geompy.MakePartition([fissPipePart, filling], [], [], [], geompy.ShapeType["FACE"], 0, [], 0)
+ partitionsPeauFissFond.append(part)
+ geompy.addToStudy( part, 'partitionPeauFissFond%d'%ipart )
+ else:
+ partitionsPeauFissFond.append(None)
+ ipart = ipart +1
+
+ # --- arêtes vives détectées (dans quadranglesToShape)
+
+ aretesVives = []
+ aretesVivesCoupees = []
+ ia = 0
+ for a in bordsPartages:
+ if a[0] is not None:
+ aretesVives.append(a[0])
+ name = "areteVive%d"%ia
+ geompy.addToStudy(a[0], name)
+ ia += 1
+ aretesVivesC = None
+ if len(aretesVives) > 0:
+ aretesVivesC =geompy.MakeCompound(aretesVives)
+
+ # -------------------------------------------------------
+ # --- inventaire des faces de peau coupées par la fissure
+ # pour chaque face de peau : 0, 1 ou 2 faces débouchante du fond de fissure
+ # 0, 1 ou plus edges de la face de fissure externe au pipe
+
+ nbFacesFilling = len(partitionsPeauFissFond)
+ ptEdgeFond = [ [] for i in range(nbFacesFilling)] # pour chaque face [points edge fond de fissure aux débouchés du pipe]
+ fsPipePeau = [ [] for i in range(nbFacesFilling)] # pour chaque face [faces du pipe débouchantes]
+ edRadFPiPo = [ [] for i in range(nbFacesFilling)] # pour chaque face [edge radiale des faces du pipe débouchantes ]
+ fsFissuExt = [ [] for i in range(nbFacesFilling)] # pour chaque face [faces de fissure externes au pipe]
+ edFisExtPe = [ [] for i in range(nbFacesFilling)] # pour chaque face [edge en peau des faces de fissure externes (pas subshape facePeau)]
+ edFisExtPi = [ [] for i in range(nbFacesFilling)] # pour chaque face [edge commun au pipe des faces de fissure externes]
+ facesPeaux = [None for i in range(nbFacesFilling)] # pour chaque face : la face de peau finale a mailler (percée des faces débouchantes)
+ edCircPeau = [ [] for i in range(nbFacesFilling)] # pour chaque face de peau : [subshape edge circulaire aux débouchés du pipe]
+ ptCircPeau = [ [] for i in range(nbFacesFilling)] # pour chaque face de peau : [subshape point sur edge circulaire aux débouchés du pipe]
+ gpedgeBord = [None for i in range(nbFacesFilling)] # pour chaque face de peau : groupe subshape des edges aux bords liés à la partie saine
+ gpedgeVifs = [None for i in range(nbFacesFilling)] # pour chaque face de peau : groupes subshape des edges aux arêtes vives entre fillings
+ edFissPeau = [ [] for i in range(nbFacesFilling)] # pour chaque face de peau : [subshape edge en peau des faces de fissure externes]
+ ptFisExtPi = [ [] for i in range(nbFacesFilling)] # pour chaque face de peau : [point commun edFissPeau edCircPeau]
+
+ for ifil, partitionPeauFissFond in enumerate(partitionsPeauFissFond):
+ fillingFaceExterne = facesDefaut[ifil]
+ fillingSansDecoupe = fillconts[idFilToCont[ifil]]
+ if partitionPeauFissFond is not None:
+ logging.debug("traitement partitionPeauFissFond %s", ifil)
+ # -----------------------------------------------------------------------
+ # --- identification edges fond de fissure, edges pipe sur la face de fissure,
+ # edges prolongées
+
+ edgesPipeC = geompy.GetInPlace(partitionPeauFissFond, geompy.MakeCompound(edgesPipeFiss))
+ geompy.addToStudyInFather(partitionPeauFissFond, edgesPipeC, "edgesPipeFiss")
+ edgesFondC = geompy.GetInPlace(partitionPeauFissFond, geompy.MakeCompound(edgesFondFiss))
+ geompy.addToStudyInFather(partitionPeauFissFond, edgesFondC, "edgesFondFiss")
+
+ if aretesVivesC is None:
+ [edgesInside, edgesOutside, edgesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "EDGE", 1.e-3)
+ [facesInside, facesOutside, facesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "FACE", 1.e-3)
+ else:
+ [edgesInside, edgesOutside, edgesOnside] = extractionOrienteeMulti(facesDefaut, ifil, partitionPeauFissFond, centreFondFiss, "EDGE", 1.e-3)
+ [facesInside, facesOutside, facesOnside] = extractionOrienteeMulti(facesDefaut, ifil, partitionPeauFissFond, centreFondFiss, "FACE", 1.e-3)
+
+ edgesPipeIn = geompy.GetSharedShapesMulti([edgesPipeC, geompy.MakeCompound(edgesInside)], geompy.ShapeType["EDGE"])
+ verticesPipePeau = []
+
+ for i, edge in enumerate(edgesPipeIn):
+ try:
+ vertices = geompy.GetSharedShapesMulti([edge, geompy.MakeCompound(facesOnside)], geompy.ShapeType["VERTEX"])
+ verticesPipePeau.append(vertices[0])
+ name = "edgePipeIn%d"%i
+ geompy.addToStudyInFather(partitionPeauFissFond, edge, name)
+ name = "verticePipePeau%d"%i
+ geompy.addToStudyInFather(partitionPeauFissFond, vertices[0], name)
+ logging.debug("edgePipeIn%s coupe les faces OnSide", i)
+ except:
+ logging.debug("edgePipeIn%s ne coupe pas les faces OnSide", i)
+ edgesFondOut = []
+ edgesFondIn =[]
+ if len(verticesPipePeau) > 0: # au moins une extrémité du pipe sur cette face de peau
+ tmp = geompy.GetSharedShapesMulti([edgesFondC, geompy.MakeCompound(edgesOutside)], geompy.ShapeType["EDGE"])
+ edgesFondOut = [ ed for ed in tmp if geompy.MinDistance(ed, geompy.MakeCompound(facesOnside)) < 1.e-3]
+ tmp = geompy.GetSharedShapesMulti([edgesFondC, geompy.MakeCompound(edgesInside)], geompy.ShapeType["EDGE"])
+ edgesFondIn = [ ed for ed in tmp if geompy.MinDistance(ed, geompy.MakeCompound(facesOnside)) < 1.e-3]
+ verticesEdgesFondIn = [] # les points du fond de fissure au débouché du pipe sur la peau (indice de edgesFondIn)
+ pipexts = [] # les segments de pipe associés au points de fond de fissure débouchants (même indice)
+ cercles = [] # les cercles de generation des pipes débouchant (même indice)
+ facesFissExt = [] # les faces de la fissure externe associés au points de fond de fissure débouchants (même indice)
+ edgesFissExtPeau = [] # edges des faces de fissure externe sur la peau (même indice)
+ edgesFissExtPipe = [] # edges des faces de fissure externe sur le pipe (même indice)
+ #logging.debug("edgesFondIn %s", edgesFondIn)
+
+ edgesFondFiss, edgesIdByOrientation = orderEdgesFromWire(wireFondFiss)
+ for i,edge in enumerate(edgesFondFiss):
+ geompy.addToStudyInFather(wireFondFiss, edge, "edgeFondFiss%d"%i)
+
+ for iedf, edge in enumerate(edgesFondIn):
+ name = "edgeFondIn%d"%iedf
+ geompy.addToStudyInFather(partitionPeauFissFond, edge, name)
+ dist = [ geompy.MinDistance(pt, edge) for pt in verticesPipePeau]
+ ptPeau = verticesPipePeau[dist.index(min(dist))] # le point de verticesPipePeau a distance minimale de l'edge
+ [u, PointOnEdge, EdgeInWireIndex] = geompy.MakeProjectionOnWire(ptPeau, wireFondFiss)
+ logging.debug("u:%s, EdgeInWireIndex: %s, len(edgesFondFiss): %s", u, EdgeInWireIndex, len(edgesFondFiss))
+ localEdgeInFondFiss = edgesFondFiss[EdgeInWireIndex]
+ centre = PointOnEdge
+ centre2 = geompy.MakeVertexOnCurve(localEdgeInFondFiss, u)
+ geompy.addToStudyInFather(partitionPeauFissFond, centre2, "centre2_%d"%iedf)
+ verticesEdgesFondIn.append(centre)
+ name = "verticeEdgesFondIn%d"%iedf
+ geompy.addToStudyInFather(partitionPeauFissFond, centre, name)
+ norm = geompy.MakeTangentOnCurve(localEdgeInFondFiss, u)
+ geompy.addToStudyInFather(partitionPeauFissFond, centre, "norm%d"%iedf)
+ cercle = geompy.MakeCircle(centre, norm, rayonPipe)
+ geompy.addToStudyInFather(partitionPeauFissFond, cercle, "cerclorig%d"%iedf)
+ [vertex] = geompy.ExtractShapes(cercle, geompy.ShapeType["VERTEX"], False)
+ vec1 = geompy.MakeVector(centre, vertex)
+ vec2 = geompy.MakeVector(centre, ptPeau)
+ angle = geompy.GetAngleRadians(vec1, vec2)
+ # cas général : on reconstitue une portion de pipe, avec l'arête de couture qui coincide
+ # avec la face de fissure, au niveau du débouché sur la face externe
+ # cas dégénéré : le pipe débouche perpendiculairement à une surface plane à l'origine.
+ # La partition filling / pipe reconstruit échoue.
+ # - Si on partitionne le filling avec un simple pipe obtenu par extrusion droite du cercle,
+ # cela donne un point en trop sur le cercle.
+ # - Si on prend une vraie surface plane (pas un filling), on peut faire la partition avec
+ # les pipes reconstruits
+ logging.debug("angle=%s", angle)
+ #if abs(angle) > 1.e-7:
+ sommetAxe = geompy.MakeTranslationVector(centre, norm)
+ pm = produitMixte(centre, vertex, ptPeau, sommetAxe)
+ if pm > 0: # ajout de pi a (-)angle pour éviter des points confondus (partition échoue) dans les cas dégénérés
+ cercle = geompy.MakeRotation(cercle, norm, angle + math.pi)
+ else:
+ cercle = geompy.MakeRotation(cercle, norm, -angle + math.pi)
+ name = "cercle%d"%iedf
+ geompy.addToStudyInFather(partitionPeauFissFond, cercle, name)
+ cercles.append(cercle)
+
+ # --- estimation de la longueur du pipe necessaire de part et d'autre du point de sortie
+ if aretesVivesC is None:
+ faceTestPeau = fillingFaceExterne
+ else:
+ faceTestPeau = facesDefaut[ifil]
+ sideCentre = whichSide(faceTestPeau, centre)
+ locPt0 = geompy.MakeVertexOnCurve(localEdgeInFondFiss, 0.0)
+ locPt1 = geompy.MakeVertexOnCurve(localEdgeInFondFiss, 1.0)
+ sidePt0 = whichSide(faceTestPeau, locPt0)
+ sidePt1 = whichSide(faceTestPeau, locPt1)
+ logging.debug("position centre cercle: %s, extremité edge u0: %s, u1: %s", sideCentre, sidePt0, sidePt1)
+ normFace = geompy.GetNormal(faceTestPeau, ptPeau)
+ inclPipe = abs(geompy.GetAngleRadians(norm, normFace))
+ lgp = max(rayonPipe/2., abs(3*rayonPipe*math.tan(inclPipe)))
+ logging.debug("angle inclinaison Pipe en sortie: %s degres, lgp: %s", inclPipe*180/math.pi, lgp)
+
+ # --- position des points extremite du pipe sur l'edge debouchante
+ # il faut la distance curviligne ofp du point central par rapport à une extrémité de l'edge débouchante
+ locEdgePart = geompy.MakePartition([localEdgeInFondFiss],[centre], [], [], geompy.ShapeType["EDGE"], 0, [], 0)
+ edgesLoc = geompy.ExtractShapes(locEdgePart, geompy.ShapeType["EDGE"], False)
+ edgesLocSorted =[(geompy.MinDistance(edge, locPt0), kk, edge) for kk, edge in enumerate(edgesLoc)]
+ edgesLocSorted.sort()
+ ofp = geompy.BasicProperties(edgesLocSorted[0][2])[0] # distance curviligne centre locPt0
+ logging.debug("distance curviligne centre extremite0: %s", ofp)
+ p1 = geompy.MakeVertexOnCurveByLength(localEdgeInFondFiss, ofp +lgp, locPt0)
+ p2 = geompy.MakeVertexOnCurveByLength(localEdgeInFondFiss, ofp -lgp, locPt0)
+ geompy.addToStudyInFather(wireFondFiss, p1, "p1_%d"%iedf)
+ geompy.addToStudyInFather(wireFondFiss, p2, "p2_%d"%iedf)
+
+ edgePart = geompy.MakePartition([localEdgeInFondFiss], [p1,p2], [], [], geompy.ShapeType["EDGE"], 0, [], 0)
+ edps = geompy.ExtractShapes(edgePart, geompy.ShapeType["EDGE"], True)
+ for edp in edps:
+ if geompy.MinDistance(centre, edp) < 1.e-3:
+ pipext = geompy.MakePipe(cercle, edp)
+ name = "pipeExt%d"%iedf
+ geompy.addToStudyInFather(partitionPeauFissFond, pipext, name)
+ pipexts.append(pipext)
+
+ for face in facesInside:
+ logging.debug("recherche edges communes entre une face inside et (faces onside, edges pipe et fond débouchante)")
+ edgesPeauFis = []
+ edgesPipeFis = []
+ edgesPipeFnd = []
+ try:
+ edgesPeauFis = geompy.GetSharedShapesMulti([geompy.MakeCompound(facesOnside), face], geompy.ShapeType["EDGE"])
+ logging.debug(" faces onside %s",edgesPeauFis)
+ edgesPipeFis = geompy.GetSharedShapesMulti([geompy.MakeCompound(edgesPipeIn), face], geompy.ShapeType["EDGE"])
+ logging.debug(" edgesPipeIn %s", edgesPipeFis)
+ edgesPipeFnd = geompy.GetSharedShapesMulti([geompy.MakeCompound(edgesFondIn), face], geompy.ShapeType["EDGE"])
+ logging.debug(" edgesFondIn %s ", edgesPipeFnd)
+ except:
+ logging.debug(" pb edges communes %s %s %s",edgesPeauFis, edgesPipeFis, edgesPipeFnd)
+ pass
+ if (len(edgesPeauFis) > 0) and (len(edgesPipeFis) > 0) and (len(edgesPipeFnd) == 0):
+ dist = geompy.MinDistance(geompy.MakeCompound(edgesPeauFis), ptPeau)
+ logging.debug(" test distance extrémité reference %s", dist)
+ if dist < 1.e-3: # c'est la face de fissure externe associée
+ logging.debug(" face %s inside ajoutée", i)
+ facesFissExt.append(face)
+ name="faceFissExt%d"%iedf
+ geompy.addToStudyInFather(partitionPeauFissFond, face, name)
+ dist = 1.
+ for ipe, edpe in enumerate(edgesPeauFis):
+ for ipi, edpi in enumerate(edgesPipeFis):
+ dist = geompy.MinDistance(edpe, edpi)
+ if dist < 1.e-3:
+ edgesFissExtPeau.append(edpe)
+ name="edgesFissExtPeau%d"%iedf
+ geompy.addToStudyInFather(partitionPeauFissFond, edpe, name)
+ edgesFissExtPipe.append(edpi)
+ name="edgesFissExtPipe%d"%iedf
+ geompy.addToStudyInFather(partitionPeauFissFond, edpi, name)
+ break
+ if dist < 1.e-3:
+ break
+
+ if len(verticesPipePeau) == 0: # aucune extrémité du pipe sur cette face de peau
+ # il faut recenser les edges de fissure sur la face de peau
+ j = 0
+ for face in facesInside:
+ edgesPeauFis = []
+ edgesPipeFis = []
+ edgesPipeFnd = []
+ try:
+ edgesPeauFis = geompy.GetSharedShapesMulti([geompy.MakeCompound(facesOnside), face], geompy.ShapeType["EDGE"])
+ edgesPipeFis = geompy.GetSharedShapesMulti([geompy.MakeCompound(edgesPipeIn), face], geompy.ShapeType["EDGE"])
+ edgesPipeFnd = geompy.GetSharedShapesMulti([geompy.MakeCompound(edgesFondIn), face], geompy.ShapeType["EDGE"])
+ except:
+ pass
+ if (len(edgesPeauFis) > 0) and (len(edgesPipeFis) > 0) and (len(edgesPipeFnd) == 0):
+ edgesFissExtPeau.append(edgesPeauFis[0])
+ name="edgesFissExtPeau%d"%j
+ geompy.addToStudyInFather(partitionPeauFissFond, edgesPeauFis[0], name)
+ j += 1
+
+ # -----------------------------------------------------------------------
+ # --- identification faces de peau : face de peau percée du pipe, extrémités du pipe
+ # La partition avec le pipe peut créer un vertex (et un edge) de trop sur le cercle projeté,
+ # quand le cercle est très proche de la face.
+ # dans ce cas, la projection du cercle sur la face suivie d'une partition permet
+ # d'éviter le point en trop
+
+ facesAndFond = facesOnside
+ facesAndFond.append(wireFondFiss)
+ try:
+ partitionPeauByPipe = geompy.MakePartition(facesAndFond, pipexts, [], [], geompy.ShapeType["FACE"], 0, [], 1)
+ except:
+ logging.debug("probleme partition face pipe, contournement avec MakeSection")
+ sections = []
+ for pipext in pipexts:
+ sections.append(geompy.MakeSection(facesOnside[0], pipext))
+ partitionPeauByPipe = geompy.MakePartition(facesAndFond, sections, [], [], geompy.ShapeType["FACE"], 0, [], 1)
+
+ # contrôle edge en trop sur edges circulaires
+ if len(verticesPipePeau) > 0: # --- au moins une extrémité du pipe sur cette face de peau
+ edgeEnTrop = []
+ outilPart = pipexts
+ facesPeau = geompy.ExtractShapes(partitionPeauByPipe, geompy.ShapeType["FACE"], False)
+ facesPeauSorted, minsur, maxsurf = sortFaces(facesPeau)
+ for i, face in enumerate(facesPeauSorted[:-1]): # on ne teste que la ou les petites faces "circulaires"
+ nbv = geompy.NumberOfEdges(face)
+ logging.debug("nombre d'edges sur face circulaire: %s", nbv)
+ if nbv > 3:
+ edgeEnTrop.append(True) # TODO : distinguer les cas avec deux faces circulaires dont l'une est correcte
+ else:
+ edgeEnTrop.append(False)
+ refaire = sum(edgeEnTrop)
+ if refaire > 0:
+ dc = [(geompy.MinDistance(verticesEdgesFondIn[0], fac), i) for i, fac in enumerate(facesPeauSorted[:-1])]
+ dc.sort()
+ logging.debug("dc sorted: %s", dc)
+ i0 = dc[0][1] # indice de facesPeauSorted qui correspond à verticesEdgesFondIn[0], donc 0 pour cercles
+ direct = (i0 == 0)
+ for i, bad in enumerate(edgeEnTrop):
+ if direct:
+ j = i
+ else:
+ j = 1-i
+ if bad:
+ outilPart[j] = geompy.MakeProjection(cercles[j],facesOnside[0])
+ pass
+ partitionPeauByPipe = geompy.MakePartition(facesAndFond, outilPart, [], [], geompy.ShapeType["FACE"], 0, [], 1)
+ pass
+
+ name="partitionPeauByPipe%d"%ifil
+ geompy.addToStudy(partitionPeauByPipe, name)
+ [edgesPeauFondIn, edgesPeauFondOut, edgesPeauFondOn] = extractionOrientee(fillingFaceExterne, partitionPeauByPipe, centreFondFiss, "EDGE", 1.e-3)
+ [facesPeauFondIn, facesPeauFondOut, facesPeauFondOn] = extractionOrientee(fillingFaceExterne, partitionPeauByPipe, centreFondFiss, "FACE", 1.e-3)
+
+ if len(verticesPipePeau) > 0: # --- au moins une extrémité du pipe sur cette face de peau
+ facesPeauSorted, minsur, maxsurf = sortFaces(facesPeauFondOn)
+ facePeau = facesPeauSorted[-1] # la plus grande face
+ else:
+ facePeau =geompy.MakePartition(facesPeauFondOn, [], [], [], geompy.ShapeType["FACE"], 0, [], 1)
+ name="facePeau%d"%ifil
+ geompy.addToStudy(facePeau, name)
+
+ facesPipePeau = [None for i in range(len(edgesFissExtPipe))]
+ endsEdgeFond = [None for i in range(len(edgesFissExtPipe))]
+ edgeRadFacePipePeau = [None for i in range(len(edgesFissExtPipe))]
+
+ edgesListees = []
+ edgesCircPeau = []
+ verticesCircPeau = []
+ if len(verticesPipePeau) > 0: # --- au moins une extrémité du pipe sur cette face de peau
+
+ for face in facesPeauSorted[:-1]: # la ou les faces débouchantes, pas la grande face de peau
+ logging.debug("examen face debouchante circulaire")
+ for i,efep in enumerate(edgesFissExtPipe):
+ dist = geompy.MinDistance(face, efep)
+ logging.debug(" distance face circulaire edge %s", dist)
+ if dist < 1e-3:
+ for ik, edpfi in enumerate(edgesPeauFondIn):
+ if geompy.MinDistance(face, edpfi) < 1e-3:
+ break
+ sharedVertices = geompy.GetSharedShapesMulti([face, edgesPeauFondIn[ik]], geompy.ShapeType["VERTEX"])
+ nameFace = "facePipePeau%d"%i
+ nameVert = "endEdgeFond%d"%i
+ nameEdge = "edgeRadFacePipePeau%d"%i
+ facesPipePeau[i] = face
+ endsEdgeFond[i] = sharedVertices[0]
+ geompy.addToStudy(face, nameFace)
+ geompy.addToStudy(sharedVertices[0], nameVert)
+ edgesFace = geompy.ExtractShapes(face, geompy.ShapeType["EDGE"], True)
+ for edge in edgesFace:
+ if geompy.MinDistance(edge, sharedVertices[0]) < 1e-3:
+ edgeRadFacePipePeau[i] = edge
+ geompy.addToStudy(edge, nameEdge)
+ break
+ pass
+ pass
+ pass
+ pass
+
+ # --- edges circulaires de la face de peau et points de jonction de la face externe de fissure
+ logging.debug("facesPipePeau: %s", facesPipePeau)
+ edgesCircPeau = [None for i in range(len(facesPipePeau))]
+ verticesCircPeau = [None for i in range(len(facesPipePeau))]
+ for i,fcirc in enumerate(facesPipePeau):
+ edges = geompy.GetSharedShapesMulti([facePeau, fcirc], geompy.ShapeType["EDGE"])
+ grpEdgesCirc = geompy.CreateGroup(facePeau, geompy.ShapeType["EDGE"])
+ geompy.UnionList(grpEdgesCirc, edges)
+ edgesCircPeau[i] = grpEdgesCirc
+ name = "edgeCirc%d"%i
+ geompy.addToStudyInFather(facePeau, grpEdgesCirc, name)
+ edgesListees = edgesListees + edges
+ vertices = geompy.GetSharedShapesMulti([facePeau, fcirc], geompy.ShapeType["VERTEX"])
+ grpVertCircPeau = geompy.CreateGroup(facePeau, geompy.ShapeType["VERTEX"])
+ geompy.UnionList(grpVertCircPeau, vertices)
+ verticesCircPeau[i] = grpVertCircPeau
+ name = "pointEdgeCirc%d"%i
+ geompy.addToStudyInFather(facePeau, grpVertCircPeau, name)
+ pass
+ pass # --- au moins une extrémité du pipe sur cette face de peau
+
+ # --- edges de bord de la face de peau
+
+ edgesFilling = geompy.ExtractShapes(fillingFaceExterne, geompy.ShapeType["EDGE"], False)
+ edgesBords = []
+ for i, edge in enumerate(edgesFilling):
+ edgepeau = geompy.GetInPlace(facePeau, edge)
+ name = "edgepeau%d"%i
+ geompy.addToStudyInFather(facePeau,edgepeau, name)
+ logging.debug("edgepeau %s", geompy.ShapeInfo(edgepeau))
+ if geompy.ShapeInfo(edgepeau)['EDGE'] > 1:
+ logging.debug(" EDGES multiples")
+ edgs = geompy.ExtractShapes(edgepeau, geompy.ShapeType["EDGE"], False)
+ edgesBords += edgs
+ edgesListees += edgs
+ else:
+ logging.debug(" EDGE")
+ edgesBords.append(edgepeau)
+ edgesListees.append(edgepeau)
+ groupEdgesBordPeau = geompy.CreateGroup(facePeau, geompy.ShapeType["EDGE"])
+ geompy.UnionList(groupEdgesBordPeau, edgesBords)
+ bordsVifs = None
+ if aretesVivesC is not None:
+ bordsVifs = geompy.GetInPlace(facePeau, aretesVivesC)
+ if bordsVifs is not None:
+ geompy.addToStudyInFather(facePeau, bordsVifs, "bordsVifs")
+ groupEdgesBordPeau = geompy.CutGroups(groupEdgesBordPeau, bordsVifs)
+ grptmp = None
+ if len(aretesVivesCoupees) > 0:
+ grpC = geompy.MakeCompound(aretesVivesCoupees)
+ grptmp = geompy.GetInPlace(facePeau, grpC)
+ if grptmp is not None:
+ grpnew = geompy.CutGroups(bordsVifs, grptmp) # ce qui est nouveau dans bordsVifs
+ else:
+ grpnew = bordsVifs
+ if grpnew is not None:
+ edv = geompy.ExtractShapes(grpnew, geompy.ShapeType["EDGE"], False)
+ aretesVivesCoupees += edv
+ logging.debug("aretesVivesCoupees %s",aretesVivesCoupees)
+ geompy.addToStudyInFather(facePeau, groupEdgesBordPeau , "EdgesBords")
+
+ # --- edges de la face de peau partagées avec la face de fissure
+
+ edgesPeau = geompy.ExtractShapes(facePeau, geompy.ShapeType["EDGE"], False)
+ edges = substractSubShapes(facePeau, edgesPeau, edgesListees)
+ edgesFissurePeau = []
+ if len(verticesPipePeau) > 0: # --- au moins une extrémité du pipe sur cette face de peau
+ edgesFissurePeau = [None for i in range(len(verticesCircPeau))] # edges associés aux extrémités du pipe, en premier
+ for edge in edges:
+ for i, grpVert in enumerate(verticesCircPeau):
+ if (geompy.MinDistance(grpVert, edge) < 1.e-3) and (edge not in edgesFissurePeau):
+ edgesFissurePeau[i] = edge
+ name = "edgeFissurePeau%d"%i
+ geompy.addToStudyInFather(facePeau, edge, name)
+ for edge in edges: # on ajoute après les edges manquantes
+ if edge not in edgesFissurePeau:
+ edgesFissurePeau.append(edge)
+ else:
+ for i, edge in enumerate(edges):
+ edgesFissurePeau.append(edge)
+ name = "edgeFissurePeau%d"%i
+ geompy.addToStudyInFather(facePeau, edge, name)
+
+
+ ptEdgeFond[ifil] = endsEdgeFond # pour chaque face [points edge fond de fissure aux débouchés du pipe]
+ fsPipePeau[ifil] = facesPipePeau # pour chaque face [faces du pipe débouchantes]
+ edRadFPiPo[ifil] = edgeRadFacePipePeau # pour chaque face [edge radiale des faces du pipe débouchantes ]
+ fsFissuExt[ifil] = facesFissExt # pour chaque face [faces de fissure externes au pipe]
+ edFisExtPe[ifil] = edgesFissExtPeau # pour chaque face [edge en peau des faces de fissure externes (pas subshape facePeau)]
+ edFisExtPi[ifil] = edgesFissExtPipe # pour chaque face [edge commun au pipe des faces de fissure externes]
+ facesPeaux[ifil] = facePeau # pour chaque face : la face de peau finale a mailler (percee des faces débouchantes)
+ edCircPeau[ifil] = edgesCircPeau # pour chaque face de peau : [groupe subshapes edges circulaires aux débouchés du pipe]
+ ptCircPeau[ifil] = verticesCircPeau # pour chaque face de peau : [groupe subshapes points sur edges circulaires aux débouchés du pipe]
+ gpedgeBord[ifil] = groupEdgesBordPeau # pour chaque face de peau : groupe subshape des edges aux bords liés à la partie saine
+ gpedgeVifs[ifil] = bordsVifs # pour chaque face de peau : groupe subshape des edges aux bords correspondant à des arêtes vives
+ edFissPeau[ifil] = edgesFissurePeau # pour chaque face de peau : [subshape edge en peau des faces de fissure externes]
+ ptFisExtPi[ifil] = verticesPipePeau # pour chaque face de peau : [point commun edFissPeau edCircPeau]
+
+ # -----------------------------------------------------------------------
+ # fin de la boucle sur les faces de filling
+ # -----------------------------------------------------------------------
+
+ for i, avc in enumerate(aretesVivesCoupees):
+ name = "areteViveCoupee%d"%i
+ geompy.addToStudy(avc, name)
+
+ # --- identification des faces et edges de fissure externe pour maillage
+
+ facesFissExt = []
+ edgesFissExtPeau = []
+ edgesFissExtPipe = []
+ for ifil in range(nbFacesFilling): # TODO: éliminer les doublons (comparer tous les vertices triés, avec mesure de distance ?)
+ facesFissExt += fsFissuExt[ifil]
+ edgesFissExtPeau += edFisExtPe[ifil]
+ edgesFissExtPipe += edFisExtPi[ifil]
+ logging.debug("---------------------------- identification faces de fissure externes au pipe :%s ", len(facesFissExt))
+ # regroupement des faces de fissure externes au pipe.
+
+ if len(facesFissExt) > 1:
+ faceFissureExterne = geompy.MakePartition(facesFissExt, [], [], [], geompy.ShapeType["FACE"], 0, [], 0)
+ edgesPipeFissureExterneC = geompy.GetInPlace(faceFissureExterne, geompy.MakeCompound(edgesPipeFiss)) # edgesFissExtPipe peut ne pas couvrir toute la longueur
+ # edgesPeauFissureExterneC = geompy.GetInPlace(faceFissureExterne, geompy.MakeCompound(edgesFissExtPeau))
+ # il peut manquer des edges de faceFissureExterne en contact avec la peau dans edgesFissExtPeau
+ (isDone, closedFreeBoundaries, openFreeBoundaries) = geompy.GetFreeBoundary(faceFissureExterne)
+ edgesBordFFE = []
+ for bound in closedFreeBoundaries:
+ edgesBordFFE += geompy.ExtractShapes(bound, geompy.ShapeType["EDGE"], False)
+ edgesBordFFEid = [ (ed,geompy.GetSubShapeID(faceFissureExterne, ed)) for ed in edgesBordFFE]
+ logging.debug("edgesBordFFEid %s", edgesBordFFEid)
+ edgesPPE = geompy.ExtractShapes(edgesPipeFissureExterneC, geompy.ShapeType["EDGE"], False)
+ edgesPPEid = [ geompy.GetSubShapeID(faceFissureExterne, ed) for ed in edgesPPE]
+ logging.debug("edgesPPEid %s", edgesPPEid)
+ edgesPFE = [ edid[0] for edid in edgesBordFFEid if edid[1] not in edgesPPEid] # on garde toutes les edges de bord non en contact avec le pipe
+ logging.debug("edgesPFE %s", edgesPFE)
+ edgesPeauFissureExterneC = geompy.MakeCompound(edgesPFE)
+ else:
+ faceFissureExterne = facesFissExt[0]
+ edgesPeauFissureExterneC = geompy.MakeCompound(edgesFissExtPeau)
+ edgesPipeFissureExterneC = geompy.MakeCompound(edgesFissExtPipe)
+ wirePipeFissureExterne = geompy.MakeWire(geompy.ExtractShapes(edgesPipeFissureExterneC, geompy.ShapeType["EDGE"], False))
+ geompy.addToStudy(faceFissureExterne, "faceFissureExterne")
+ geompy.addToStudyInFather(faceFissureExterne, edgesPeauFissureExterneC, "edgesPeauFissureExterne")
+ geompy.addToStudyInFather(faceFissureExterne, edgesPipeFissureExterneC, "edgesPipeFissureExterne")
+
+ logging.debug("---------------------------- Preparation Maillage du Pipe --------------")
+ # -----------------------------------------------------------------------
+ # --- preparation maillage du pipe :
+ # - détections des points a respecter : jonction des edges/faces constituant
+ # la face de fissure externe au pipe
+ # - points sur les edges de fond de fissure et edges pipe/face fissure,
+ # - vecteurs tangents au fond de fissure (normal au disque maillé)
+
+ # --- option de maillage selon le rayon de courbure du fond de fissure
+ lenEdgeFondExt = 0
+ for edff in edgesFondFiss:
+ lenEdgeFondExt += geompy.BasicProperties(edff)[0]
+
+ disfond = []
+ for filling in facesDefaut:
+ disfond.append(geompy.MinDistance(centreFondFiss, filling))
+ disfond.sort()
+ rcourb = disfond[0]
+ nbSegQuart = 5 # on veut 5 segments min sur un quart de cercle
+ alpha = math.pi/(4*nbSegQuart)
+ deflexion = rcourb*(1.0 -math.cos(alpha))
+ lgmin = lenSegPipe*0.25
+ lgmax = lenSegPipe*1.5
+ logging.debug("rcourb: %s, lenFond:%s, deflexion: %s, lgmin: %s, lgmax: %s", rcourb, lenEdgeFondExt, deflexion, lgmin, lgmax)
+
+ meshFondExt = smesh.Mesh(wireFondFiss)
+ algo1d = meshFondExt.Segment()
+ hypo1d = algo1d.Adaptive(lgmin, lgmax, deflexion) # a ajuster selon la profondeur de la fissure
+ isDone = meshFondExt.Compute()
+
+ ptGSdic = {} # dictionnaire [paramètre sur la courbe] --> point géométrique
+ allNodeIds = meshFondExt.GetNodesId()
+ for nodeId in allNodeIds:
+ xyz = meshFondExt.GetNodeXYZ(nodeId)
+ #logging.debug("nodeId %s, coords %s", nodeId, str(xyz))
+ pt = geompy.MakeVertex(xyz[0], xyz[1], xyz[2])
+ u, PointOnEdge, EdgeInWireIndex = geompy.MakeProjectionOnWire(pt, wireFondFiss) # u compris entre 0 et 1
+ edgeOrder = edgesIdByOrientation[EdgeInWireIndex]
+ ptGSdic[(edgeOrder, EdgeInWireIndex, u)] = pt
+ #logging.debug("nodeId %s, u %s", nodeId, str(u))
+ usort = sorted(ptGSdic)
+ logging.debug("nombre de points obtenus par deflexion %s",len(usort))
+
+ centres = []
+ origins = []
+ normals = []
+ for edu in usort:
+ ied = edu[1]
+ u = edu[2]
+ vertcx = ptGSdic[edu]
+ norm = geompy.MakeTangentOnCurve(edgesFondFiss[ied], u)
+ plan = geompy.MakePlane(vertcx, norm, 3*rayonPipe)
+ part = geompy.MakePartition([plan], [wirePipeFiss], [], [], geompy.ShapeType["VERTEX"], 0, [], 0)
+ liste = geompy.ExtractShapes(part, geompy.ShapeType["VERTEX"], True)
+ if len(liste) == 5: # 4 coins du plan plus intersection recherchée
+ for point in liste:
+ if geompy.MinDistance(point, vertcx) < 1.1*rayonPipe: # les quatre coins sont plus loin
+ vertpx = point
+ break
+ centres.append(vertcx)
+ origins.append(vertpx)
+ normals.append(norm)
+# name = "vertcx%d"%i
+# geompy.addToStudyInFather(wireFondFiss, vertcx, name)
+# name = "vertpx%d"%i
+# geompy.addToStudyInFather(wireFondFiss, vertpx, name)
+# name = "plan%d"%i
+# geompy.addToStudyInFather(wireFondFiss, plan, name)
+
+ # --- maillage du pipe étendu, sans tenir compte de l'intersection avec la face de peau
+
+ logging.debug("nbsegCercle %s", nbsegCercle)
+
+ # -----------------------------------------------------------------------
+ # --- points géométriques
+
+ gptsdisks = [] # vertices géométrie de tous les disques
+ raydisks = [[] for i in range(nbsegCercle)]
+ for i in range(len(centres)): # boucle sur les disques
+ gptdsk = [] # vertices géométrie d'un disque
+ vertcx = centres[i]
+ vertpx = origins[i]
+ normal = normals[i]
+ vec1 = geompy.MakeVector(vertcx, vertpx)
+
+ points = [vertcx] # les points du rayon de référence
+ for j in range(nbsegRad):
+ pt = geompy.MakeTranslationVectorDistance(vertcx, vec1, (j+1)*float(rayonPipe)/nbsegRad)
+ points.append(pt)
+ gptdsk.append(points)
+ pt = geompy.MakeTranslationVectorDistance(vertcx, vec1, 1.5*rayonPipe)
+ rayon = geompy.MakeLineTwoPnt(vertcx, pt)
+ raydisks[0].append(rayon)
+
+ for k in range(nbsegCercle-1):
+ angle = (k+1)*2*math.pi/nbsegCercle
+ pts = [vertcx] # les points d'un rayon obtenu par rotation
+ for j in range(nbsegRad):
+ pt = geompy.MakeRotation(points[j+1], normal, angle)
+ pts.append(pt)
+ gptdsk.append(pts)
+ ray = geompy.MakeRotation(rayon, normal, angle)
+ raydisks[k+1].append(ray)
+
+ gptsdisks.append(gptdsk)
+
+ # -----------------------------------------------------------------------
+ # --- recherche des points en trop (externes au volume à remailler)
+ # - on associe chaque extrémité du pipe à une face filling
+ # - on part des disques aux extrémités du pipe
+ # - pour chaque disque, on prend les vertices de géométrie,
+ # on marque leur position relative à la face.
+ # - on s'arrete quand tous les noeuds sont dedans
+
+ logging.debug("---------------------------- recherche des points du pipe a éliminer --------------")
+
+ pt0 = centres[0]
+ pt1 = centres[-1]
+ idFillingFromBout = [None, None] # contiendra l'index du filling pour les extrémités 0 et 1
+ for ifil in range(nbFacesFilling):
+ for ipt, pt in enumerate(ptEdgeFond[ifil]): # il y a un ou deux points débouchant sur cette face
+ if geompy.MinDistance(pt,pt0) < geompy.MinDistance(pt,pt1): # TODO: trouver plus fiable pour les cas tordus...
+ idFillingFromBout[0] = ifil
+ else:
+ idFillingFromBout[1] = ifil
+ logging.debug("association bouts du pipe - faces de filling: %s", idFillingFromBout)
+
+ facesPipePeau = []
+ edgeRadFacePipePeau = []
+ for ifil in range(nbFacesFilling):
+ facesPipePeau += fsPipePeau[ifil]
+ edgeRadFacePipePeau += edRadFPiPo[ifil]
+
+ logging.debug("recherche des disques de noeuds complètement internes")
+ idisklim = [] # indices des premier et dernier disques internes
+ idiskout = [] # indices des premier et dernier disques externes
+ for bout in range(2):
+ if bout == 0:
+ idisk = -1
+ inc = 1
+ numout = -1
+ else:
+ idisk = len(gptsdisks)
+ inc = -1
+ numout = len(gptsdisks)
+ inside = False
+ outside = True
+ while not inside:
+ idisk = idisk + inc
+ logging.debug("examen disque %s", idisk)
+ gptdsk = gptsdisks[idisk]
+ inside = True
+ for k in range(nbsegCercle):
+ points = gptdsk[k]
+ for j, pt in enumerate(points):
+ side = whichSideVertex(facesDefaut[idFillingFromBout[bout]], pt)
+ if side < 0:
+ if outside: # premier point detecté dedans
+ outside = False
+ numout = idisk -inc # le disque précédent était dehors
+ else:
+ inside = False # ce point est dehors
+ if not inside and not outside:
+ break
+ idisklim.append(idisk) # premier et dernier disques internes
+ idiskout.append(numout) # premier et dernier disques externes
+
+ # --- listes de nappes radiales en filling à chaque extrémité débouchante
+ facesDebouchantes = [False, False]
+ idFacesDebouchantes = [-1, -1] # contiendra les indices des faces disque débouchantes (facesPipePeau)
+ listNappes =[]
+ for i, idisk in enumerate(idisklim):
+ numout = idiskout[i]
+ logging.debug("extremité %s, indices disques interne %s, externe %s",i, idisk, numout)
+ nappes = []
+ if (idisk != 0) and (idisk != len(gptsdisks)-1): # si extrémité débouchante
+ for k in range(nbsegCercle):
+ if i == 0:
+ iddeb = max(0, numout)
+ idfin = max(iddeb+3,idisk+1) # il faut 3 rayons pour faire un filling qui suive le fond de fissure
+ #logging.debug("extremité %s, indices retenus interne %s, externe %s",i, idfin, iddeb)
+ comp = geompy.MakeCompound(raydisks[k][iddeb:idfin])
+ name='compoundRay%d'%k
+ geompy.addToStudy(comp, name)
+ else:
+ idfin = min(len(gptsdisks), numout+1)
+ iddeb = min(idfin-3, idisk) # il faut 3 rayons pour faire un filling qui suive le fond de fissure
+ #logging.debug("extremité %s, indices retenus interne %s, externe %s",i, idfin, iddeb)
+ comp = geompy.MakeCompound(raydisks[k][iddeb:idfin])
+ name='compoundRay%d'%k
+ geompy.addToStudy(comp, name)
+ nappe = geompy.MakeFilling(comp, 2, 5, 0.0001, 0.0001, 0, GEOM.FOM_Default)
+ nappes.append(nappe)
+ name='nappe%d'%k
+ geompy.addToStudy(nappe, name)
+ facesDebouchantes[i] = True
+ listNappes.append(nappes)
+
+ # --- mise en correspondance avec les indices des faces disque débouchantes (facesPipePeau)
+ for i, nappes in enumerate(listNappes):
+ if facesDebouchantes[i]:
+ for k, face in enumerate(facesPipePeau):
+ edge = geompy.MakeSection(face, nappes[0])
+ if geompy.NbShapes(edge, geompy.ShapeType["EDGE"]) > 0:
+ idFacesDebouchantes[i] = k
+ break
+ logging.debug("idFacesDebouchantes: %s", idFacesDebouchantes)
+
+ # --- construction des listes d'edges radiales sur chaque extrémité débouchante
+ listEdges = []
+ for i, nappes in enumerate(listNappes):
+ id = idFacesDebouchantes[i] # indice de face débouchante (facesPipePeau)
+ if id < 0:
+ listEdges.append([])
+ else:
+ face = facesPipePeau[id]
+ edges = [edgeRadFacePipePeau[id]]
+ for k, nappe in enumerate(nappes):
+ if k > 0:
+ obj = geompy.MakeSection(face, nappes[k]) # normalement une edge, parfois un compound d'edges dont un tout petit
+ edge = obj
+ vs = geompy.ExtractShapes(obj, geompy.ShapeType["VERTEX"], False)
+ if len(vs) > 2:
+ eds = geompy.ExtractShapes(obj, geompy.ShapeType["EDGE"], False)
+ [edsorted, minl,maxl] = sortEdges(eds)
+ edge = edsorted[-1]
+ else:
+ maxl = geompy.BasicProperties(edge)[0]
+ if maxl < 0.01: # problème MakeSection
+ logging.debug("problème MakeSection recherche edge radiale %s, longueur trop faible: %s, utilisation partition", k, maxl)
+ partNappeFace = geompy.MakePartition([face, nappes[k]], [] , [], [], geompy.ShapeType["FACE"], 0, [], 0)
+ edps= geompy.ExtractShapes(partNappeFace, geompy.ShapeType["EDGE"], False)
+ ednouv = []
+ for ii, ed in enumerate(edps):
+ vxs = geompy.ExtractShapes(ed, geompy.ShapeType["VERTEX"], False)
+ distx = [geompy.MinDistance(vx, face) for vx in vxs]
+ distx += [geompy.MinDistance(vx, nappes[k]) for vx in vxs]
+ dmax = max(distx)
+ logging.debug(" dmax %s",dmax)
+ if dmax < 0.01:
+ ednouv.append(ed)
+ logging.debug(" edges issues de la partition: %s", ednouv)
+ for ii, ed in enumerate(ednouv):
+ geompy.addToStudy(ed, "ednouv%d"%ii)
+ [edsorted, minl,maxl] = sortEdges(ednouv)
+ logging.debug(" longueur edge trouvée: %s", maxl)
+ edge = edsorted[-1]
+ edges.append(edge)
+ name = 'edgeEndPipe%d'%k
+ geompy.addToStudy(edge, name)
+ listEdges.append(edges)
+
+ # --- création des points du maillage du pipe sur la face de peau
+ for i, edges in enumerate(listEdges):
+ id = idFacesDebouchantes[i] # indice de face débouchante (facesPipePeau)
+ if id >= 0:
+ gptdsk = []
+ if id > 0: # id vaut 0 ou 1
+ id = -1 # si id vaut 1, on prend le dernier élément de la liste (1 ou 2 extrémités débouchent sur la face)
+ centre = ptEdgeFond[idFillingFromBout[i]][id]
+ name = "centre%d"%id
+ geompy.addToStudy(centre, name)
+ vertPipePeau = ptFisExtPi[idFillingFromBout[i]][id]
+ geompy.addToStudyInFather(centre, vertPipePeau, "vertPipePeau")
+ grpsEdgesCirc = edCircPeau[idFillingFromBout[i]] # liste de groupes
+ edgesCirc = []
+ for grpEdgesCirc in grpsEdgesCirc:
+ edgesCirc += geompy.ExtractShapes(grpEdgesCirc, geompy.ShapeType["EDGE"], False)
+ for k, edge in enumerate(edges):
+ extrems = geompy.ExtractShapes(edge, geompy.ShapeType["VERTEX"], True)
+ if geompy.MinDistance(centre, extrems[0]) < geompy.MinDistance(centre, extrems[1]):
+ bout = extrems[1]
+ else:
+ bout = extrems[0]
+ # ajustement du point extrémité (bout) sur l'edge circulaire en face de peau
+ logging.debug("edgesCirc: %s", edgesCirc)
+ distEdgeCirc = [(geompy.MinDistance(bout, edgeCirc), k2, edgeCirc) for k2, edgeCirc in enumerate(edgesCirc)]
+ distEdgeCirc.sort()
+ logging.debug("distEdgeCirc: %s", distEdgeCirc)
+ u = projettePointSurCourbe(bout, distEdgeCirc[0][2])
+ if (abs(u) < 0.02) or (abs(1-u) < 0.02): # les points très proches d'une extrémité doivent y être mis précisément.
+ extrCircs = geompy.ExtractShapes(distEdgeCirc[0][2], geompy.ShapeType["VERTEX"], True)
+ if geompy.MinDistance(bout, extrCircs[0]) < geompy.MinDistance(bout, extrCircs[1]):
+ bout = extrCircs[0]
+ else:
+ bout = extrCircs[1]
+ pass
+ else:
+ bout = geompy.MakeVertexOnCurve(distEdgeCirc[0][2], u)
+ name ="bout%d"%k
+ geompy.addToStudyInFather(centre, bout, name)
+ # enregistrement des points dans la structure
+ points = []
+ for j in range(nbsegRad +1):
+ u = j/float(nbsegRad)
+ points.append(geompy.MakeVertexOnCurve(edge, u))
+ if geompy.MinDistance(bout, points[0]) < geompy.MinDistance(centre, points[0]):
+ points.reverse()
+ points[0] = centre
+ points[-1] = bout
+ gptdsk.append(points)
+ if i == 0:
+ gptsdisks[idisklim[0] -1] = gptdsk
+ idisklim[0] = idisklim[0] -1
+ else:
+ gptsdisks[idisklim[1] +1] = gptdsk
+ idisklim[1] = idisklim[1] +1
+
+ # --- ajustement precis des points sur edgesPipeFissureExterneC
+
+ edgesPFE = geompy.ExtractShapes(edgesPipeFissureExterneC, geompy.ShapeType["EDGE"], False)
+ verticesPFE = findWireIntermediateVertices(wirePipeFissureExterne) # vertices intermédiaires (des points en trop dans ptsInWireFissExtPipe)
+ idiskmin = idisklim[0] + 1 # on ne prend pas le disque sur la peau, déjà ajusté
+ idiskmax = idisklim[1] # on ne prend pas le disque sur la peau, déjà ajusté
+ idiskint = []
+ for vtx in verticesPFE:
+ distPtVt = []
+ for idisk in range(idiskmin, idiskmax):
+ gptdsk = gptsdisks[idisk]
+ pt = gptdsk[0][-1] # le point sur l'edge de la fissure externe au pipe
+ distPtVt.append((geompy.MinDistance(pt, vtx), idisk))
+ distPtVt.sort()
+ idiskint.append(distPtVt[0][1])
+ gptsdisks[idiskint[-1]][0][-1] = vtx
+ logging.debug("ajustement point sur edgePipeFissureExterne, vertex: %s %s", idiskint[-1], distPtVt[0][0])
+ for idisk in range(idiskmin, idiskmax):
+ if idisk in idiskint:
+ break
+ logging.debug("ajustement point sur edgePipeFissureExterne: %s", idisk)
+ gptdsk = gptsdisks[idisk]
+ pt = gptdsk[0][-1] # le point sur l'edge de la fissure externe au pipe
+ distPtEd = [(geompy.MinDistance(pt, edgePFE), k, edgePFE) for k, edgePFE in enumerate(edgesPFE)]
+ distPtEd.sort()
+ edgePFE = distPtEd[0][2]
+ u = projettePointSurCourbe(pt, edgePFE)
+ ptproj = geompy.MakeVertexOnCurve(edgePFE, u)
+ gptsdisks[idisk][0][-1] = ptproj
+
+ # -----------------------------------------------------------------------
+ # --- maillage effectif du pipe
+
+ logging.debug("---------------------------- maillage effectif du pipe --------------")
+ meshPipe = smesh.Mesh(None, "meshPipe")
+ fondFissGroup = meshPipe.CreateEmptyGroup(SMESH.EDGE, "FONDFISS")
+ nodesFondFissGroup = meshPipe.CreateEmptyGroup(SMESH.NODE, "nfondfis")
+ faceFissGroup = meshPipe.CreateEmptyGroup(SMESH.FACE, "fisInPi")
+ edgeFaceFissGroup = meshPipe.CreateEmptyGroup(SMESH.EDGE, "edgeFaceFiss")
+ edgeCircPipe0Group = meshPipe.CreateEmptyGroup(SMESH.EDGE, "edgeCircPipe0")
+ edgeCircPipe1Group = meshPipe.CreateEmptyGroup(SMESH.EDGE, "edgeCircPipe1")
+ faceCircPipe0Group = meshPipe.CreateEmptyGroup(SMESH.FACE, "faceCircPipe0")
+ faceCircPipe1Group = meshPipe.CreateEmptyGroup(SMESH.FACE, "faceCircPipe1")
+ mptsdisks = [] # vertices maillage de tous les disques
+ mEdges = [] # identifiants edges maillage fond de fissure
+ mEdgeFaces = [] # identifiants edges maillage edge face de fissure externe
+ mFaces = [] # identifiants faces maillage fissure
+ mVols = [] # identifiants volumes maillage pipe
+
+ mptdsk = None
+ for idisk in range(idisklim[0], idisklim[1]+1): # boucle sur les disques internes
+
+ # -----------------------------------------------------------------------
+ # --- points
+
+ gptdsk = gptsdisks[idisk]
+ if idisk > idisklim[0]:
+ oldmpts = mptdsk
+ mptdsk = [] # vertices maillage d'un disque
+ for k in range(nbsegCercle):
+ points = gptdsk[k]
+ mptids = []
+ for j, pt in enumerate(points):
+ if j == 0 and k > 0:
+ id = mptdsk[0][0]
+ else:
+ coords = geompy.PointCoordinates(pt)
+ id = meshPipe.AddNode(coords[0], coords[1], coords[2])
+ mptids.append(id)
+ mptdsk.append(mptids)
+ mptsdisks.append(mptdsk)
+
+ # -----------------------------------------------------------------------
+ # --- groupes edges cercles debouchants
+
+ if idisk == idisklim[0]:
+ pts = []
+ for k in range(nbsegCercle):
+ pts.append(mptdsk[k][-1])
+ edges = []
+ for k in range(len(pts)):
+ k1 = (k+1)%len(pts)
+ idEdge = meshPipe.AddEdge([pts[k], pts[k1]])
+ edges.append(idEdge)
+ edgeCircPipe0Group.Add(edges)
+
+ if idisk == idisklim[1]:
+ pts = []
+ for k in range(nbsegCercle):
+ pts.append(mptdsk[k][-1])
+ edges = []
+ for k in range(len(pts)):
+ k1 = (k+1)%len(pts)
+ idEdge = meshPipe.AddEdge([pts[k], pts[k1]])
+ edges.append(idEdge)
+ edgeCircPipe1Group.Add(edges)
+
+ # -----------------------------------------------------------------------
+ # --- groupes faces debouchantes
+
+ if idisk == idisklim[0]:
+ faces = []
+ for j in range(nbsegRad):
+ for k in range(nbsegCercle):
+ k1 = k+1
+ if k == nbsegCercle-1:
+ k1 = 0
+ if j == 0:
+ idf = meshPipe.AddFace([mptdsk[k][0], mptdsk[k][1], mptdsk[k1][1]]) # triangle
+ else:
+ idf = meshPipe.AddFace([mptdsk[k][j], mptdsk[k][j+1], mptdsk[k1][j+1], mptdsk[k1][j]]) # quadrangle
+ faces.append(idf)
+ faceCircPipe0Group.Add(faces)
+
+ if idisk == idisklim[1]:
+ faces = []
+ for j in range(nbsegRad):
+ for k in range(nbsegCercle):
+ k1 = k+1
+ if k == nbsegCercle-1:
+ k1 = 0
+ if j == 0:
+ idf = meshPipe.AddFace([mptdsk[k][0], mptdsk[k][1], mptdsk[k1][1]]) # triangle
+ else:
+ idf = meshPipe.AddFace([mptdsk[k][j], mptdsk[k][j+1], mptdsk[k1][j+1], mptdsk[k1][j]]) # quadrangle
+ faces.append(idf)
+ faceCircPipe1Group.Add(faces)
+
+ # -----------------------------------------------------------------------
+ # --- mailles volumiques, groupes noeuds et edges de fond de fissure, groupe de face de fissure
+
+ if idisk == idisklim[0]:
+ mEdges.append(0)
+ mEdgeFaces.append(0)
+ mFaces.append([0])
+ mVols.append([[0]])
+ nodesFondFissGroup.Add([mptdsk[0][0]])
+ else:
+ ide = meshPipe.AddEdge([oldmpts[0][0], mptdsk[0][0]])
+ mEdges.append(ide)
+ fondFissGroup.Add([ide])
+ nodesFondFissGroup.Add([mptdsk[0][0]])
+ ide2 = meshPipe.AddEdge([oldmpts[0][-1], mptdsk[0][-1]])
+ mEdgeFaces.append(ide2)
+ edgeFaceFissGroup.Add([ide2])
+ idFaces = []
+ idVols = []
+
+ for j in range(nbsegRad):
+ idf = meshPipe.AddFace([oldmpts[0][j], mptdsk[0][j], mptdsk[0][j+1], oldmpts[0][j+1]])
+ faceFissGroup.Add([idf])
+ idFaces.append(idf)
+
+ idVolCercle = []
+ for k in range(nbsegCercle):
+ k1 = k+1
+ if k == nbsegCercle-1:
+ k1 = 0
+ if j == 0:
+ idv = meshPipe.AddVolume([mptdsk[k][j], mptdsk[k][j+1], mptdsk[k1][j+1],
+ oldmpts[k][j], oldmpts[k][j+1], oldmpts[k1][j+1]])
+ else:
+ idv = meshPipe.AddVolume([mptdsk[k][j], mptdsk[k][j+1], mptdsk[k1][j+1], mptdsk[k1][j],
+ oldmpts[k][j], oldmpts[k][j+1], oldmpts[k1][j+1], oldmpts[k1][j]])
+ idVolCercle.append(idv)
+ idVols.append(idVolCercle)
+
+ mFaces.append(idFaces)
+ mVols.append(idVols)
+
+ pipeFissGroup = meshPipe.CreateEmptyGroup( SMESH.VOLUME, 'PIPEFISS' )
+ nbAdd = pipeFissGroup.AddFrom( meshPipe.GetMesh() )
+
+ nb, new_mesh, new_group = meshPipe.MakeBoundaryElements(SMESH.BND_2DFROM3D, "pipeBoundaries")
+ edgesCircPipeGroup = [edgeCircPipe0Group, edgeCircPipe1Group]
+
+ # --- fin du maillage du pipe
+ # -----------------------------------------------------------------------
+ # --- edges de bord, faces défaut à respecter
+
+ aFilterManager = smesh.CreateFilterManager()
+ nbAdded, internalBoundary, _NoneGroup = internalBoundary.MakeBoundaryElements( SMESH.BND_1DFROM2D, '', '', 0, [ ])
+ criteres = []
+ unCritere = smesh.GetCriterion(SMESH.EDGE,SMESH.FT_FreeBorders,SMESH.FT_Undefined,0)
+ criteres.append(unCritere)
+ filtre = smesh.GetFilterFromCriteria(criteres)
+ bordsLibres = internalBoundary.MakeGroupByFilter( 'bords', filtre )
+ smesh.SetName(bordsLibres, 'bordsLibres')
+
+ # --- pour aider l'algo hexa-tetra à ne pas mettre de pyramides à l'exterieur des volumes repliés sur eux-mêmes
+ # on désigne les faces de peau en quadrangles par le groupe "skinFaces"
+
+ skinFaces = internalBoundary.CreateEmptyGroup( SMESH.FACE, 'skinFaces' )
+ nbAdd = skinFaces.AddFrom( internalBoundary.GetMesh() )
+
+ # --- maillage des éventuelles arêtes vives entre faces reconstruites
+
+ if len(aretesVivesCoupees) > 0:
+ aretesVivesC = geompy.MakeCompound(aretesVivesCoupees)
+ meshAretesVives = smesh.Mesh(aretesVivesC)
+ algo1d = meshAretesVives.Segment()
+ hypo1d = algo1d.LocalLength(dmoyen/3.0,[],1e-07)
+ putName(algo1d.GetSubMesh(), "aretesVives")
+ putName(algo1d, "algo1d_aretesVives")
+ putName(hypo1d, "hypo1d_aretesVives")
+ isDone = meshAretesVives.Compute()
+ logging.info("aretesVives fini")
+ grpAretesVives = meshAretesVives.CreateEmptyGroup( SMESH.EDGE, 'grpAretesVives' )
+ nbAdd = grpAretesVives.AddFrom( meshAretesVives.GetMesh() )
+
+ # -----------------------------------------------------------------------
+ # --- maillage faces de fissure
+
+ logging.debug("---------------------------- maillage faces de fissure externes au pipe :%s --------------", len(facesFissExt))
+
+ meshFaceFiss = smesh.Mesh(faceFissureExterne)
+ algo2d = meshFaceFiss.Triangle(algo=smeshBuilder.NETGEN_1D2D)
+ hypo2d = algo2d.Parameters()
+ hypo2d.SetMaxSize( areteFaceFissure )
+ hypo2d.SetSecondOrder( 0 )
+ hypo2d.SetOptimize( 1 )
+ hypo2d.SetFineness( 2 )
+ hypo2d.SetMinSize( rayonPipe/float(nbsegRad) )
+ hypo2d.SetQuadAllowed( 0 )
+ putName(algo2d.GetSubMesh(), "faceFiss")
+ putName(algo2d, "algo2d_faceFiss")
+ putName(hypo2d, "hypo2d_faceFiss")
+
+ algo1d = meshFaceFiss.UseExisting1DElements(geom=edgesPipeFissureExterneC)
+ hypo1d = algo1d.SourceEdges([ edgeFaceFissGroup ],0,0)
+ putName(algo1d.GetSubMesh(), "edgeFissPeau")
+ putName(algo1d, "algo1d_edgeFissPeau")
+ putName(hypo1d, "hypo1d_edgeFissPeau")
+
+ isDone = meshFaceFiss.Compute()
+ logging.info("meshFaceFiss fini")
+
+ grpFaceFissureExterne = meshFaceFiss.GroupOnGeom(faceFissureExterne, "fisOutPi", SMESH.FACE)
+ grpEdgesPeauFissureExterne = meshFaceFiss.GroupOnGeom(edgesPeauFissureExterneC,'edgesPeauFissureExterne',SMESH.EDGE)
+ grpEdgesPipeFissureExterne = meshFaceFiss.GroupOnGeom(edgesPipeFissureExterneC,'edgesPipeFissureExterne',SMESH.EDGE)
+
+ # --- maillage faces de peau
+
+ boutFromIfil = [None for i in range(nbFacesFilling)]
+ if idFillingFromBout[0] != idFillingFromBout[1]: # repérage des extremites du pipe quand elles débouchent sur des faces différentes
+ boutFromIfil[idFillingFromBout[0]] = 0
+ boutFromIfil[idFillingFromBout[1]] = 1
+
+ logging.debug("---------------------------- maillage faces de peau --------------")
+ meshesFacesPeau = []
+ for ifil in range(nbFacesFilling):
+ meshFacePeau = None
+ if partitionsPeauFissFond[ifil] is None: # face de peau maillage sain intacte
+
+ # --- edges de bord de la face de filling
+ filling = facesDefaut[ifil]
+ edgesFilling = geompy.ExtractShapes(filling, geompy.ShapeType["EDGE"], False)
+ groupEdgesBordPeau = geompy.CreateGroup(filling, geompy.ShapeType["EDGE"])
+ geompy.UnionList(groupEdgesBordPeau, edgesFilling)
+ geompy.addToStudyInFather(filling, groupEdgesBordPeau , "EdgesBords")
+
+ meshFacePeau = smesh.Mesh(facesDefaut[ifil])
+
+ algo1d = meshFacePeau.UseExisting1DElements(geom=groupEdgesBordPeau)
+ hypo1d = algo1d.SourceEdges([ bordsLibres ],0,0)
+ putName(algo1d.GetSubMesh(), "bordsLibres", ifil)
+ putName(algo1d, "algo1d_bordsLibres", ifil)
+ putName(hypo1d, "hypo1d_bordsLibres", ifil)
+
+ else:
+
+ facePeau = facesPeaux[ifil] # pour chaque face : la face de peau finale a mailler (percée des faces débouchantes)
+ edgesCircPeau = edCircPeau[ifil] # pour chaque face de peau : [subshape edge circulaire aux débouchés du pipe]
+ verticesCircPeau = ptCircPeau[ifil] # pour chaque face de peau : [subshape point sur edge circulaire aux débouchés du pipe]
+ groupEdgesBordPeau = gpedgeBord[ifil] # pour chaque face de peau : groupe subshape des edges aux bords liés à la partie saine
+ bordsVifs = gpedgeVifs[ifil] # pour chaque face de peau : groupe subshape des edges aux bords correspondant à des arêtes vives
+ edgesFissurePeau = edFissPeau[ifil] # pour chaque face de peau : [subshape edge en peau des faces de fissure externes]
+
+ meshFacePeau = smesh.Mesh(facePeau)
+
+ algo1d = meshFacePeau.UseExisting1DElements(geom=groupEdgesBordPeau)
+ hypo1d = algo1d.SourceEdges([ bordsLibres ],0,0)
+ putName(algo1d.GetSubMesh(), "bordsLibres", ifil)
+ putName(algo1d, "algo1d_bordsLibres", ifil)
+ putName(hypo1d, "hypo1d_bordsLibres", ifil)
+
+ algo1d = meshFacePeau.UseExisting1DElements(geom=geompy.MakeCompound(edgesFissurePeau))
+ hypo1d = algo1d.SourceEdges([ grpEdgesPeauFissureExterne ],0,0)
+ putName(algo1d.GetSubMesh(), "edgePeauFiss", ifil)
+ putName(algo1d, "algo1d_edgePeauFiss", ifil)
+ putName(hypo1d, "hypo1d_edgePeauFiss", ifil)
+
+ if bordsVifs is not None:
+ algo1d = meshFacePeau.UseExisting1DElements(geom=bordsVifs)
+ hypo1d = algo1d.SourceEdges([ grpAretesVives ],0,0)
+ putName(algo1d.GetSubMesh(), "bordsVifs", ifil)
+ putName(algo1d, "algo1d_bordsVifs", ifil)
+ putName(hypo1d, "hypo1d_bordsVifs", ifil)
+
+ for i, edgeCirc in enumerate(edgesCircPeau):
+ if edgeCirc is not None:
+ algo1d = meshFacePeau.UseExisting1DElements(geom=edgeCirc)
+ if boutFromIfil[ifil] is None:
+ hypo1d = algo1d.SourceEdges([ edgesCircPipeGroup[i] ],0,0)
+ else:
+ hypo1d = algo1d.SourceEdges([ edgesCircPipeGroup[boutFromIfil[ifil]] ],0,0)
+ name = "cercle%d"%i
+ putName(algo1d.GetSubMesh(), name, ifil)
+ putName(algo1d, "algo1d_" + name, ifil)
+ putName(hypo1d, "hypo1d_" + name, ifil)
+
+ algo2d = meshFacePeau.Triangle(algo=smeshBuilder.NETGEN_1D2D)
+ hypo2d = algo2d.Parameters()
+ hypo2d.SetMaxSize( dmoyen )
+ hypo2d.SetOptimize( 1 )
+ hypo2d.SetFineness( 2 )
+ hypo2d.SetMinSize( rayonPipe/float(nbsegRad) )
+ hypo2d.SetQuadAllowed( 0 )
+ putName(algo2d.GetSubMesh(), "facePeau", ifil)
+ putName(algo2d, "algo2d_facePeau", ifil)
+ putName(hypo2d, "hypo2d_facePeau", ifil)
+
+ isDone = meshFacePeau.Compute()
+ logging.info("meshFacePeau %d fini", ifil)
+ GroupFaces = meshFacePeau.CreateEmptyGroup( SMESH.FACE, "facePeau%d"%ifil )
+ nbAdd = GroupFaces.AddFrom( meshFacePeau.GetMesh() )
+ meshesFacesPeau.append(meshFacePeau)
+
+ # --- regroupement des maillages du défaut
+
+ listMeshes = [internalBoundary.GetMesh(),
+ meshPipe.GetMesh(),
+ meshFaceFiss.GetMesh()]
+ for mp in meshesFacesPeau:
+ listMeshes.append(mp.GetMesh())
+
+ meshBoiteDefaut = smesh.Concatenate(listMeshes, 1, 1, 1e-05,False)
+ # pour aider l'algo hexa-tetra à ne pas mettre de pyramides à l'exterieur des volumes re
