2 // C++ : Gestion des cylindres croises
4 // Copyright (C) 2009-2013 CEA/DEN, EDF R&D
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License.
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // Lesser General Public License for more details.
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 // See http://www.salome-platform.org/
21 // or email : webmaster.salome@opencascade.com
23 #include "HexCrossElements.hxx"
25 #include "HexDocument.hxx"
26 #include "HexVector.hxx"
27 #include "HexVertex.hxx"
28 #include "HexHexa.hxx"
29 #include "HexEdge.hxx"
31 #include "HexGlobale.hxx"
32 #include "HexCylinder.hxx"
33 #include "HexNewShape.hxx"
37 static bool db = false;
39 static const double UnSur2pi = DEMI/M_PI;
43 // ====================================================== Constructeur
44 CrossElements::CrossElements (Document* doc, EnumGrid type)
52 angle_intermed = angle_inter [CylSmall] = angle_inter [CylBig] = 0;
53 at_right = at_left = true;
57 // ====================================================== resize
58 void CrossElements::resize ()
62 size_hz [CylSmall] = size_h1z;
63 size_hz [CylBig] = size_h2z;
65 size_vx = size_hx + 1;
67 size_vz[CylSmall] = size_v1z;
68 size_vz[CylBig] = size_v2z;
70 nbr_vertex1 = size_vx*size_vy* size_v1z;
71 nbr_quads1 = nbr_vertex1*DIM3;
72 nbr_edges1 = nbr_quads1;
73 nbr_hexas1 = size_hx * size_hy * size_h1z;
75 nbr_vertex = nbr_vertex1 + size_vx * size_vy * size_v1z;
76 nbr_quads = nbr_vertex*DIM3;
77 nbr_edges = nbr_quads;
78 nbr_hexas = nbr_hexas1 + size_hx * size_hy * size_h2z;
80 tab_hexa .resize (nbr_hexas*2);
81 tab_quad .resize (nbr_quads*2);
82 tab_edge .resize (nbr_edges*2);
83 tab_vertex.resize (nbr_vertex*2);
85 for (int nc=0 ; nc< nbr_hexas ; nc++) tab_hexa [nc] = NULL;
86 for (int nc=0 ; nc< nbr_quads ; nc++) tab_quad [nc] = NULL;
87 for (int nc=0 ; nc< nbr_edges ; nc++) tab_edge [nc] = NULL;
88 for (int nc=0 ; nc< nbr_vertex ; nc++) tab_vertex [nc] = NULL;
90 // ====================================================== indHexa
91 int CrossElements::indHexa (int cyl, int nx, int ny, int nz)
95 if ( nx < 0 || nx >= size_hx || ny < 0 || ny >= size_hy
96 || nz < 0 || nz >= size_hz[cyl]) return NOTHING;
98 int nro = cyl*nbr_hexas1 + nx + size_hx*ny + size_hx*size_hy*nz;
101 // ====================================================== indQuad
102 int CrossElements::indQuad (int cyl, int dd, int nx, int ny, int nz)
104 if (cyl<0 || cyl>1 || dd <0 || dd >= DIM3)
106 if ( nx < 0 || nx >= size_vx || ny < 0 || ny >= size_vy
107 || nz < 0 || nz >= size_vz[cyl]) return NOTHING;
109 int nro = cyl*nbr_quads1 + nx + size_vx*ny + size_vx*size_vy*nz
110 + size_vx*size_vy*size_vz[cyl]*dd;
113 // ====================================================== indEdge
114 int CrossElements::indEdge (int cyl, int dd, int nx, int ny, int nz)
116 return indQuad (cyl, dd, nx, ny, nz);
118 // ====================================================== indVertex
119 int CrossElements::indVertex (int cyl, int nx, int ny, int nz)
123 if ( nx < 0 || nx >= size_vx || ny < 0 || ny >= size_vy
124 || nz < 0 || nz >= size_vz[cyl])
127 int nro = cyl*nbr_vertex1 + nx + size_vx*ny + size_vx*size_vy*nz;
130 // ------------------------------------------------------------------------
131 // ====================================================== getHexaIJK
132 Hexa* CrossElements::getHexaIJK (int cyl, int nx, int ny, int nz)
134 int nro = indHexa (cyl, nx, ny, nz);
136 if (nro >= 0 && tab_hexa[nro]!= NULL && tab_hexa[nro]->isHere ())
137 return tab_hexa [nro];
141 // ====================================================== getQuadIJ
142 Quad* CrossElements::getQuadIJ (int cyl, int nx, int ny, int nz)
144 int nro = indQuad (cyl, dir_z, nx, ny, nz);
148 return tab_quad [nro];
150 // ====================================================== getQuadJK
151 Quad* CrossElements::getQuadJK (int cyl, int nx, int ny, int nz)
153 int nro = indQuad (cyl, dir_x, nx, ny, nz);
156 return tab_quad [nro];
158 // ====================================================== getQuadIK
159 Quad* CrossElements::getQuadIK (int cyl, int nx, int ny, int nz)
161 int nro = indQuad (cyl, dir_y, nx, ny, nz);
164 return tab_quad [nro];
166 // ====================================================== getEdgeI
167 Edge* CrossElements::getEdgeI (int cyl, int nx, int ny, int nz)
169 int nro = indEdge (cyl, dir_x, nx, ny, nz);
172 return tab_edge [nro];
174 // ====================================================== getEdgeJ
175 Edge* CrossElements::getEdgeJ (int cyl, int nx, int ny, int nz)
177 int nro = indEdge (cyl, dir_y, nx, ny, nz);
180 return tab_edge [nro];
182 // ====================================================== getEdgeK
183 Edge* CrossElements::getEdgeK (int cyl, int nx, int ny, int nz)
185 int nro = indEdge (cyl, dir_z, nx, ny, nz);
188 return tab_edge [nro];
190 // ====================================================== getVertexIJK
191 Vertex* CrossElements::getVertexIJK (int cyl, int nx, int ny, int nz)
193 int nro = indVertex (cyl, nx, ny, nz);
196 return tab_vertex [nro];
198 // ------------------------------------------------------------------------
199 // ====================================================== setHexa
200 void CrossElements::setHexa (Hexa* elt, int cyl, int nx, int ny, int nz)
204 printf ("tab_hexa [%d, %d,%d,%d] = ", cyl, nx, ny, nz);
209 int nro = indHexa (cyl, nx, ny, nz);
212 tab_hexa [nro] = elt;
214 // ====================================================== setQuad
215 void CrossElements::setQuad (Quad* elt, int cyl, int dd, int nx, int ny, int nz)
219 printf ("tab_quad [%d,%d, %d,%d,%d] = ", cyl, dd, nx, ny, nz);
224 int nro = indQuad (cyl, dd, nx, ny, nz);
227 tab_quad [nro] = elt;
229 // ====================================================== setEdge
230 void CrossElements::setEdge (Edge* elt, int cyl, int dd, int nx, int ny, int nz)
234 printf ("tab_edge [%d,%d, %d,%d,%d] = ", cyl, dd, nx, ny, nz);
239 int nro = indEdge (cyl, dd, nx, ny, nz);
242 tab_edge [nro] = elt;
244 // ====================================================== setVertex
245 void CrossElements::setVertex (Vertex* elt, int cyl, int nx, int ny, int nz)
249 printf ("tab_vertex [%d, %d,%d,%d] = ", cyl, nx, ny, nz);
254 int nro = indVertex (cyl, nx, ny, nz);
257 tab_vertex [nro] = elt;
259 // ====================================================== setVertex (2)
260 inline bool isequals (double v1, double v2)
262 const double eps = 0.01;
263 bool equals = v1 <= v2 + eps && v1 >= v2 - eps;
266 // ====================================================== setVertex (2)
267 void CrossElements::setVertex (int cyl, int nx, int ny, int nz, double px,
268 double py, double pz)
270 if (isequals (px, 0) && isequals (py, -1.5) && isequals (pz, 5))
271 printf (" Vertex trouve : Cyl%d [%d,%d,%d] = (%g,%g,%g)\n",
272 cyl, nx,ny,nz, px,py,pz);
274 int nro = indVertex (cyl, nx, ny, nz);
277 else if (tab_vertex[nro] != NULL)
279 Vertex* node = tab_vertex[nro];
280 if (node->definedBy (px, py, pz))
283 printf (" ************ ATTENTION ****************\n");
284 printf (" Creation d'un vertex : Cyl%d [%d,%d,%d] = (%g,%g,%g)\n",
285 cyl, nx,ny,nz, px,py,pz);
286 printf (" Indice %d deja occupe par le vertex (%g,%g,%g)\n", nro,
287 node->getX(), node->getY(), node->getZ());
292 int trouve = findVertex (px, py, pz);
295 printf (" Creation d'un vertex : Cyl%d [%d,%d,%d] = (%g,%g,%g)\n",
296 cyl, nx,ny,nz, px,py,pz);
297 printf (" Vertex %d present a l'indice %d\n", nro, trouve);
298 tab_vertex [nro] = tab_vertex [trouve];
301 Vertex* node = el_root->addVertex (px, py, pz);
302 setVertex (node, cyl, nx, ny, nz);
304 // ====================================================== copyEdge
305 void CrossElements::copyEdge (int d1, int i1, int j1, int k1, int d2, int i2,
311 case dir_x : edge = getEdgeI (CylSmall, i1, j1, k1);
313 case dir_y : edge = getEdgeJ (CylSmall, i1, j1, k1);
315 case dir_z : edge = getEdgeK (CylSmall, i1, j1, k1);
319 setEdge (edge, CylBig, d2, i2, j2, k2);
321 // ====================================================== copyQuad
322 void CrossElements::copyQuad (int d1, int i1, int j1, int k1, int d2, int i2,
328 case dir_x : quad = getQuadJK (CylSmall, i1, j1, k1);
330 case dir_y : quad = getQuadIK (CylSmall, i1, j1, k1);
332 case dir_z : quad = getQuadIJ (CylSmall, i1, j1, k1);
336 setQuad (quad, CylBig, d2, i2, j2, k2);
338 // ====================================================== addEdge
339 Edge* CrossElements::addEdge (Vertex* v1, Vertex* v2, int cyl, int dir,
340 int nx, int ny, int nz)
343 if (v1==NULL || v2==NULL)
346 else if (cyl==CylBig)
348 edge = findEdge1 (v1, v2);
349 /* ************************************************
352 printf (" Edge (%d, %d,%d,%d) trouve = ", dir, nx, ny, nz);
353 edge->printName ("\n");
355 ************************************************ */
359 edge = newEdge (v1, v2);
361 setEdge (edge, cyl, dir, nx, ny, nz);
364 // ====================================================== addHexa
365 Hexa* CrossElements::addHexa (Quad* q1, Quad* q2, Quad* q3, Quad* q4, Quad* q5,
366 Quad* q6, int cyl, int nx, int ny, int nz)
368 /* **************************
371 if (nx == 0) return NULL;
372 if (nz != 1) return NULL;
373 if (ny != 4) return NULL;
379 if (nz > 2) return NULL;
380 if (nz < 1) return NULL;
381 // if (nx == 0) return NULL;
382 // if (ny != 4) return NULL;
384 ************************** */
388 hexa = findHexa1 (q1, q2);
391 hexa = newHexa (q1, q2, q3, q4, q5, q6);
394 printf (" Hexa (%d,%d,%d) trouve = ", nx, ny, nz);
395 hexa->printName ("\n");
398 setHexa (hexa, cyl, nx, ny, nz);
401 // ====================================================== addQuad
402 Quad* CrossElements::addQuad (Edge* e1, Edge* e2, Edge* e3, Edge* e4, int cyl,
403 int dir, int nx, int ny, int nz)
407 quad = findQuad1 (e1, e3);
410 quad = newQuad (e1, e2, e3, e4);
413 printf (" Quad (%d, %d,%d,%d) trouve = ", dir, nx, ny, nz);
414 quad->printName ("\n");
417 setQuad (quad, cyl, dir, nx, ny, nz);
420 // ====================================================== findEdge1
421 Edge* CrossElements::findEdge1 (Vertex* v1, Vertex* v2)
423 for (int nc=0; nc < nbr_edges1 ; nc++)
424 if (tab_edge[nc] != NULL && tab_edge[nc]->definedBy (v1, v2))
429 // ====================================================== findHexa1
430 Hexa* CrossElements::findHexa1 (Quad* e1, Quad* e2)
432 for (int nc=0; nc < nbr_hexas1 ; nc++)
433 if (tab_hexa[nc] != NULL && tab_hexa[nc]->definedBy (e1, e2))
438 // ====================================================== findQuad1
439 Quad* CrossElements::findQuad1 (Edge* e1, Edge* e2)
441 for (int nc=0; nc < nbr_quads1 ; nc++)
442 if (tab_quad[nc] != NULL && tab_quad[nc]->definedBy (e1, e2))
447 // ====================================================== fillGrid
448 void CrossElements::fillGrid (int cyl, int deb, int fin)
450 int nz0 = deb >= 0 ? deb : 0;
451 int nzn = fin > 0 ? fin : size_vz [cyl];
453 fillCenter (cyl, nz0, nzn);
455 for (int nz=nz0 ; nz<nzn ; nz++)
457 for (int nx=1 ; nx<size_hx ; nx++)
459 // Edges horizontaux radiaux
460 // Edges horizontaux // cloisons ext
461 for (int ny=0 ; ny<size_vy ; ny++)
463 int ny1 = (ny + 1) MODULO size_vy;
464 Vertex* vc = getVertexIJK (cyl, nx, ny, nz);
465 Vertex* v1 = getVertexIJK (cyl, nx+1, ny, nz);
466 Vertex* v2 = getVertexIJK (cyl, nx+1, ny1,nz);
468 addEdge (vc, v1, cyl, dir_x, nx, ny, nz);
469 addEdge (v1, v2, cyl, dir_y, nx+1, ny, nz);
472 for (int ny=0 ; ny<size_vy ; ny++)
474 int ny1 = (ny + 1) MODULO size_vy;
475 Edge* e1 = getEdgeI (cyl, nx, ny, nz);
476 Edge* e2 = getEdgeJ (cyl, nx+1, ny, nz);
477 Edge* e3 = getEdgeI (cyl, nx, ny1, nz);
478 Edge* e4 = getEdgeJ (cyl, nx, ny, nz);
480 addQuad (e1, e2, e3, e4, cyl, dir_z, nx, ny, nz);
485 // Edges verticaux + cloisons interieures
486 for (int ny=0 ; ny<size_vy ; ny++)
488 Vertex* vp = getVertexIJK (cyl, nx+1, ny, nz-1);
489 Vertex* vv = getVertexIJK (cyl, nx+1, ny, nz);
491 Edge* edge = addEdge (vp, vv, cyl, dir_z, nx+1, ny, nz-1);
493 Edge* e0 = getEdgeI (cyl, nx, ny, nz-1);
494 Edge* e2 = getEdgeI (cyl, nx, ny, nz);
495 Edge* e3 = getEdgeK (cyl, nx, ny, nz-1);
497 addQuad (e0, edge, e2, e3, cyl, dir_y, nx, ny, nz-1);
499 // Cloisons exterieures ***
500 for (int ny=0 ; ny<size_vy ; ny++)
502 int ny1 = (ny + 1) MODULO size_vy;
503 Edge* e0 = getEdgeJ (cyl, nx+1, ny, nz-1);
504 Edge* e2 = getEdgeJ (cyl, nx+1, ny, nz);
506 Edge* e1 = getEdgeK (cyl, nx+1, ny, nz-1);
507 Edge* e3 = getEdgeK (cyl, nx+1, ny1, nz-1);
508 addQuad (e0, e1, e2, e3, cyl, dir_x, nx+1, ny, nz-1);
511 if (is_filled || cyl==CylBig || (nz!=3 && nz != 4))
513 for (int ny=0 ; ny<size_hy ; ny++)
515 int ny1 = (ny + 1) MODULO size_vy;
516 // printf (" ---------- Hexa : nz=%d, ny=%d\n", ny, nz);
517 Quad* qa = getQuadIJ (cyl, nx, ny, nz-1);
518 Quad* qb = getQuadIJ (cyl, nx, ny, nz);
520 Quad* qc = getQuadJK (cyl, nx+1, ny, nz-1);
521 Quad* qd = getQuadJK (cyl, nx, ny, nz-1);
523 Quad* qe = getQuadIK (cyl, nx, ny1, nz-1);
524 Quad* qf = getQuadIK (cyl, nx, ny, nz-1);
526 // Hexa* cell = newHexa (qa, qb, qc, qd, qe, qf);
527 // setHexa (cell, cyl, nx, ny, nz-1);
528 addHexa (qa, qb, qc, qd, qe, qf, cyl, nx, ny, nz-1);
535 // ====================================================== fillCenter
536 void CrossElements::fillCenter (int cyl, int nz0, int nzn)
540 for (int nz=nz0 ; nz<nzn ; nz++)
542 Vertex* center = getVertexIJK (cyl, 0, 0, nz);
543 // Edges horizontaux // cloisons ext
544 for (int ny=0 ; ny<size_vy ; ny++)
546 Vertex* v1 = getVertexIJK (cyl, 1, ny, nz);
547 Vertex* v2 = getVertexIJK (cyl, 1, (ny+1) MODULO size_vy, nz);
548 addEdge (v1, v2, cyl, dir_y, nx+1, ny, nz);
552 // Edges horizontaux radiaux
553 for (int nc=0 ; nc<NbrIntCotes ; nc++)
555 Vertex* vv = getVertexIJK (cyl, 1, 2*nc, nz);
556 addEdge (center, vv, cyl, dir_x, nx, nc, nz);
559 for (int nc=0; nc<NbrIntCotes ; nc++)
561 int nc1 = (nc + 1) MODULO NbrIntCotes;
562 Edge* e1 = getEdgeI (cyl, nx, nc, nz);
563 Edge* e2 = getEdgeJ (cyl, nx+1, 2*nc, nz);
564 Edge* e3 = getEdgeJ (cyl, nx+1, 2*nc+1, nz);
565 Edge* e4 = getEdgeI (cyl, nx, nc1, nz);
567 addQuad (e1, e2, e3, e4, cyl, dir_z, nx, nc, nz);
573 // Edges verticaux + cloisons interieures
574 Vertex* vhaut = getVertexIJK (cyl,nx,0, nz-1);
575 Edge* pilier = addEdge (center, vhaut, cyl, dir_z, nx, 0, nz-1);
577 for (int ny=0 ; ny<size_vy ; ny++)
579 Vertex* vp = getVertexIJK (cyl, 1, ny, nz-1);
580 Vertex* vv = getVertexIJK (cyl, 1, ny, nz);
581 Edge* edge = addEdge (vp, vv, cyl, dir_z, 1, ny, nz-1);
582 if (is_filled && (ny MODULO 2) == 0)
584 Edge* e0 = getEdgeI (cyl, nx, ny/2, nz-1);
585 Edge* e2 = getEdgeI (cyl, nx, ny/2, nz);
586 addQuad (e0,edge, e2,pilier, cyl, dir_y, nx, ny/2, nz-1);
589 // Cloisons exterieures
590 for (int ny=0 ; ny<size_vy ; ny++)
592 int ny1 = (ny + 1) MODULO size_vy;
593 Edge* e0 = getEdgeJ (cyl, 1, ny, nz-1);
594 Edge* e2 = getEdgeJ (cyl, 1, ny, nz);
595 Edge* e1 = getEdgeK (cyl, 1, ny, nz-1);
596 Edge* e3 = getEdgeK (cyl, 1, ny1, nz-1);
598 addQuad (e0, e1, e2, e3, cyl, dir_x, 1, ny, nz-1);
603 for (int nc=0 ; nc < NbrIntCotes ; nc++)
605 // printf (" --------------- Hexa : nz=%d, nc=%d\n", nc, nz);
606 int nc1 = (nc + 1) MODULO NbrIntCotes;
607 Quad* qa = getQuadIJ (cyl, 0, nc, nz-1);
608 Quad* qb = getQuadIJ (cyl, 0, nc, nz);
610 Quad* qc = getQuadJK (cyl, 1, 2*nc, nz-1);
611 Quad* qe = getQuadJK (cyl, 1, 2*nc+1, nz-1);
613 Quad* qd = getQuadIK (cyl, 0, nc1, nz-1);
614 Quad* qf = getQuadIK (cyl, 0, nc, nz-1);
616 // Hexa* cell = newHexa (qa, qb, qc, qd, qe, qf);
617 // setHexa (cell, cyl, 0, nc, nz-1);
618 addHexa (qa, qb, qc, qd, qe, qf, cyl, nx, nc, nz-1);
624 // ====================================================== dump
625 void CrossElements::dump ()
627 int sizey [2] = { 4, S_MAXI };
628 for (int cyl=CylSmall ; cyl<=CylBig ; cyl++)
630 printf (" +++++++++ \n");
631 printf (" +++++++++ Hexas du Cylindre nro %d\n", cyl);
632 printf (" +++++++++ \n");
633 for (int nz=0; nz<size_hz[cyl]; nz++)
635 for (int nx=0; nx<size_hx; nx++)
638 for (int ny=0; ny<sizey[nx]; ny++)
640 Hexa* cell = getHexaIJK (cyl,nx,ny,nz);
641 int nro = indHexa (cyl, nx, ny, nz);
642 printf ("tab_hexa[%03d] (%d, %d,%d,%d) = ",
644 if (cell!=NULL) cell->printName("\n");
645 else printf ("NULL\n");
651 // ====================================================== dumpVertex
652 void CrossElements::dumpVertex ()
654 int sizey [3] = { 1, S_MAXI, S_MAXI };
656 for (int cyl=CylSmall ; cyl<=CylBig ; cyl++)
658 printf (" +++++++++ \n");
659 printf (" +++++++++ Vertex du Cylindre nro %d\n", cyl);
660 printf (" +++++++++ \n");
661 for (int nz=0; nz<size_vz[cyl]; nz++)
663 for (int nx=0; nx<size_vx; nx++)
666 for (int ny=0; ny<sizey[nx]; ny++)
668 Vertex* node = getVertexIJK (cyl,nx,ny,nz);
669 int nro = indVertex (cyl, nx, ny, nz);
670 printf ("tab_vertex[%03d] (%d, %d,%d,%d) = ",
672 if (node!=NULL) node->printName("\n");
673 else printf ("NULL\n");
679 // ====================================================== dumpHexas
680 void CrossElements::dumpHexas ()
682 int sizey [3] = { 1, 4, S_MAXI };
684 for (int cyl=CylSmall ; cyl<=CylBig ; cyl++)
686 printf (" +++++++++ \n");
687 printf (" +++++++++ Hexaedres du Cylindre nro %d\n", cyl);
688 printf (" +++++++++ \n");
689 for (int nz=0; nz<size_hz[cyl]; nz++)
691 for (int nx=0; nx<size_hx; nx++)
694 for (int ny=0; ny<sizey[nx]; ny++)
696 Hexa* elt = getHexaIJK (cyl,nx,ny,nz);
699 int nro = indHexa (cyl, nx, ny, nz);
700 printf ("tab_hexa[%03d] (%d, %d,%d,%d) = ",
702 elt->printName("\n");
709 // ====================================================== calcul_centre
710 double calcul_centre (Vertex* orig, Vertex* inter)
712 double dx = inter->getX () - orig->getX ();
713 double dy = inter->getY () - orig->getY ();
714 double dz = inter->getZ () - orig->getZ ();
715 double dd = sqrt (dx*dx + dy*dy + dz*dz);
718 // ===================================================== assoSlice
719 void CrossElements::assoSlice (int cyl, double* base, double* normal, int nx,
722 Real3 center, pnt1, pnt2;
725 Vertex* v_n = getVertexIJK (cyl, nx, S_N , nzs);
726 Vertex* v_s = getVertexIJK (cyl, nx, S_S , nzs);
728 v_s->getPoint (pnt1);
729 v_n->getPoint (pnt2);
731 double rayon = calc_distance (pnt1, pnt2)/2;
732 for (int nro=0 ; nro<DIM3 ; nro++)
733 center[nro] = (pnt1[nro] + pnt2[nro])/2;
735 int subid = grid_geom->addCircle (center, rayon, normal, base);
737 for (int ny=0 ; ny<S_MAXI ; ny++)
739 assoArc (cyl, nx, ny, nzs, subid);
742 // ===================================================== assoArc
743 void CrossElements::assoArc (int cyl, int nx, int ny, int nz, int subid)
745 double angle1 = getAngle (cyl, ny, nz);
746 double angle2 = getAngle (cyl, ny+1, nz);
747 Edge* edge = getEdgeJ (cyl, nx, ny, nz);
751 grid_geom->addAssociation (edge, subid, angle1*UnSur2pi, angle2*UnSur2pi);
753 // Assurer avec les vertex
754 int ny2 = ny>=S_MAXI-1 ? 0 : ny+1;
755 Vertex* node1 = getVertexIJK (cyl, nx, ny, nz);
756 Vertex* node2 = getVertexIJK (cyl, nx, ny2, nz);
758 grid_geom->addAssociation (node1, subid, angle1*UnSur2pi);
759 grid_geom->addAssociation (node2, subid, angle2*UnSur2pi);
761 // ====================================================== getAngleInter
762 // ==== Angle intersection intermediaire
763 double CrossElements::getAngleInter (int cyl, int nz)
765 if (cyl==CylBig && (nz==1 || nz==3))
766 return angle_intermed;
768 return angle_inter[cyl];
770 // ====================================================== getAngle
771 double CrossElements::getAngle (int cyl, int nj, int nz)
776 case S_NE : return angle_inter[cyl];
777 case S_N : return M_PI/2;
778 case S_NW : return M_PI - angle_inter[cyl];
779 case S_W : return M_PI;
780 case S_SW : return M_PI + angle_inter[cyl];
781 case S_S : return 3*M_PI/2;
782 case S_SE : return 2*M_PI - angle_inter[cyl];
783 case S_MAXI : return 2*M_PI;
788 // ====================================================== addVertex
789 void CrossElements::addVertex (int cyl, int ni, int nj, int nk, double px,
793 rayon = cross_rayon [cyl][ni];
794 double theta = getAngle (cyl, nj);
797 setVertex (cyl, ni, nj, nk, px, rayon*cos(theta), rayon*sin(theta));
799 setVertex (cyl, ni, nj, nk, rayon*cos(theta), rayon*sin(theta), px);
801 // ====================================================== addSlice
802 void CrossElements::addSlice (int cyl, int ni, int nk, double px, double rayon)
804 for (int nj=0 ; nj < S_MAXI ; nj++)
805 addVertex (cyl, ni, nj, nk, px, rayon);