# -*- coding: utf-8 -*-
+# Copyright (C) 2014-2020 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+import os
import logging
import salome
-from geomsmesh import geompy
-from geomsmesh import geomPublish
-from geomsmesh import geomPublishInFather
-import initLog
-from geomsmesh import smesh
+from .geomsmesh import geompy
+from .geomsmesh import geomPublish
+from .geomsmesh import geomPublishInFather
+from . import initLog
+from .geomsmesh import smesh
from salome.smesh import smeshBuilder
import SMESH
import math
-from extractionOrientee import extractionOrientee
-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 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 .extractionOrientee import extractionOrientee
+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 .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
# -----------------------------------------------------------------------------
# --- procedure complete fissure longue
#nbsegFis = maillageFissureParams['nbsegFis'] # 20
#lensegEllipsoide = maillageFissureParams['lensegEllipso'] # 1.0
- #fichierMaillageSain = nomRep + '/' + nomFicSain + '.med'
- fichierMaillageFissure = nomRep + '/' + nomFicFissure + '.med'
+ #fichierMaillageSain = os.path.join(nomRep, '{}.med'.format(nomFicSain))
+ fichierMaillageFissure = os.path.join(nomRep, '{}.med'.format(nomFicFissure))
facesDefaut = elementsDefaut[0]
#centreDefaut = elementsDefaut[1]
edgesFilling = geompy.ExtractShapes(fillingFaceExterne, geompy.ShapeType["EDGE"], False)
O, OX, OY, OZ = triedreBase()
-
+
# -----------------------------------------------------------------------------
# --- peau et face de fissure
# --- partition peau defaut - face de fissure prolongee - wire de fond de fissure prolongée
- partitionPeauFissFond = geompy.MakePartition([facePorteFissure, WirePorteFondFissure, fillingFaceExterne], [], [], [], geompy.ShapeType["FACE"], 0, [], 0)
+ partitionPeauFissFond = geompy.MakePartition([facePorteFissure, WirePorteFondFissure, fillingFaceExterne], list(), list(), list(), geompy.ShapeType["FACE"], 0, list(), 0)
geomPublish(initLog.debug, partitionPeauFissFond, 'partitionPeauFissFond' )
edges = geompy.ExtractShapes(WirePorteFondFissure, geompy.ShapeType["EDGE"], False)
[facesInside, facesOutside, facesOnside] = extractionOrientee(fillingFaceExterne, partitionPeauFissFond, centreFondFiss, "FACE", 1.e-3)
# --- partition peau -face fissure - pipe fond de fissure prolongé
- partitionPeauFissByPipe = geompy.MakePartition([facesInside[0], facesOnside[0]], [pipefiss], [], [], geompy.ShapeType["FACE"], 0, [], 0)
+ partitionPeauFissByPipe = geompy.MakePartition([facesInside[0], facesOnside[0]], [pipefiss], list(), list(), geompy.ShapeType["FACE"], 0, list(), 0)
geomPublish(initLog.debug, partitionPeauFissByPipe, 'partitionPeauFissByPipe' )
# --- identification face de peau
geomPublishInFather(initLog.debug,partitionPeauFissByPipe, facePeau, "facePeau")
# --- identification edges de bord face peau
- edgesBords = []
+ edgesBords = list()
for i, edge in enumerate(edgesFilling):
edgepeau = geompy.GetInPlace(facePeau, edge)
edgesBords.append(edgepeau)
edgesFacePeau = geompy.ExtractShapes(facePeau, geompy.ShapeType["EDGE"], False)
edgesFacePeauSorted, minlg, maxlg = sortEdges(edgesFacePeau)
demiCerclesPeau = edgesFacePeauSorted[0:4]
- verticesDemiCerclesPeau = []
+ verticesDemiCerclesPeau = list()
for i, edge in enumerate(demiCerclesPeau):
name = "demiCerclePeau_%d"%i
geomPublishInFather(initLog.debug,facePeau, edge, name)
geomPublishInFather(initLog.debug,facePeau, vertex, name)
# --- demi cercles regroupés
- groupsDemiCerclesPeau = []
+ groupsDemiCerclesPeau = list()
for i, vertex in enumerate(verticesEdgePeauFiss):
- demis = []
+ demis = list()
for edge in demiCerclesPeau:
if geompy.MinDistance(vertex, edge) < 1.e-5:
demis.append(edge)
# --- identification edges commune pipe face fissure externe au pipe
edgePeauFissId = geompy.GetSubShapeID(partitionPeauFissByPipe, edgePeauFiss)
edgesFaceFiss = geompy.ExtractShapes(faceFiss, geompy.ShapeType["EDGE"], False)
- edgesFaceFissPipe = []
+ edgesFaceFissPipe = list()
for edge in edgesFaceFiss:
if geompy.GetSubShapeID(partitionPeauFissByPipe, edge) != edgePeauFissId:
edgesFaceFissPipe.append(edge)
[vertexReference] = geompy.ExtractShapes(disque, geompy.ShapeType["VERTEX"], False)
pipeFondFiss = geompy.MakePipe(disque, wireFondFiss)
- pipeFondFiss = geompy.MakePartition([pipeFondFiss], [planfiss, wireFondFiss, planBord1, planBord2], [], [], geompy.ShapeType["SOLID"], 0, [], 0)
+ pipeFondFiss = geompy.MakePartition([pipeFondFiss], [planfiss, wireFondFiss, planBord1, planBord2], list(), list(), geompy.ShapeType["SOLID"], 0, list(), 0)
#pipe = geompy.MakePipe(disque, WirePorteFondFissure)
- #pipe = geompy.MakePartition([pipe],[fillingFaceExterne], [], [], geompy.ShapeType["SOLID"], 0, [], 0)
+ #pipe = geompy.MakePartition([pipe],[fillingFaceExterne], list(), list(), geompy.ShapeType["SOLID"], 0, list(), 0)
#pipes = geompy.ExtractShapes(pipe, geompy.ShapeType["SOLID"], False)
#pipesSorted, volmin, volmax = sortSolids(pipes)
#pipeFondFiss = pipesSorted[-1]
- #pipeFondFiss = geompy.MakePartition([pipeFondFiss], [planfiss, wireFondFiss, planBord1, planBord2], [], [], geompy.ShapeType["SOLID"], 0, [], 0)
+ #pipeFondFiss = geompy.MakePartition([pipeFondFiss], [planfiss, wireFondFiss, planBord1, planBord2], list(), list(), geompy.ShapeType["SOLID"], 0, list(), 0)
geomPublish(initLog.debug, disque, 'disque')
geomPublish(initLog.debug, wireFondFiss, 'wireFondFiss')
for i, v in enumerate(VerticesEndFondFiss):
name = "vertexEndFondFiss_%d"%i
geomPublishInFather(initLog.debug,wireFondFiss, v, name)
- VerticesEndPipeFiss = []
+ VerticesEndPipeFiss = list()
for v in VerticesEndFondFiss:
VerticesEndPipeFiss.append(geompy.GetInPlace(pipeFondFiss, v))
for i, v in enumerate(VerticesEndPipeFiss):
# generatrices = edgesPipeOnplan moins rayon disques (3 grandes et 6 petites)
edgesIdPipeOnside = getSubshapeIds(pipeFondFiss, edgesPipeOnside)
edgesIdPipeOnplan = getSubshapeIds(pipeFondFiss, edgesPipeOnplan)
- rayons = []
- demiCercles = []
+ rayons = list()
+ demiCercles = list()
for i, edgeId in enumerate(edgesIdPipeOnside):
if edgeId in edgesIdPipeOnplan:
rayons.append(edgesPipeOnside[i])
rayons = rayons + edgesSorted[:4] # les 4 plus petits sont les rayons
demiCercles = demiCercles + edgesSorted[4:] # les suivants sont les arcs de cercle
rayonsId = getSubshapeIds(pipeFondFiss, rayons)
- generatrices = []
+ generatrices = list()
for i, edgeId in enumerate(edgesIdPipeOnplan):
if edgeId not in rayonsId:
generatrices.append(edgesPipeOnplan[i])
# --- generatrices en contact avec la face fissure externe au pipe
- generFiss = []
+ generFiss = list()
for edge in generatrices:
distance = geompy.MinDistance(vertexReference, edge)
logging.debug("distance %s", distance)
geomPublishInFather(initLog.debug,pipeFondFiss, groupGenerFiss, "GenFiss")
# --- demi cercles externes regroupés
- groupsDemiCerclesPipe = []
+ groupsDemiCerclesPipe = list()
for i, vertex in enumerate(verticesEdgePeauFiss):
- demis = []
+ demis = list()
for edge in demiCerclesExternes:
if geompy.MinDistance(vertex, edge) < 0.1:
demis.append(edge)
# --- faces fissure dans le pipe
- facesFissinPipe = []
+ facesFissinPipe = list()
generFissId = getSubshapeIds(pipeFondFiss, generFiss)
logging.debug("generatrice fissure %s", generFissId)
for face in facesPipeOnplan:
# --- edges de fond de fissure
- edgesFondFiss = []
+ edgesFondFiss = list()
for i, edge in enumerate(edgesInside):
anEdge = geompy.GetInPlace(pipeFondFiss, edge)
logging.debug(" edge %s ", anEdge)
aFilterManager = smesh.CreateFilterManager()
nbAdded, internalBoundary, _NoneGroup = internalBoundary.MakeBoundaryElements( SMESH.BND_1DFROM2D, '', '', 0, [ ])
- criteres = []
+ criteres = list()
unCritere = smesh.GetCriterion(SMESH.EDGE,SMESH.FT_FreeBorders,SMESH.FT_Undefined,0)
criteres.append(unCritere)
filtre = smesh.GetFilterFromCriteria(criteres)
# --- maillage pipe fond fissure
- meshFondFiss = smesh.Mesh(pipeFondFiss)
- algo2d = meshFondFiss.Quadrangle(algo=smeshBuilder.QUADRANGLE)
- algo3d = meshFondFiss.Prism()
- putName(algo3d.GetSubMesh(), "pipe")
- putName(algo3d, "algo3d_pipe")
- putName(algo2d, "algo2d_pipe")
-
- for i, face in enumerate(disques):
- algo2d = meshFondFiss.Quadrangle(algo=smeshBuilder.RADIAL_QUAD,geom=face)
- putName(algo2d.GetSubMesh(), "disque", i)
- putName(algo2d, "algo2d_disque", i)
-
- for i, edge in enumerate(rayons):
- algo1d = meshFondFiss.Segment(geom=edge)
- hypo1d = algo1d.NumberOfSegments(4)
- putName(algo1d.GetSubMesh(), "rayon", i)
- putName(algo1d, "algo1d_rayon", i)
- putName(hypo1d, "hypo1d_rayon", i)
-
- for i, edge in enumerate(demiCercles):
- algo1d = meshFondFiss.Segment(geom=edge)
- hypo1d = algo1d.NumberOfSegments(6)
- putName(algo1d.GetSubMesh(), "demiCercle", i)
- putName(algo1d, "algo1d_demiCercle", i)
- putName(hypo1d, "hypo1d_demiCercle", i)
-
- generSorted, minlg, maxlg = sortEdges(generatrices)
- nbSegGenLong = int(math.sqrt(3.0)*maxlg/(profondeur - rayonPipe)) # on veut 2 triangles equilateraux dans la largeur de la face
- nbSegGenBout = 6
- logging.info("min %s, max %s, nombre de segments %s, nombre de generatrices %s", minlg, maxlg, nbSegGenLong, len(generSorted))
- for i, edge in enumerate(generSorted):
- algo1d = meshFondFiss.Segment(geom=edge)
- if i < 6:
- hypo1d = algo1d.NumberOfSegments(nbSegGenBout)
- else:
- hypo1d = algo1d.NumberOfSegments(nbSegGenLong)
- putName(algo1d.GetSubMesh(), "generatrice", i)
- putName(algo1d, "algo1d_generatrice", i)
- putName(hypo1d, "hypo1d_generatrice", i)
- isDone = meshFondFiss.Compute()
- logging.info("meshFondFiss computed")
-
- disks = []
- for i, face in enumerate(disques[:4]):
- name = "disk%d"%i
- disks.append(meshFondFiss.GroupOnGeom(face, name, SMESH.FACE))
- peauext_pipe = meshFondFiss.GetMesh().UnionListOfGroups( disks, 'PEAUEXT' )
-
- grpPFOR = meshFondFiss.GroupOnGeom(VerticesEndPipeFiss[0], "PFOR", SMESH.NODE)
- grpPFEX = meshFondFiss.GroupOnGeom(VerticesEndPipeFiss[1], "PFEX", SMESH.NODE)
-
- grp = meshFondFiss.GroupOnGeom(groupFaceFissInPipe, "fisInPi", SMESH.FACE)
- group_edgeFondFiss = meshFondFiss.GroupOnGeom(groupEdgeFondFiss, "FONDFISS", SMESH.EDGE)
- noeudsFondFissure = meshFondFiss.GroupOnGeom(groupEdgeFondFiss, "nfondfis", SMESH.NODE)
- groups_demiCercles = []
- groupnodes_demiCercles = []
- for i, group in enumerate(groupsDemiCerclesPipe):
- name = "Cercle%d"%i
- groups_demiCercles.append(meshFondFiss.GroupOnGeom(group, name, SMESH.EDGE))
- name = "nCercle%d"%i
- groupnodes_demiCercles.append(meshFondFiss.GroupOnGeom(group, name, SMESH.NODE))
- group_generFiss = meshFondFiss.GroupOnGeom(groupGenerFiss, "GenFiss", SMESH.EDGE)
- groupnode_generFiss = meshFondFiss.GroupOnGeom(groupGenerFiss, "GenFiss", SMESH.NODE)
- grpNode0 = meshFondFiss.IntersectGroups(groupnode_generFiss, groupnodes_demiCercles[0], "Node0")
- grpNode1 = meshFondFiss.IntersectGroups(groupnode_generFiss, groupnodes_demiCercles[1], "Node1")
- idNode0 = grpNode0.GetID(1)
- idNode1 = grpNode1.GetID(1)
- coordsMesh = []
- coordsMesh.append(meshFondFiss.GetNodeXYZ(idNode0))
- coordsMesh.append(meshFondFiss.GetNodeXYZ(idNode1))
- coordsGeom = []
- for vertex in verticesEdgePeauFiss:
- coord = geompy.PointCoordinates(vertex);
- if distance2(coord, coordsMesh[0]) < 0.1:
- meshFondFiss.MoveNode(idNode0, coord[0], coord[1], coord[2])
- if distance2(coord, coordsMesh[1]) < 0.1:
- meshFondFiss.MoveNode(idNode1, coord[0], coord[1], coord[2])
-
- for groupNodes in groupnodes_demiCercles:
- for idNode in groupNodes.GetListOfID():
- coordMesh = meshFondFiss.GetNodeXYZ(idNode)
- vertex = geompy.MakeVertex(coordMesh[0], coordMesh[1], coordMesh[2])
- minDist = 100000
- minCoord = None
- imin = -1
- for i, edge in enumerate(demiCerclesPeau):
- discoord = geompy.MinDistanceComponents(vertex, edge)
- if discoord[0] <minDist:
- minDist = discoord[0]
- minCoord = discoord[1:]
- imin = i
- if imin >= 0 and minDist > 1.E-6:
- logging.debug("node id moved : %s distance=%s", idNode, minDist)
- meshFondFiss.MoveNode(idNode, coordMesh[0] + minCoord[0], coordMesh[1] + minCoord[1], coordMesh[2] + minCoord[2])
-
+ meshFondFiss, groups_demiCercles, group_generFiss, nbSegGenLong, nbSegGenBout = \
+ insereFissureLongue_a (pipeFondFiss, disques, rayons, demiCercles, demiCerclesPeau, generatrices, \
+ VerticesEndPipeFiss, verticesEdgePeauFiss, \
+ groupFaceFissInPipe, groupEdgeFondFiss, groupsDemiCerclesPipe, groupGenerFiss, \
+ profondeur, rayonPipe, distance2)
# --- maillage face de peau
- meshFacePeau = smesh.Mesh(facePeau)
- algo2d = meshFacePeau.Triangle(algo=smeshBuilder.NETGEN_2D)
- hypo2d = algo2d.Parameters()
- hypo2d.SetMaxSize( 1000 )
- hypo2d.SetOptimize( 1 )
- hypo2d.SetFineness( 2 )
- hypo2d.SetMinSize( 2 )
- hypo2d.SetQuadAllowed( 0 )
- putName(algo2d.GetSubMesh(), "facePeau")
- putName(algo2d, "algo2d_facePeau")
- putName(hypo2d, "hypo2d_facePeau")
- #
- lenEdgePeauFiss = geompy.BasicProperties(edgePeauFiss)[0]
- frac = profondeur/lenEdgePeauFiss
- nbSeg = nbSegGenLong +2*nbSegGenBout
- ratio = (nbSegGenBout/float(profondeur)) / (nbSegGenLong/lenEdgePeauFiss)
- logging.info("lenEdgePeauFiss %s, profondeur %s, nbSegGenLong %s, nbSegGenBout %s, frac %s, ratio %s", lenEdgePeauFiss, profondeur, nbSegGenLong, nbSegGenBout, frac, ratio)
- algo1d = meshFacePeau.Segment(geom=edgePeauFiss)
- hypo1d = algo1d.NumberOfSegments(nbSeg,[],[ ])
- hypo1d.SetDistrType( 2 )
- hypo1d.SetConversionMode( 1 )
- hypo1d.SetTableFunction( [ 0, ratio, frac, 1, (1.-frac), 1, 1, ratio ] )
- putName(algo1d.GetSubMesh(), "edgePeauFiss")
- putName(algo1d, "algo1d_edgePeauFiss")
- putName(hypo1d, "hypo1d_edgePeauFiss")
- #
- algo1d = meshFacePeau.UseExisting1DElements(geom=groupEdgesBordPeau)
- hypo1d = algo1d.SourceEdges([ bordsLibres ],0,0)
- putName(algo1d.GetSubMesh(), "bordsLibres")
- putName(algo1d, "algo1d_bordsLibres")
- putName(hypo1d, "hypo1d_bordsLibres")
- #
- for i in range(2):
- algo1d = meshFacePeau.UseExisting1DElements(geom=groupsDemiCerclesPeau[i])
- hypo1d = algo1d.SourceEdges([ groups_demiCercles[i] ],0,0)
- putName(algo1d.GetSubMesh(), "DemiCercles", i)
- putName(algo1d, "algo1d_groupDemiCercles", i)
- putName(hypo1d, "hypo1d_groupDemiCercles", i)
- #
- isDone = meshFacePeau.Compute()
- logging.info("meshFacePeau computed")
- grpTHOR = meshFacePeau.GroupOnGeom(verticesOutCercles[0], "THOR", SMESH.NODE)
- grpTHEX = meshFacePeau.GroupOnGeom(verticesOutCercles[1], "THEX", SMESH.NODE)
-
- groupEdgesPeauFiss = meshFacePeau.GroupOnGeom(edgePeauFiss, "PeauFis", SMESH.EDGE)
-
- peauext_face = meshFacePeau.CreateEmptyGroup( SMESH.FACE, 'PEAUEXT' )
- nbAdd = peauext_face.AddFrom( meshFacePeau.GetMesh() )
-
+ meshFacePeau, groupEdgesPeauFiss = \
+ insereFissureLongue_b (facePeau, edgePeauFiss, groupEdgesBordPeau, bordsLibres, \
+ groupsDemiCerclesPeau, groups_demiCercles, verticesOutCercles, \
+ nbSegGenLong, nbSegGenBout, profondeur)
# --- maillage face de fissure
- meshFaceFiss = smesh.Mesh(faceFiss)
- algo2d = meshFaceFiss.Triangle(algo=smeshBuilder.NETGEN_2D)
- hypo2d = algo2d.Parameters()
- hypo2d.SetMaxSize( (profondeur - rayonPipe)/math.sqrt(3.0) ) # pour avoir deux couches de triangles equilateraux partout sur la fissure
- hypo2d.SetOptimize( 1 )
- hypo2d.SetFineness( 2 )
- hypo2d.SetMinSize( 2 )
- hypo2d.SetQuadAllowed( 0 )
- putName(algo2d.GetSubMesh(), "faceFiss")
- putName(algo2d, "algo2d_faceFiss")
- putName(hypo2d, "hypo2d_faceFiss")
- #
- algo1d = meshFaceFiss.UseExisting1DElements(geom=edgePeauFiss)
- hypo1d = algo1d.SourceEdges([ groupEdgesPeauFiss ],0,0)
- putName(algo1d.GetSubMesh(), "edgeFissPeau")
- putName(algo1d, "algo1d_edgeFissPeau")
- putName(hypo1d, "hypo1d_edgeFissPeau")
- #
- algo1d = meshFaceFiss.UseExisting1DElements(geom=groupEdgesFaceFissPipe)
- hypo1d = algo1d.SourceEdges([ group_generFiss ],0,0)
- putName(algo1d.GetSubMesh(), "edgeFissPeau")
- putName(algo1d, "algo1d_edgeFissPeau")
- putName(hypo1d, "hypo1d_edgeFissPeau")
- #
- isDone = meshFaceFiss.Compute()
- logging.info("meshFaceFiss computed")
-
- grp = meshFaceFiss.GroupOnGeom(faceFiss, "fisOutPi", SMESH.FACE)
-
- meshBoiteDefaut = smesh.Concatenate([internalBoundary.GetMesh(),
- meshFondFiss.GetMesh(),
- meshFacePeau.GetMesh(),
- meshFaceFiss.GetMesh()],
- 1, 1, 1e-05,False)
- # pour aider l'algo hexa-tetra a ne pas mettre de pyramides a l'exterieur des volumes replies sur eux-memes
- # on designe les faces de peau en quadrangles par le groupe "skinFaces"
- group_faceFissOutPipe = None
- group_faceFissInPipe = None
- groups = meshBoiteDefaut.GetGroups()
- for grp in groups:
- if grp.GetType() == SMESH.FACE:
- #if "internalBoundary" in grp.GetName():
- # grp.SetName("skinFaces")
- if grp.GetName() == "fisOutPi":
- group_faceFissOutPipe = grp
- elif grp.GetName() == "fisInPi":
- group_faceFissInPipe = grp
-
- # le maillage NETGEN ne passe pas toujours ==> utiliser GHS3D
+ meshFaceFiss = \
+ insereFissureLongue_c (faceFiss, groupEdgesPeauFiss, edgePeauFiss, group_generFiss, groupEdgesFaceFissPipe, \
+ profondeur, rayonPipe)
+
+ # --- maillage meshBoiteDefaut
+
distene=True
- if distene:
- algo3d = meshBoiteDefaut.Tetrahedron(algo=smeshBuilder.GHS3D)
- else:
- algo3d = meshBoiteDefaut.Tetrahedron(algo=smeshBuilder.NETGEN)
- hypo3d = algo3d.MaxElementVolume(1000.0)
- putName(algo3d.GetSubMesh(), "boiteDefaut")
- putName(algo3d, "algo3d_boiteDefaut")
- isDone = meshBoiteDefaut.Compute()
- logging.info("meshBoiteDefaut computed")
- putName(meshBoiteDefaut, "boiteDefaut")
+ meshBoiteDefaut, group_faceFissInPipe, group_faceFissOutPipe = \
+ insereFissureLongue_d (internalBoundary, meshFondFiss, meshFacePeau, meshFaceFiss, \
+ distene)
+
groups = maillageSain.GetGroups()
grps1 = [ grp for grp in groups if grp.GetName() == 'P1']
#isDone = maillageComplet.ReorientObject( grps[0] )
fond = maillageComplet.GetMesh().CreateDimGroup( grps, SMESH.NODE, 'FACE2' )
- maillageComplet.ExportMED( fichierMaillageFissure, 0, SMESH.MED_V2_2, 1 )
+ maillageComplet.ExportMED(fichierMaillageFissure)
putName(maillageComplet, nomFicFissure)
logging.info("fichier maillage fissure %s", fichierMaillageFissure)
if salome.sg.hasDesktop():
- salome.sg.updateObjBrowser(True)
+ salome.sg.updateObjBrowser()
- return maillageComplet
\ No newline at end of file
+ return maillageComplet