smesh/src/Tools/blocFissure/gmu/fissureCoude.py

# -*- 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

from .geomsmesh import geompy, smesh
from .geomsmesh import geomPublish
from .geomsmesh import geomPublishInFather
from . import initLog

import math
import GEOM
import SALOMEDS
import SMESH
#import StdMeshers
#import GHS3DPlugin
#import NETGENPlugin
import logging

from .fissureGenerique import fissureGenerique

from .triedreBase import triedreBase
from .genereMeshCalculZoneDefaut import genereMeshCalculZoneDefaut
from .creeZoneDefautDansObjetSain import creeZoneDefautDansObjetSain
from .construitFissureGenerale import construitFissureGenerale
from .sortEdges import sortEdges

O, OX, OY, OZ = triedreBase()

class fissureCoude(fissureGenerique):
  """
  problème de fissure du Coude : version de base
  maillage hexa
  """

  nomProbleme = "fissureCoude"

  # ---------------------------------------------------------------------------
  def setParamGeometrieSaine(self):
    """
    Paramètres géométriques du tuyau coudé sain:
    angleCoude
    r_cintr
    l_tube_p1
    l_tube_p2
    epais
    de
    """
    self.geomParams = dict(angleCoude = 60,
                           r_cintr    = 1200,
                           l_tube_p1  = 1600,
                           l_tube_p2  = 1200,
                           epais      = 40,
                           de         = 760)

  # ---------------------------------------------------------------------------
  def genereGeometrieSaine(self, geomParams):
    logging.info("genereGeometrieSaine %s", self.nomCas)

    angleCoude = geomParams['angleCoude']
    r_cintr    = geomParams['r_cintr']
    l_tube_p1  = geomParams['l_tube_p1']
    l_tube_p2  = geomParams['l_tube_p2']
    epais      = geomParams['epais']
    de         = geomParams['de']

    centre = geompy.MakeVertex(0, 0, -l_tube_p1)
    diskext = geompy.MakeDiskPntVecR(centre, OZ, de/2.)
    diskint = geompy.MakeDiskPntVecR(centre, OZ, de/2. -epais)
    couronne = geompy.MakeCut(diskext, diskint)
    tube_1 = geompy.MakePrismVecH(couronne, OZ, l_tube_p1)
    axe = geompy.MakeTranslation(OY, -r_cintr, 0, -l_tube_p1)
    coude = geompy.MakeRevolution(couronne, axe, angleCoude*math.pi/180.0)
    Rotation_1 = geompy.MakeRotation(couronne, axe, angleCoude*math.pi/180.0)
    Rotation_2 = geompy.MakeRotation(OZ, OY, angleCoude*math.pi/180.0)
    tube_2 = geompy.MakePrismVecH(Rotation_1, Rotation_2, -l_tube_p2)
    plan_y = geompy.MakePlaneLCS(None, 100000, 3)
    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" )

    P1 = O
    geompy.addToStudy(P1, "P1" )
    op2 = geompy.MakeVertex(0, 0, -l_tube_p1)
    P2 = geompy.MakeRotation(op2, axe, angleCoude*math.pi/180.0)
    P2 = geompy.MakeTranslationVectorDistance(P2, Rotation_2, -l_tube_p2)
    geompy.addToStudy(P2, "P2" )

    # --- tube coude sain

    geometrieSaine = geompy.MakePartition([tube_1, coude, tube_2, P1, P2], [plan_y], [], [], geompy.ShapeType["SOLID"], 0, [], 1)
    geomPublish(initLog.debug,  geometrieSaine, self.nomCas )
    [P1, P2] = geompy.RestoreGivenSubShapes(geometrieSaine, [P1, P2], GEOM.FSM_GetInPlaceByHistory, False, True)

    xmin = -de -r_cintr -l_tube_p2
    zmin = -l_tube_p1 -r_cintr -l_tube_p2 -de
    ymax = de +100.
    boxypos = geompy.MakeBox(xmin, 0, zmin, ymax, ymax, 100, "boxypos")
    boxyneg = geompy.MakeBox(xmin, 0, zmin, ymax, -ymax, 100, "boxyneg")
    edgesypos = geompy.GetShapesOnShape(boxypos, geometrieSaine, geompy.ShapeType["EDGE"], GEOM.ST_IN)
    edgesyneg = geompy.GetShapesOnShape(boxyneg, geometrieSaine, geompy.ShapeType["EDGE"], GEOM.ST_IN)
    circ_g = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["EDGE"])
    geompy.UnionList(circ_g, edgesyneg)
    circ_d = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["EDGE"])
    geompy.UnionList(circ_d, edgesypos)
    edgesy0pos = geompy.GetShapesOnShape(boxypos, geometrieSaine, geompy.ShapeType["EDGE"], GEOM.ST_ONIN)
    grpedpos = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["EDGE"])
    geompy.UnionList(grpedpos, edgesy0pos)
    grpedy0 = geompy.CutGroups(grpedpos, circ_d, "edges_y0")
    boxtub1 = geompy.MakeBox(-de/2.0 -1, -1, -l_tube_p1, de, de, 0, "boxtub1")
    edgestub1 = geompy.GetShapesOnShape(boxtub1, geometrieSaine, geompy.ShapeType["EDGE"], GEOM.ST_IN)
    grped = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["EDGE"])
    geompy.UnionList(grped, edgestub1)
    long_p1 = geompy.IntersectGroups(grped, grpedy0)
    boxtub  = geompy.MakeBox(-de/2.0 -1, -1, -l_tube_p1 -l_tube_p2, de, de, -l_tube_p1)
    boxtub2 = geompy.MakeRotation(boxtub, axe, angleCoude*math.pi/180.0, "boxttub2")
    edgestub2 = geompy.GetShapesOnShape(boxtub2, geometrieSaine, geompy.ShapeType["EDGE"], GEOM.ST_IN)
    grped = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["EDGE"])
    geompy.UnionList(grped, edgestub2)
    long_p2 = geompy.IntersectGroups(grped, grpedy0)
    boxtub1t = geompy.MakeTranslationVectorDistance(boxtub1, OZ, -l_tube_p1)
    facer = geompy.GetShapesOnShape(boxtub1t, boxtub1, geompy.ShapeType["FACE"], GEOM.ST_ONIN, "facer")
    boxcoud = geompy.MakeRevolution(facer[0], axe, angleCoude*math.pi/180.0, "boxcoud")
    edgescoud = geompy.GetShapesOnShape(boxcoud, geometrieSaine, geompy.ShapeType["EDGE"], GEOM.ST_IN)
    grped = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["EDGE"])
    geompy.UnionList(grped, edgescoud)
    long_coude = geompy.IntersectGroups(grped, grpedy0)
    grped = geompy.CutGroups(grpedy0, long_p1)
    grped = geompy.CutGroups(grped, long_p2)
    ep = geompy.CutGroups(grped, long_coude)
    geomPublishInFather(initLog.debug, geometrieSaine, long_p1, 'long_p1' )
    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' )
    geomPublishInFather(initLog.debug, geometrieSaine, long_p2, 'long_p2' )

    # --- face extremite tube (EXTUBE)

    facesIds = geompy.GetShapesOnPlaneIDs(geometrieSaine, geompy.ShapeType["FACE"], OZ, GEOM.ST_ON)
    EXTUBE = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["FACE"])
    geompy.UnionIDs(EXTUBE, facesIds)
    geomPublishInFather(initLog.debug, geometrieSaine, EXTUBE, 'EXTUBE' )

    # --- edge bord extremite tube (BORDTU)

    edge1Ids = geompy.GetShapesOnPlaneIDs(geometrieSaine, geompy.ShapeType["EDGE"], OZ, GEOM.ST_ON)
    edge2Ids = geompy.GetShapesOnCylinderIDs(geometrieSaine, geompy.ShapeType["EDGE"], OZ, de/2. -epais, GEOM.ST_ON)
    edgesIds = []
    for edge in edge1Ids:
      if edge in edge2Ids:
        edgesIds.append(edge)
    BORDTU = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["EDGE"])
    geompy.UnionIDs(BORDTU, edgesIds)
    geomPublishInFather(initLog.debug, geometrieSaine, BORDTU, 'BORDTU' )

    # --- face origine tube (CLGV)

    pp2 = geompy.MakeTranslationVectorDistance(P2, Rotation_2, 10)
    vec2 = geompy.MakeVector(P2, pp2)
    #geomPublish(initLog.debug, vec2, 'vec2')
    facesIds = geompy.GetShapesOnPlaneIDs(geometrieSaine, geompy.ShapeType["FACE"], vec2, GEOM.ST_ON)
    CLGV = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["FACE"])
    geompy.UnionIDs(CLGV, facesIds)
    geomPublishInFather(initLog.debug, geometrieSaine, CLGV, 'CLGV' )

    # --- peau tube interieur (PEAUINT)

    extru1 = geompy.MakePrismVecH(diskint, OZ, l_tube_p1)
    revol1 = geompy.MakeRevolution(diskint, axe, angleCoude*math.pi/180.0)
    rot1 = geompy.MakeRotation(diskint, axe, angleCoude*math.pi/180.0)
    extru2 = geompy.MakePrismVecH(rot1, Rotation_2, -l_tube_p2)
    interne = geompy.MakeFuse(extru1, revol1)
    interne = geompy.MakeFuse(extru2, interne)
    geomPublish(initLog.debug, interne, 'interne')
    facesIds = geompy.GetShapesOnShapeIDs(interne, geometrieSaine, geompy.ShapeType["FACE"], GEOM.ST_ONIN)
    PEAUINT = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["FACE"])
    geompy.UnionIDs(PEAUINT, facesIds)
    geomPublishInFather(initLog.debug, geometrieSaine, PEAUINT, 'PEAUINT' )

    # --- peau tube exterieur (PEAUEXT)

    Disk_3 = geompy.MakeDiskPntVecR(centre, OZ, de/2. +epais)
    extru1 = geompy.MakePrismVecH(Disk_3, OZ, l_tube_p1)
    revol1 = geompy.MakeRevolution(Disk_3, axe, angleCoude*math.pi/180.0)
    rot1 = geompy.MakeRotation(Disk_3, axe, angleCoude*math.pi/180.0)
    extru2 = geompy.MakePrismVecH(rot1, Rotation_2, -l_tube_p2)
    externe = geompy.MakeFuse(extru1, revol1)
    externe = geompy.MakeFuse(extru2, externe)
    geomPublish(initLog.debug, externe, 'externe')
    facesIds = geompy.GetShapesOnShapeIDs(externe, geometrieSaine, geompy.ShapeType["FACE"], GEOM.ST_ON)
    PEAUEXT = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["FACE"])
    geompy.UnionIDs(PEAUEXT, facesIds)
    geomPublishInFather(initLog.debug, geometrieSaine, PEAUEXT, 'PEAUEXT' )

    # --- solide sain

    volIds = geompy.SubShapeAllIDs(geometrieSaine, geompy.ShapeType["SOLID"])
    COUDE = geompy.CreateGroup(geometrieSaine, geompy.ShapeType["SOLID"])
    geompy.UnionIDs(COUDE, volIds)
    geomPublishInFather(initLog.debug, geometrieSaine, COUDE, 'COUDSAIN' )

    geometriesSaines = [geometrieSaine, long_p1, ep, long_coude, circ_g, circ_d, long_p2, P1, P2, EXTUBE, BORDTU, CLGV, PEAUINT, PEAUEXT, COUDE]

    return geometriesSaines

  # ---------------------------------------------------------------------------
  def setParamMaillageSain(self):
    self.meshParams = dict(n_long_p1    = 16,
                           n_ep         = 3,
                           n_long_coude = 15,
                           n_circ_g     = 20,
                           n_circ_d     = 20,
                           n_long_p2    = 12)

  # ---------------------------------------------------------------------------
  def genereMaillageSain(self, geometriesSaines, meshParams):
    logging.info("genereMaillageSain %s", self.nomCas)

    geometrieSaine = geometriesSaines[0]
    long_p1        = geometriesSaines[1]
    ep             = geometriesSaines[2]
    long_coude     = geometriesSaines[3]
    circ_g         = geometriesSaines[4]
    circ_d         = geometriesSaines[5]
    long_p2        = geometriesSaines[6]
    P1             = geometriesSaines[7]
    P2             = geometriesSaines[8]
    EXTUBE         = geometriesSaines[9]
    BORDTU         = geometriesSaines[10]
    CLGV           = geometriesSaines[11]
    PEAUINT        = geometriesSaines[12]
    PEAUEXT        = geometriesSaines[13]
    COUDE          = geometriesSaines[14]

    n_long_p1    = meshParams['n_long_p1']
    n_ep         = meshParams['n_ep']
    n_long_coude = meshParams['n_long_coude']
    n_circ_g     = meshParams['n_circ_g']
    n_circ_d     = meshParams['n_circ_d']
    n_long_p2    = meshParams['n_long_p2']

    maillageSain = smesh.Mesh(geometrieSaine)

    algo3d = maillageSain.Hexahedron()
    algo2d = maillageSain.Quadrangle()
    smesh.SetName(algo3d, "algo3d_maillageSain")
    smesh.SetName(algo2d, "algo2d_maillageSain")

    algo1d_long_p1 = maillageSain.Segment(geom=long_p1)
    hypo1d_long_p1 = algo1d_long_p1.NumberOfSegments(n_long_p1)
    smesh.SetName(algo1d_long_p1, "algo1d_long_p1")
    smesh.SetName(hypo1d_long_p1, "hypo1d_long_p1")

    algo1d_ep = maillageSain.Segment(geom=ep)
    hypo1d_ep = algo1d_ep.NumberOfSegments(n_ep)
    smesh.SetName(algo1d_ep, "algo1d_ep")
    smesh.SetName(hypo1d_ep, "hypo1d_ep")

    algo1d_long_coude = maillageSain.Segment(geom=long_coude)
    hypo1d_long_coude = algo1d_long_coude.NumberOfSegments(n_long_coude)
    smesh.SetName(algo1d_long_coude, "algo1d_long_coude")
    smesh.SetName(hypo1d_long_coude, "hypo1d_long_coude")

    algo1d_circ_g = maillageSain.Segment(geom=circ_g)
    hypo1d_circ_g = algo1d_circ_g.NumberOfSegments(n_circ_g)
    smesh.SetName(algo1d_circ_g, "algo1d_circ_g")
    smesh.SetName(hypo1d_circ_g, "hypo1d_circ_g")

    algo1d_circ_d = maillageSain.Segment(geom=circ_d)
    hypo1d_circ_d = algo1d_circ_d.NumberOfSegments(n_circ_d)
    smesh.SetName(algo1d_circ_d, "algo1d_circ_d")
    smesh.SetName(hypo1d_circ_d, "hypo1d_circ_d")

    algo1d_long_p2 = maillageSain.Segment(geom=long_p2)
    hypo1d_long_p2 = algo1d_long_p2.NumberOfSegments(n_long_p2)
    smesh.SetName(algo1d_long_p2, "algo1d_long_p2")
    smesh.SetName(hypo1d_long_p2, "hypo1d_long_p2")

    isDone = maillageSain.Compute()

    mp1 = maillageSain.GroupOnGeom(P1,'P1',SMESH.NODE)
    mp2 = maillageSain.GroupOnGeom(P2,'P2',SMESH.NODE)
    ext = maillageSain.GroupOnGeom(EXTUBE,'EXTUBE',SMESH.FACE)
    btu = maillageSain.GroupOnGeom(BORDTU,'BORDTU',SMESH.EDGE)
    clg = maillageSain.GroupOnGeom(CLGV,'CLGV',SMESH.FACE)
    pei = maillageSain.GroupOnGeom(PEAUINT,'PEAUINT',SMESH.FACE)
    pex = maillageSain.GroupOnGeom(PEAUEXT,'PEAUEXT',SMESH.FACE)
    cou = maillageSain.GroupOnGeom(COUDE,'COUDSAIN',SMESH.VOLUME)

    return [maillageSain, True] # True : maillage hexa

  # ---------------------------------------------------------------------------
  def setParamShapeFissure(self):
    """
    paramètres de la fissure pour le tuyau coude
    profondeur  : 0 < profondeur <= épaisseur
    rayonPipe   : rayon du pipe correspondant au maillage rayonnant
    lenSegPipe  : longueur des mailles rayonnantes le long du fond de fissure (= rayonPipe par défaut)
    azimut      : entre 0 et 360°
    alpha       : 0 < alpha < angleCoude
    longueur    : <=2*profondeur ==> force une fissure elliptique (longueur/profondeur = grand axe/petit axe).
    orientation : 0° : longitudinale, 90° : circonférentielle, autre : uniquement fissures elliptiques
    lgInfluence : distance autour de la shape de fissure a remailler (si 0, pris égal à profondeur. A ajuster selon le maillage)
    elliptique  : True : fissure elliptique (longueur/profondeur = grand axe/petit axe); False : fissure longue (fond de fissure de profondeur constante, demi-cercles aux extrémites)
    pointIn_x   : optionnel coordonnées x d'un point dans le solide, pas trop loin du centre du fond de fissure (idem y,z)
    externe     : True : fissure face externe, False : fissure face interne
    """
    logging.info("setParamShapeFissure %s", self.nomCas)
    self.shapeFissureParams = dict(profondeur  = 10,
                                   rayonPipe   = 2.5,
                                   lenSegPipe  = 2.5,
                                   azimut      = 160,
                                   alpha       = 20,
                                   longueur    = 400,
                                   orientation = 90,
                                   lgInfluence = 50,
                                   elliptique  = False,
                                   externe     = True)

  # ---------------------------------------------------------------------------
  def genereShapeFissure( self, geometriesSaines, geomParams, shapeFissureParams):
    logging.info("genereShapeFissure %s", self.nomCas)
    logging.info("shapeFissureParams %s", shapeFissureParams)

    angleCoude = geomParams['angleCoude']
    r_cintr    = geomParams['r_cintr']
    l_tube_p1  = geomParams['l_tube_p1']
    l_tube_p2  = geomParams['l_tube_p2']
    epais      = geomParams['epais']
    de         = geomParams['de']

    profondeur  = shapeFissureParams['profondeur']
    azimut      = shapeFissureParams['azimut']
    alpha       = shapeFissureParams['alpha']
    longueur    = shapeFissureParams['longueur']
    orientation = shapeFissureParams['orientation']
    externe     = shapeFissureParams['externe']
    lgInfluence = shapeFissureParams['lgInfluence']
    self.elliptique  = False
    if '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")

    if not lgInfluence:
      lgInfluence = profondeur

    if longueur > 2*profondeur:
      self.fissureLongue=True
    else:
      self.fissureLongue=False
      self.elliptique = True

    self.circonferentielle = False
    self.longitudinale = False
    if self.fissureLongue and not self.elliptique:
      if abs(orientation) < 45 :
        self.longitudinale = True
      else:
        self.circonferentielle = True

    nbp1 = 10
    if self.circonferentielle:
      if externe:
        dp = -1.0
        raybor = de/2.
        rayint = raybor - profondeur
        rayext = raybor + profondeur/5.0
      else:
        dp = 1.0
        raybor = de/2. - epais
        rayint = raybor + profondeur
        rayext = raybor - profondeur/5.0
      lgfond = longueur -2*profondeur
      angle = lgfond/(2*raybor)
      pb = geompy.MakeVertex(raybor, 0, 0)
      pi = geompy.MakeVertex(rayint, 0, 0)
      pbl = geompy.MakeRotation(pb, OZ, angle)
      pbr = geompy.MakeRotation(pb, OZ, -angle)
      geomPublish(initLog.debug, pbl,"pbl")
      geomPublish(initLog.debug, pbr,"pbr")
      pal = geompy.MakeTranslationVector(pbl, OZ)
      par = geompy.MakeTranslationVector(pbr, OZ)
      axl = geompy.MakeVector(pbl,pal)
      axr = geompy.MakeVector(pbr,par)
      pil = geompy.MakeRotation(pi, OZ, angle)
      pir = geompy.MakeRotation(pi, OZ, -angle)
      points = []
      nbp = 3*nbp1
      for i in range(nbp):
        angi = dp*(nbp -i)*(2.0*math.pi/3.0)/nbp
        pt = geompy.MakeRotation(pil, axl, angi)
        points.append(pt)
      for i in range(nbp):
        angi = angle -2.0*i*angle/nbp
        pt = geompy.MakeRotation(pi, OZ, angi)
        points.append(pt)
      for i in range(nbp+1):
        angi = -dp*i*(2.0*math.pi/3.0)/nbp
        pt = geompy.MakeRotation(pir, axr, angi)
        points.append(pt)
      for i, pt in enumerate(points):
        pt = geompy.MakeRotation(pt, OZ, azimut*math.pi/180.)
        pt = geompy.MakeTranslation(pt, 0, 0, -l_tube_p1)
        pt = geompy.MakeRotation(pt, axe, alpha*math.pi/180.)
        points[i] = pt
      wire0 = geompy.MakeInterpol(points[0:nbp+1])
      wire1 = geompy.MakeInterpol(points[nbp:2*nbp+1])
      wire2 = geompy.MakeInterpol(points[2*nbp:3*nbp+1])
      #wiretube = geompy.MakeInterpol(points)
      wiretube=geompy.MakeWire([wire0,wire1,wire2])
      geomPublish(initLog.debug, wiretube,"wiretube")

      pe = geompy.MakeVertex(rayext, 0, 0)
      pe = geompy.MakeRotation(pe, OZ, azimut*math.pi/180.)
      pe = geompy.MakeTranslation(pe, 0, 0, -l_tube_p1)
      pe = geompy.MakeRotation(pe, axe, alpha*math.pi/180.)

      arce = geompy.MakeArc(points[0], pe, points[-1])
      geomPublish(initLog.debug, arce,"arce")

      facefiss = geompy.MakeFaceWires([arce, wiretube], 1)
      geomPublish(initLog.debug,  facefiss, 'facefissPlace' )

      pc = geompy.MakeVertex((raybor + rayint)/2.0, 0, 0)
      centre = geompy.MakeRotation(pc, OZ, azimut*math.pi/180.)
      centre = geompy.MakeTranslation(centre, 0, 0, -l_tube_p1)
      centre = geompy.MakeRotation(centre, axe, alpha*math.pi/180.)
      geomPublish(initLog.debug,  centre, 'centrefissPlace' )

      wiretube = geompy.GetInPlace(facefiss, wiretube)
      geomPublish(initLog.debug, wiretube, 'wiretubePlace' )
      try:
        edgetube = geompy.MakeEdgeWire(wiretube)
        geomPublish(initLog.debug, edgetube,"edgetube")
      except:
        logging.debug("erreur MakeEdgeWire sur fond de fissure, on fait sans")
        edgetube = None

    # ---------------------------------------------------------

    elif self.longitudinale:
      if externe:
        raybor = de/2.
        dp = -1.0
      else:
        raybor = de/2. - epais
        dp = +1.0
      prof = dp * profondeur
      lgfond = longueur -2*profondeur
      cosaz = math.cos(azimut*math.pi/180.)
      sinaz = math.sin(azimut*math.pi/180.)
      alfrd = alpha*math.pi/180.
      rayxy = r_cintr + raybor*cosaz
      angle = lgfond/(2.*rayxy)
      logging.debug("longueur: %s, angle: %s, rayon: %s",lgfond, angle, rayxy)
      pb = geompy.MakeVertex(raybor*cosaz, raybor*sinaz, -l_tube_p1, "pb")
      pi = geompy.MakeTranslation(pb, prof*cosaz, prof*sinaz, 0., "pi")
      pbv = geompy.MakeTranslation(pb, -sinaz, cosaz, 0., "pbv")
      axb  = geompy.MakeVector(pb,pbv, "axb")
      pbl = geompy.MakeRotation(pb, axe, alfrd -angle, "pbl")
      pbr = geompy.MakeRotation(pb, axe, alfrd +angle, "pbr")
      axl = geompy.MakeRotation(axb, axe, alfrd -angle, "axl")
      axr = geompy.MakeRotation(axb, axe, alfrd +angle, "axr")
      pil = geompy.MakeRotation(pi, axe, alfrd -angle, "pil")
      pir = geompy.MakeRotation(pi, axe, alfrd +angle, "pir")

      curves = []

      points = []
      nbp = 3*nbp1
      xs = []
      totx = 0
      for i in range(nbp+2):
        x = math.sin(i*math.pi/(nbp+1)) # fonction de répartition des points : distance relative
        x2 = x*x
        totx += x2
        xs.append(totx)
        logging.debug("x2: %s, totx: %s", x2, totx)
      for i in range(nbp+1):
        #posi = nbp -i             # répartition équidistante des points sur la courbe
        posi = nbp*(1 -xs[i]/totx) # points plus resserrés aux extrémités de la courbe
        angi = -dp*posi*(5.0*math.pi/8.0)/nbp
        pt = geompy.MakeRotation(pil, axl, angi)
        points.append(pt)
      curves.append(geompy.MakeInterpol(points))
      point0 = points[0]
      geomPublish(initLog.debug, curves[-1],"curve0")
