1 # -*- coding: latin-1 -*-
2 # Copyright (C) 2009-2013 CEA/DEN, EDF R&D
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.
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.
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
18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21 # Francis KLOSS : 2011-2013 : CEA-Saclay, DEN, DM2S, SFME, LGLS, F-91191 Gif-sur-Yvette, France
22 # =============================================================================================
29 # Construire le modèle de bloc
30 # ============================
32 doc = hexablock.addDocument("bielle")
34 # Construire les 2 grilles cylindriques
35 # -------------------------------------
37 centre_pb = doc.addVertex(0, 0, 0)
38 centre_gb = doc.addVertex(7, 0, 0)
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)
44 vecteur_z = doc.addVector(0, 0, 1)
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)
49 # Relier les 2 grilles
50 # --------------------
52 quad_p = grille_p.getQuadJK(1, 2, 0)
53 quad_g = grille_g.getQuadJK(1, 1, 0)
55 point_p1 = grille_p.getVertexIJK(1, 0, 0)
56 point_p2 = grille_p.getVertexIJK(1, 2, 0)
58 point_g1 = grille_g.getVertexIJK(1, 1, 0)
59 point_g2 = grille_g.getVertexIJK(1, 2, 0)
61 prisme = doc.joinQuad(quad_p, quad_g, point_p1, point_g1, point_p2, point_g2, 3)
63 # Charger la géométrie
64 # ====================
66 bielle = geompy.ImportSTEP("bielle.stp")
68 # Sélectionner des sous-parties de la géométrie
69 # ---------------------------------------------
71 sommets = geompy.SubShapeAllSortedCentres(bielle, geompy.ShapeType["VERTEX"])
73 sommets_petit = [ 6, 8, 7, 9 ]
74 sommets_grand = [ 10, 12, 11, 13 ]
76 aretes = geompy.SubShapeAllSortedCentres(bielle, geompy.ShapeType["EDGE"])
78 aretes_petit = [ 7, 9, 8, 10 ]
79 aretes_grand = [ 19, 21, 20, 22 ]
93 # Associer le modèle de bloc avec la géométrie
94 # ============================================
98 # Netoyer les associations implicites du prisme
99 # ---------------------------------------------
101 for i in xrange( prisme.countEdge() ):
102 em = prisme.getEdge(i)
104 em.clearAssociation()
106 # Associer les cercles extérieurs
107 # -------------------------------
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, [])
116 cercle(grille_p, 0, ga_pbe, 5.0/6)
117 cercle(grille_p, 1, ga_phe, 5.0/6)
119 cercle(grille_g, 0, ga_gbe, 0)
120 cercle(grille_g, 1, ga_ghe, 0)
122 # Associer les arcs extérieurs (excentrés)
123 # ----------------------------------------
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)
130 arc(grille_p, 1, 0, 0, ga_pbcd)
131 arc(grille_p, 1, 0, 1, ga_phcd)
133 arc(grille_g, 0, 2, 0, ga_gbcd)
134 arc(grille_g, 0, 2, 1, ga_ghcd)
136 # Associer les arcs de cercle de raccord
137 # --------------------------------------
139 hm = prisme.getHexa(0)
140 for i in xrange(0, 4):
142 ga = aretes[ aretes_petit[i] ]
144 em.addAssociation(ga, 0, 1)
146 hm = prisme.getHexa(2)
147 for i in xrange(0, 4):
149 ga = aretes[ aretes_grand[i] ]
151 # Associer les sommets des arcs de cercle de raccord
152 # --------------------------------------------------
154 hm = prisme.getHexa(1)
155 for i in xrange(0, 4):
157 ga = sommets[ sommets_petit[i] ]
158 vm.setAssociation(ga)
160 hm = prisme.getHexa(2)
161 for i in xrange(0, 4):
163 ga = sommets[ sommets_grand[i] ]
164 vm.setAssociation(ga)
166 # Associer les arcs de cercle de raccord
167 # --------------------------------------
169 hm = prisme.getHexa(0)
170 for i in xrange(0, 4):
172 ga = aretes[ aretes_petit[i] ]
173 em.clearAssociation()
174 em.addAssociation(ga, 0, 1)
176 hm = prisme.getHexa(2)
177 for i in xrange(0, 4):
179 ga = aretes[ aretes_grand[i] ]
180 em.clearAssociation()
181 em.addAssociation(ga, 0, 1)
183 # Arrondir des associations implicites cylindriques
184 # -------------------------------------------------
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)
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)
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()
207 print " ... %d Edge = %s, nb asso = %d" % (nro, edge.getName(), nbass)
208 for na in range (nbass) :
209 print " ... Asso(", na, ") = ", assos[na]
212 # Mailler le modèle de bloc
213 # =========================
215 # Définir 5 groupes de faces
216 # --------------------------
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")
224 # Constituer les groupes petit et grand
225 # -------------------------------------
228 groupe_petit.addElement( grille_p.getQuadJK(0, i, 0) )
229 groupe_grand.addElement( grille_g.getQuadJK(0, i, 0) )
231 # Constituer les groupes bas et haut
232 # ----------------------------------
235 groupe_bas.addElement( grille_p.getQuadIJ(0, i, 0) )
236 groupe_bas.addElement( grille_g.getQuadIJ(0, i, 0) )
238 groupe_haut.addElement( grille_p.getQuadIJ(0, i, 1) )
239 groupe_haut.addElement( grille_g.getQuadIJ(0, i, 1) )
242 h = prisme.getHexa(i)
243 groupe_bas.addElement( h.getQuad(2) )
244 groupe_haut.addElement( h.getQuad(3) )
246 # Constituer le groupe contour
247 # ----------------------------
250 groupe_contour.addElement( grille_p.getQuadJK(1, i, 0) )
253 groupe_contour.addElement( grille_g.getQuadJK(1, i, 0) )
256 h = prisme.getHexa(i)
258 groupe_contour.addElement( h.getQuad(4) )
259 groupe_contour.addElement( h.getQuad(5) )
261 # Définir 3 groupes de volumes
262 # ----------------------------
264 groupe_petit = doc.addHexaGroup("Petit")
265 groupe_grand = doc.addHexaGroup("Grand")
266 groupe_prisme = doc.addHexaGroup("Prisme")
269 groupe_petit.addElement( grille_p.getHexa(i) )
270 groupe_grand.addElement( grille_g.getHexa(i) )
273 groupe_prisme.addElement( prisme.getHexa(i) )
275 # Mailler le modèle de bloc avec association
276 # ------------------------------------------
278 hexablock.addLaws(doc, 0.003, True)
280 blocs = hexablock.mesh(doc)
282 muv, mue, muq, muh = hexablock.dump(doc, blocs)