src/Tools/blocFissure/gmu/fissureCoude.py

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