#      for i, pt in enumerate(points):
#        name = "point%d"%i
#        geomPublishInFather(initLog.debug,curves[-1], pt, name)

      points = []
      nbp = 3*nbp1
      xs =[]
      totx = 0
      for i in range(nbp+1):
        x = math.sin(i*math.pi/nbp)
        #x = 1.0 # répartition équidistante des points sur la courbe
        x2 = x*x # points plus resserrés aux extrémités de la courbe
        totx += x2
        xs.append(totx)
        logging.debug("x2: %s, totx: %s", x2, totx)
      for i in range(nbp):
        angi = alfrd -angle +2.0*angle*xs[i]/totx
        pt = geompy.MakeRotation(pi, axe, angi)
        points.append(pt)
      curves.append(geompy.MakeInterpol(points))
      geomPublish(initLog.debug, curves[-1],"curve1")
#      for i, pt in enumerate(points):
#        name = "point%d"%i
#        geomPublishInFather(initLog.debug,curves[-1], pt, name)

      points = []
      nbp = 3*nbp1
      xs = []
      totx = 0
      for i in range(nbp+2):
        x = math.sin(i*math.pi/(nbp+1))
        x2 = x*x
        totx += x2
        xs.append(totx)
        logging.debug("x2: %s, totx: %s", x2, totx)
      for i in range(nbp+1):
        #posi = nbp -i        # répartition équidistante des points sur la courbe
        posi = nbp*xs[i]/totx # points plus resserrés aux extrémités de la courbe
        angi = dp*posi*(5.0*math.pi/8.0)/nbp
        pt = geompy.MakeRotation(pir, axr, angi)
        points.append(pt)
      curves.append(geompy.MakeInterpol(points))
      point1 = points[-1]
      geomPublish(initLog.debug, curves[-1],"curve2")
