src/Tools/blocFissure/gmu/fissureCoude.py

   1 # -*- coding: utf-8 -*-
   2
   3 from geomsmesh import geompy, smesh
   4
   5 import math
   6 import GEOM
   7 import SALOMEDS
   8 import SMESH
   9 #import StdMeshers
  10 #import GHS3DPlugin
  11 #import NETGENPlugin
  12 import logging
  13
  14 from fissureGenerique import fissureGenerique
  15
  16 from triedreBase import triedreBase
  17 from genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
  18 from creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
  19 from insereFissureGenerale import insereFissureGenerale
  20 from sortEdges import sortEdges
  21
  22 O, OX, OY, OZ = triedreBase()
  23
  24 class fissureCoude(fissureGenerique):
  25   """
  26   problème de fissure du Coude : version de base
  27   maillage hexa
  28   """
  29
  30   nomProbleme = "tuyau_Coude"
  31
  32   # ---------------------------------------------------------------------------
  33   def setParamGeometrieSaine(self):
  34     """
  35     Paramètres géométriques du tuyau coudé sain:
  36     angleCoude
  37     r_cintr
  38     l_tube_p1
  39     l_tube_p2
  40     epais
  41     de
  42     """
  43     self.geomParams = dict(angleCoude = 60,
  44                            r_cintr    = 1200,
  45                            l_tube_p1  = 1600,
  46                            l_tube_p2  = 1200,
  47                            epais      = 40,
  48                            de         = 760)
  49
  50   # ---------------------------------------------------------------------------
  51   def genereGeometrieSaine(self, geomParams):
  52     logging.info("genereGeometrieSaine %s", self.nomCas)
  53
  54     angleCoude = geomParams['angleCoude']
  55     r_cintr    = geomParams['r_cintr']
  56     l_tube_p1  = geomParams['l_tube_p1']
  57     l_tube_p2  = geomParams['l_tube_p2']
  58     epais      = geomParams['epais']
  59     de         = geomParams['de']
  60
  61     centre = geompy.MakeVertex(0, 0, -l_tube_p1)
  62     diskext = geompy.MakeDiskPntVecR(centre, OZ, de/2.)
  63     diskint = geompy.MakeDiskPntVecR(centre, OZ, de/2. -epais)
  64     couronne = geompy.MakeCut(diskext, diskint)
  65     tube_1 = geompy.MakePrismVecH(couronne, OZ, l_tube_p1)
  66     axe = geompy.MakeTranslation(OY, -r_cintr, 0, -l_tube_p1)
  67     coude = geompy.MakeRevolution(couronne, axe, angleCoude*math.pi/180.0)
  68     Rotation_1 = geompy.MakeRotation(couronne, axe, angleCoude*math.pi/180.0)
  69     Rotation_2 = geompy.MakeRotation(OZ, OY, angleCoude*math.pi/180.0)
  70     tube_2 = geompy.MakePrismVecH(Rotation_1, Rotation_2, -l_tube_p2)
  71     plan_y = geompy.MakePlaneLCS(None, 100000, 3)
  72     geompy.addToStudy( plan_y, "plan_y" )
  73     geompy.addToStudy( tube_1, "tube_1" )
  74     geompy.addToStudy( coude, "coude" )
  75     geompy.addToStudy( tube_2, "tube_2" )
  76
  77     P1 = O
  78     geompy.addToStudy( P1, "P1" )
  79     op2 = geompy.MakeVertex(0, 0, -l_tube_p1)
  80     P2 = geompy.MakeRotation(op2, axe, angleCoude*math.pi/180.0)
  81     P2 = geompy.MakeTranslationVectorDistance(P2, Rotation_2, -l_tube_p2)
  82     geompy.addToStudy( P2, "P2" )
  83
  84     # --- tube coude sain
  85
  86     geometrieSaine = geompy.MakePartition([tube_1, coude, tube_2, P1, P2], [plan_y], [], [], geompy.ShapeType["SOLID"], 0, [], 1)
  87     geompy.addToStudy( geometrieSaine, self.nomCas )
  88     [P1, P2] = geompy.RestoreGivenSubShapes(geometrieSaine, [P1, P2], GEOM.FSM_GetInPlaceByHistory, False, True)
  89
  90     xmin = -de -r_cintr -l_tube_p2
  91     zmin = -l_tube_p1 -r_cintr -l_tube_p2 -de
  92     ymax = de +100.
  93     boxypos = geompy.MakeBox(xmin, 0, zmin, ymax, ymax, 100, "boxypos")
  94     boxyneg = geompy.MakeBox(xmin, 0, zmin, ymax, -ymax, 100, "boxyneg")
  95     edgesypos = geompy.GetShapesOnShape(boxypos, geometrieSaine, geompy.ShapeType["EDGE"], GEOM.ST_IN)
  96     edgesyneg = geompy.GetShapesOnShape(boxyneg, geometrieSaine, geompy.ShapeType["EDGE"], GEOM.ST_IN)
  97     circ_g = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["EDGE"])
  98     geompy.UnionList(circ_g, edgesyneg)
  99     circ_d = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["EDGE"])
 100     geompy.UnionList(circ_d, edgesypos)
 101     edgesy0pos = geompy.GetShapesOnShape(boxypos, geometrieSaine, geompy.ShapeType["EDGE"], GEOM.ST_ONIN)
 102     grpedpos = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["EDGE"])
 103     geompy.UnionList(grpedpos, edgesy0pos)
 104     grpedy0 = geompy.CutGroups(grpedpos, circ_d, "edges_y0")
 105     boxtub1 = geompy.MakeBox(-de/2.0 -1, -1, -l_tube_p1, de, de, 0, "boxtub1")
 106     edgestub1 = geompy.GetShapesOnShape(boxtub1, geometrieSaine, geompy.ShapeType["EDGE"], GEOM.ST_IN)
 107     grped = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["EDGE"])
 108     geompy.UnionList(grped, edgestub1)
 109     long_p1 = geompy.IntersectGroups(grped, grpedy0)
 110     boxtub  = geompy.MakeBox(-de/2.0 -1, -1, -l_tube_p1 -l_tube_p2, de, de, -l_tube_p1)
 111     boxtub2 = geompy.MakeRotation(boxtub, axe, angleCoude*math.pi/180.0, "boxttub2")
 112     edgestub2 = geompy.GetShapesOnShape(boxtub2, geometrieSaine, geompy.ShapeType["EDGE"], GEOM.ST_IN)
 113     grped = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["EDGE"])
 114     geompy.UnionList(grped, edgestub2)
 115     long_p2 = geompy.IntersectGroups(grped, grpedy0)
 116     boxtub1t = geompy.MakeTranslationVectorDistance(boxtub1, OZ, -l_tube_p1)
 117     facer = geompy.GetShapesOnShape(boxtub1t, boxtub1, geompy.ShapeType["FACE"], GEOM.ST_ONIN, "facer")
 118     boxcoud = geompy.MakeRevolution(facer[0], axe, angleCoude*math.pi/180.0, "boxcoud")
 119     edgescoud = geompy.GetShapesOnShape(boxcoud, geometrieSaine, geompy.ShapeType["EDGE"], GEOM.ST_IN)
 120     grped = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["EDGE"])
 121     geompy.UnionList(grped, edgescoud)
 122     long_coude = geompy.IntersectGroups(grped, grpedy0)
 123     grped = geompy.CutGroups(grpedy0, long_p1)
 124     grped = geompy.CutGroups(grped, long_p2)
 125     ep = geompy.CutGroups(grped, long_coude)
 126     geompy.addToStudyInFather( geometrieSaine, long_p1, 'long_p1' )
 127     geompy.addToStudyInFather( geometrieSaine, ep, 'ep' )
 128     geompy.addToStudyInFather( geometrieSaine, long_coude, 'long_coude' )
 129     geompy.addToStudyInFather( geometrieSaine, circ_g, 'circ_g' )
 130     geompy.addToStudyInFather( geometrieSaine, circ_d, 'circ_d' )
 131     geompy.addToStudyInFather( geometrieSaine, long_p2, 'long_p2' )
 132
 133     # --- face extremite tube (EXTUBE)
 134
 135     facesIds = geompy.GetShapesOnPlaneIDs(geometrieSaine, geompy.ShapeType["FACE"], OZ, GEOM.ST_ON)
 136     EXTUBE = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["FACE"])
 137     geompy.UnionIDs(EXTUBE, facesIds)
 138     geompy.addToStudyInFather( geometrieSaine, EXTUBE, 'EXTUBE' )
 139
 140     # --- edge bord extremite tube (BORDTU)
 141
 142     edge1Ids = geompy.GetShapesOnPlaneIDs(geometrieSaine, geompy.ShapeType["EDGE"], OZ, GEOM.ST_ON)
 143     edge2Ids = geompy.GetShapesOnCylinderIDs(geometrieSaine, geompy.ShapeType["EDGE"], OZ, de/2. -epais, GEOM.ST_ON)
 144     edgesIds = []
 145     for edge in edge1Ids:
 146       if edge in edge2Ids:
 147         edgesIds.append(edge)
 148     BORDTU = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["EDGE"])
 149     geompy.UnionIDs(BORDTU, edgesIds)
 150     geompy.addToStudyInFather( geometrieSaine, BORDTU, 'BORDTU' )
 151
 152     # --- face origine tube (CLGV)
 153
 154     pp2 = geompy.MakeTranslationVectorDistance(P2, Rotation_2, 10)
 155     vec2 = geompy.MakeVector(P2, pp2)
 156     #geompy.addToStudy(vec2, 'vec2')
 157     facesIds = geompy.GetShapesOnPlaneIDs(geometrieSaine, geompy.ShapeType["FACE"], vec2, GEOM.ST_ON)
 158     CLGV = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["FACE"])
 159     geompy.UnionIDs(CLGV, facesIds)
 160     geompy.addToStudyInFather( geometrieSaine, CLGV, 'CLGV' )
 161
 162     # --- peau tube interieur (PEAUINT)
 163
 164     extru1 = geompy.MakePrismVecH(diskint, OZ, l_tube_p1)
 165     revol1 = geompy.MakeRevolution(diskint, axe, angleCoude*math.pi/180.0)
 166     rot1 = geompy.MakeRotation(diskint, axe, angleCoude*math.pi/180.0)
 167     extru2 = geompy.MakePrismVecH(rot1, Rotation_2, -l_tube_p2)
 168     interne = geompy.MakeFuse(extru1, revol1)
 169     interne = geompy.MakeFuse(extru2, interne)
 170     geompy.addToStudy(interne, 'interne')
 171     facesIds = geompy.GetShapesOnShapeIDs(interne, geometrieSaine, geompy.ShapeType["FACE"], GEOM.ST_ONIN)
 172     PEAUINT = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["FACE"])
 173     geompy.UnionIDs(PEAUINT, facesIds)
 174     geompy.addToStudyInFather( geometrieSaine, PEAUINT, 'PEAUINT' )
 175
 176     # --- peau tube exterieur (PEAUEXT)
 177
 178     cercle1 = geompy.MakeCircle(centre, OZ, de/2.)
 179     extru1 = geompy.MakePrismVecH(cercle1, OZ, l_tube_p1)
 180     revol1 = geompy.MakeRevolution(cercle1, axe, angleCoude*math.pi/180.0)
 181     rot1 = geompy.MakeRotation(cercle1, axe, angleCoude*math.pi/180.0)
 182     extru2 = geompy.MakePrismVecH(rot1, Rotation_2, -l_tube_p2)
 183     externe = geompy.MakeFuse(extru1, revol1)
 184     externe = geompy.MakeFuse(extru2, externe)
 185     geompy.addToStudy(externe, 'externe')
 186     facesIds = geompy.GetShapesOnShapeIDs(externe, geometrieSaine, geompy.ShapeType["FACE"], GEOM.ST_ON)
 187     PEAUEXT = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["FACE"])
 188     geompy.UnionIDs(PEAUEXT, facesIds)
 189     geompy.addToStudyInFather( geometrieSaine, PEAUEXT, 'PEAUEXT' )
 190
 191     # --- solide sain
 192
 193     volIds = geompy.SubShapeAllIDs(geometrieSaine, geompy.ShapeType["SOLID"])
 194     COUDE = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["SOLID"])
 195     geompy.UnionIDs(COUDE, volIds)
 196     geompy.addToStudyInFather( geometrieSaine, COUDE, 'COUDSAIN' )
 197
 198     geometriesSaines = [geometrieSaine, long_p1, ep, long_coude, circ_g, circ_d, long_p2, P1, P2, EXTUBE, BORDTU, CLGV, PEAUINT, PEAUEXT, COUDE]
 199
 200     return geometriesSaines
 201
 202   # ---------------------------------------------------------------------------
 203   def setParamMaillageSain(self):
 204     self.meshParams = dict(n_long_p1    = 16,
 205                            n_ep         = 3,
 206                            n_long_coude = 15,
 207                            n_circ_g     = 20,
 208                            n_circ_d     = 20,
 209                            n_long_p2    = 12)
 210
 211   # ---------------------------------------------------------------------------
 212   def genereMaillageSain(self, geometriesSaines, meshParams):
 213     logging.info("genereMaillageSain %s", self.nomCas)
 214
 215     geometrieSaine = geometriesSaines[0]
 216     long_p1        = geometriesSaines[1]
 217     ep             = geometriesSaines[2]
 218     long_coude     = geometriesSaines[3]
 219     circ_g         = geometriesSaines[4]
 220     circ_d         = geometriesSaines[5]
 221     long_p2        = geometriesSaines[6]
 222     P1             = geometriesSaines[7]
 223     P2             = geometriesSaines[8]
 224     EXTUBE         = geometriesSaines[9]
 225     BORDTU         = geometriesSaines[10]
 226     CLGV           = geometriesSaines[11]
 227     PEAUINT        = geometriesSaines[12]
 228     PEAUEXT        = geometriesSaines[13]
 229     COUDE          = geometriesSaines[14]
 230
 231     n_long_p1    = meshParams['n_long_p1']
 232     n_ep         = meshParams['n_ep']
 233     n_long_coude = meshParams['n_long_coude']
 234     n_circ_g     = meshParams['n_circ_g']
 235     n_circ_d     = meshParams['n_circ_d']
 236     n_long_p2    = meshParams['n_long_p2']
 237
 238     maillageSain = smesh.Mesh(geometrieSaine)
 239
 240     algo3d = maillageSain.Hexahedron()
 241     algo2d = maillageSain.Quadrangle()
 242     smesh.SetName(algo3d, "algo3d_maillageSain")
 243     smesh.SetName(algo2d, "algo2d_maillageSain")
 244
 245     algo1d_long_p1 = maillageSain.Segment(geom=long_p1)
 246     hypo1d_long_p1 = algo1d_long_p1.NumberOfSegments(n_long_p1)
 247     smesh.SetName(algo1d_long_p1, "algo1d_long_p1")
 248     smesh.SetName(hypo1d_long_p1, "hypo1d_long_p1")
 249
 250     algo1d_ep = maillageSain.Segment(geom=ep)
 251     hypo1d_ep = algo1d_ep.NumberOfSegments(n_ep)
 252     smesh.SetName(algo1d_ep, "algo1d_ep")
 253     smesh.SetName(hypo1d_ep, "hypo1d_ep")
 254
 255     algo1d_long_coude = maillageSain.Segment(geom=long_coude)
 256     hypo1d_long_coude = algo1d_long_coude.NumberOfSegments(n_long_coude)
 257     smesh.SetName(algo1d_long_coude, "algo1d_long_coude")
 258     smesh.SetName(hypo1d_long_coude, "hypo1d_long_coude")
 259
 260     algo1d_circ_g = maillageSain.Segment(geom=circ_g)
 261     hypo1d_circ_g = algo1d_circ_g.NumberOfSegments(n_circ_g)
 262     smesh.SetName(algo1d_circ_g, "algo1d_circ_g")
 263     smesh.SetName(hypo1d_circ_g, "hypo1d_circ_g")
 264
 265     algo1d_circ_d = maillageSain.Segment(geom=circ_d)
 266     hypo1d_circ_d = algo1d_circ_d.NumberOfSegments(n_circ_d)
 267     smesh.SetName(algo1d_circ_d, "algo1d_circ_d")
 268     smesh.SetName(hypo1d_circ_d, "hypo1d_circ_d")
 269
 270     algo1d_long_p2 = maillageSain.Segment(geom=long_p2)
 271     hypo1d_long_p2 = algo1d_long_p2.NumberOfSegments(n_long_p2)
 272     smesh.SetName(algo1d_long_p2, "algo1d_long_p2")
 273     smesh.SetName(hypo1d_long_p2, "hypo1d_long_p2")
 274
 275     isDone = maillageSain.Compute()
 276
 277     mp1 = maillageSain.GroupOnGeom(P1,'P1',SMESH.NODE)
 278     mp2 = maillageSain.GroupOnGeom(P2,'P2',SMESH.NODE)
 279     ext = maillageSain.GroupOnGeom(EXTUBE,'EXTUBE',SMESH.FACE)
 280     btu = maillageSain.GroupOnGeom(BORDTU,'BORDTU',SMESH.EDGE)
 281     clg = maillageSain.GroupOnGeom(CLGV,'CLGV',SMESH.FACE)
 282     pei = maillageSain.GroupOnGeom(PEAUINT,'PEAUINT',SMESH.FACE)
 283     pex = maillageSain.GroupOnGeom(PEAUEXT,'PEAUEXT',SMESH.FACE)
 284     cou = maillageSain.GroupOnGeom(COUDE,'COUDSAIN',SMESH.VOLUME)
 285
 286     return [maillageSain, True] # True : maillage hexa
 287
 288   # ---------------------------------------------------------------------------
 289   def setParamShapeFissure(self):
 290     """
 291     paramètres de la fissure pour le tuyau coude
 292     profondeur  : 0 < profondeur <= épaisseur
 293     rayonPipe   : rayon du pipe correspondant au maillage rayonnant
 294     lenSegPipe  : longueur des mailles rayonnantes le long du fond de fissure (= rayonPipe par défaut)
 295     azimut      : entre 0 et 360°
 296     alpha       : 0 < alpha < angleCoude
 297     longueur    : <=2*profondeur ==> force une fissure elliptique (longueur/profondeur = grand axe/petit axe).
 298     orientation : 0° : longitudinale, 90° : circonférentielle, autre : uniquement fissures elliptiques
 299     lgInfluence : distance autour de la shape de fissure a remailler (si 0, pris égal à profondeur. A ajuster selon le maillage)
 300     elliptique  : True : fissure elliptique (longueur/profondeur = grand axe/petit axe); False : fissure longue (fond de fissure de profondeur constante, demi-cercles aux extrémites)
 301     pointIn_x   : optionnel coordonnées x d'un point dans le solide, pas trop loin du centre du fond de fissure (idem y,z)
 302     externe     : True : fissure face externe, False : fissure face interne
 303     """
 304     logging.info("setParamShapeFissure %s", self.nomCas)
 305     self.shapeFissureParams = dict(profondeur  = 10,
 306                                    rayonPipe   = 2.5,
 307                                    lenSegPipe  = 2.5,
 308                                    azimut      = 160,
 309                                    alpha       = 20,
 310                                    longueur    = 400,
 311                                    orientation = 90,
 312                                    lgInfluence = 50,
 313                                    elliptique  = False,
 314                                    externe     = True)
 315
 316   # ---------------------------------------------------------------------------
 317   def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams):
 318     logging.info("genereShapeFissure %s", self.nomCas)
 319     logging.info("shapeFissureParams %s", shapeFissureParams)
 320
 321     angleCoude = geomParams['angleCoude']
 322     r_cintr    = geomParams['r_cintr']
 323     l_tube_p1  = geomParams['l_tube_p1']
 324     l_tube_p2  = geomParams['l_tube_p2']
 325     epais      = geomParams['epais']
 326     de         = geomParams['de']
 327
 328     profondeur  = shapeFissureParams['profondeur']
 329     azimut      = shapeFissureParams['azimut']
 330     alpha       = shapeFissureParams['alpha']
 331     longueur    = shapeFissureParams['longueur']
 332     orientation = shapeFissureParams['orientation']
 333     externe     = shapeFissureParams['externe']
 334     lgInfluence = shapeFissureParams['lgInfluence']
 335     self.elliptique  = False
 336     if shapeFissureParams.has_key('elliptique'):
 337       self.elliptique = shapeFissureParams['elliptique']
 338
 339
 340
 341     azimut = -azimut # axe inverse / ASCOUF
 342     axe = geompy.MakeTranslation(OY, -r_cintr, 0, -l_tube_p1)
 343     geompy.addToStudy(axe,"axe")
 344
 345     if not lgInfluence:
 346       lgInfluence = profondeur
 347
 348     if longueur > 2*profondeur:
 349       self.fissureLongue=True
 350     else:
 351       self.fissureLongue=False
 352       self.elliptique = True
 353
 354     self.circonferentielle = False
 355     self.longitudinale = False
 356     if self.fissureLongue and not self.elliptique:
 357       if abs(orientation) < 45 :
 358         self.longitudinale = True
 359       else:
 360         self.circonferentielle = True
 361
 362     nbp1 = 10
 363     if self.circonferentielle:
 364       if externe:
 365         dp = -1.0
 366         raybor = de/2.
 367         rayint = raybor - profondeur
 368         rayext = raybor + profondeur/5.0
 369       else:
 370         dp = 1.0
 371         raybor = de/2. - epais
 372         rayint = raybor + profondeur
 373         rayext = raybor - profondeur/5.0
 374       lgfond = longueur -2*profondeur
 375       angle = lgfond/(2*raybor)
 376       pb = geompy.MakeVertex(raybor, 0, 0)
 377       pi = geompy.MakeVertex(rayint, 0, 0)
 378       pbl = geompy.MakeRotation(pb, OZ, angle)
 379       pbr = geompy.MakeRotation(pb, OZ, -angle)
 380       geompy.addToStudy(pbl,"pbl")
 381       geompy.addToStudy(pbr,"pbr")
 382       pal = geompy.MakeTranslationVector(pbl, OZ)
 383       par = geompy.MakeTranslationVector(pbr, OZ)
 384       axl = geompy.MakeVector(pbl,pal)
 385       axr = geompy.MakeVector(pbr,par)
 386       pil = geompy.MakeRotation(pi, OZ, angle)
 387       pir = geompy.MakeRotation(pi, OZ, -angle)
 388       points = []
 389       nbp = 3*nbp1
 390       for i in range(nbp):
 391         angi = dp*(nbp -i)*(2.0*math.pi/3.0)/nbp
 392         pt = geompy.MakeRotation(pil, axl, angi)
 393         points.append(pt)
 394       for i in range(nbp):
 395         angi = angle -2.0*i*angle/nbp
 396         pt = geompy.MakeRotation(pi, OZ, angi)
 397         points.append(pt)
 398       for i in range(nbp+1):
 399         angi = -dp*i*(2.0*math.pi/3.0)/nbp
 400         pt = geompy.MakeRotation(pir, axr, angi)
 401         points.append(pt)
 402       for i, pt in enumerate(points):
 403         pt = geompy.MakeRotation(pt, OZ, azimut*math.pi/180.)
 404         pt = geompy.MakeTranslation(pt, 0, 0, -l_tube_p1)
 405         pt = geompy.MakeRotation(pt, axe, alpha*math.pi/180.)
 406         points[i] = pt
 407       wire0 = geompy.MakeInterpol(points[0:nbp+1])
 408       wire1 = geompy.MakeInterpol(points[nbp:2*nbp+1])
 409       wire2 = geompy.MakeInterpol(points[2*nbp:3*nbp+1])
 410       #wiretube = geompy.MakeInterpol(points)
 411       wiretube=geompy.MakeWire([wire0,wire1,wire2])
 412       geompy.addToStudy(wiretube,"wiretube")
 413
 414       pe = geompy.MakeVertex(rayext, 0, 0)
 415       pe = geompy.MakeRotation(pe, OZ, azimut*math.pi/180.)
 416       pe = geompy.MakeTranslation(pe, 0, 0, -l_tube_p1)
 417       pe = geompy.MakeRotation(pe, axe, alpha*math.pi/180.)
 418
 419       arce = geompy.MakeArc(points[0], pe, points[-1])
 420       geompy.addToStudy(arce,"arce")
 421
 422       facefiss = geompy.MakeFaceWires([arce, wiretube], 1)
 423       geompy.addToStudy( facefiss, 'facefissPlace' )
 424
 425       pc = geompy.MakeVertex((raybor + rayint)/2.0, 0, 0)
 426       centre = geompy.MakeRotation(pc, OZ, azimut*math.pi/180.)
 427       centre = geompy.MakeTranslation(centre, 0, 0, -l_tube_p1)
 428       centre = geompy.MakeRotation(centre, axe, alpha*math.pi/180.)
 429       geompy.addToStudy( centre, 'centrefissPlace' )
 430
 431       wiretube = geompy.GetInPlace(facefiss, wiretube)
 432       geompy.addToStudy(wiretube, 'wiretubePlace' )
 433       try:
 434         edgetube = geompy.MakeEdgeWire(wiretube)
 435         geompy.addToStudy(edgetube,"edgetube")
 436       except:
 437         logging.debug("erreur MakeEdgeWire sur fond de fissure, on fait sans")
 438         edgetube = None
 439
 440     # ---------------------------------------------------------
 441
 442     elif self.longitudinale:
 443       if externe:
 444         raybor = de/2.
 445         dp = -1.0
 446       else:
 447         raybor = de/2. - epais
 448         dp = +1.0
 449       prof = dp * profondeur
 450       lgfond = longueur -2*profondeur
 451       cosaz = math.cos(azimut*math.pi/180.)
 452       sinaz = math.sin(azimut*math.pi/180.)
 453       alfrd = alpha*math.pi/180.
 454       rayxy = r_cintr + raybor*cosaz
 455       angle = lgfond/(2.*rayxy)
 456       logging.debug("longueur: %s, angle: %s, rayon: %s",lgfond, angle, rayxy)
 457       pb = geompy.MakeVertex(raybor*cosaz, raybor*sinaz, -l_tube_p1, "pb")
 458       pi = geompy.MakeTranslation(pb, prof*cosaz, prof*sinaz, 0., "pi")
 459       pbv = geompy.MakeTranslation(pb, -sinaz, cosaz, 0., "pbv")
 460       axb  = geompy.MakeVector(pb,pbv, "axb")
 461       pbl = geompy.MakeRotation(pb, axe, alfrd -angle, "pbl")
 462       pbr = geompy.MakeRotation(pb, axe, alfrd +angle, "pbr")
 463       axl = geompy.MakeRotation(axb, axe, alfrd -angle, "axl")
 464       axr = geompy.MakeRotation(axb, axe, alfrd +angle, "axr")
 465       pil = geompy.MakeRotation(pi, axe, alfrd -angle, "pil")
 466       pir = geompy.MakeRotation(pi, axe, alfrd +angle, "pir")
 467
 468       curves = []
 469
 470       points = []
 471       nbp = 3*nbp1
 472       xs = []
 473       totx = 0
 474       for i in range(nbp+2):
 475         x = math.sin(i*math.pi/(nbp+1)) # fonction de répartition des points : distance relative
 476         x2 = x*x
 477         totx += x2
 478         xs.append(totx)
 479         logging.debug("x2: %s, totx: %s", x2, totx)
 480       for i in range(nbp+1):
 481         #posi = nbp -i             # répartition équidistante des points sur la courbe
 482         posi = nbp*(1 -xs[i]/totx) # points plus resserrés aux extrémités de la courbe
 483         angi = -dp*posi*(5.0*math.pi/8.0)/nbp
 484         pt = geompy.MakeRotation(pil, axl, angi)
 485         points.append(pt)
 486       curves.append(geompy.MakeInterpol(points))
 487       point0 = points[0]
 488       geompy.addToStudy(curves[-1],"curve0")
 489 #      for i, pt in enumerate(points):
 490 #        name = "point%d"%i
 491 #        geompy.addToStudyInFather(curves[-1], pt, name)
 492
 493       points = []
 494       nbp = 3*nbp1
 495       xs =[]
 496       totx = 0
 497       for i in range(nbp+1):
 498         x = math.sin(i*math.pi/nbp)
 499         #x = 1.0 # répartition équidistante des points sur la courbe
 500         x2 = x*x # points plus resserrés aux extrémités de la courbe
 501         totx += x2
 502         xs.append(totx)
 503         logging.debug("x2: %s, totx: %s", x2, totx)
 504       for i in range(nbp):
 505         angi = alfrd -angle +2.0*angle*xs[i]/totx
 506         pt = geompy.MakeRotation(pi, axe, angi)
 507         points.append(pt)
 508       curves.append(geompy.MakeInterpol(points))
 509       geompy.addToStudy(curves[-1],"curve1")
 510 #      for i, pt in enumerate(points):
 511 #        name = "point%d"%i
 512 #        geompy.addToStudyInFather(curves[-1], pt, name)
 513
 514       points = []
 515       nbp = 3*nbp1
 516       xs = []
 517       totx = 0
 518       for i in range(nbp+2):
 519         x = math.sin(i*math.pi/(nbp+1))
 520         x2 = x*x
 521         totx += x2
 522         xs.append(totx)
 523         logging.debug("x2: %s, totx: %s", x2, totx)
 524       for i in range(nbp+1):
 525         #posi = nbp -i        # répartition équidistante des points sur la courbe
 526         posi = nbp*xs[i]/totx # points plus resserrés aux extrémités de la courbe
 527         angi = dp*posi*(5.0*math.pi/8.0)/nbp
 528         pt = geompy.MakeRotation(pir, axr, angi)
 529         points.append(pt)
 530       curves.append(geompy.MakeInterpol(points))
 531       point1 = points[-1]
 532       geompy.addToStudy(curves[-1],"curve2")
 533 #      for i, pt in enumerate(points):
 534 #        name = "point%d"%i
 535 #        geompy.addToStudyInFather(curves[-1], pt, name)
 536
 537       wiretube = geompy.MakeWire(curves)
 538       geompy.addToStudy(wiretube,"wiretube")
 539       try:
 540         edgetube = geompy.MakeEdgeWire(wiretube)
 541         geompy.addToStudy(edgetube,"edgetube")
 542       except:
 543         logging.debug("erreur MakeEdgeWire sur fond de fissure, on fait sans")
 544         edgetube = None
 545
 546       pts = []
 547       pts.append(point0)
 548       dpr = prof*math.cos(5.0*math.pi/8.0)
 549       pe = geompy.MakeTranslation(pb, dpr*cosaz, dpr*sinaz, 0., "pe")
 550       for i in range(nbp):
 551         angi = alfrd -angle +2.0*i*angle/nbp
 552         pt = geompy.MakeRotation(pe, axe, angi)
 553         pts.append(pt)
 554       pts.append(point1)
 555       arce = geompy.MakeInterpol(pts)
 556       geompy.addToStudy(arce,"arce")
 557
 558       facefiss = geompy.MakeFaceWires([arce, wiretube], 0)
 559       geompy.addToStudy( facefiss, 'facefissPlace' )
 560
 561       pc = geompy.MakeTranslation(pb, 0.5*prof*cosaz, 0.5*prof*sinaz, 0.)
 562       centre = geompy.MakeRotation(pc, axe, alfrd)
 563       geompy.addToStudy( centre, 'centrefissPlace' )
 564
 565       edges = geompy.ExtractShapes(facefiss, geompy.ShapeType["EDGE"], True)
 566       edgesTriees, minl, maxl = sortEdges(edges)
 567       edges = edgesTriees[:-1] # la plus grande correspond à arce, on l'elimine
 568       wiretube = geompy.MakeWire(edges)
 569       #wiretube = edgesTriees[-1]
 570       geompy.addToStudy(wiretube, 'wiretubePlace' )
 571
 572     # ---------------------------------------------------------
 573
 574     else: # fissure elliptique, longue ou courte
 575       if externe:
 576         raybor = de/2.
 577         dp = -1.0
 578       else:
 579         raybor = de/2. - epais
 580         dp = +1.0
 581       prof = dp * profondeur
 582       cosaz = math.cos(azimut*math.pi/180.)
 583       sinaz = math.sin(azimut*math.pi/180.)
 584       alfrd = alpha*math.pi/180.
 585       pb = geompy.MakeVertex(raybor*cosaz, raybor*sinaz, -l_tube_p1, "pb")
 586       pi = geompy.MakeTranslation(pb, prof*cosaz, prof*sinaz, 0., "pi")
 587       pbv = geompy.MakeTranslation(pb, -profondeur*sinaz, profondeur*cosaz, 0., "pbv")
 588       ayb  = geompy.MakeVector(pb,pbv, "ayb")
 589       pb0 = geompy.MakeRotation(pb, axe, alfrd, "pb0")
 590       ay0 = geompy.MakeRotation(ayb, axe, alfrd, "ay0")
 591       pi0 = geompy.MakeRotation(pi, axe, alfrd, "pi0")
 592       az_ = geompy.MakeVector(pi0, pb0, "az_")
 593       az0 = geompy.MakeTranslationVector(az_, az_, "az0") #normale sortante
 594       ax0 = geompy.MakeRotation(ay0, az0, -math.pi/2.0, "ax0")
 595       ax1 = geompy.MakeRotation(ax0, az0, orientation*math.pi/180., "ax1")
 596       ay1 = geompy.MakeRotation(ay0, az0, orientation*math.pi/180., "ay1")
 597       originLCS = geompy.MakeMarker(0, 0, 0, 1, 0, 0, 0, 1, 0, "originLCS")
 598       coo = geompy.PointCoordinates(pb0)
 599       cox = geompy.VectorCoordinates(ax1)
 600       coy = geompy.VectorCoordinates(ay1)
 601       localLCS = geompy.MakeMarker(coo[0], coo[1], coo[2], cox[0], cox[1], cox[2], coy[0], coy[1], coy[2], "localLCS")
 602
 603       pco = geompy.MakeVertex(0, 0, -profondeur, "pco")
 604       pao = geompy.MakeRotation(pco, OY, 0.6*math.pi, "pao")
 605       pbo = geompy.MakeRotation(pco, OY, -0.6*math.pi, "pbo")
 606       pce = geompy.MakeVertex(0, 0, 0.1*profondeur,"pce")
 607       arcoo = geompy.MakeArc(pao, pco, pbo, "arcoo")
 608       linoo = geompy.MakeArc(pao, pce, pbo, "linoo")
 609       scalex = longueur/profondeur
 610       arco =geompy.MakeScaleAlongAxes(arcoo, O, scalex, 1., 1., "arco")
 611       lino =geompy.MakeScaleAlongAxes(linoo, O, scalex, 1., 1., "lino")
 612       arci = geompy.MakePosition(arco, originLCS, localLCS, "arci")
 613       arce = geompy.MakePosition(lino, originLCS, localLCS, "arce")
 614       facefiss = geompy.MakeFaceWires([arce, arci], 0)
 615       geompy.addToStudy( facefiss, 'facefissPlace' )
 616       edges = geompy.ExtractShapes(facefiss, geompy.ShapeType["EDGE"], True)
 617       edgesTriees, minl, maxl = sortEdges(edges)
 618       edgetube = edgesTriees[-1] # la plus grande correspond à arci
 619       wiretube = edgetube
 620
 621       pc = geompy.MakeTranslation(pb, 0.5*prof*cosaz, 0.5*prof*sinaz, 0.)
 622       centre = geompy.MakeRotation(pc, axe, alfrd)
 623       geompy.addToStudy( centre, 'centrefissPlace' )
 624
 625     coordsNoeudsFissure = genereMeshCalculZoneDefaut(facefiss, profondeur/2. ,profondeur)
 626
 627     return [facefiss, centre, lgInfluence, coordsNoeudsFissure, wiretube, edgetube]
 628
 629   # ---------------------------------------------------------------------------
 630   def setParamMaillageFissure(self):
 631     """
 632     Paramètres du maillage de la fissure pour le tuyau coudé
 633     Voir également setParamShapeFissure, paramètres rayonPipe et lenSegPipe.
 634     nbSegRad = nombre de couronnes
 635     nbSegCercle = nombre de secteurs
 636     areteFaceFissure = taille cible de l'arête des triangles en face de fissure.
 637     """
 638     self.maillageFissureParams = dict(nomRep        = '.',
 639                                       nomFicSain    = self.nomCas,
 640                                       nomFicFissure = 'fissure_' + self.nomCas,
 641                                       nbsegRad      = 5,
 642                                       nbsegCercle   = 6,
 643                                       areteFaceFissure = 5)
 644
 645   # ---------------------------------------------------------------------------
 646   def genereZoneDefaut(self, geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams):
 647     elementsDefaut = creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams)
 648     return elementsDefaut
 649
 650   # ---------------------------------------------------------------------------
 651   def genereMaillageFissure(self, geometriesSaines, maillagesSains,
 652                             shapesFissure, shapeFissureParams,
 653                             maillageFissureParams, elementsDefaut, step):
 654     maillageFissure = insereFissureGenerale(maillagesSains,
 655                                             shapesFissure, shapeFissureParams,
 656                                             maillageFissureParams, elementsDefaut, step)
 657     return maillageFissure
 658
 659   # ---------------------------------------------------------------------------
 660   def setReferencesMaillageFissure(self):
 661     self.referencesMaillageFissure = dict(Entity_Node            = 77917,
 662                                           Entity_Quad_Edge       = 975,
 663                                           Entity_Quad_Triangle   = 2182,
 664                                           Entity_Quad_Quadrangle = 6842,
 665                                           Entity_Quad_Tetra      = 20135,
 666                                           Entity_Quad_Hexa       = 8994,
 667                                           Entity_Quad_Penta      = 972,
 668                                           Entity_Quad_Pyramid    = 1038)
 669