2 // C++ : Gestion des Hexaedres
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/ or email : webmaster.salome@opencascade.com
22 #include "HexHexa.hxx"
23 #include "HexQuad.hxx"
25 #include "HexVertex.hxx"
26 #include "HexDocument.hxx"
27 #include "HexEdge.hxx"
29 #include "HexGlobale.hxx"
30 #include "HexXmlWriter.hxx"
31 #include "HexDiagnostics.hxx"
32 #include "HexGlobale.hxx"
33 #include "HexMatrix.hxx"
34 #include "HexElements.hxx"
38 // ======================================================== Constructeur
39 Hexa::Hexa (Vertex* va, Vertex* vb, Vertex* vc, Vertex* vd,
40 Vertex* ve, Vertex* vf, Vertex* vg, Vertex* vh)
41 : EltBase (va->dad(), EL_HEXA)
43 h_vertex [V_ACE] = va;
44 h_vertex [V_ACF] = vb; // = vc ; Modif Abu 30/08/2011
45 h_vertex [V_ADE] = vc; // = vb ; Modif Abu 30/08/2011
46 h_vertex [V_ADF] = vd;
48 h_vertex [V_BCE] = ve;
49 h_vertex [V_BCF] = vf; // = vg ; Modif Abu 30/08/2011
50 h_vertex [V_BDE] = vg; // = vf ; Modif Abu 30/08/2011
51 h_vertex [V_BDF] = vh;
57 Globale* glob = Globale::getInstance ();
59 for (int nro=0 ; nro<HE_MAXI ; nro++)
61 h_edge[nro] = new Edge (h_vertex[glob->EdgeVertex (nro, V_AMONT)],
62 h_vertex[glob->EdgeVertex (nro, V_AVAL)]);
65 for (int nro=0 ; nro<HQ_MAXI ; nro++)
67 h_quad[nro] = new Quad (h_edge [glob->QuadEdge (nro, E_A)],
68 h_edge [glob->QuadEdge (nro, E_B)],
69 h_edge [glob->QuadEdge (nro, E_C)],
70 h_edge [glob->QuadEdge (nro, E_D)]);
72 h_quad[nro] -> addParent (this);
75 if (el_root != NULL && el_status==HOK)
76 el_root->addHexa (this);
78 // ======================================================== Constructeur 2
79 Hexa::Hexa (Quad* qa, Quad* qb, Quad* qc, Quad* qd, Quad* qe, Quad* qf)
80 : EltBase (qa->dad(), EL_HEXA)
90 for (int nb=0 ; nb<HE_MAXI ; nb++) h_edge [nb] = NULL;
91 for (int nb=0 ; nb<HV_MAXI ; nb++) h_vertex [nb] = NULL;
101 printf (" +++++++++++++++++++++++++++++++++++++++++++ \n");
102 printf (" +++ Heaedre impossible \n");
103 printf (" +++++++++++++++++++++++++++++++++++++++++++ \n");
105 // printf (" +++++++++++++++++++++++++++++++++++++++++++ \n");
107 for (int nro=0; nro<HQ_MAXI; nro++) HexDump (h_quad[nro]);
108 for (int nro=0; nro<HE_MAXI; nro++) HexDump (h_edge[nro]);
109 for (int nro=0; nro<HV_MAXI; nro++) HexDump (h_vertex[nro]);
110 printf (" +++++++++++++++++++++++++++++++++++++++++++ \n");
114 el_root->addHexa (this);
116 // ========================================================= Constructeur 3
117 // === a utiliser uniquement pour le clonage
118 Hexa::Hexa (Hexa* other)
119 : EltBase (other->el_root, EL_HEXA)
121 for (int nro=0 ; nro<HQ_MAXI ; nro++) h_quad [nro] = NULL;
122 for (int nro=0 ; nro<HE_MAXI ; nro++) h_edge [nro] = NULL;
123 for (int nro=0 ; nro<HV_MAXI ; nro++) h_vertex [nro] = NULL;
126 if (el_root != NULL && el_status==HOK)
127 el_root->addHexa (this);
129 // ======================================================== majReferences
130 void Hexa::majReferences ()
132 for (int nro=0 ; nro<HQ_MAXI ; nro++)
133 h_quad[nro]->addParent (this);
135 // ======================================================== controlerArete
136 void Hexa::controlerArete (int arete, int face1, int face2)
138 h_edge [arete] = h_quad[face1]->commonEdge (h_quad[face2]);
139 if (h_edge [arete]==NULL)
141 el_root->putError (W_H_BAD_EDGE,
142 el_root->glob->namofHexaEdge (arete));
146 // ======================================================== controlerSomet
147 void Hexa::controlerSommet (int node, int ne1, int ne2, int ne3)
149 if (h_edge[ne1] == NULL || h_edge[ne2] == NULL || h_edge[ne3] == NULL)
152 Vertex* hv = h_edge[ne1]->commonVertex (h_edge[ne2]);
153 h_vertex [node] = hv;
156 el_root->putError (W_H_BAD_VERTEX,
157 el_root->glob->namofHexaVertex(node));
160 else if (hv == NULL || h_edge[ne3]->index (hv)<0)
163 el_root->putError (W_H_BAD_VERTEX,
164 el_root->glob->namofHexaVertex(node));
166 printf ("%s = %s\n", el_root->glob->namofHexaVertex(node),
168 printf ("%s = %s\n", el_root->glob->namofHexaEdge(ne1),
169 h_edge[ne1]->getName(b));
170 printf ("%s = %s\n", el_root->glob->namofHexaEdge(ne2),
171 h_edge[ne2]->getName(b));
172 printf ("%s = %s\n", el_root->glob->namofHexaEdge(ne3),
173 h_edge[ne3]->getName(b));
176 // ======================================================== controlerFaces
177 void Hexa::controlerFaces ()
179 for (int n1=0 ; n1<HQ_MAXI ; n1++)
181 if (BadElement (h_quad [n1]))
183 el_root->putError (W_H_NULL_QUAD,
184 el_root->glob->namofHexaQuad (n1));
188 for (int n2=n1+1 ; n2<HQ_MAXI ; n2++)
189 if (h_quad [n1] == h_quad[n2])
191 el_root->putError (W_H_EQ_QUAD,
192 el_root->glob->namofHexaQuad (n1),
193 el_root->glob->namofHexaQuad (n2));
198 // ======================================================== controlerSommets
199 void Hexa::controlerSommets ()
201 for (int n1=0 ; n1<HV_MAXI ; n1++)
203 if (BadElement (h_vertex [n1]))
205 el_root->putError (W_H_NULL_QUAD,
206 el_root->glob->namofHexaVertex (n1));
210 for (int n2=n1+1 ; n2<HQ_MAXI ; n2++)
211 if (h_vertex [n1] == h_vertex[n2])
213 el_root->putError (W_H_EQ_QUAD,
214 el_root->glob->namofHexaVertex (n1),
215 el_root->glob->namofHexaVertex (n2));
220 // ======================================================== verifierAretes
221 void Hexa::verifierAretes ()
223 for (int nro=0 ; nro<HE_MAXI ; nro++) h_edge [nro] = NULL;
225 controlerArete ( E_AC, Q_A, Q_C);
226 controlerArete ( E_AF, Q_A, Q_F);
227 controlerArete ( E_AD, Q_A, Q_D);
228 controlerArete ( E_AE, Q_A, Q_E);
230 controlerArete ( E_BC, Q_B, Q_C);
231 controlerArete ( E_BF, Q_B, Q_F);
232 controlerArete ( E_BD, Q_B, Q_D);
233 controlerArete ( E_BE, Q_B, Q_E);
235 controlerArete ( E_CE, Q_C, Q_E);
236 controlerArete ( E_CF, Q_C, Q_F);
237 controlerArete ( E_DF, Q_D, Q_F);
238 controlerArete ( E_DE, Q_D, Q_E);
240 // ======================================================== verifierSommets
241 void Hexa::verifierSommets ()
243 for (int nro=0 ; nro<HV_MAXI ; nro++) h_vertex [nro] = NULL;
245 controlerSommet (V_ACE, E_AC, E_AE, E_CE);
246 controlerSommet (V_ACF, E_AC, E_AF, E_CF);
247 controlerSommet (V_ADF, E_AD, E_AF, E_DF);
248 controlerSommet (V_ADE, E_AD, E_AE, E_DE);
250 controlerSommet (V_BCE, E_BC, E_BE, E_CE);
251 controlerSommet (V_BCF, E_BC, E_BF, E_CF);
252 controlerSommet (V_BDF, E_BD, E_BF, E_DF);
253 controlerSommet (V_BDE, E_BD, E_BE, E_DE);
255 // ======================================================== Inter
256 Quad* Hexa::Inter (Hexa* other)
258 for (int nf1=0 ; nf1 < HQ_MAXI ; nf1++)
259 for (int nf2=0 ; nf2 < HQ_MAXI ; nf2++)
260 if (h_quad[nf1] == other->h_quad[nf2])
265 // -------------------------------------------------------------------
267 // -------------------------------------------------------------------
268 // ======================================================= razNodes
269 void Hexa::razNodes ()
271 for (int nb=0 ; nb<HV_MAXI ; nb++)
272 h_vertex[nb]->setMark (NO_COUNTED);
274 // ======================================================= countNodes
275 int Hexa::countNodes ()
278 for (int nb=0 ; nb<HV_MAXI ; nb++)
279 if (h_vertex[nb]->getMark () == NO_COUNTED)
281 h_vertex[nb]->setMark (NO_USED);
287 // ======================================================= printNodes
288 void Hexa::printNodes (pfile vtk, int& compteur)
290 const double minvtk = 1e-30;
293 for (int nb=0 ; nb<HV_MAXI ; nb++)
294 if (h_vertex[nb]->getMark()==NO_USED)
296 h_vertex[nb]->getPoint (koord);
297 for (int nc=dir_x ; nc<=dir_z ; nc++)
298 if (koord [nc] < minvtk && koord [nc] > -minvtk)
301 fprintf (vtk, "%g %g %g\n", koord[dir_x], koord[dir_y], koord[dir_z]);
302 h_vertex[nb]->setMark (compteur);
306 // ======================================================= colorNodes
307 void Hexa::colorNodes (pfile vtk)
309 for (int nb=0 ; nb<HV_MAXI ; nb++)
310 if (h_vertex[nb]->getMark()>=0)
312 double color = 100*(h_vertex[nb]->getScalar()+1);
313 fprintf (vtk, "%g\n", color);
314 h_vertex[nb]->setMark (NO_COUNTED);
317 // ======================================================= moveNodes
318 void Hexa::moveNodes (Matrix* matrice)
320 for (int nb=0 ; nb<HV_MAXI ; nb++)
321 if (h_vertex[nb]->getMark()!=IS_USED)
323 matrice->perform (h_vertex[nb]);
324 h_vertex[nb]->setMark (IS_USED);
327 // ======================================================= transform
328 void Hexa::transform (Matrix* matrice)
330 for (int nb=0 ; nb<HV_MAXI ; nb++)
331 matrice->perform (h_vertex[nb]);
333 // ======================================================= printHexa
334 void Hexa::printHexa (pfile vtk)
336 fprintf (vtk, "%d", HV_MAXI);
338 fprintf (vtk, " %d", h_vertex[V_ACE]->getMark ());
339 fprintf (vtk, " %d", h_vertex[V_ACF]->getMark ());
340 fprintf (vtk, " %d", h_vertex[V_ADF]->getMark ());
341 fprintf (vtk, " %d", h_vertex[V_ADE]->getMark ());
343 fprintf (vtk, " %d", h_vertex[V_BCE]->getMark ());
344 fprintf (vtk, " %d", h_vertex[V_BCF]->getMark ());
345 fprintf (vtk, " %d", h_vertex[V_BDF]->getMark ());
346 fprintf (vtk, " %d", h_vertex[V_BDE]->getMark ());
350 // ======================================================= printHexaVtk
351 void Hexa::printHexaVtk (pfile vtk)
353 fprintf (vtk, "%d", HV_MAXI);
355 fprintf (vtk, " %d", h_vertex[V_ACE]->getId ());
356 fprintf (vtk, " %d", h_vertex[V_ACF]->getId ());
357 fprintf (vtk, " %d", h_vertex[V_ADF]->getId ());
358 fprintf (vtk, " %d", h_vertex[V_ADE]->getId ());
360 fprintf (vtk, " %d", h_vertex[V_BCE]->getId ());
361 fprintf (vtk, " %d", h_vertex[V_BCF]->getId ());
362 fprintf (vtk, " %d", h_vertex[V_BDF]->getId ());
363 fprintf (vtk, " %d", h_vertex[V_BDE]->getId ());
367 // ======================================================== hasFreEdges
368 bool Hexa::hasFreeEdges ()
373 for (int nro=0; nro<HE_MAXI ; nro++)
374 if (h_edge[nro]->getMark()<0)
379 // ======================================================== propager
380 void Hexa::propager (Propagation* prop, int nro)
385 for (int nro=0; nro<HE_MAXI ; nro++)
386 if (h_edge[nro]->getMark()<0)
387 h_edge[nro]->propager (prop, nro);
389 // ========================================================= saveXml
390 void Hexa::saveXml (XmlWriter* xml)
395 for (int nro=0 ; nro<HQ_MAXI ; nro++)
397 if (nro>0) quads += " ";
398 quads += h_quad[nro]->getName(ident);
402 xml->openMark ("Hexa");
403 xml->addAttribute ("id", ident);
404 xml->addAttribute ("quads", quads);
406 xml->addAttribute ("name", el_name);
409 // ========================================================= findQuad
410 int Hexa::findQuad (Quad* element)
412 for (int nro=0 ; nro<HQ_MAXI ; nro++)
413 if (h_quad[nro]==element)
418 // ========================================================= findEdge
419 int Hexa::findEdge (Edge* element)
421 for (int nro=0 ; nro<HE_MAXI ; nro++)
422 if (h_edge[nro]==element)
427 // ========================================================= findVertex
428 int Hexa::findVertex (Vertex* element)
430 for (int nro=0 ; nro<HV_MAXI ; nro++)
431 if (h_vertex[nro]==element)
436 // ========================================================= disconnectQuad
437 Elements* Hexa::disconnectQuad (Quad* quad)
444 printf (" ... Avant disconnectQuad, quad=");
445 quad->printName ("\n");
449 int nface = findQuad (quad);
452 // Face opposee : replace
453 // int nfopp = (nface MODULO 2==0) ? nface+1 : nface-1;
455 int ind_edge [QUAD4], ind_opp_quad [QUAD4];
456 bool make_quad [QUAD4], make_edge [QUAD4];
458 for (int nro=0 ; nro<QUAD4 ; nro++)
459 make_quad [nro] = make_edge[nro] = false;
461 for (int nro=0 ; nro<QUAD4 ; nro++)
463 int nro1 = (nro+1) MODULO QUAD4;
464 int pedge = findEdge (quad->getEdge (nro));
465 int pnode = findVertex (quad->getVertex (nro));
466 int oppq = findOpposedQuad (quad, quad->getEdge (nro));
468 ind_edge [nro] = pedge;
469 ind_opp_quad [nro] = oppq;
471 if (pedge==NOTHING || pnode==NOTHING || oppq==NOTHING)
474 make_quad [nro] = h_quad[oppq]->getNbrParents() == 2;
475 make_edge [nro ] = make_edge [nro ] || make_quad [nro];
476 make_edge [nro1] = make_edge [nro1] || make_quad [nro];
480 printf (" Sommet nro %d : ", nro);
481 quad->getVertex(nro)->printName (", ");
483 quad->getEdge(nro)->printName (", ");
484 printf (" quad oppose = ");
485 h_quad[oppq]->printName("");
487 printf (" a dissocier\n");
494 Vertex* new_node [QUAD4];
495 Edge* new_opp_edge [QUAD4];
496 Edge* old_opp_edge [QUAD4];
498 for (int nro=0 ; nro<QUAD4 ; nro++)
500 old_opp_edge [nro] = NULL;
501 new_opp_edge [nro] = NULL;
502 Vertex* o_v0 = quad->getVertex (nro);
503 new_node [nro] = new Vertex (o_v0);
506 printf (" quad.vertex [%d] = ", nro);
507 quad->getVertex (nro)->printName (" --> ");
508 new_node [nro]->printName ("\n");
513 Quad* pface = h_quad [ind_opp_quad [nro]];
515 int ncut = pface->inter (quad, bid);
516 Edge* ecut = pface->getEdge ((ncut+1) MODULO QUAD4);
517 Vertex* vopp = ecut->getVertex(V_AMONT);
519 vopp = ecut->getVertex (V_AVAL);
520 else if (o_v0 != ecut->getVertex (V_AVAL));
522 ecut = pface->getEdge ((ncut+3) MODULO QUAD4);
523 vopp = ecut->getVertex(V_AMONT);
525 vopp = ecut->getVertex (V_AVAL);
526 else if (o_v0 != ecut->getVertex (V_AVAL))
530 old_opp_edge [nro] = ecut;
531 new_opp_edge [nro] = new Edge (new_node[nro], vopp);
534 printf (" quad.opp_edge [%d] = ", nro);
535 old_opp_edge [nro]->printName (" --> ");
536 new_opp_edge [nro]->printName ("\n");
541 Quad* new_quad = new Quad (new_node[0], new_node[1], new_node[2],
544 Quad* new_opp_quad [QUAD4];
545 Quad* old_opp_quad [QUAD4];
546 for (int nro=0 ; nro<QUAD4 ; nro++)
548 old_opp_quad [nro] = NULL;
549 new_opp_quad [nro] = NULL;
552 int nro1 = (nro+1) MODULO QUAD4;
554 Edge* n_edge0 = new_quad->getEdge (nro);
555 Edge* n_edge1 = new_opp_edge [nro];
556 Edge* n_edge3 = new_opp_edge [nro1];
558 int iv1 = n_edge1->inter (n_edge0);
559 int iv3 = n_edge3->inter (n_edge0);
560 if (iv1 <0 || iv3 <0)
563 Quad* o_face = h_quad [ind_opp_quad [nro]];
564 Edge* edge2 = o_face->findEdge (n_edge1->getVertex (1-iv1),
565 n_edge3->getVertex (1-iv3));
568 // Edge* o_edge0 = h_edge [ind_edge [nro]];
570 // Edge* edge2 = o_face->getOpposEdge (o_edge0, sens);
572 old_opp_quad [nro] = o_face;
574 printf (" -------- Quad oppose nro %d\n", nro);
575 new_opp_quad [nro] = new Quad (n_edge0, n_edge1, edge2, n_edge3);
579 replaceQuad (quad, new_quad);
580 for (int nro=0 ; nro<QUAD4 ; nro++)
582 replaceQuad (old_opp_quad [nro], new_opp_quad [nro]);
584 for (int nro=0 ; nro<QUAD4 ; nro++)
586 replaceEdge (h_edge[ind_edge[nro]], new_quad->getEdge (nro));
588 replaceEdge (old_opp_edge [nro], new_opp_edge [nro]);
591 for (int nro=0 ; nro<QUAD4 ; nro++)
593 replaceVertex (quad->getVertex(nro), new_node[nro]);
597 h_quad [nface] = new_quad;
600 printf (" ... Apres disconnectQuad, new_quad=");
601 new_quad->printName ("\n");
605 Elements* nouveaux = new Elements (el_root);
606 nouveaux->addQuad (new_quad);
607 for (int nro=0 ; nro<QUAD4 ; nro++)
609 nouveaux->addEdge (new_quad->getEdge (nro));
610 nouveaux->addVertex (new_quad->getVertex (nro));
612 nouveaux->addEdge (new_opp_edge [nro]);
614 nouveaux->addQuad (new_opp_quad [nro]);
616 nouveaux->moveDisco (this);
619 // ========================================================= disconnectEdge
620 Elements* Hexa::disconnectEdge (Edge* arete)
622 int nedge = findEdge (arete);
623 int namont = findVertex (arete->getVertex(V_AMONT));
624 int naval = findVertex (arete->getVertex(V_AVAL ));
626 if (nedge==NOTHING || namont==NOTHING || naval==NOTHING)
631 printf (" ... Avant disconnectEdge, arete=");
632 arete->printName ("\n");
636 Edge* n_edge [HE_MAXI];
637 Quad* n_quad [HQ_MAXI];
638 Vertex* n_vertex [HV_MAXI];
640 for (int nro=0 ; nro<HQ_MAXI ; nro++) n_quad [nro] = NULL;
641 for (int nro=0 ; nro<HE_MAXI ; nro++) n_edge [nro] = NULL;
642 for (int nro=0 ; nro<HV_MAXI ; nro++) n_vertex [nro] = NULL;
644 Vertex* old_amont = arete->getVertex (V_AMONT);
645 Vertex* old_aval = arete->getVertex (V_AVAL );
646 Vertex* new_amont = n_vertex [namont] = new Vertex (old_amont);
647 Vertex* new_aval = n_vertex [naval] = new Vertex (old_aval);
648 n_edge [nedge] = new Edge (new_amont, new_aval);
650 // Un edge non remplace, qui contient un vertex remplace
651 // commun a plus de 2 faces (donc appartenant a un autre hexa)
652 // doit etre duplique
654 for (int nro=0 ; nro<HE_MAXI ; nro++)
656 if ( n_edge[nro]==NULL && h_edge[nro] != NULL
657 && h_edge[nro]->getNbrParents()>2)
659 Vertex* va = h_edge[nro]->getVertex (V_AMONT);
660 Vertex* vb = h_edge[nro]->getVertex (V_AVAL);
663 n_edge [nro] = new Edge (new_amont, vb);
664 else if (va==old_aval)
665 n_edge [nro] = new Edge (new_aval, vb);
666 else if (vb==old_amont)
667 n_edge [nro] = new Edge (va, new_amont);
668 else if (vb==old_aval)
669 n_edge [nro] = new Edge (va, new_aval);
673 // Un quad non remplace, qui contient un edge remplace
674 // commun a plus de 2 Hexas
675 // doit etre duplique
677 Globale* glob = Globale::getInstance();
678 for (int nro=0 ; nro<HQ_MAXI ; nro++)
679 if ( n_quad[nro]==NULL && h_quad[nro] != NULL
680 && h_quad[nro]->getNbrParents()>1)
684 for (int ned=0 ; ned<QUAD4 ; ned++)
686 int ndup = glob->QuadEdge (nro, (EnumQuad)ned);
687 if (n_edge [ndup] ==NULL)
688 qedge [ned] = h_edge[ndup];
691 qedge [ned] = n_edge[ndup];
696 n_quad[nro] = new Quad (qedge[Q_A], qedge[Q_B],
697 qedge[Q_C], qedge[Q_D]);
700 Elements* nouveaux = new Elements (el_root);
701 for (int nro=0 ; nro<HQ_MAXI ; nro++)
702 if (n_quad[nro]!=NULL)
704 replaceQuad (h_quad[nro], n_quad[nro]);
705 nouveaux->addQuad (n_quad[nro]);
708 for (int nro=0 ; nro<HE_MAXI ; nro++)
709 if (n_edge[nro]!=NULL)
711 replaceEdge (h_edge[nro], n_edge[nro]);
712 nouveaux->addEdge (n_edge[nro]);
715 for (int nro=0 ; nro<HV_MAXI ; nro++)
716 if (n_vertex[nro]!=NULL)
718 replaceVertex (h_vertex[nro], n_vertex[nro]);
719 nouveaux->addVertex (n_vertex[nro]);
724 printf (" ... Apres disconnectEdge\n");
728 nouveaux->moveDisco (this);
731 // ========================================================= disconnectVertex
732 Elements* Hexa::disconnectVertex (Vertex* noeud)
736 printf (" ... Avant disconnectVertex, vertex=");
737 noeud->printName ("\n");
741 int node = findVertex (noeud);
745 Vertex* new_node = new Vertex (noeud);
746 Quad* new_quad [HQ_MAXI];
747 Edge* new_edge [HE_MAXI];
749 for (int nro=0 ; nro<HE_MAXI ; nro++) new_edge [nro] = NULL;
750 for (int nro=0 ; nro<HQ_MAXI ; nro++)
752 new_quad [nro] = NULL;
753 // Cete face contient le sommet et est commune a 2 hexas
754 if ( h_quad[nro]->indexVertex(noeud) >= 0
755 && h_quad[nro]->getNbrParents () >= 2)
759 for (int qed=0 ; qed<QUAD4 ; qed++)
761 Edge* arete = tedge[qed] = h_quad[nro]->getEdge (qed);
762 int indv = arete->index (noeud);
766 int hed = findEdge (arete);
769 if (new_edge [hed]==NULL)
770 new_edge [hed] = new Edge (new_node,
771 arete->getVertex(1-indv));
772 tedge [qed] = new_edge [hed];
777 new_quad [nro] = new Quad (tedge[0], tedge[1], tedge[2], tedge[3]);
781 Elements* nouveaux = new Elements (el_root);
783 for (int nro=0 ; nro<HQ_MAXI ; nro++)
784 if (new_quad [nro] != NULL)
786 replaceQuad (h_quad [nro], new_quad [nro]);
787 nouveaux->addQuad (new_quad[nro]);
790 for (int nro=0 ; nro<HE_MAXI ; nro++)
791 if (new_edge [nro] != NULL)
793 replaceEdge (h_edge [nro], new_edge [nro]);
794 nouveaux->addEdge (new_edge[nro]);
797 replaceVertex (noeud, new_node);
798 nouveaux->addVertex (new_node);
803 printf (" ... Apres disconnectVertex\n");
807 nouveaux->moveDisco (this);
810 // ========================================================= getBase
811 int Hexa::getBase (Vertex* orig, Edge* normale)
813 for (int nq=0 ; nq<HQ_MAXI ; nq++)
815 if ( h_quad[nq]->indexVertex(orig) >= 0
816 && h_quad[nq]->indexEdge (normale) < 0)
821 // ======================================================== replaceQuad
822 void Hexa::replaceQuad (Quad* old, Quad* par)
824 for (int nro=0 ; nro<HQ_MAXI ; nro++)
826 if (h_quad[nro]==old)
833 printf (" [%d], ", nro);
834 old->printName (" est remplace par ");
835 par->printName ("\n");
841 // ======================================================== replaceEdge
842 void Hexa::replaceEdge (Edge* old, Edge* par)
844 for (int nro=0 ; nro<HE_MAXI ; nro++)
846 if (h_edge[nro]==old)
853 printf (" [%d], ", nro);
854 old->printName (" est remplace par ");
855 par->printName ("\n");
860 for (int nro=0 ; nro<HQ_MAXI ; nro++)
862 h_quad[nro]->replaceEdge (old, par);
865 // ======================================================== replaceVertex
866 void Hexa::replaceVertex (Vertex* old, Vertex* par)
868 for (int nro=0 ; nro<HV_MAXI ; nro++)
870 if (h_vertex [nro]==old)
872 h_vertex [nro] = par;
877 printf (" [%d], ", nro);
878 old->printName (" est remplace par ");
879 par->printName ("\n");
884 for (int nro=0 ; nro<HE_MAXI ; nro++)
886 h_edge[nro]->replaceVertex (old, par);
889 for (int nro=0 ; nro<HQ_MAXI ; nro++)
891 h_quad[nro]->replaceVertex (old, par);
894 // ======================================================== removeConnected
895 void Hexa::removeConnected ()
898 if (el_type == EL_REMOVED)
903 for (int nro=0 ; nro<HQ_MAXI ; nro++)
905 Quad* face = h_quad [nro];
906 int nbhexas = face->getNbrParents ();
908 for (int nc=0 ; nc<nbhexas ; nc++)
910 Hexa* cell = face->getParent(nc);
911 if (cell!=NULL && cell->isValid ())
912 cell->removeConnected ();
916 for (int nro=0 ; nro<HQ_MAXI ; nro++)
917 h_quad [nro]->remove();
918 for (int nro=0 ; nro<HE_MAXI ; nro++)
919 h_edge [nro]->remove();
920 for (int nro=0 ; nro<HV_MAXI ; nro++)
921 h_vertex [nro]->remove();
923 // ======================================================== findOpposedQuad
924 int Hexa::findOpposedQuad (Quad* face, Edge* arete)
926 for (int nro=0 ; nro<HQ_MAXI ; nro++)
928 Quad* quad = h_quad [nro];
929 if (quad!=face && quad->indexEdge (arete) >=0)
935 // ========================================================= dump
941 printf ("*** deleted ***)\n");
945 for (int nro=0; nro<HQ_MAXI ; nro++)
946 PrintName (h_quad[nro]);
951 for (int nro=0; nro<HE_MAXI ; nro++)
953 PrintName (h_edge[nro]);
954 if (nro==3 || nro ==7)
960 for (int nro=0; nro<HV_MAXI ; nro++)
961 PrintName (h_vertex[nro]);
965 printf ("cg = (%g, %g, %g)\n", cg[0], cg[1], cg[2]);
968 // ======================================================== dumpPlus
969 void Hexa::dumpPlus ()
972 for (int nro=0 ; nro < HV_MAXI ; nro++)
974 Vertex* pv = h_vertex[nro];
979 printf ( " (%g, %g, %g)\n", pv->getX(), pv->getY(), pv->getZ());
987 // ======================================================== dumpFull
988 void Hexa::dumpFull ()
991 Globale* glob = Globale::getInstance ();
994 for (int nro=0; nro<HQ_MAXI ; nro++)
996 printf (" quad(%s) = ", glob->namofHexaQuad(nro));
997 if (h_quad[nro] ==NULL)
1001 h_quad[nro]->printName (" = (");
1002 for (int nc=0; nc<QUAD4 ; nc++)
1003 h_quad[nro]->getEdge(nc)->printName ();
1006 for (int nc=0; nc<QUAD4 ; nc++)
1007 h_quad[nro]->getVertex(nc)->printName ();
1013 for (int nro=0; nro<HE_MAXI ; nro++)
1015 printf (" edge(%s) = ", glob->namofHexaEdge(nro));
1016 if (h_edge[nro] ==NULL)
1020 h_edge[nro]->printName (" = (");
1021 for (int nc=0; nc<V_TWO ; nc++)
1022 h_edge[nro]->getVertex(nc)->printName ();
1028 for (int nro=0; nro<HV_MAXI ; nro++)
1030 Vertex* pv = h_vertex[nro];
1031 printf (" vertex(%s) = ", glob->namofHexaVertex(nro));
1036 pv->printName (" = (");
1037 printf ("%g, %g, %g)\n", pv->getX(), pv->getY(), pv->getZ());
1042 // ======================================================== getOpposedQuad
1043 Quad* Hexa::getOpposedQuad (Quad* face)
1045 if (face == h_quad [Q_A]) return h_quad [Q_B];
1046 else if (face == h_quad [Q_B]) return h_quad [Q_A];
1047 else if (face == h_quad [Q_C]) return h_quad [Q_D];
1048 else if (face == h_quad [Q_D]) return h_quad [Q_C];
1049 else if (face == h_quad [Q_E]) return h_quad [Q_F];
1050 else if (face == h_quad [Q_F]) return h_quad [Q_F];
1053 // ========================================================= findQuad
1054 Quad* Hexa::findQuad (Edge* ed1, Edge* ed2)
1056 for (int nro=0 ; nro<HQ_MAXI ; nro++)
1058 if ( h_quad[nro]->indexEdge (ed1) >= 0
1059 && h_quad[nro]->indexEdge (ed2) >= 0)
1060 return h_quad [nro];
1065 // ========================================================= findEdge
1066 Edge* Hexa::findEdge (Vertex* v1, Vertex* v2)
1068 for (int nro=0 ; nro<HE_MAXI ; nro++)
1070 if ( h_edge[nro]->index (v1) >= 0
1071 && h_edge[nro]->index (v2) >= 0)
1072 return h_edge [nro];
1077 // ====================================================== getPerpendicularEdge
1078 Edge* Hexa::getPerpendicularEdge (Quad* quad, Vertex* vertex)
1080 if (quad==NULL || vertex==NULL)
1083 int nv = quad->indexVertex (vertex);
1084 int nq = findQuad (quad);
1088 for (int nro=0 ; nro<HE_MAXI ; nro++)
1090 if (quad->indexEdge (h_edge[nro])<0 && h_edge[nro]->index(vertex)>=0)
1091 return h_edge [nro];
1096 // ============================================================ getQuad
1097 Quad* Hexa::getQuad (int nro)
1100 if (nro >=0 && nro < HQ_MAXI && el_status == HOK && h_quad [nro]->isValid())
1105 // ============================================================ getEdge
1106 Edge* Hexa::getEdge (int nro)
1109 if (nro >=0 && nro < HE_MAXI && el_status == HOK && h_edge [nro]->isValid())
1114 // ============================================================ getVertex
1115 Vertex* Hexa::getVertex (int nro)
1118 if (nro >=0 && nro < HV_MAXI && el_status == HOK && h_vertex [nro]->isValid())
1119 elt = h_vertex [nro];
1123 // ============================================================ getCenter
1124 double* Hexa::getCenter (double centre[])
1126 centre [dir_x] = centre [dir_y] = centre [dir_z] = 0;
1128 for (int nv=0 ; nv<HV_MAXI ; nv++)
1130 centre [dir_x] += h_vertex[nv]->getX ();
1131 centre [dir_y] += h_vertex[nv]->getY ();
1132 centre [dir_z] += h_vertex[nv]->getZ ();
1135 centre [dir_x] /= HV_MAXI;
1136 centre [dir_y] /= HV_MAXI;
1137 centre [dir_z] /= HV_MAXI;
1140 // =============================================================== definedBy
1141 bool Hexa::definedBy (Vertex* v1, Vertex* v2)
1143 for (int n1=0 ; n1< HV_MAXI ; n1++)
1145 // ( Diagonale ) Dessus
1146 int n2 = (n1 + 2) MODULO HV_MAXI + HV_MAXI;
1147 if ( (v1 == h_vertex[n1] && v2 == h_vertex[n2])
1148 || (v1 == h_vertex[n2] && v2 == h_vertex[n1])) return true;
1152 // =============================================================== definedBy
1153 bool Hexa::definedBy (Quad* qa, Quad* qb)
1155 if (qa==qb || BadElement (qa) || BadElement (qb))
1158 bool p1 = false, p2 = false;
1159 for (int nq=0 ; nq< HQ_MAXI ; nq++)
1161 if (qa == h_quad[nq])
1163 else if (qb == h_quad[nq])
1168 // =============================================================== setColor
1169 void Hexa::setColor (double val)
1171 for (int nc=0 ; nc< HV_MAXI ; nc++)
1172 h_vertex[nc] -> setColor (val);
1174 // ============================================================== markElements
1175 void Hexa::markElements (int marque)
1177 for (int nc=0 ; nc< HQ_MAXI ; nc++) h_quad [nc] -> setMark (marque);
1178 for (int nc=0 ; nc< HE_MAXI ; nc++) h_edge [nc] -> setMark (marque);
1179 for (int nc=0 ; nc< HV_MAXI ; nc++) h_vertex[nc] -> setMark (marque);
1181 // =============================================================== duplicate
1182 void Hexa::duplicate ()
1184 h_clone = new Hexa (GetClone (h_quad [Q_A]),
1185 GetClone (h_quad [Q_B]),
1186 GetClone (h_quad [Q_C]),
1187 GetClone (h_quad [Q_D]),
1188 GetClone (h_quad [Q_E]),
1189 GetClone (h_quad [Q_F]));