#      for i, pt in enumerate(points):
#        name = "point%d"%i
#        geomPublishInFather(initLog.debug,curves[-1], pt, name)

      wiretube = geompy.MakeWire(curves)
      geomPublish(initLog.debug, wiretube,"wiretube")
      try:
        edgetube = geompy.MakeEdgeWire(wiretube)
        geomPublish(initLog.debug, edgetube,"edgetube")
      except:
        logging.debug("erreur MakeEdgeWire sur fond de fissure, on fait sans")
        edgetube = None

      pts = []
      pts.append(point0)
      dpr = prof*math.cos(5.0*math.pi/8.0)
      pe = geompy.MakeTranslation(pb, dpr*cosaz, dpr*sinaz, 0., "pe")
      for i in range(nbp):
        angi = alfrd -angle +2.0*i*angle/nbp
        pt = geompy.MakeRotation(pe, axe, angi)
        pts.append(pt)
      pts.append(point1)
      arce = geompy.MakeInterpol(pts)
      geomPublish(initLog.debug, arce,"arce")

      facefiss = geompy.MakeFaceWires([arce, wiretube], 0)
      geomPublish(initLog.debug,  facefiss, 'facefissPlace' )

      pc = geompy.MakeTranslation(pb, 0.5*prof*cosaz, 0.5*prof*sinaz, 0.)
      centre = geompy.MakeRotation(pc, axe, alfrd)
      geomPublish(initLog.debug,  centre, 'centrefissPlace' )

      edges = geompy.ExtractShapes(facefiss, geompy.ShapeType["EDGE"], True)
      edgesTriees, minl, maxl = sortEdges(edges)
      edges = edgesTriees[:-1] # la plus grande correspond à arce, on l'elimine
      wiretube = geompy.MakeWire(edges)
      #wiretube = edgesTriees[-1]
      geomPublish(initLog.debug, wiretube, 'wiretubePlace' )

    # ---------------------------------------------------------

    else: # fissure elliptique, longue ou courte
      if externe:
        raybor = de/2.
        dp = -1.0
      else:
        raybor = de/2. - epais
        dp = +1.0
      prof = dp * profondeur
      cosaz = math.cos(azimut*math.pi/180.)
      sinaz = math.sin(azimut*math.pi/180.)
      alfrd = alpha*math.pi/180.
      pb = geompy.MakeVertex(raybor*cosaz, raybor*sinaz, -l_tube_p1, "pb")
      pi = geompy.MakeTranslation(pb, prof*cosaz, prof*sinaz, 0., "pi")
      pbv = geompy.MakeTranslation(pb, -profondeur*sinaz, profondeur*cosaz, 0., "pbv")
      ayb  = geompy.MakeVector(pb,pbv, "ayb")
      pb0 = geompy.MakeRotation(pb, axe, alfrd, "pb0")
      ay0 = geompy.MakeRotation(ayb, axe, alfrd, "ay0")
      pi0 = geompy.MakeRotation(pi, axe, alfrd, "pi0")
      az_ = geompy.MakeVector(pi0, pb0, "az_")
      az0 = geompy.MakeTranslationVector(az_, az_, "az0") #normale sortante
      ax0 = geompy.MakeRotation(ay0, az0, -math.pi/2.0, "ax0")
      ax1 = geompy.MakeRotation(ax0, az0, orientation*math.pi/180., "ax1")
      ay1 = geompy.MakeRotation(ay0, az0, orientation*math.pi/180., "ay1")
      originLCS = geompy.MakeMarker(0, 0, 0, 1, 0, 0, 0, 1, 0, "originLCS")
      coo = geompy.PointCoordinates(pb0)
      cox = geompy.VectorCoordinates(ax1)
      coy = geompy.VectorCoordinates(ay1)
      localLCS = geompy.MakeMarker(coo[0], coo[1], coo[2], cox[0], cox[1], cox[2], coy[0], coy[1], coy[2], "localLCS")

      pco = geompy.MakeVertex(0, 0, -profondeur, "pco")
      pao = geompy.MakeRotation(pco, OY, 0.6*math.pi, "pao")
      pbo = geompy.MakeRotation(pco, OY, -0.6*math.pi, "pbo")
      pce = geompy.MakeVertex(0, 0, 0.1*profondeur,"pce")
      arcoo = geompy.MakeArc(pao, pco, pbo, "arcoo")
      linoo = geompy.MakeArc(pao, pce, pbo, "linoo")
      scalex = longueur/profondeur
      arco =geompy.MakeScaleAlongAxes(arcoo, O, scalex, 1., 1., "arco")
      lino =geompy.MakeScaleAlongAxes(linoo, O, scalex, 1., 1., "lino")
      arci = geompy.MakePosition(arco, originLCS, localLCS, "arci")
      arce = geompy.MakePosition(lino, originLCS, localLCS, "arce")
      facefiss = geompy.MakeFaceWires([arce, arci], 0)
      geomPublish(initLog.debug,  facefiss, 'facefissPlace' )
      edges = geompy.ExtractShapes(facefiss, geompy.ShapeType["EDGE"], True)
      edgesTriees, minl, maxl = sortEdges(edges)
      edgetube = edgesTriees[-1] # la plus grande correspond à arci
      wiretube = edgetube

      pc = geompy.MakeTranslation(pb, 0.5*prof*cosaz, 0.5*prof*sinaz, 0.)
      centre = geompy.MakeRotation(pc, axe, alfrd)
      geomPublish(initLog.debug,  centre, 'centrefissPlace' )

    coordsNoeudsFissure = genereMeshCalculZoneDefaut(facefiss, profondeur/2. ,profondeur)

    return [facefiss, centre, lgInfluence, coordsNoeudsFissure, wiretube, edgetube]

  # ---------------------------------------------------------------------------
  def setParamMaillageFissure(self):
    """
    Paramètres du maillage de la fissure pour le tuyau coudé
    Voir également setParamShapeFissure, paramètres rayonPipe et lenSegPipe.
    nbSegRad = nombre de couronnes
    nbSegCercle = nombre de secteurs
    areteFaceFissure = taille cible de l'arête des triangles en face de fissure.
    """
    self.maillageFissureParams = dict(nomRep        = os.curdir,
                                      nomFicSain    = self.nomCas,
                                      nomFicFissure = 'fissure_' + self.nomCas,
                                      nbsegRad      = 5,
                                      nbsegCercle   = 6,
                                      areteFaceFissure = 5)

  # ---------------------------------------------------------------------------
  def genereZoneDefaut(self, geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams):
    elementsDefaut = creeZoneDefautDansObjetSain(geometriesSaines, maillagesSains, shapesFissure, shapeFissureParams, maillageFissureParams)
    return elementsDefaut

  # ---------------------------------------------------------------------------
  def genereMaillageFissure(self, geometriesSaines, maillagesSains,
                            shapesFissure, shapeFissureParams,
                            maillageFissureParams, elementsDefaut, step):
    maillageFissure = construitFissureGenerale(maillagesSains,
                                               shapesFissure, shapeFissureParams,
                                               maillageFissureParams, elementsDefaut, step)
    return maillageFissure

  # ---------------------------------------------------------------------------
  def setReferencesMaillageFissure(self):
    self.referencesMaillageFissure = dict(Entity_Node            = 77917,
                                          Entity_Quad_Edge       = 975,
                                          Entity_Quad_Triangle   = 2182,
                                          Entity_Quad_Quadrangle = 6842,
                                          Entity_Quad_Tetra      = 20135,
                                          Entity_Quad_Hexa       = 8994,
                                          Entity_Quad_Penta      = 972,
                                          Entity_Quad_Pyramid    = 1038)