X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FTools%2FblocFissure%2Fgmu%2FfissureCoude.py;h=e5b22727d7464c05a8949f9d3c1d1024c4a243e0;hp=c2fa0e36ffa86d2eca89e00335bdb6a51e01e141;hb=2cf6435f1492b63b9adf4e8256d88968638ed9bf;hpb=d5029840731bccaa1718e65f0abf3b19198c7293 diff --git a/src/Tools/blocFissure/gmu/fissureCoude.py b/src/Tools/blocFissure/gmu/fissureCoude.py index c2fa0e36f..e5b22727d 100644 --- a/src/Tools/blocFissure/gmu/fissureCoude.py +++ b/src/Tools/blocFissure/gmu/fissureCoude.py @@ -1,18 +1,36 @@ # -*- coding: utf-8 -*- +# Copyright (C) 2014-2021 EDF R&D +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# +"""Fissure dans un coude""" + +import os -from .geomsmesh import geompy, smesh -from .geomsmesh import geomPublish -from .geomsmesh import geomPublishInFather -from . import initLog - +import logging import math import GEOM -import SALOMEDS import SMESH -#import StdMeshers -#import GHS3DPlugin -#import NETGENPlugin -import logging + +from . import initLog + +from .geomsmesh import geompy, smesh +from .geomsmesh import geomPublish +from .geomsmesh import geomPublishInFather from .fissureGenerique import fissureGenerique @@ -21,16 +39,17 @@ from .genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut from .creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain from .construitFissureGenerale import construitFissureGenerale from .sortEdges import sortEdges +from .putName import putName O, OX, OY, OZ = triedreBase() class fissureCoude(fissureGenerique): - """ - problème de fissure du Coude : version de base - maillage hexa - """ + """Problème de fissure du Coude : version de base - maillage hexa""" - nomProbleme = "tuyau_Coude" + nomProbleme = "fissureCoude" + longitudinale = None + circonferentielle = None + elliptique = None # --------------------------------------------------------------------------- def setParamGeometrieSaine(self): @@ -52,6 +71,7 @@ class fissureCoude(fissureGenerique): # --------------------------------------------------------------------------- def genereGeometrieSaine(self, geomParams): + """a écrire""" logging.info("genereGeometrieSaine %s", self.nomCas) angleCoude = geomParams['angleCoude'] @@ -72,22 +92,22 @@ class fissureCoude(fissureGenerique): 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) - geomPublish(initLog.debug, plan_y, "plan_y" ) - geomPublish(initLog.debug, tube_1, "tube_1" ) - geomPublish(initLog.debug, coude, "coude" ) - geomPublish(initLog.debug, tube_2, "tube_2" ) + geomPublish(initLog.debug, plan_y, "plan_y", self.numeroCas ) + geomPublish(initLog.debug, tube_1, "tube_1", self.numeroCas ) + geomPublish(initLog.debug, coude, "coude", self.numeroCas ) + geomPublish(initLog.debug, tube_2, "tube_2", self.numeroCas ) P1 = O - geompy.addToStudy(P1, "P1" ) + geomPublish(initLog.always, P1, "P1", self.numeroCas ) 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" ) + geomPublish(initLog.always, P2, "P2", self.numeroCas ) # --- tube coude sain geometrieSaine = geompy.MakePartition([tube_1, coude, tube_2, P1, P2], [plan_y], [], [], geompy.ShapeType["SOLID"], 0, [], 1) - geomPublish(initLog.debug, geometrieSaine, self.nomCas ) + geomPublish(initLog.debug, geometrieSaine, self.nomCas, self.numeroCas ) [P1, P2] = geompy.RestoreGivenSubShapes(geometrieSaine, [P1, P2], GEOM.FSM_GetInPlaceByHistory, False, True) xmin = -de -r_cintr -l_tube_p2 @@ -127,7 +147,7 @@ class fissureCoude(fissureGenerique): grped = geompy.CutGroups(grped, long_p2) ep = geompy.CutGroups(grped, long_coude) geomPublishInFather(initLog.debug, geometrieSaine, long_p1, 'long_p1' ) - geomPublishInFather(initLog.debug, geometrieSaine, ep, 'ep' ) + geomPublishInFather(initLog.debug, geometrieSaine, ep, 'ep') geomPublishInFather(initLog.debug, geometrieSaine, long_coude, 'long_coude' ) geomPublishInFather(initLog.debug, geometrieSaine, circ_g, 'circ_g' ) geomPublishInFather(initLog.debug, geometrieSaine, circ_d, 'circ_d' ) @@ -144,7 +164,7 @@ class fissureCoude(fissureGenerique): 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 = [] + edgesIds = list() for edge in edge1Ids: if edge in edge2Ids: edgesIds.append(edge) @@ -156,7 +176,7 @@ class fissureCoude(fissureGenerique): pp2 = geompy.MakeTranslationVectorDistance(P2, Rotation_2, 10) vec2 = geompy.MakeVector(P2, pp2) - #geomPublish(initLog.debug, vec2, 'vec2') + #geomPublish(initLog.debug, vec2, 'vec2', self.numeroCas) facesIds = geompy.GetShapesOnPlaneIDs(geometrieSaine, geompy.ShapeType["FACE"], vec2, GEOM.ST_ON) CLGV = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["FACE"]) geompy.UnionIDs(CLGV, facesIds) @@ -170,7 +190,7 @@ class fissureCoude(fissureGenerique): extru2 = geompy.MakePrismVecH(rot1, Rotation_2, -l_tube_p2) interne = geompy.MakeFuse(extru1, revol1) interne = geompy.MakeFuse(extru2, interne) - geomPublish(initLog.debug, interne, 'interne') + geomPublish(initLog.debug, interne, 'interne', self.numeroCas) facesIds = geompy.GetShapesOnShapeIDs(interne, geometrieSaine, geompy.ShapeType["FACE"], GEOM.ST_ONIN) PEAUINT = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["FACE"]) geompy.UnionIDs(PEAUINT, facesIds) @@ -185,7 +205,7 @@ class fissureCoude(fissureGenerique): extru2 = geompy.MakePrismVecH(rot1, Rotation_2, -l_tube_p2) externe = geompy.MakeFuse(extru1, revol1) externe = geompy.MakeFuse(extru2, externe) - geomPublish(initLog.debug, externe, 'externe') + geomPublish(initLog.debug, externe, 'externe', self.numeroCas) facesIds = geompy.GetShapesOnShapeIDs(externe, geometrieSaine, geompy.ShapeType["FACE"], GEOM.ST_ON) PEAUEXT = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["FACE"]) geompy.UnionIDs(PEAUEXT, facesIds) @@ -242,49 +262,56 @@ class fissureCoude(fissureGenerique): algo3d = maillageSain.Hexahedron() algo2d = maillageSain.Quadrangle() - smesh.SetName(algo3d, "algo3d_maillageSain") - smesh.SetName(algo2d, "algo2d_maillageSain") + putName(algo3d, "{}_3d_maillageSain".format(self.mailleur2d3d()), i_pref=self.numeroCas) + putName(algo2d, "{}_2d_maillageSain".format(self.mailleur2d3d()), i_pref=self.numeroCas) algo1d_long_p1 = maillageSain.Segment(geom=long_p1) hypo1d_long_p1 = algo1d_long_p1.NumberOfSegments(n_long_p1) - smesh.SetName(algo1d_long_p1, "algo1d_long_p1") - smesh.SetName(hypo1d_long_p1, "hypo1d_long_p1") + putName(algo1d_long_p1, "algo1d_long_p1", i_pref=self.numeroCas) + putName(hypo1d_long_p1, "hypo1d_long_p1", i_pref=self.numeroCas) algo1d_ep = maillageSain.Segment(geom=ep) hypo1d_ep = algo1d_ep.NumberOfSegments(n_ep) - smesh.SetName(algo1d_ep, "algo1d_ep") - smesh.SetName(hypo1d_ep, "hypo1d_ep") + putName(algo1d_ep, "algo1d_ep", i_pref=self.numeroCas) + putName(hypo1d_ep, "hypo1d_ep", i_pref=self.numeroCas) algo1d_long_coude = maillageSain.Segment(geom=long_coude) hypo1d_long_coude = algo1d_long_coude.NumberOfSegments(n_long_coude) - smesh.SetName(algo1d_long_coude, "algo1d_long_coude") - smesh.SetName(hypo1d_long_coude, "hypo1d_long_coude") + putName(algo1d_long_coude, "algo1d_long_coude", i_pref=self.numeroCas) + putName(hypo1d_long_coude, "hypo1d_long_coude", i_pref=self.numeroCas) algo1d_circ_g = maillageSain.Segment(geom=circ_g) hypo1d_circ_g = algo1d_circ_g.NumberOfSegments(n_circ_g) - smesh.SetName(algo1d_circ_g, "algo1d_circ_g") - smesh.SetName(hypo1d_circ_g, "hypo1d_circ_g") + putName(algo1d_circ_g, "algo1d_circ_g", i_pref=self.numeroCas) + putName(hypo1d_circ_g, "hypo1d_circ_g", i_pref=self.numeroCas) algo1d_circ_d = maillageSain.Segment(geom=circ_d) hypo1d_circ_d = algo1d_circ_d.NumberOfSegments(n_circ_d) - smesh.SetName(algo1d_circ_d, "algo1d_circ_d") - smesh.SetName(hypo1d_circ_d, "hypo1d_circ_d") + putName(algo1d_circ_d, "algo1d_circ_d", i_pref=self.numeroCas) + putName(hypo1d_circ_d, "hypo1d_circ_d", i_pref=self.numeroCas) algo1d_long_p2 = maillageSain.Segment(geom=long_p2) hypo1d_long_p2 = algo1d_long_p2.NumberOfSegments(n_long_p2) - smesh.SetName(algo1d_long_p2, "algo1d_long_p2") - smesh.SetName(hypo1d_long_p2, "hypo1d_long_p2") - - isDone = maillageSain.Compute() + putName(algo1d_long_p2, "algo1d_long_p2", i_pref=self.numeroCas) + putName(hypo1d_long_p2, "hypo1d_long_p2", i_pref=self.numeroCas) - 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) + is_done = maillageSain.Compute() + text = "maillageSain.Compute" + if is_done: + logging.info(text+" OK") + else: + text = "Erreur au calcul du maillage.\n" + text + logging.info(text) + raise Exception(text) + + _ = maillageSain.GroupOnGeom(P1,'P1',SMESH.NODE) + _ = maillageSain.GroupOnGeom(P2,'P2',SMESH.NODE) + _ = maillageSain.GroupOnGeom(EXTUBE,'EXTUBE',SMESH.FACE) + _ = maillageSain.GroupOnGeom(BORDTU,'BORDTU',SMESH.EDGE) + _ = maillageSain.GroupOnGeom(CLGV,'CLGV',SMESH.FACE) + _ = maillageSain.GroupOnGeom(PEAUINT,'PEAUINT',SMESH.FACE) + _ = maillageSain.GroupOnGeom(PEAUEXT,'PEAUEXT',SMESH.FACE) + _ = maillageSain.GroupOnGeom(COUDE,'COUDSAIN',SMESH.VOLUME) return [maillageSain, True] # True : maillage hexa @@ -317,14 +344,13 @@ class fissureCoude(fissureGenerique): externe = True) # --------------------------------------------------------------------------- - def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams): + def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams, \ + mailleur="MeshGems"): logging.info("genereShapeFissure %s", self.nomCas) logging.info("shapeFissureParams %s", shapeFissureParams) - angleCoude = geomParams['angleCoude'] 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'] @@ -339,11 +365,9 @@ class fissureCoude(fissureGenerique): if 'elliptique' in shapeFissureParams: self.elliptique = shapeFissureParams['elliptique'] - - azimut = -azimut # axe inverse / ASCOUF axe = geompy.MakeTranslation(OY, -r_cintr, 0, -l_tube_p1) - geomPublish(initLog.debug, axe,"axe") + geomPublish(initLog.debug, axe,"axe", self.numeroCas) if not lgInfluence: lgInfluence = profondeur @@ -357,10 +381,8 @@ class fissureCoude(fissureGenerique): self.circonferentielle = False self.longitudinale = False if self.fissureLongue and not self.elliptique: - if abs(orientation) < 45 : - self.longitudinale = True - else: - self.circonferentielle = True + self.longitudinale = bool(abs(orientation) < 45) + self.circonferentielle = not bool(abs(orientation) < 45) nbp1 = 10 if self.circonferentielle: @@ -374,45 +396,45 @@ class fissureCoude(fissureGenerique): raybor = de/2. - epais rayint = raybor + profondeur rayext = raybor - profondeur/5.0 - lgfond = longueur -2*profondeur - angle = lgfond/(2*raybor) + 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) - geomPublish(initLog.debug, pbl,"pbl") - geomPublish(initLog.debug, pbr,"pbr") + geomPublish(initLog.debug, pbl,"pbl", self.numeroCas) + geomPublish(initLog.debug, pbr,"pbr", self.numeroCas) 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 = [] + points = list() nbp = 3*nbp1 - for i in range(nbp): - angi = dp*(nbp -i)*(2.0*math.pi/3.0)/nbp + for i_aux in range(nbp): + angi = dp*(nbp - i_aux)*(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 + for i_aux in range(nbp): + angi = angle -2.0*float(i_aux)*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 + for i_aux in range(nbp+1): + angi = -dp*float(i_aux)*(2.0*math.pi/3.0)/nbp pt = geompy.MakeRotation(pir, axr, angi) points.append(pt) - for i, pt in enumerate(points): + for i_aux, 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 + points[i_aux] = 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]) - geomPublish(initLog.debug, wiretube,"wiretube") + geomPublish(initLog.debug, wiretube,"wiretube", self.numeroCas) pe = geompy.MakeVertex(rayext, 0, 0) pe = geompy.MakeRotation(pe, OZ, azimut*math.pi/180.) @@ -420,22 +442,22 @@ class fissureCoude(fissureGenerique): pe = geompy.MakeRotation(pe, axe, alpha*math.pi/180.) arce = geompy.MakeArc(points[0], pe, points[-1]) - geomPublish(initLog.debug, arce,"arce") + geomPublish(initLog.debug, arce,"arce", self.numeroCas) facefiss = geompy.MakeFaceWires([arce, wiretube], 1) - geomPublish(initLog.debug, facefiss, 'facefissPlace' ) + geomPublish(initLog.debug, facefiss, 'facefissPlace', self.numeroCas ) 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.) - geomPublish(initLog.debug, centre, 'centrefissPlace' ) + geomPublish(initLog.debug, centre, 'centrefissPlace', self.numeroCas ) wiretube = geompy.GetInPlace(facefiss, wiretube) - geomPublish(initLog.debug, wiretube, 'wiretubePlace' ) + geomPublish(initLog.debug, wiretube, 'wiretubePlace', self.numeroCas ) try: edgetube = geompy.MakeEdgeWire(wiretube) - geomPublish(initLog.debug, edgetube,"edgetube") + geomPublish(initLog.debug, edgetube,"edgetube", self.numeroCas) except: logging.debug("erreur MakeEdgeWire sur fond de fissure, on fait sans") edgetube = None @@ -468,109 +490,109 @@ class fissureCoude(fissureGenerique): pil = geompy.MakeRotation(pi, axe, alfrd -angle, "pil") pir = geompy.MakeRotation(pi, axe, alfrd +angle, "pir") - curves = [] + curves = list() - points = [] + points = list() nbp = 3*nbp1 - xs = [] + xs = list() totx = 0 - for i in range(nbp+2): - x = math.sin(i*math.pi/(nbp+1)) # fonction de répartition des points : distance relative + for i_aux in range(nbp+2): + x = math.sin(float(i_aux)*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 + for i_aux in range(nbp+1): + #posi = nbp - i_aux # répartition équidistante des points sur la courbe + posi = nbp*(1 -xs[i_aux]/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] - geomPublish(initLog.debug, curves[-1],"curve0") -# for i, pt in enumerate(points): -# name = "point%d"%i + geomPublish(initLog.debug, curves[-1],"curve0", self.numeroCas) +# for i_aux, pt in enumerate(points): +# name = "point%d"%i_aux # geomPublishInFather(initLog.debug,curves[-1], pt, name) - points = [] + points = list() nbp = 3*nbp1 - xs =[] + xs = list() totx = 0 - for i in range(nbp+1): - x = math.sin(i*math.pi/nbp) + for i_aux in range(nbp+1): + x = math.sin(float(i_aux)*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 + for i_aux in range(nbp): + angi = alfrd -angle +2.0*angle*xs[i_aux]/totx pt = geompy.MakeRotation(pi, axe, angi) points.append(pt) curves.append(geompy.MakeInterpol(points)) - geomPublish(initLog.debug, curves[-1],"curve1") -# for i, pt in enumerate(points): -# name = "point%d"%i + geomPublish(initLog.debug, curves[-1],"curve1", self.numeroCas) +# for i_aux, pt in enumerate(points): +# name = "point%d"%i_aux # geomPublishInFather(initLog.debug,curves[-1], pt, name) - points = [] + points = list() nbp = 3*nbp1 - xs = [] + xs = list() totx = 0 - for i in range(nbp+2): - x = math.sin(i*math.pi/(nbp+1)) + for i_aux in range(nbp+2): + x = math.sin(float(i_aux)*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 + for i_aux in range(nbp+1): + #posi = nbp - i_aux # répartition équidistante des points sur la courbe + posi = nbp*xs[i_aux]/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] - geomPublish(initLog.debug, curves[-1],"curve2") -# for i, pt in enumerate(points): -# name = "point%d"%i + geomPublish(initLog.debug, curves[-1],"curve2", self.numeroCas) +# for i_aux, pt in enumerate(points): +# name = "point%d"%i_aux # geomPublishInFather(initLog.debug,curves[-1], pt, name) wiretube = geompy.MakeWire(curves) - geomPublish(initLog.debug, wiretube,"wiretube") + geomPublish(initLog.debug, wiretube,"wiretube", self.numeroCas) try: edgetube = geompy.MakeEdgeWire(wiretube) - geomPublish(initLog.debug, edgetube,"edgetube") + geomPublish(initLog.debug, edgetube,"edgetube", self.numeroCas) except: logging.debug("erreur MakeEdgeWire sur fond de fissure, on fait sans") edgetube = None - pts = [] + pts = list() 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 + for i_aux in range(nbp): + angi = alfrd -angle +2.0*float(i_aux)*angle/nbp pt = geompy.MakeRotation(pe, axe, angi) pts.append(pt) pts.append(point1) arce = geompy.MakeInterpol(pts) - geomPublish(initLog.debug, arce,"arce") + geomPublish(initLog.debug, arce,"arce", self.numeroCas) facefiss = geompy.MakeFaceWires([arce, wiretube], 0) - geomPublish(initLog.debug, facefiss, 'facefissPlace' ) + geomPublish(initLog.debug, facefiss, 'facefissPlace', self.numeroCas) pc = geompy.MakeTranslation(pb, 0.5*prof*cosaz, 0.5*prof*sinaz, 0.) centre = geompy.MakeRotation(pc, axe, alfrd) - geomPublish(initLog.debug, centre, 'centrefissPlace' ) + geomPublish(initLog.debug, centre, 'centrefissPlace', self.numeroCas) edges = geompy.ExtractShapes(facefiss, geompy.ShapeType["EDGE"], True) - edgesTriees, minl, maxl = sortEdges(edges) + edgesTriees, _, _ = sortEdges(edges) edges = edgesTriees[:-1] # la plus grande correspond à arce, on l'elimine wiretube = geompy.MakeWire(edges) #wiretube = edgesTriees[-1] - geomPublish(initLog.debug, wiretube, 'wiretubePlace' ) + geomPublish(initLog.debug, wiretube, 'wiretubePlace', self.numeroCas) # --------------------------------------------------------- @@ -615,17 +637,18 @@ class fissureCoude(fissureGenerique): arci = geompy.MakePosition(arco, originLCS, localLCS, "arci") arce = geompy.MakePosition(lino, originLCS, localLCS, "arce") facefiss = geompy.MakeFaceWires([arce, arci], 0) - geomPublish(initLog.debug, facefiss, 'facefissPlace' ) + geomPublish(initLog.debug, facefiss, 'facefissPlace', self.numeroCas ) edges = geompy.ExtractShapes(facefiss, geompy.ShapeType["EDGE"], True) - edgesTriees, minl, maxl = sortEdges(edges) + edgesTriees, _, _ = 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) - geomPublish(initLog.debug, centre, 'centrefissPlace' ) + geomPublish(initLog.debug, centre, 'centrefissPlace', self.numeroCas ) - coordsNoeudsFissure = genereMeshCalculZoneDefaut(facefiss, profondeur/2. ,profondeur) + coordsNoeudsFissure = genereMeshCalculZoneDefaut(facefiss, profondeur/2. ,profondeur, \ + mailleur, self.numeroCas) return [facefiss, centre, lgInfluence, coordsNoeudsFissure, wiretube, edgetube] @@ -638,7 +661,7 @@ class fissureCoude(fissureGenerique): nbSegCercle = nombre de secteurs areteFaceFissure = taille cible de l'arête des triangles en face de fissure. """ - self.maillageFissureParams = dict(nomRep = '.', + self.maillageFissureParams = dict(nomRep = os.curdir, nomFicSain = self.nomCas, nomFicFissure = 'fissure_' + self.nomCas, nbsegRad = 5, @@ -647,26 +670,29 @@ class fissureCoude(fissureGenerique): # --------------------------------------------------------------------------- def genereZoneDefaut(self, geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams): - elementsDefaut = creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams) + elementsDefaut = creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams, \ + self.numeroCas) return elementsDefaut # --------------------------------------------------------------------------- - def genereMaillageFissure(self, geometriesSaines, maillagesSains, - shapesFissure, shapeFissureParams, - maillageFissureParams, elementsDefaut, step): - maillageFissure = construitFissureGenerale(maillagesSains, - shapesFissure, shapeFissureParams, - maillageFissureParams, elementsDefaut, step) + def genereMaillageFissure(self, geometriesSaines, maillagesSains, \ + shapesFissure, shapeFissureParams, \ + maillageFissureParams, elementsDefaut, step, \ + mailleur="MeshGems"): + maillageFissure = construitFissureGenerale(shapesFissure, shapeFissureParams, \ + maillageFissureParams, elementsDefaut, \ + mailleur, self.numeroCas) 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) - + self.referencesMaillageFissure = dict( \ + Entity_Quad_Edge = 975, \ + Entity_Quad_Quadrangle = 6842, \ + Entity_Quad_Hexa = 8994, \ + Entity_Node = 77917, \ + Entity_Quad_Triangle = 2182, \ + Entity_Quad_Tetra = 20135, \ + Entity_Quad_Pyramid = 1038, \ + Entity_Quad_Penta = 972 \ + )