From 5f04e121019ea1adc447a0792636d037a3158477 Mon Sep 17 00:00:00 2001 From: opailles Date: Wed, 24 May 2017 09:46:05 +0200 Subject: [PATCH] Artifact 8676 : suppress the ver_class.py script from sat cos it's not useful anymore --- src/test/ver_class.py | 1553 ----------------------------------------- 1 file changed, 1553 deletions(-) delete mode 100644 src/test/ver_class.py diff --git a/src/test/ver_class.py b/src/test/ver_class.py deleted file mode 100644 index b3cdbfd..0000000 --- a/src/test/ver_class.py +++ /dev/null @@ -1,1553 +0,0 @@ -#!/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: [ [, ...], [, ...], [, ...], [, ...] ], -# avec pour un élément inclus dans le cube, -# avec pour un élément qui coupe une face du cube, -# avec pour un élément qui coupe une arête du cube, -# avec 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) (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 idi: - 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