src/TEST_PY/non_regression/k21592_getAsso.py

   1 # -*- coding: latin-1 -*-
   2 # Copyright (C) 2009-2023  CEA, EDF
   3 #
   4 # This library is free software; you can redistribute it and/or
   5 # modify it under the terms of the GNU Lesser General Public
   6 # License as published by the Free Software Foundation; either
   7 # version 2.1 of the License, or (at your option) any later version.
   8 #
   9 # This library is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 # Lesser General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU Lesser General Public
  15 # License along with this library; if not, write to the Free Software
  16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 #
  18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 #
  20
  21 # Francis KLOSS : 2011-2013 : CEA-Saclay, DEN, DM2S, SFME, LGLS, F-91191 Gif-sur-Yvette, France
  22 # =============================================================================================
  23
  24 import math
  25
  26 import geompy
  27 import hexablock
  28
  29 # Construire le modèle de bloc
  30 # ============================
  31
  32 doc = hexablock.addDocument("bielle")
  33
  34 # Construire les 2 grilles cylindriques
  35 # -------------------------------------
  36
  37 centre_pb = doc.addVertex(0, 0, 0)
  38 centre_gb = doc.addVertex(7, 0, 0)
  39
  40 angle_px   = math.pi / 3
  41 vecteur_px = doc.addVector(math.cos(angle_px), math.sin(angle_px), 0)
  42 vecteur_gx = doc.addVector(1, 0, 0)
  43
  44 vecteur_z = doc.addVector(0, 0, 1)
  45
  46 grille_p = doc.makeCylindrical(centre_pb, vecteur_px, vecteur_z,  1, 360, 1,  1, 3, 1,  False)
  47 grille_g = doc.makeCylindrical(centre_gb, vecteur_gx, vecteur_z,  1, 360, 1,  1, 3, 1,  False)
  48
  49 # Relier les 2 grilles
  50 # --------------------
  51
  52 quad_p = grille_p.getQuadJK(1, 2, 0)
  53 quad_g = grille_g.getQuadJK(1, 1, 0)
  54
  55 point_p1 = grille_p.getVertexIJK(1, 0, 0)
  56 point_p2 = grille_p.getVertexIJK(1, 2, 0)
  57
  58 point_g1 = grille_g.getVertexIJK(1, 1, 0)
  59 point_g2 = grille_g.getVertexIJK(1, 2, 0)
  60
  61 prisme = doc.joinQuad(quad_p, quad_g,  point_p1, point_g1,  point_p2, point_g2,  3)
  62
  63 # Charger la géométrie
  64 # ====================
  65
  66 bielle = geompy.ImportSTEP("bielle.stp")
  67
  68 # Sélectionner des sous-parties de la géométrie
  69 # ---------------------------------------------
  70
  71 sommets = geompy.SubShapeAllSortedCentres(bielle, geompy.ShapeType["VERTEX"])
  72
  73 sommets_petit = [  6,  8,  7,  9 ]
  74 sommets_grand = [ 10, 12, 11, 13 ]
  75
  76 aretes = geompy.SubShapeAllSortedCentres(bielle, geompy.ShapeType["EDGE"])
  77
  78 aretes_petit = [  7,  9,  8, 10 ]
  79 aretes_grand = [ 19, 21, 20, 22 ]
  80
  81 ga_pbcd = aretes[ 0]
  82 ga_pbe  = aretes[ 2]
  83
  84 ga_phcd = aretes[ 1]
  85 ga_phe  = aretes[ 3]
  86
  87 ga_gbcd = aretes[27]
  88 ga_gbe  = aretes[25]
  89
  90 ga_ghcd = aretes[28]
  91 ga_ghe  = aretes[26]
  92
  93 # Associer le modèle de bloc avec la géométrie
  94 # ============================================
  95
  96 doc.setShape(bielle)
  97
  98 # Netoyer les associations implicites du prisme
  99 # ---------------------------------------------
 100
 101 for i in range( prisme.countEdge() ):
 102   em = prisme.getEdge(i)
 103   if em != None:
 104     em.clearAssociation()
 105
 106 # Associer les cercles extérieurs
 107 # -------------------------------
 108
 109 def cercle(grille, k, ge, p):
 110     ms  = grille.getVertexIJK(0, 0, k)
 111     ma1 = grille.getEdgeJ(0, 2, k)
 112     ma2 = grille.getEdgeJ(0, 1, k)
 113     ma3 = grille.getEdgeJ(0, 0, k)
 114     doc.associateClosedLine(ms, ma1, [ ma2, ma3 ], ge, p, False, [])
 115
 116 cercle(grille_p, 0, ga_pbe, 5.0/6)
 117 cercle(grille_p, 1, ga_phe, 5.0/6)
 118
 119 cercle(grille_g, 0, ga_gbe, 0)
 120 cercle(grille_g, 1, ga_ghe, 0)
 121
 122 # Associer les arcs extérieurs (excentrés)
 123 # ----------------------------------------
 124
 125 def arc(grille, i1, i2, k, ge):
 126     ma1 = grille.getEdgeJ(1, i1, k)
 127     ma2 = grille.getEdgeJ(1, i2, k)
 128     doc.associateOpenedLine(ma1, [ ma2 ], ge, 0, [], 1)
 129
 130 arc(grille_p, 1, 0, 0, ga_pbcd)
 131 arc(grille_p, 1, 0, 1, ga_phcd)
 132
 133 arc(grille_g, 0, 2, 0, ga_gbcd)
 134 arc(grille_g, 0, 2, 1, ga_ghcd)
 135
 136 # Associer les arcs de cercle de raccord
 137 # --------------------------------------
 138
 139 hm = prisme.getHexa(0)
 140 for i in range(0, 4):
 141   em = hm.getEdge(i+8)
 142   ga = aretes[ aretes_petit[i] ]
 143
 144   em.addAssociation(ga, 0, 1)
 145
 146 hm = prisme.getHexa(2)
 147 for i in range(0, 4):
 148   em = hm.getEdge(i+8)
 149   ga = aretes[ aretes_grand[i] ]
 150
 151 # Associer les sommets des arcs de cercle de raccord
 152 # --------------------------------------------------
 153
 154 hm = prisme.getHexa(1)
 155 for i in range(0, 4):
 156   vm = hm.getVertex(i)
 157   ga = sommets[ sommets_petit[i] ]
 158   vm.setAssociation(ga)
 159
 160 hm = prisme.getHexa(2)
 161 for i in range(0, 4):
 162   vm = hm.getVertex(i)
 163   ga = sommets[ sommets_grand[i] ]
 164   vm.setAssociation(ga)
 165
 166 # Associer les arcs de cercle de raccord
 167 # --------------------------------------
 168
 169 hm = prisme.getHexa(0)
 170 for i in range(0, 4):
 171   em = hm.getEdge(i+8)
 172   ga = aretes[ aretes_petit[i] ]
 173   em.clearAssociation()
 174   em.addAssociation(ga, 0, 1)
 175
 176 hm = prisme.getHexa(2)
 177 for i in range(0, 4):
 178   em = hm.getEdge(i+8)
 179   ga = aretes[ aretes_grand[i] ]
 180   em.clearAssociation()
 181   em.addAssociation(ga, 0, 1)
 182
 183 # Arrondir des associations implicites cylindriques
 184 # -------------------------------------------------
 185
 186 for h, i, ech in [ [0, 0, 0.95], [0, 1, 0.95],  [2, 2, 0.85], [2, 3, 0.85] ]:
 187   hm = prisme.getHexa(h)
 188   em = hm.getEdge(i)
 189   va = em.getVertex(0).getAssociation()
 190   vb = em.getVertex(1).getAssociation()
 191   vax, vay, vaz = geompy.PointCoordinates(va)
 192   vbx, vby, vbz = geompy.PointCoordinates(vb)
 193   vmx = ( vax + vbx ) / 2.0 * ech
 194   vmy = ( vay + vby ) / 2.0
 195   vmz = ( vaz + vbz ) / 2.0
 196   vm = geompy.MakeVertex(vmx, vmy, vmz)
 197   eg = geompy.MakeArc(va, vm, vb)
 198   em.clearAssociation()
 199   em.addAssociation(eg, 0, 1)
 200
 201 # Test getAsso sur les edges
 202 nbedges = doc.countEdge ()
 203 for nro in range (nbedges) :
 204     edge  = doc.getEdge (nro)
 205     assos = edge.getAssociations()
 206     nbass = len (assos)
 207     print(" ... %d Edge = %s, nb asso = %d" % (nro, edge.getName(), nbass))
 208     for na in range (nbass) :
 209         print(" ... Asso(", na, ") = ", assos[na])
 210
 211
 212 # Mailler le modèle de bloc
 213 # =========================
 214
 215 # Définir 5 groupes de faces
 216 # --------------------------
 217
 218 groupe_petit   = doc.addQuadGroup("Petit")
 219 groupe_grand   = doc.addQuadGroup("Grand")
 220 groupe_bas     = doc.addQuadGroup("Bas")
 221 groupe_haut    = doc.addQuadGroup("Haut")
 222 groupe_contour = doc.addQuadGroup("Contour")
 223
 224 # Constituer les groupes petit et grand
 225 # -------------------------------------
 226
 227 for i in range(3):
 228   groupe_petit.addElement( grille_p.getQuadJK(0, i, 0) )
 229   groupe_grand.addElement( grille_g.getQuadJK(0, i, 0) )
 230
 231 # Constituer les groupes bas et haut
 232 # ----------------------------------
 233
 234 for i in range(3):
 235   groupe_bas.addElement(  grille_p.getQuadIJ(0, i, 0) )
 236   groupe_bas.addElement(  grille_g.getQuadIJ(0, i, 0) )
 237
 238   groupe_haut.addElement( grille_p.getQuadIJ(0, i, 1) )
 239   groupe_haut.addElement( grille_g.getQuadIJ(0, i, 1) )
 240
 241 for i in range(3):
 242   h = prisme.getHexa(i)
 243   groupe_bas.addElement(  h.getQuad(2) )
 244   groupe_haut.addElement( h.getQuad(3) )
 245
 246 # Constituer le groupe contour
 247 # ----------------------------
 248
 249 for i in range(2):
 250   groupe_contour.addElement( grille_p.getQuadJK(1, i, 0) )
 251
 252 for i in [0, 2]:
 253   groupe_contour.addElement( grille_g.getQuadJK(1, i, 0) )
 254
 255 for i in range(3):
 256   h = prisme.getHexa(i)
 257
 258   groupe_contour.addElement( h.getQuad(4) )
 259   groupe_contour.addElement( h.getQuad(5) )
 260
 261 # Définir 3 groupes de volumes
 262 # ----------------------------
 263
 264 groupe_petit  = doc.addHexaGroup("Petit")
 265 groupe_grand  = doc.addHexaGroup("Grand")
 266 groupe_prisme = doc.addHexaGroup("Prisme")
 267
 268 for i in range(3):
 269   groupe_petit.addElement( grille_p.getHexa(i) )
 270   groupe_grand.addElement( grille_g.getHexa(i) )
 271
 272 for i in range(3):
 273   groupe_prisme.addElement( prisme.getHexa(i) )
 274
 275 # Mailler le modèle de bloc avec association
 276 # ------------------------------------------
 277
 278 hexablock.addLaws(doc, 0.003, True)
 279
 280 blocs = hexablock.mesh(doc)
 281
 282 muv, mue, muq, muh = hexablock.dump(doc, blocs)