From: opailles <opailles@astek.fr>
Date: Fri, 19 May 2017 09:42:40 +0000 (+0200)
Subject: Artifact 1968 : add the ver_class module to correct error in SMESH/ver test
X-Git-Tag: V8_3_0rc1~8^2~3
X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=e91481495a8a118c4e3bbfe4314ec298b1e52a12;p=tools%2Fsat.git

Artifact 1968 : add the ver_class module to correct error in SMESH/ver test
---

diff --git a/src/test/ver_class.py b/src/test/ver_class.py
new file mode 100644
index 0000000..b3cdbfd
--- /dev/null
+++ b/src/test/ver_class.py
@@ -0,0 +1,1553 @@
+#!/usr/bin/env python
+#-*- coding:utf-8 -*-
+
+# CEA/LGLS 2007-2008, Francis KLOSS (OCC)
+# =======================================
+
+# Caractériser le cas VER pour Pléïades
+# -------------------------------------
+
+# La géométrie d'un combustible à particules est définie par:
+#   - un cube représentant une partie du combustible,
+#   - ce cube contenant des éléments, ces éléments représentent les particules.
+# Chaque élément est constitué d'une écorce sphérique contenant un noyau sphérique et concentrique.
+# La matrice est le cube d'ou sont exclus tous les éléments.
+
+# Les relations entre le cube et les éléments sont:
+#   - pas d'intersection entre les éléments entre-eux (tolérance),
+#   - un élément peut ne pas intersecter le cube (tolérance),
+#   - un élément peut intersecter un sommet unique du cube et avec uniquement les 3 arêtes et les 3 faces reliés à ce sommet,
+#   - un élément peut intersecter une arête unique du cube et avec uniquement les 2 faces reliées à cette arête (et sans sommet),
+#   - un élément peut intersecter une face  unique du cube (et sans sommet, ni arête).
+
+# De plus, toutes les intersections sont:
+#   - sans aucun cas de tangence (tolérance),
+#   - si un élément est coupé par une face, alors son noyau est aussi coupé par cette même face.
+
+# Si un élément touche le cube, alors les éléments symétriques sont créés automatiquement.
+
+# Les faces en vis à vis du cube sont maillées de manière identique afin d'assurer la périodicité.
+# La matrice et les noyaux sont maillés avec des tétraèdres, et les écorces sont maillées avec des prismes.
+
+# Les groupes 2D à constituer sont:
+#   - les 6 groupes correspondant aux 6 faces du cube (triangles et quadrangles),
+#   - pour chaque noyau , avoir un groupe de son enveloppe (triangles),
+#   - pour chaque écorce, avoir un groupe de son enveloppe (triangles),
+#   - le groupe de l'ensemble des enveloppes de tous les noyaux,
+#   - le groupe de l'ensemble des enveloppes de toutes les écorces.
+
+# Les groupes 3D à constituer sont:
+#   - un groupe pour la matrice (tétraèdres),
+#   - pour chaque noyau , avoir un groupe (tétraèdres),
+#   - pour chaque écorce, avoir un groupe (couches de prismes),
+#   - le groupe de l'ensemble des noyaux,
+#   - le groupe de l'ensemble des écorces.
+
+# Mode d'emploi
+# -------------
+
+# Pour créer une étude avec ce fichier python,
+# il faut créer un fichier contenant la ligne "import ver", puis:
+#   - construire une géométrie,
+#   - mailler cette géométrie.
+
+# Pour construire une géométrie, il y a 2 étapes:
+#   - construire le cube,
+#   - construire les éléments.
+
+# Pour construire le cube, il y a 4 manières différentes:
+#   - cas_1 = ver.geometrie()
+#   - cas_2 = ver.geometrie("cas")
+#   - cas_3 = ver.geometrie("kas", 200)
+#   - cas_4 = ver.geometrie("qua", 400, 1)
+
+# La description des 3 paramètres est dans l'ordre:
+#   - le nom de la géométrie (par défaut: "VER"),
+#   - le coté du cube        (par défaut: 100),
+#   - la tolérance           (par défaut: 1).
+
+# Pour construire les éléments, il existe 2 fonctions de base:
+#   - element,
+#   - elements.
+
+# Pour construire un élement précis, la fonction "element" a pour syntaxe:
+#   status = cas_2.element(x, y, z,  nr, er)
+#   - x, y, z : les coordonnées du centre de l'élément,
+#   - nr      : rayon du noyau,
+#   - er      : rayon de l'élément,
+#   - status  : vaut True  quand l'élément est correct (respect de la tolérance, pas de collision et coupe du noyau si nécessaire),
+#               vaut False quand l'élément n'est pas correct et dans ce cas, il n'est pas construit dans le géométrie.
+
+# Pour effectuer un tirage aléatoire d'éléments, la fonction "elements" a 2 syntaxes:
+#   cas_4.elements(sommet, arete, face, solide,  rmin, rmax)
+#   cas_4.elements(sommet, arete, face, solide,  rmin, rmax, ratio)
+#   - sommet : booléen pour indiquer si l'on veut couper le sommet du cube,
+#   - arete  : nombre d'éléments à générer coupant une arête,
+#   - face   : nombre d'éléments à générer coupant une face,
+#   - solide : nombre d'éléments à générer ne coupant pas le cube,
+#   - rmin   : rayon minimum pour le noyau,
+#   - rmax   : rayon minimum pour l'élément,
+#   - ratio  : a pour valeur par défaut 0.5 et permet de borner le rayon maximun du noyau selon la formule: rmin + (rmax-rmin)*ratio.
+# Nota: dans le cas des paramètres "arete" et "face", les éléments symétriques générés automatiquement ne compte pas.
+
+# Il existe quelques méthodes complémentaires sur la géométrie:
+#   - n = cas_1.nom()       donne le nom de la géométrie,
+#   - c = cas_2.cote()      donne le coté du cube,
+#   - t = cas_3.tolerance() donne la tolérance,
+#   - b = cas_0.infos()     dit si des traces sont affichées ou pas,
+#   - cas_0.infos(bool)     affiche ou pas des traces lors du traitement (par défaut: pas de traces),
+#   - s = cas_4.obtenir()   donne la shape correspondant à la géométrie,
+#   - cas_1.valeurs()       donne les caractéristiques de tous les éléments ou:
+#                           le résultat est de la forme: [ [<solide>, ...], [<face>, ...], [<arête>, ...], [<sommmet>, ...] ],
+#                           avec <solide> pour un élément inclus dans le cube,
+#                           avec <face>   pour un élément qui coupe une face  du cube,
+#                           avec <arête>  pour un élément qui coupe une arête du cube,
+#                           avec <sommet> pour un élément qui coupe un sommet du cube,
+#                           et chaque élément est une liste de la forme [ x-centre, y-centre, z-centre,  rayon-noyau, rayon-ecorce ],
+#   - cas_2.sauver()        sauve la géométrie au format BREP dans le répertoire courant,
+#   - cas_3.sauver(rep)     sauve la géométrie au format BREP dans le répertoire passé en argument,
+#   - cas_6.tous()          donne tous les éléments englobants sans tenir compte des éventuelles intersections.
+
+# Pour mailler une géométrie, il faut utiliser la fonction "maillage":
+#   mesh = ver.maillage(cas_3)
+#   - cas_3 est une géométrie définie comme ci-avant,
+#   - mesh est la définition du maillage de cette géometrie.
+
+# Avant de générer le maillage, il est possible de donner les différentes options suivantes:
+#   - mesh.longueur(4)     permet de donner la longueur moyenne des cotés des triangles            (défaut: 20),
+#   - mesh.couches(5)      permet de donner le nombre de couche de prismes pour toutes les écorces (défaut:  2),
+#   - mesh.fichier("file") permet de sauver automatiquement le maillage dans ce fichier            (défaut: "" (soit pas de fichier)).
+
+# Pour connaitre les valeurs des options, il suffit de réaliser les appels suivants:
+#   - mesh.longueur() permet d'obtenir la longueur moyenne des cotés des triangles,
+#   - mesh.couches()  permet d'obtenir le nombre de couche de prismes pour toutes les écorces,
+#   - mesh.fichier()  permet d'obtenir le fichier correspondant au maillage (si "" alors soit pas de fichier).
+
+# Pour générer le maillage et ses groupes paramétré par ses éventuelles options, il suffit de faire:
+#   - mesh.generer()
+
+# Il est possible de sauver le maillage après génération:
+#   - mesh.sauver(fichier)
+
+# Voir aussi des exemples programmés dans le fichier ver_exemples.py
+
+# Importer
+# --------
+
+import math
+import random
+import string
+
+import geompy
+import smesh
+
+geo = geompy
+
+# Définir des constantes
+# ----------------------
+
+random.seed(0)
+
+
+#######################
+angle_e   = math.pi/90
+angle_ee   = math.pi/180
+
+
+angle_30  = math.pi/6
+angle_45  = math.pi/4
+angle_60  = math.pi/3
+angle_90  = math.pi/2
+angle_120 = angle_60*2
+angle_135 = angle_45*3
+angle_180 = math.pi
+angle_360 = math.pi*2
+
+geo_origine = geo.MakeVertex(0, 0, 0)
+
+geo_vertex = geo.ShapeType["VERTEX"]
+geo_edge   = geo.ShapeType["EDGE"]
+geo_wire   = geo.ShapeType["WIRE"]
+geo_face   = geo.ShapeType["FACE"]
+geo_shell  = geo.ShapeType["SHELL"]
+geo_solid  = geo.ShapeType["SOLID"]
+
+# Définir la géométrie
+# ====================
+
+class geometrie:
+
+    # Initialiser
+    # -----------
+
+    def __init__(self, nom="VER", cote=100, tolerance=1, mox="mox"):
+        self.nom(nom)
+        self.tolerance(tolerance)
+        self.cote(cote)
+        self.infos(False)
+
+        self.element_solides([])
+        self.element_faces([])
+        self.element_aretes([])
+        self.element_sommets([])
+
+        self._shape = None
+        self._tous  = []
+
+        self.nom_noyau   = "noy"
+        self.nom_ecorce  = "eco"
+        self.nom_matrice = "mat"
+        self.nom_xy      = "xy"
+        self.nom_xz      = "xz"
+        self.nom_yz      = "yz"
+        self.nom_coupees = "coupe"
+        self._type = mox
+
+
+    # Donner le nom du combustible
+    # ---------------------
+
+    def type_comb(self, type=None):
+        if type!=None:
+            self._type = type
+
+        return self._type
+
+
+
+    # Donner le nom du cube
+    # ---------------------
+
+    def nom(self, nom=None):
+        if nom!=None:
+            self._nom = nom
+
+        return self._nom
+
+    # Donner la tolérance
+    # -------------------
+
+    def tolerance(self, t=None):
+        if t!=None:
+            self._tolerance = t
+
+        return self._tolerance
+
+    # Donner le coté du cube
+    # ----------------------
+
+    def cote(self, c=None):
+        if c!=None:
+            self._cote = c
+
+            self._boite_e = geo.MakeBox(0, 0, 0,  c, c, c)
+            mi = -c/1000.
+            ma = c-mi
+            self._boite_t = geo.MakeBox(mi, mi, mi,  ma, ma, ma)
+
+            self.axe_x = geo.MakeVectorDXDYDZ(c, 0, 0)
+            self.axe_y = geo.MakeVectorDXDYDZ(0, c, 0)
+            self.axe_z = geo.MakeVectorDXDYDZ(0, 0, c)
+
+        return self._cote
+
+    # Donner tous les éléments englobants sans tenir compte des intersections
+    # -----------------------------------------------------------------------
+
+    def tous(self, x=None, y=None, z=None, r=None):
+        if x==None:
+            t = geo.MakeCompound(self._tous)
+            geo.addToStudy(t, self.nom() + ":tous")
+            return t
+        else:
+            s = geo.MakeSphere(x, y, z, r)
+            self._tous.append(s)
+
+    # Tracer ou pas des messages
+    # --------------------------
+
+    def infos(self, b=None):
+        if b!=None:
+            self._infos = b
+
+        return self._infos
+
+    # Donner la boite
+    # ---------------
+
+    def boite(self, b=True):
+        if b:
+            return self._boite_e
+        else:
+            return self._boite_t
+
+    # Donner les valeurs caractérisant tous les éléments
+    # --------------------------------------------------
+
+    def valeurs(self):
+        sol = []
+        fac = []
+        are = []
+        som = []
+
+        for c, nr, er,  ax, an in self.element_solides():
+            x, y, z = geo.PointCoordinates(c)
+            sol.append( [x, y, z,  nr, er] )
+
+        for c, nr, er,  ax, an in self.element_faces():
+            x, y, z = geo.PointCoordinates(c)
+            fac.append( [x, y, z,  nr, er] )
+
+        for c, nr, er,  ax, an in self.element_aretes():
+            x, y, z = geo.PointCoordinates(c)
+            are.append( [x, y, z,  nr, er] )
+
+        for c, nr, er,  ax, an in self.element_sommets():
+            x, y, z = geo.PointCoordinates(c)
+            som.append( [x, y, z,  nr, er] )
+
+        return [ sol, fac, are, som ]
+
+    # Calculer l'union de 2 listes
+    # ----------------------------
+
+    def union(self, a, b):
+        r = b
+        for e in a:
+            if not (e in r):
+                r.append(e)
+
+        return r
+
+    # Calculer l'intersection de 2 listes
+    # -----------------------------------
+
+    def intersection(self, a, b):
+        r = []
+        for e in a:
+            if e in b:
+                r.append(e)
+
+        return r
+
+    # Calculer la différence de 2 listes
+    # ----------------------------------
+
+    def difference(self, a, b):
+        r = []
+        for e in a:
+            if not (e in b):
+                r.append(e)
+
+        return r
+
+    # Calculer la distance entre 2 points
+    # -----------------------------------
+
+    def distance(self, x1, y1, z1,  p):
+        x2, y2, z2 = geo.PointCoordinates(p)
+
+        dx = x2 - x1
+        dy = y2 - y1
+        dz = z2 - z1
+
+        return math.sqrt(dx*dx + dy*dy + dz*dz)
+
+    # Dire si un edge est dégénéré
+    # ----------------------------
+
+    def edge_degenere(self, e):
+        return geo.KindOfShape(e) == [geo.kind.EDGE, 1]
+
+    # Récupérer une shape ou une liste de shape à partir d'un ID ou d'une liste d'IDs
+    # -------------------------------------------------------------------------------
+
+    def donner_shapes(self, l):
+        if type(l)==type(0):
+            return geo.GetSubShape(self._shape, [l])
+
+        r = []
+        for i in l:
+            s = geo.GetSubShape(self._shape, [i])
+            r.append(s)
+
+        return r
+
+    # Dire si 2 points sont identiques
+    # --------------------------------
+
+    def point_egal(self, v1, v2):
+        t = self.tolerance()*0.01
+
+        if ( type(v1)==type([]) ) or ( type(v1)==type(()) ):
+            x1, y1, z1 = v1
+        else:
+            x1, y1, z1 = geo.PointCoordinates(v1)
+
+        if ( type(v2)==type([]) ) or ( type(v2)==type(()) ):
+            x2, y2, z2 = v2
+        else:
+            x2, y2, z2 = geo.PointCoordinates(v2)
+
+        return ( abs(x1-x2)<t ) and ( abs(y1-y2)<t ) and ( abs(z1-z2)<t )
+
+    # Définir les éléments géométriques de la shape
+    # =============================================
+
+    # Déterminer l'élément symétrique
+    # -------------------------------
+
+    def element_symetrique(self, ix, iy, iz,  x1, y1, z1):
+        if ix==1:
+            x2 = x1 + self.cote()
+        else:
+            x2 = x1 - self.cote()
+
+        if iy==1:
+            y2 = y1 + self.cote()
+        else:
+            y2 = y1 - self.cote()
+
+        if iz==1:
+            z2 = z1 + self.cote()
+        else:
+            z2 = z1 - self.cote()
+
+        return x2, y2, z2
+
+    # Dire si le nouvel élément intersecte les autres éléments déjà choisis
+    # ---------------------------------------------------------------------
+
+    def element_intersecter(self, x, y, z, r):
+        rt = r + self.tolerance()
+
+        for c, nr, er,  ax, an in self.element_solides():
+            if self.distance(x, y, z,  c) < (rt + er):
+                return True
+
+        for c, nr, er,  ax, an in self.element_faces():
+            if self.distance(x, y, z,  c) < (rt + er):
+                return True
+
+        for c, nr, er,  ax, an in self.element_aretes():
+            if self.distance(x, y, z,  c) < (rt + er):
+                return True
+
+        for c, nr, er,  ax, an in self.element_sommets():
+            if self.distance(x, y, z,  c) < (rt + er):
+                return True
+
+        return False
+
+    # Ajouter un élément, s'il n'en intersecte aucun autre
+    # ----------------------------------------------------
+
+    def ajouter(self, r, l,  x, y, z,  nr, er,  ax=None, an=None):
+        self.tous(x, y, z, er)
+        if self.infos():
+            print "VER: x = ", x, ", y = ", y, " , z = ", z, " , nr = ", nr, " , er = ", er
+
+        b, n = r
+        if b:
+            if self.element_intersecter(x, y, z, er):
+                if n!=0:
+                    del l[-n:]
+                return [False, 0]
+            else:
+                c = geo.MakeVertex(x, y, z)
+                l.append( [c, nr, er, ax, an] )
+                return [True, n+1]
+        else:
+            return r
+
+    # Donner les sphères entières
+    # ---------------------------
+
+    def element_solides(self, l=None):
+        if l!=None:
+            self._solides = l
+
+        return self._solides
+
+    # Ajouter une sphère entière
+    # --------------------------
+
+    def element_solide(self, x, y, z,  nr, er):
+        r = [True, 0]
+        r = self.ajouter(r, self._solides,  x, y, z,  nr, er)
+
+        return r[0]
+
+    # Donner les sphères coupées par une face
+    # ---------------------------------------
+
+    def element_faces(self, l=None):
+        if l!=None:
+            self._faces = l
+
+        return self._faces
+
+    # Ajouter une sphère coupée par une face avec sa symétrique
+    # ---------------------------------------------------------
+
+    def element_face(self, ix, iy, iz,  x1, y1, z1,  nr, er):
+        r = [True, 0]
+        x2, y2, z2 = self.element_symetrique(ix, iy, iz,  x1, y1, z1)
+
+        if ix!=0:
+            r = self.ajouter(r, self._faces,  x1, y1, z1,  nr, er,  self.axe_x, -angle_45)
+            r = self.ajouter(r, self._faces,  x2, y1, z1,  nr, er,  self.axe_x, -angle_45)
+
+        elif iy!=0:
+            if iy==1:
+                a = -angle_90
+            else:
+                a = +angle_90
+
+            r = self.ajouter(r, self._faces,  x1, y1, z1,  nr, er, [self.axe_z, self.axe_y], [a, -angle_45])
+            r = self.ajouter(r, self._faces,  x1, y2, z1,  nr, er, [self.axe_z, self.axe_y], [a, -angle_45])
+
+        else:
+            r = self.ajouter(r, self._faces,  x1, y1, z1,  nr, er, [self.axe_y, self.axe_z], [-angle_90, -angle_45])
+            r = self.ajouter(r, self._faces,  x1, y1, z2,  nr, er, [self.axe_y, self.axe_z], [-angle_90, -angle_45])
+
+        return r[0]
+
+    # Calculer l'angle de rotation
+    # ----------------------------
+
+    def element_angle(self, x, y, z, v, nr, er):
+        b = self.boite(False)
+
+        if v==self.axe_z:
+            s = geo.MakeVertex(x   , y-er, z)
+            m = geo.MakeVertex(x+er, y   , z)
+            e = geo.MakeVertex(x   , y+er, z)
+        elif v==self.axe_y:
+            s = geo.MakeVertex(x, y, z+er)
+            m = geo.MakeVertex(x+er, y, z)
+            e = geo.MakeVertex(x, y, z-er)
+        else:
+            s = geo.MakeVertex(x, y   , z+er)
+            m = geo.MakeVertex(x, y+er, z   )
+            e = geo.MakeVertex(x, y   , z-er)
+
+        c  = geo.MakeVertex(x, y, z)
+        a1 = geo.MakeArc(s, m, e)
+        a2 = geo.MakeScaleTransform(a1, c, nr/er)
+        as_compound = geo.MakeCompound([a1, a2])
+
+        an = angle_ee
+        print " an1 : ", an
+        ax = geo.MakeLine(c, v)
+        ro = geo.MakeRotation(as_compound, ax, an)
+        pa = geo.MakePartition([b], [ro], [], [], geo_vertex)
+
+        i = 1
+        n = 1800
+        while (( len(geo.SubShapeAll(pa, geo_vertex))!=8 ) and ( i<=n )):
+            if self.infos() and ( (i%int(n/10)) == 0 ):
+                print " (i%int(n/10)", (i%int(n/10))
+                print "VER: echantillon: nombre de vertex = ", len(geo.SubShapeAll(pa, geo_vertex))
+            an = an + angle_ee
+            #an = random.uniform(0, angle_360)
+            ro = geo.MakeRotation(as_compound, ax, an)
+            pa = geo.MakePartition([b], [ro], [], [], geo_vertex)
+            i = i + 1
+        print "VER: echantillon: nombre de vertex = ", len(geo.SubShapeAll(pa, geo_vertex))
+        if i==n+1 :
+            print "WARNING: element_angle: nombre d'essai: ", n            
+        print " an2 : ", an
+        geo.addToStudy(pa, " pa" )
+        geo.addToStudy(as_compound, " as" )
+        geo.addToStudy(ro, " ro" )
+
+        return an
+
+    # Donner les sphères coupées par une arête
+    # ----------------------------------------
+
+    def element_aretes(self, l=None):
+        if l!=None:
+            self._aretes = l
+
+        return self._aretes
+
+    # Ajouter une sphère coupée par une arête et ses 3 autres symétriques
+    # -------------------------------------------------------------------
+
+    def element_arete(self, ix, iy, iz,  x1, y1, z1,  nr, er):
+        r = [True, 0]
+        x2, y2, z2 = self.element_symetrique(ix, iy, iz,  x1, y1, z1)
+
+        if iz==0:
+            a1 = self.element_angle(x1, y1, z1, self.axe_z, nr, er)
+            a2 = self.element_angle(x1, y2, z1, self.axe_z, nr, er)
+            a3 = self.element_angle(x2, y1, z1, self.axe_z, nr, er)
+            a4 = self.element_angle(x2, y2, z1, self.axe_z, nr, er)
+
+            r = self.ajouter(r, self._aretes,  x1, y1, z1,  nr, er,  [self.axe_x, self.axe_z], [angle_90, a1])
+            r = self.ajouter(r, self._aretes,  x1, y2, z1,  nr, er,  [self.axe_x, self.axe_z], [angle_90, a2])
+            r = self.ajouter(r, self._aretes,  x2, y1, z1,  nr, er,  [self.axe_x, self.axe_z], [angle_90, a3])
+            r = self.ajouter(r, self._aretes,  x2, y2, z1,  nr, er,  [self.axe_x, self.axe_z], [angle_90, a4])
+
+        elif iy==0:
+            a1 = self.element_angle(x1, y1, z1, self.axe_y, nr, er)
+            a2 = self.element_angle(x1, y1, z2, self.axe_y, nr, er)
+            a3 = self.element_angle(x2, y1, z1, self.axe_y, nr, er)
+            a4 = self.element_angle(x2, y1, z2, self.axe_y, nr, er)
+
+            r = self.ajouter(r, self._aretes,  x1, y1, z1,  nr, er,  self.axe_y, a1)
+            r = self.ajouter(r, self._aretes,  x1, y1, z2,  nr, er,  self.axe_y, a2)
+            r = self.ajouter(r, self._aretes,  x2, y1, z1,  nr, er,  self.axe_y, a3)
+            r = self.ajouter(r, self._aretes,  x2, y1, z2,  nr, er,  self.axe_y, a4)
+
+        else:
+            a1 = self.element_angle(x1, y1, z1, self.axe_x, nr, er)
+            a2 = self.element_angle(x1, y1, z2, self.axe_x, nr, er)
+            a3 = self.element_angle(x1, y2, z1, self.axe_x, nr, er)
+            a4 = self.element_angle(x1, y2, z2, self.axe_x, nr, er)
+
+            r = self.ajouter(r, self._aretes,  x1, y1, z1,  nr, er,  [self.axe_z, self.axe_x], [angle_90, a1])
+            r = self.ajouter(r, self._aretes,  x1, y1, z2,  nr, er,  [self.axe_z, self.axe_x], [angle_90, a2])
+            r = self.ajouter(r, self._aretes,  x1, y2, z1,  nr, er,  [self.axe_z, self.axe_x], [angle_90, a3])
+            r = self.ajouter(r, self._aretes,  x1, y2, z2,  nr, er,  [self.axe_z, self.axe_x], [angle_90, a4])
+
+        return r[0]
+
+    # Donner les sphères coupées par un sommet
+    # ----------------------------------------
+
+    def element_sommets(self, l=None):
+        if l!=None:
+            self._sommets = l
+
+        return self._sommets
+
+    # Ajouter une sphère coupée par un sommet et ses 7 autres symétriques
+    # -------------------------------------------------------------------
+
+    def element_sommet(self, ix, iy, iz,  x1, y1, z1,  nr, er):
+        r = [True, 0]
+        x2, y2, z2 = self.element_symetrique(ix, iy, iz,  x1, y1, z1)
+
+        if ( ix==1 and iz==1 ) or ( ix==2 and iz==2 ):
+            a = angle_135
+            b = angle_45
+        else:
+            a = angle_45
+            b = angle_135
+
+        r = self.ajouter(r, self._sommets,  x1, y1, z1,  nr, er,  self.axe_y, +a)
+        r = self.ajouter(r, self._sommets,  x1, y1, z2,  nr, er,  self.axe_y, -a)
+        r = self.ajouter(r, self._sommets,  x1, y2, z1,  nr, er,  self.axe_y, +a)
+        r = self.ajouter(r, self._sommets,  x1, y2, z2,  nr, er,  self.axe_y, -a)
+
+        r = self.ajouter(r, self._sommets,  x2, y1, z1,  nr, er,  self.axe_y, +b)
+        r = self.ajouter(r, self._sommets,  x2, y1, z2,  nr, er,  self.axe_y, -b)
+        r = self.ajouter(r, self._sommets,  x2, y2, z1,  nr, er,  self.axe_y, +b)
+        r = self.ajouter(r, self._sommets,  x2, y2, z2,  nr, er,  self.axe_y, -b)
+
+        return r[0]
+
+    # Dire si l'élément touche le cube
+    # --------------------------------
+
+    def element_toucher(self, x, r):
+        if x < r:
+            return 1
+        elif x > (self.cote()-r):
+            return 2
+        else:
+            return 0
+
+    # Définir un élément dans un cube qui ne touchent les éléments déjà définis, retourne True si l'élément a été créé
+    # ----------------------------------------------------------------------------------------------------------------
+
+    def element(self, x, y, z,  nr, er):
+        x  = float(x)
+        y  = float(y)
+        z  = float(z)
+        nr = float(nr)
+        er = float(er)
+
+        ix = self.element_toucher(x, er)
+        iy = self.element_toucher(y, er)
+        iz = self.element_toucher(z, er)
+
+        if (ix==0) and (iy==0) and (iz==0):
+            return self.element_solide(x, y, z,  nr, er)
+
+        if (ix!=0) and (iy!=0) and (iz!=0):
+            return self.element_sommet(ix, iy, iz,  x, y, z,  nr, er)
+
+        if ( (ix==0) and (iy==0) ) or ( (ix==0) and (iz==0) ) or ( (iy==0) and (iz==0) ):
+            return self.element_face(ix, iy, iz,  x, y, z,  nr, er)
+
+        return self.element_arete(ix, iy, iz,  x, y, z,  nr, er)
+
+    # Choisir les rayons de l'élément
+    # -------------------------------
+
+    def element_choisir_rayons(self, rmin, rmax, ratio):
+        t = self.tolerance()
+
+        nr = random.uniform(rmin, rmin+ratio*(rmax-rmin)-t)
+        er = random.uniform(nr+t, rmax)
+
+        mi = er + t
+        ma = self.cote() - mi
+
+        r = random.uniform(0, nr-t*2)
+        a = random.uniform(0, angle_360)
+
+        return nr, er,  mi, ma,  r, a
+
+    # Choisir un nouvel élément qui coupe un sommet
+    # ---------------------------------------------
+
+    def element_choisir_sommet(self, rmin, rmax, ratio):
+        nr, er,  mi, ma,  r, a = self.element_choisir_rayons(rmin, rmax, ratio)
+
+        x = random.uniform(-r, +r)
+        s = math.sqrt(r*r - x*x)
+        y = s * math.cos(a)
+        z = s * math.sin(a)
+
+        return x, y, z,  nr, er
+
+    # Choisir un nouvel élément qui coupe une arête
+    # ---------------------------------------------
+
+    def element_choisir_arete(self, rmin, rmax, ratio):
+        nr, er,  mi, ma,  r, a = self.element_choisir_rayons(rmin, rmax, ratio)
+
+        d = random.randint(1, 3)
+
+        if d==1:
+            x = random.uniform(mi, ma)
+            y = r * math.cos(a)
+            z = r * math.sin(a)
+        elif d==2:
+            y = random.uniform(mi, ma)
+            x = r * math.cos(a)
+            z = r * math.sin(a)
+        else:
+            z = random.uniform(mi, ma)
+            x = r * math.cos(a)
+            y = r * math.sin(a)
+
+        return x, y, z,  nr, er
+
+    # Choisir un nouvel élément qui coupe une face
+    # --------------------------------------------
+
+    def element_choisir_face(self, rmin, rmax, ratio):
+        nr, er,  mi, ma,  r, a = self.element_choisir_rayons(rmin, rmax, ratio)
+
+        d = random.randint(1, 3)
+
+        if d==1:
+            x = random.uniform(mi, ma)
+            y = random.uniform(mi, ma)
+            z = random.uniform(-r, +r)
+        elif d==2:
+            x = random.uniform(mi, ma)
+            y = random.uniform(-r, +r)
+            z = random.uniform(mi, ma)
+        else:
+            x = random.uniform(-r, +r)
+            y = random.uniform(mi, ma)
+            z = random.uniform(mi, ma)
+
+        return x, y, z,  nr, er
+
+    # Choisir un nouvel élément qui ne coupe pas le cube
+    # --------------------------------------------------
+
+    def element_choisir_solide(self, rmin, rmax, ratio):
+        nr, er,  mi, ma,  r, a = self.element_choisir_rayons(rmin, rmax, ratio)
+
+        x = random.uniform(mi, ma)
+        y = random.uniform(mi, ma)
+        z = random.uniform(mi, ma)
+
+        return x, y, z,  nr, er
+
+    # Choisir de nouveaux éléments
+    # ----------------------------
+
+    def elements_choisir(self, choisir, n,  rmin, rmax, ratio):
+        i = 0
+        while i<n:
+            x, y, z,  nr, er = choisir(rmin, rmax, ratio)
+            if self.element(x, y, z,  nr, er):
+                i = i + 1
+
+    # Construire automatiquement des éléments
+    # ---------------------------------------
+
+    def elements(self, s, na, nf, ns,  rmin, rmax, ratio=0.5):
+        self.elements_choisir(self.element_choisir_sommet, int(s), rmin, rmax, ratio)
+        self.elements_choisir(self.element_choisir_arete , na    , rmin, rmax, ratio)
+        self.elements_choisir(self.element_choisir_face  , nf    , rmin, rmax, ratio)
+        self.elements_choisir(self.element_choisir_solide, ns    , rmin, rmax, ratio)
+
+    # Définir la shape
+    # ================
+
+    # Construire un élément qui coupe une face
+    # ----------------------------------------
+
+    def construire_element_face(self, c, nr, er,  ax, an,  n, e):
+        if ax==self.axe_x:
+            a = self.axe_y
+            b = self.axe_z
+        elif ax==self.axe_y:
+            a = self.axe_x
+            b = self.axe_z
+        else:
+            a = self.axe_x
+            b = self.axe_y
+
+        l = 4*self.cote()
+        p = geo.MakePlane(c, a, l)
+        q = geo.MakePlane(c, b, l)
+        s = geo.MakePartition([e, n], [p, q], [], [], geo_solid)
+
+        o = False
+        for e in geo.SubShapeAll(s, geo_solid):
+            k = string.split(geo.WhatIs(e))
+            print "k cas HTR", k
+            if (int(k[6])==6) and (int(k[9])==9) and (int(k[15])==5):
+                o = True
+                break
+
+        if not o:
+            raise "construire_element_face"
+
+        a = geo.MakeLine(c, ax)
+        f = geo.MakeRotation(e, a, +angle_90)
+        g = geo.MakeRotation(e, a, -angle_90)
+        h = geo.MakeMirrorByAxis(e, a)
+
+        return [e, f, g, h]
+
+
+    # Construire un élément qui coupe une face sans couches(mox)
+    # ---------------------------------------------------------
+
+    def construire_element_face_mox(self, c, nr, er,  ax, an, e):
+        if ax==self.axe_x:
+            a = self.axe_y
+            b = self.axe_z
+        elif ax==self.axe_y:
+            a = self.axe_z
+            b = self.axe_x
+        else:
+            a = self.axe_x
+            b = self.axe_y
+
+        l = 4*self.cote()
+        p = geo.MakePlane(c, a, l)
+        q = geo.MakePlane(c, b, l)
+        s = geo.MakePartition([e], [p, q], [], [], geo_solid)
+        
+        o = False
+        for e in geo.SubShapeAll(s, geo_solid):
+            k = string.split(geo.WhatIs(e))
+            print k
+            if (int(k[6])==4) and (int(k[9])==6) and (int(k[15])==4):
+                o = True
+                break
+        if not o:
+             raise "construire_element_face_mox"
+        
+        a = geo.MakeLine(c, ax)
+        f = geo.MakeRotation(e, a, +angle_90)
+        g = geo.MakeRotation(e, a, -angle_90)
+        h = geo.MakeMirrorByAxis(e, a)
+
+        return [e, f, g, h]
+
+    # Construire un élément
+    # ---------------------
+
+    def construire_element(self, s, b, g=False):
+        c, nr, er,  ax, an = s
+
+        n = geo.MakeSpherePntR(c, nr)
+        e = geo.MakeSpherePntR(c, er)
+
+        if ax!=None:
+            if type(ax)==type([]):
+                ax1, ax = ax
+                an1, an = an
+
+                l = geo.MakeLine(c, ax1)
+
+                n = geo.MakeRotation(n, l, an1)
+                e = geo.MakeRotation(e, l, an1)
+
+            l = geo.MakeLine(c, ax)
+
+            n = geo.MakeRotation(n, l, an)
+            e = geo.MakeRotation(e, l, an)
+
+        n = geo.MakeCommon(n, b)
+        e = geo.MakeCommon(e, b)
+
+        if self._type!="mox":
+            if g:
+                return self.construire_element_face(c, nr, er,  ax, an,  n, e)
+            else:
+                return [e, n]
+        else:
+            if g:
+                return self.construire_element_face_mox(c, nr, er,  ax, an, e)
+            else:
+                return [e]
+        
+    # Construire un élément sphérique
+    # -------------------------------
+
+    def construire_element_sphere(self, s):
+        c, nr, er,  ax, an = s
+        
+        t = 4*self.cote()
+
+        x = math.cos(angle_30)
+        z = math.sin(angle_30)
+
+        u = geo.MakeVectorDXDYDZ(-x, 0, +z)
+        v = geo.MakeVectorDXDYDZ(-x, 0, -z)
+
+        p = geo.MakePlane(c, u, t)
+        q = geo.MakePlane(c, v, t)
+
+        s = geo.MakeSpherePntR(c, er)
+
+        d = geo.MakePartition([s], [p, q], [], [], geo_solid)
+
+        p1 = geo.MakeTranslation(c, -er, 0, 0)
+        f1 = geo.GetFaceNearPoint(d, p1)
+
+        a  = geo.MakeLine(c, self.axe_y)
+        f2 = geo.MakeRotation(f1, a, +angle_120)
+        f3 = geo.MakeRotation(f1, a, -angle_120)
+
+        e = geo.MakeShell([f1, f2, f3])
+        
+        #add VB test cas sans ecorces:
+        if er==nr :
+            n = geo.MakeSolid([e])
+            return [n]
+        else :
+            e = geo.MakeSolid([e])
+            n = geo.MakeScaleTransform(e, c, nr/er)
+            return [e,n]
+        #endadd
+
+    # Construire la shape
+    # -------------------
+
+    def construire(self):
+        b = self.boite()
+        l = [b]
+
+        for s in self.element_solides():
+            l = l + self.construire_element_sphere(s)
+
+        for s in self.element_faces():
+            l = l + self.construire_element(s, b, True)
+
+        for s in self.element_aretes():
+            l = l + self.construire_element(s, b)
+
+        for s in self.element_sommets():
+            l = l + self.construire_element(s, b)
+
+        r = geo.MakePartition(l, [], [], [], geo_solid)
+        geo.addToStudy(r, self.nom())
+
+        return r
+
+    # Obtenir la shape
+    # ----------------
+
+    def obtenir(self):
+        if self._shape==None:
+            self._shape = self.construire()
+            self.groupes()
+
+        return self._shape
+
+    # Sauver la shape
+    # ---------------
+
+    def sauver(self, rep="./"):
+        s = self.obtenir()
+        f = rep + self.nom() + ".brep"
+        geo.ExportBREP(s, f)
+
+        return f
+
+    # Définir les groupes
+    # ===================
+
+    # Définir un groupe géométrique
+    # -----------------------------
+
+    def groupe(self, t, nom, l=[]):
+        g = geo.CreateGroup(self._shape, t)
+        geo.addToStudyInFather(self._shape, g, nom)
+        g.SetName(nom)
+
+        if l!=[]:
+            if type(l[0])==type(0):
+                geo.UnionIDs(g, l)
+            else:
+                geo.UnionList(g, l)
+
+        return g
+
+    # Construire la liste translatée d'une liste de shape
+    # ---------------------------------------------------
+
+    def groupe__trans(self, l,  dx, dy=None, dz=None):
+        if dy==None:
+            v = dx
+        else:
+            v = geo.MakeVectorDXDYDZ(dx, dy, dz)
+
+        r = []
+        for s in l:
+            t = geo.MakeTranslationVector(s, v)
+            o = geo.GetInPlace(self._shape, t)
+            if o==None:
+                geo.addToStudy(t, "Error:GetInPlace")
+            r.append(o)
+
+        return r
+
+    # Construire la liste des edges passant par les axes et les plans des axes
+    # ------------------------------------------------------------------------
+
+    def groupe1_faces_aretes(self):
+        xy0 = geo.GetShapesOnPlaneWithLocationIDs(self._shape, geo_edge, self.axe_z, geo_origine, geo.GEOM.ST_ON)
+        xz0 = geo.GetShapesOnPlaneWithLocationIDs(self._shape, geo_edge, self.axe_y, geo_origine, geo.GEOM.ST_ON)
+        yz0 = geo.GetShapesOnPlaneWithLocationIDs(self._shape, geo_edge, self.axe_x, geo_origine, geo.GEOM.ST_ON)
+
+        x0 = self.intersection(xy0, xz0)
+        y0 = self.intersection(xy0, yz0)
+        z0 = self.intersection(xz0, yz0)
+
+        p = geo.MakeVertex(self.cote(), self.cote(), self.cote())
+
+        xy1 = geo.GetShapesOnPlaneWithLocationIDs(self._shape, geo_edge, self.axe_z, p, geo.GEOM.ST_ON)
+        xz1 = geo.GetShapesOnPlaneWithLocationIDs(self._shape, geo_edge, self.axe_y, p, geo.GEOM.ST_ON)
+        yz1 = geo.GetShapesOnPlaneWithLocationIDs(self._shape, geo_edge, self.axe_x, p, geo.GEOM.ST_ON)
+
+        a = xy1 + xz1 + yz1
+
+        xy = self.difference(xy0, xz0)
+        xy = self.difference(xy , xz1)
+        xy = self.difference(xy , yz0)
+        xy = self.difference(xy , yz1)
+
+        xz = self.difference(xz0, xy0)
+        xz = self.difference(xz , xy1)
+        xz = self.difference(xz , yz0)
+        xz = self.difference(xz , yz1)
+
+        yz = self.difference(yz0, xy0)
+        yz = self.difference(yz , xy1)
+        yz = self.difference(yz , xz0)
+        yz = self.difference(yz , xz1)
+
+        x0 = self.donner_shapes(x0)
+        y0 = self.donner_shapes(y0)
+        z0 = self.donner_shapes(z0)
+
+        xy = self.donner_shapes(xy)
+        xz = self.donner_shapes(xz)
+        yz = self.donner_shapes(yz)
+
+        return a,  x0, y0, z0,  xy, xz, yz
+
+    # Construire la liste des edges sur les plans des axes entre les écorces et les noyaux coupés
+    # -------------------------------------------------------------------------------------------
+
+    def groupe1_coupees(self, a):
+        l = self.element_faces() + self.element_aretes() + self.element_sommets()
+        r = []
+        for c, nr, er,  ax, an in l:
+            e = geo.GetShapesOnSphereIDs(self._shape, geo_edge, c, er, geo.GEOM.ST_IN)
+            n = geo.GetShapesOnSphereIDs(self._shape, geo_edge, c, nr, geo.GEOM.ST_ONIN)
+            if (er!=nr) and (self._type!="mox"):
+                d = self.difference(e, n)
+                r = r + self.difference(d, a)
+            else :
+                d = e
+                r = r + self.difference(d,a)
+                      
+        return self.groupe(geo_edge, self.nom_coupees+"1", r)
+
+    # Récupérer les génératrices
+    # --------------------------
+
+    def groupe1_filter(self, c, r, a):
+        l = geo.GetShapesOnSphereIDs(self._shape, geo_edge, c, r, geo.GEOM.ST_ON)
+        l = self.difference(l, a)
+
+        r = []
+        for i in l:
+            e = self.donner_shapes(i)
+            if not self.edge_degenere(e):
+                r.append(e)
+
+        return r
+
+    # Construire les listes des génératrices des écorces et des noyaux
+    # ----------------------------------------------------------------
+
+    def groupe1_ecorces_noyaux(self, a):
+        l = self.element_solides() + self.element_faces() + self.element_aretes() + self.element_sommets()
+        e = []
+        n = []
+        for c, nr, er,  ax, an in l:
+            el = self.groupe1_filter(c, er, a)
+            nl = self.groupe1_filter(c, nr, a)
+
+            for ee in el:
+                ev = geo.MakeVertexOnCurve(ee, 0.5)
+                mi = self.cote()
+                for ed in nl:
+                    nv = geo.MakeVertexOnCurve(ed, 0.5)
+                    di = geo.MinDistance(ev, nv)
+                    if mi>di:
+                        mi = di
+                        ne = ed
+                e.append(ee)
+                n.append(ne)
+# adds RL-VB
+        if (er!=nr) and (self._type!="mox"):
+            
+            return e,n
+        else:
+            print " groupe 1 mox"
+            return e
+
+    # Construire la liste des faces passant par un plan
+    # -------------------------------------------------
+
+    def groupe2_faces(self, normale):
+        return geo.GetShapesOnPlaneWithLocation(self._shape, geo_face, normale, geo_origine, geo.GEOM.ST_ON)
+
+    # Construire la liste des faces des plans axiaux entre les écorces et les noyaux coupés
+    # -------------------------------------------------------------------------------------
+
+    def groupe2_coupees(self, p):
+        a = []
+        for s in p:
+            i = geo.GetSubShapeID(self._shape, s)
+            a.append(i)
+
+        l = self.element_faces() + self.element_aretes() + self.element_sommets()
+        r = []
+        if self._type!="mox":
+            for c, nr, er,  ax, an in l:
+                e = geo.GetShapesOnSphereIDs(self._shape, geo_face, c, er, geo.GEOM.ST_IN)
+                n = geo.GetShapesOnSphereIDs(self._shape, geo_face, c, nr, geo.GEOM.ST_ONIN)
+                d = self.difference(e, n)
+                r = r + self.difference(d, a)
+        else:
+            for c, nr, er,  ax, an in l:
+                e = geo.GetShapesOnSphereIDs(self._shape, geo_face, c, er, geo.GEOM.ST_ONIN)
+                r = r + self.difference(e, a)
+                
+        return self.groupe(geo_face, self.nom_coupees+"2", r)
+
+    # Construire les listes des groupes des enveloppes des écorces entières et coupées et de même pour les noyaux
+    # -----------------------------------------------------------------------------------------------------------
+
+    def groupe2_ecorces_noyaux(self):
+        l = self.element_solides() + self.element_faces() + self.element_aretes() + self.element_sommets()
+        i = 0
+        e = []
+        n = []
+
+        for c, nr, er,  ax, an in l:
+            i = i + 1
+
+            el = geo.GetShapesOnSphere(self._shape, geo_face, c, er, geo.GEOM.ST_ON)
+
+            e.append(self.groupe(geo_face, self.nom_ecorce+"2"+str(i), el))
+           
+            # adds RL-VB
+            if (er!=nr) and (self._type!="mox"):
+                nl = geo.GetShapesOnSphere(self._shape, geo_face, c, nr, geo.GEOM.ST_ON)
+                n.append(self.groupe(geo_face, self.nom_noyau +"2"+str(i), nl))
+                
+        
+        if (er!=nr) and (self._type!="mox"):
+            return e, n
+        else:
+            print "groupe 2 mox"
+            return e
+
+    # Construire les listes des groupes des écorces coupées, des groupes des écorces entières et des groupes des noyaux entiers et coupés
+    # -----------------------------------------------------------------------------------------------------------------------------------
+
+    def groupe3_ecorces_noyaux(self):
+        i = 0
+        c = []
+        e = []
+        n = []
+        e1 = []
+        c1=[]
+        
+        for ce, nr, er,  ax, an in self.element_solides():
+            i = i + 1
+            
+            pl = geo.GetShapesOnSphereIDs(self._shape, geo_solid, ce, er, geo.GEOM.ST_ONIN)
+            e1.append(self.groupe(geo_solid, self.nom_ecorce+"3"+str(i), pl))
+
+            if er<>nr:
+                
+                nl = geo.GetShapesOnSphereIDs(self._shape, geo_solid, ce, nr, geo.GEOM.ST_ONIN)
+                el = self.difference(pl, nl)
+                e.append(self.groupe(geo_solid, self.nom_ecorce+"3"+str(i), el))
+                n.append(self.groupe(geo_solid, self.nom_noyau +"3"+str(i), nl))
+                
+        l = self.element_faces() + self.element_aretes() + self.element_sommets()
+        
+        for ce, nr, er,  ax, an in l:
+            i = i + 1
+            pl = geo.GetShapesOnSphereIDs(self._shape, geo_solid, ce, er, geo.GEOM.ST_ONIN)
+            c1.append(self.groupe(geo_solid, self.nom_ecorce+"3"+str(i), pl))
+            
+                        
+            if (er!=nr) and (self._type!="mox") :
+                nl = geo.GetShapesOnSphereIDs(self._shape, geo_solid, ce, nr, geo.GEOM.ST_ONIN)
+                el = self.difference(pl, nl)
+                c.append(self.groupe(geo_solid, self.nom_ecorce+"3"+str(i), el))
+                n.append(self.groupe(geo_solid, self.nom_noyau +"3"+str(i), nl))
+                
+# adds RL-VB
+        if (er!=nr) and (self._type!="mox"):
+            return c,e,n
+        else:
+            return c1, e1
+
+    # Construire le groupe de la matrice
+    # ----------------------------------
+
+    def groupe3_matrice(self):
+        l = geo.SubShapeAll(self._shape, geo_solid)
+        for s in l:
+            f = geo.SubShapeAllIDs(s, geo_face)
+            if len(f) > 6:
+                return self.groupe(geo_solid, self.nom_matrice, [s])
+
+        raise "groupe3_matrice"
+
+    # Construire les groupes
+    # ----------------------
+
+    def groupes(self):
+        a,  self.g1_x0, self.g1_y0, self.g1_z0,  self.g1_xy0, self.g1_xz0, self.g1_yz0 = self.groupe1_faces_aretes()
+
+        self.g1_x1  = self.groupe__trans(self.g1_x0, self.axe_y)
+        self.g1_x2  = self.groupe__trans(self.g1_x0, self.axe_z)
+        self.g1_x3  = self.groupe__trans(self.g1_x0, 0, self.cote(), self.cote())
+
+        self.g1_y1  = self.groupe__trans(self.g1_y0, self.axe_x)
+        self.g1_y2  = self.groupe__trans(self.g1_y0, self.axe_z)
+        self.g1_y3  = self.groupe__trans(self.g1_y0, self.cote(), 0, self.cote())
+
+        self.g1_z1  = self.groupe__trans(self.g1_z0, self.axe_x)
+        self.g1_z2  = self.groupe__trans(self.g1_z0, self.axe_y)
+        self.g1_z3  = self.groupe__trans(self.g1_z0, self.cote(), self.cote(), 0)
+
+        self.g1_xy1 = self.groupe__trans(self.g1_xy0, self.axe_z)
+        self.g1_xz1 = self.groupe__trans(self.g1_xz0, self.axe_y)
+        self.g1_yz1 = self.groupe__trans(self.g1_yz0, self.axe_x)
+
+        
+        self.g2_xy0 = self.groupe2_faces(self.axe_z)
+        self.g2_xy1 = self.groupe__trans(self.g2_xy0, self.axe_z)
+        self.g2_xz0 = self.groupe2_faces(self.axe_y)
+        self.g2_xz1 = self.groupe__trans(self.g2_xz0, self.axe_y)
+        self.g2_yz0 = self.groupe2_faces(self.axe_x)
+        self.g2_yz1 = self.groupe__trans(self.g2_yz0, self.axe_x)
+
+       
+        if self._type!="mox":
+            self.g1_coupees = self.groupe1_coupees(a)
+            self.g1_ecorces, self.g1_noyaux = self.groupe1_ecorces_noyaux(a)
+            self.g2_coupees = self.groupe2_coupees(self.g2_xy1 + self.g2_xz1 + self.g2_yz1)
+            self.g2_ecorces, self.g2_noyaux = self.groupe2_ecorces_noyaux()
+            self.g3_coupees, self.g3_ecorces, self.g3_noyaux = self.groupe3_ecorces_noyaux()
+
+        else:
+            self.g1_coupees = self.groupe1_coupees(a)
+            self.g1_ecorces = self.groupe1_ecorces_noyaux(a)
+            self.g2_coupees = self.groupe2_coupees(self.g2_xy1 + self.g2_xz1 + self.g2_yz1)
+            self.g2_ecorces = self.groupe2_ecorces_noyaux()
+            self.g3_coupees, self.g3_ecorces = self.groupe3_ecorces_noyaux()
+            
+       
+        
+        
+        self.g3_matrice = self.groupe3_matrice()
+
+        
+
+        
+# Définir le maillage du VER
+# ==========================
+
+class maillage:
+
+    # Initialiser le maillage
+    # -----------------------
+
+    def __init__(self, shape,mox="mox"):
+        self.shape = shape
+        print " type de structure", mox
+        self._type = mox
+        self.mesh = smesh.Mesh(self.shape.obtenir(), self.shape.nom())
+
+        self.couches(2)
+        self.longueur(20)
+        self.triangle(smesh.NETGEN_2D)
+        self.tetra(smesh.NETGEN, 1000)
+        self.fichier("")
+
+    def type_comb(self, type=None):
+        if type!=None:
+            self._type = type
+            
+        return self._type
+
+    # Donner le nombre de couches de prismes
+    # --------------------------------------
+
+    def couches(self, c=None):
+        if c!=None:
+            self._couches = c
+
+        return self._couches
+
+    # Donner la longueur moyenne des cotés des triangles
+    # --------------------------------------------------
+
+    def longueur(self, l=None):
+        if l!=None:
+            self._longueur = l
+
+        return self._longueur
+
+    # Donner l'algorithme pour générer les triangles
+    # ----------------------------------------------
+
+    def triangle(self, a=None):
+        if a!=None:
+            self._triangle = a
+
+        return self._triangle
+
+    # Donner l'algorithme et ses éventuelles options pour générer les tétraèdres
+    # --------------------------------------------------------------------------
+
+    def tetra(self, a=None, o=None):
+        if a!=None:
+            self._tetra = [a, o]
+
+        return self._tetra
+
+    # Donner le fichier med pour sauver le maillage
+    # ---------------------------------------------
+
+    def fichier(self, f=None):
+        if f!=None:
+            self._fichier = f
+
+        return self._fichier
+
+    # Projeter le maillage d'une liste d'edges vers une autre liste d'edges
+    # ---------------------------------------------------------------------
+
+    def projeter_1d_liste(self, s, d):
+        i = 0
+        n = len(s)
+        while i<n:
+            a = self.mesh.Projection1D(d[i])
+            a.SourceEdge(s[i])
+            i = i + 1
+
+    # Mailler avec des segments
+    # -------------------------
+
+    def segments(self):
+        a = self.mesh.Segment()
+        a.LocalLength(self.longueur())
+
+        if self._type!="mox":
+            a = self.mesh.Segment(self.shape.g1_coupees)
+            a.NumberOfSegments(self.couches())
+            self.projeter_1d_liste(self.shape.g1_ecorces, self.shape.g1_noyaux)
+        else :
+            a = self.mesh.Segment(self.shape.g1_coupees)
+            a.NumberOfSegments(10)
+        self.projeter_1d_liste(self.shape.g1_x0, self.shape.g1_x1)
+        self.projeter_1d_liste(self.shape.g1_x0, self.shape.g1_x2)
+        self.projeter_1d_liste(self.shape.g1_x0, self.shape.g1_x3)
+
+        self.projeter_1d_liste(self.shape.g1_y0, self.shape.g1_y1)
+        self.projeter_1d_liste(self.shape.g1_y0, self.shape.g1_y2)
+        self.projeter_1d_liste(self.shape.g1_y0, self.shape.g1_y3)
+
+        self.projeter_1d_liste(self.shape.g1_z0, self.shape.g1_z1)
+        self.projeter_1d_liste(self.shape.g1_z0, self.shape.g1_z2)
+        self.projeter_1d_liste(self.shape.g1_z0, self.shape.g1_z3)
+
+        self.projeter_1d_liste(self.shape.g1_xy0, self.shape.g1_xy1)
+        self.projeter_1d_liste(self.shape.g1_xz0, self.shape.g1_xz1)
+        self.projeter_1d_liste(self.shape.g1_yz0, self.shape.g1_yz1)
+
+    # Projeter le maillage d'une liste de faces vers une autre liste de faces
+    # -----------------------------------------------------------------------
+
+    def projeter_2d_liste(self, s, d):
+        i = 0
+        n = len(s)
+        while i<n:
+            a = self.mesh.Projection2D(d[i])
+            a.SourceFace(s[i])
+            i = i + 1
+
+    # Mailler avec des triangles
+    # --------------------------
+
+    def triangles(self):
+        a = self.mesh.Triangle(self.triangle())
+        a.LengthFromEdges()
+
+        if self._type!="mox":
+            self.projeter_2d_liste(self.shape.g2_ecorces, self.shape.g2_noyaux)
+
+        self.projeter_2d_liste(self.shape.g2_xy0, self.shape.g2_xy1)
+        self.projeter_2d_liste(self.shape.g2_xz0, self.shape.g2_xz1)
+        self.projeter_2d_liste(self.shape.g2_yz0, self.shape.g2_yz1)
+
+    # Mailler avec des quadrangles
+    # ----------------------------
+
+    def quadrangles(self):
+        self.mesh.Quadrangle(self.shape.g2_coupees)
+
+    # Mailler avec des tétraèdres
+    # ---------------------------
+
+    def tetraedres(self):
+        a, o = self.tetra()
+        t = self.mesh.Tetrahedron(a)
+        if o!=None:
+            t.MaxElementVolume(o)
+
+    # Mailler avec des prismes
+    # ------------------------
+
+    def prismes(self):
+        for g in self.shape.g3_ecorces:
+            a = self.mesh.Prism(g)
+            a.NumberOfSegments(self.couches())
+
+        for g in self.shape.g3_coupees:
+            self.mesh.Prism(g)
+
+    # Construire les groupes de maille
+    # --------------------------------
+
+    def groupes(self):
+        self.mesh.Group(self.shape.groupe(geo_face, self.shape.nom_xy+"0", self.shape.g2_xy0))
+        self.mesh.Group(self.shape.groupe(geo_face, self.shape.nom_xy+"1", self.shape.g2_xy1))
+        self.mesh.Group(self.shape.groupe(geo_face, self.shape.nom_xz+"0", self.shape.g2_xz0))
+        self.mesh.Group(self.shape.groupe(geo_face, self.shape.nom_xz+"1", self.shape.g2_xz1))
+        self.mesh.Group(self.shape.groupe(geo_face, self.shape.nom_yz+"0", self.shape.g2_yz0))
+        self.mesh.Group(self.shape.groupe(geo_face, self.shape.nom_yz+"1", self.shape.g2_yz1))
+
+        el = []
+        for g in self.shape.g2_ecorces:
+            self.mesh.Group(g)
+            el = el + geo.GetObjectIDs(g)
+        self.mesh.Group(self.shape.groupe(geo_face, self.shape.nom_ecorce+"2", el))
+
+        if self._type!="mox":
+            nl = []
+            for g in self.shape.g2_noyaux:
+                self.mesh.Group(g)
+                nl = nl + geo.GetObjectIDs(g)
+            self.mesh.Group(self.shape.groupe(geo_face, self.shape.nom_noyau +"2", nl))
+
+        el = []
+        for g in self.shape.g3_ecorces:
+            self.mesh.Group(g)
+            el = el + geo.GetObjectIDs(g)
+
+        for g in self.shape.g3_coupees:
+            self.mesh.Group(g)
+            el = el + geo.GetObjectIDs(g)
+
+        self.mesh.Group(self.shape.groupe(geo_solid, self.shape.nom_ecorce+"3", el))
+        
+        if self._type!="mox":
+            nl = []
+            for g in self.shape.g3_noyaux:
+                self.mesh.Group(g)
+                nl = nl + geo.GetObjectIDs(g)
+            self.mesh.Group(self.shape.groupe(geo_solid, self.shape.nom_noyau +"3", nl))
+
+        self.mesh.Group(self.shape.g3_matrice)
+
+    # Sauver le maillage
+    # ------------------
+
+    def sauver(self, fic=None):
+        if fic==None:
+            f = self.fichier()
+        else:
+            f = fic
+
+        if f=="":
+            return False
+        else:
+            self.mesh.ExportToMED(f, smesh.SMESH.MED_V2_2)
+            return True
+
+    # Générer le maillage
+    # -------------------
+
+    def generer(self):
+        
+        self.segments()
+
+        self.triangles()
+        
+        if self._type!="mox":
+            print "maillage par des quadrangles"
+            self.quadrangles()
+
+        self.tetraedres()
+
+        if self._type!="mox":
+            print "maillage par des prismes"
+            self.prismes()
+
+        self.groupes()
+
+        self.mesh.Compute()
+
+        self.sauver()