2 // C++ : Gestion des Hexaedres
4 // Copyright (C) 2009-2016 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, or (at your option) any later version.
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));
197 for (int dd=0 ; dd<DIM3 ; dd++)
199 Quad* qa = h_quad [2*dd];
200 Quad* qb = h_quad [2*dd+1];
201 Edge* cut = qa->inter (qb);
205 for (int nc=2*dd+2 ; more && nc<HQ_MAXI ; nc++)
207 Edge* cut = qa->inter (h_quad[nc]);
211 // cout << " ... le quad oppose au quad " << 2*dd
212 // << " est le " << nc << endl;
214 h_quad[nc] = h_quad [2*dd+1];
221 sprintf (num, "%d", 2*dd+1);
222 el_root->putError ("addHexa : the %sth quad has no opposed quad",
230 // ======================================================== controlerSommets
231 void Hexa::controlerSommets ()
233 for (int n1=0 ; n1<HV_MAXI ; n1++)
235 if (BadElement (h_vertex [n1]))
237 el_root->putError (W_H_NULL_QUAD,
238 el_root->glob->namofHexaVertex (n1));
242 for (int n2=n1+1 ; n2<HQ_MAXI ; n2++)
243 if (h_vertex [n1] == h_vertex[n2])
245 el_root->putError (W_H_EQ_QUAD,
246 el_root->glob->namofHexaVertex (n1),
247 el_root->glob->namofHexaVertex (n2));
252 // ======================================================== verifierAretes
253 void Hexa::verifierAretes ()
255 for (int nro=0 ; nro<HE_MAXI ; nro++) h_edge [nro] = NULL;
257 controlerArete ( E_AC, Q_A, Q_C);
258 controlerArete ( E_AF, Q_A, Q_F);
259 controlerArete ( E_AD, Q_A, Q_D);
260 controlerArete ( E_AE, Q_A, Q_E);
262 controlerArete ( E_BC, Q_B, Q_C);
263 controlerArete ( E_BF, Q_B, Q_F);
264 controlerArete ( E_BD, Q_B, Q_D);
265 controlerArete ( E_BE, Q_B, Q_E);
267 controlerArete ( E_CE, Q_C, Q_E);
268 controlerArete ( E_CF, Q_C, Q_F);
269 controlerArete ( E_DF, Q_D, Q_F);
270 controlerArete ( E_DE, Q_D, Q_E);
272 // ======================================================== verifierSommets
273 void Hexa::verifierSommets ()
275 for (int nro=0 ; nro<HV_MAXI ; nro++) h_vertex [nro] = NULL;
277 controlerSommet (V_ACE, E_AC, E_AE, E_CE);
278 controlerSommet (V_ACF, E_AC, E_AF, E_CF);
279 controlerSommet (V_ADF, E_AD, E_AF, E_DF);
280 controlerSommet (V_ADE, E_AD, E_AE, E_DE);
282 controlerSommet (V_BCE, E_BC, E_BE, E_CE);
283 controlerSommet (V_BCF, E_BC, E_BF, E_CF);
284 controlerSommet (V_BDF, E_BD, E_BF, E_DF);
285 controlerSommet (V_BDE, E_BD, E_BE, E_DE);
287 // ======================================================== Inter
288 Quad* Hexa::Inter (Hexa* other)
290 for (int nf1=0 ; nf1 < HQ_MAXI ; nf1++)
291 for (int nf2=0 ; nf2 < HQ_MAXI ; nf2++)
292 if (h_quad[nf1] == other->h_quad[nf2])
297 // -------------------------------------------------------------------
299 // -------------------------------------------------------------------
300 // ======================================================= razNodes
301 void Hexa::razNodes ()
303 for (int nb=0 ; nb<HV_MAXI ; nb++)
304 h_vertex[nb]->setMark (NO_COUNTED);
306 // ======================================================= countNodes
307 int Hexa::countNodes ()
310 for (int nb=0 ; nb<HV_MAXI ; nb++)
311 if (h_vertex[nb]->getMark () == NO_COUNTED)
313 h_vertex[nb]->setMark (NO_USED);
319 // ======================================================= printNodes
320 void Hexa::printNodes (pfile vtk, int& compteur)
322 const double minvtk = 1e-30;
325 for (int nb=0 ; nb<HV_MAXI ; nb++)
326 if (h_vertex[nb]->getMark()==NO_USED)
328 h_vertex[nb]->getPoint (koord);
329 for (int nc=dir_x ; nc<=dir_z ; nc++)
330 if (koord [nc] < minvtk && koord [nc] > -minvtk)
333 fprintf (vtk, "%g %g %g\n", koord[dir_x], koord[dir_y], koord[dir_z]);
334 h_vertex[nb]->setMark (compteur);
338 // ======================================================= colorNodes
339 void Hexa::colorNodes (pfile vtk)
341 for (int nb=0 ; nb<HV_MAXI ; nb++)
342 if (h_vertex[nb]->getMark()>=0)
344 double color = 100*(h_vertex[nb]->getScalar()+1);
345 fprintf (vtk, "%g\n", color);
346 h_vertex[nb]->setMark (NO_COUNTED);
349 // ======================================================= moveNodes
350 void Hexa::moveNodes (Matrix* matrice)
352 for (int nb=0 ; nb<HV_MAXI ; nb++)
353 if (h_vertex[nb]->getMark()!=IS_USED)
355 matrice->perform (h_vertex[nb]);
356 h_vertex[nb]->setMark (IS_USED);
359 // ======================================================= transform
360 void Hexa::transform (Matrix* matrice)
362 for (int nb=0 ; nb<HV_MAXI ; nb++)
363 matrice->perform (h_vertex[nb]);
365 // ======================================================= printHexa
366 void Hexa::printHexa (pfile vtk)
368 fprintf (vtk, "%d", HV_MAXI);
370 fprintf (vtk, " %d", h_vertex[V_ACE]->getMark ());
371 fprintf (vtk, " %d", h_vertex[V_ACF]->getMark ());
372 fprintf (vtk, " %d", h_vertex[V_ADF]->getMark ());
373 fprintf (vtk, " %d", h_vertex[V_ADE]->getMark ());
375 fprintf (vtk, " %d", h_vertex[V_BCE]->getMark ());
376 fprintf (vtk, " %d", h_vertex[V_BCF]->getMark ());
377 fprintf (vtk, " %d", h_vertex[V_BDF]->getMark ());
378 fprintf (vtk, " %d", h_vertex[V_BDE]->getMark ());
382 // ======================================================= printHexaVtk
383 void Hexa::printHexaVtk (pfile vtk)
385 fprintf (vtk, "%d", HV_MAXI);
387 fprintf (vtk, " %d", h_vertex[V_ACE]->getId ());
388 fprintf (vtk, " %d", h_vertex[V_ACF]->getId ());
389 fprintf (vtk, " %d", h_vertex[V_ADF]->getId ());
390 fprintf (vtk, " %d", h_vertex[V_ADE]->getId ());
392 fprintf (vtk, " %d", h_vertex[V_BCE]->getId ());
393 fprintf (vtk, " %d", h_vertex[V_BCF]->getId ());
394 fprintf (vtk, " %d", h_vertex[V_BDF]->getId ());
395 fprintf (vtk, " %d", h_vertex[V_BDE]->getId ());
399 // ======================================================== hasFreEdges
400 bool Hexa::hasFreeEdges ()
405 for (int nro=0; nro<HE_MAXI ; nro++)
406 if (h_edge[nro]->getMark()<0)
411 // ======================================================== propager
412 void Hexa::propager (Propagation* prop, int nro)
417 for (int nro=0; nro<HE_MAXI ; nro++)
418 if (h_edge[nro]->getMark()<0)
419 h_edge[nro]->propager (prop, nro);
421 // ========================================================= saveXml
422 void Hexa::saveXml (XmlWriter* xml)
427 for (int nro=0 ; nro<HQ_MAXI ; nro++)
429 if (nro>0) quads += " ";
430 quads += h_quad[nro]->getName(ident);
434 xml->openMark ("Hexa");
435 xml->addAttribute ("id", ident);
436 xml->addAttribute ("quads", quads);
438 xml->addAttribute ("name", el_name);
441 // ========================================================= findQuad
442 int Hexa::findQuad (Quad* element)
444 for (int nro=0 ; nro<HQ_MAXI ; nro++)
445 if (h_quad[nro]==element)
450 // ========================================================= findEdge
451 int Hexa::findEdge (Edge* element)
453 for (int nro=0 ; nro<HE_MAXI ; nro++)
454 if (h_edge[nro]==element)
459 // ========================================================= findVertex
460 int Hexa::findVertex (Vertex* element)
462 for (int nro=0 ; nro<HV_MAXI ; nro++)
463 if (h_vertex[nro]==element)
468 // ========================================================= disconnectQuad
469 Elements* Hexa::disconnectQuad (Quad* quad)
476 printf (" ... Avant disconnectQuad, quad=");
477 quad->printName ("\n");
481 int nface = findQuad (quad);
484 // Face opposee : replace
485 // int nfopp = (nface MODULO 2==0) ? nface+1 : nface-1;
487 int ind_edge [QUAD4], ind_opp_quad [QUAD4];
488 bool make_quad [QUAD4], make_edge [QUAD4];
490 for (int nro=0 ; nro<QUAD4 ; nro++)
491 make_quad [nro] = make_edge[nro] = false;
493 for (int nro=0 ; nro<QUAD4 ; nro++)
495 int nro1 = (nro+1) MODULO QUAD4;
496 int pedge = findEdge (quad->getEdge (nro));
497 int pnode = findVertex (quad->getVertex (nro));
498 int oppq = findOpposedQuad (quad, quad->getEdge (nro));
500 ind_edge [nro] = pedge;
501 ind_opp_quad [nro] = oppq;
503 if (pedge==NOTHING || pnode==NOTHING || oppq==NOTHING)
506 make_quad [nro] = h_quad[oppq]->getNbrParents() == 2;
507 make_edge [nro ] = make_edge [nro ] || make_quad [nro];
508 make_edge [nro1] = make_edge [nro1] || make_quad [nro];
512 printf (" Sommet nro %d : ", nro);
513 quad->getVertex(nro)->printName (", ");
515 quad->getEdge(nro)->printName (", ");
516 printf (" quad oppose = ");
517 h_quad[oppq]->printName("");
519 printf (" a dissocier\n");
526 Vertex* new_node [QUAD4];
527 Edge* new_opp_edge [QUAD4];
528 Edge* old_opp_edge [QUAD4];
530 for (int nro=0 ; nro<QUAD4 ; nro++)
532 old_opp_edge [nro] = NULL;
533 new_opp_edge [nro] = NULL;
534 Vertex* o_v0 = quad->getVertex (nro);
535 new_node [nro] = new Vertex (o_v0);
538 printf (" quad.vertex [%d] = ", nro);
539 quad->getVertex (nro)->printName (" --> ");
540 new_node [nro]->printName ("\n");
545 Quad* pface = h_quad [ind_opp_quad [nro]];
547 int ncut = pface->inter (quad, bid);
548 Edge* ecut = pface->getEdge ((ncut+1) MODULO QUAD4);
549 Vertex* vopp = ecut->getVertex(V_AMONT);
551 vopp = ecut->getVertex (V_AVAL);
552 else if (o_v0 != ecut->getVertex (V_AVAL));
554 ecut = pface->getEdge ((ncut+3) MODULO QUAD4);
555 vopp = ecut->getVertex(V_AMONT);
557 vopp = ecut->getVertex (V_AVAL);
558 else if (o_v0 != ecut->getVertex (V_AVAL))
562 old_opp_edge [nro] = ecut;
563 new_opp_edge [nro] = new Edge (new_node[nro], vopp);
566 printf (" quad.opp_edge [%d] = ", nro);
567 old_opp_edge [nro]->printName (" --> ");
568 new_opp_edge [nro]->printName ("\n");
573 Quad* new_quad = new Quad (new_node[0], new_node[1], new_node[2],
576 Quad* new_opp_quad [QUAD4];
577 Quad* old_opp_quad [QUAD4];
578 for (int nro=0 ; nro<QUAD4 ; nro++)
580 old_opp_quad [nro] = NULL;
581 new_opp_quad [nro] = NULL;
584 int nro1 = (nro+1) MODULO QUAD4;
586 Edge* n_edge0 = new_quad->getEdge (nro);
587 Edge* n_edge1 = new_opp_edge [nro];
588 Edge* n_edge3 = new_opp_edge [nro1];
590 int iv1 = n_edge1->inter (n_edge0);
591 int iv3 = n_edge3->inter (n_edge0);
592 if (iv1 <0 || iv3 <0)
595 Quad* o_face = h_quad [ind_opp_quad [nro]];
596 Edge* edge2 = o_face->findEdge (n_edge1->getVertex (1-iv1),
597 n_edge3->getVertex (1-iv3));
600 // Edge* o_edge0 = h_edge [ind_edge [nro]];
602 // Edge* edge2 = o_face->getOpposEdge (o_edge0, sens);
604 old_opp_quad [nro] = o_face;
606 printf (" -------- Quad oppose nro %d\n", nro);
607 new_opp_quad [nro] = new Quad (n_edge0, n_edge1, edge2, n_edge3);
611 replaceQuad (quad, new_quad);
612 for (int nro=0 ; nro<QUAD4 ; nro++)
614 replaceQuad (old_opp_quad [nro], new_opp_quad [nro]);
616 for (int nro=0 ; nro<QUAD4 ; nro++)
618 replaceEdge (h_edge[ind_edge[nro]], new_quad->getEdge (nro));
620 replaceEdge (old_opp_edge [nro], new_opp_edge [nro]);
623 for (int nro=0 ; nro<QUAD4 ; nro++)
625 replaceVertex (quad->getVertex(nro), new_node[nro]);
629 h_quad [nface] = new_quad;
632 printf (" ... Apres disconnectQuad, new_quad=");
633 new_quad->printName ("\n");
637 Elements* nouveaux = new Elements (el_root);
638 nouveaux->addQuad (new_quad);
639 for (int nro=0 ; nro<QUAD4 ; nro++)
641 nouveaux->addEdge (new_quad->getEdge (nro));
642 nouveaux->addVertex (new_quad->getVertex (nro));
644 nouveaux->addEdge (new_opp_edge [nro]);
646 nouveaux->addQuad (new_opp_quad [nro]);
648 nouveaux->moveDisco (this);
651 // ========================================================= disconnectEdge
652 Elements* Hexa::disconnectEdge (Edge* arete)
654 int nedge = findEdge (arete);
655 int namont = findVertex (arete->getVertex(V_AMONT));
656 int naval = findVertex (arete->getVertex(V_AVAL ));
658 if (nedge==NOTHING || namont==NOTHING || naval==NOTHING)
663 printf (" ... Avant disconnectEdge, arete=");
664 arete->printName ("\n");
668 Edge* n_edge [HE_MAXI];
669 Quad* n_quad [HQ_MAXI];
670 Vertex* n_vertex [HV_MAXI];
672 for (int nro=0 ; nro<HQ_MAXI ; nro++) n_quad [nro] = NULL;
673 for (int nro=0 ; nro<HE_MAXI ; nro++) n_edge [nro] = NULL;
674 for (int nro=0 ; nro<HV_MAXI ; nro++) n_vertex [nro] = NULL;
676 Vertex* old_amont = arete->getVertex (V_AMONT);
677 Vertex* old_aval = arete->getVertex (V_AVAL );
678 Vertex* new_amont = n_vertex [namont] = new Vertex (old_amont);
679 Vertex* new_aval = n_vertex [naval] = new Vertex (old_aval);
680 n_edge [nedge] = new Edge (new_amont, new_aval);
682 // Un edge non remplace, qui contient un vertex remplace
683 // commun a plus de 2 faces (donc appartenant a un autre hexa)
684 // doit etre duplique
686 for (int nro=0 ; nro<HE_MAXI ; nro++)
688 if ( n_edge[nro]==NULL && h_edge[nro] != NULL
689 && h_edge[nro]->getNbrParents()>2)
691 Vertex* va = h_edge[nro]->getVertex (V_AMONT);
692 Vertex* vb = h_edge[nro]->getVertex (V_AVAL);
695 n_edge [nro] = new Edge (new_amont, vb);
696 else if (va==old_aval)
697 n_edge [nro] = new Edge (new_aval, vb);
698 else if (vb==old_amont)
699 n_edge [nro] = new Edge (va, new_amont);
700 else if (vb==old_aval)
701 n_edge [nro] = new Edge (va, new_aval);
705 // Un quad non remplace, qui contient un edge remplace
706 // commun a plus de 2 Hexas
707 // doit etre duplique
709 Globale* glob = Globale::getInstance();
710 for (int nro=0 ; nro<HQ_MAXI ; nro++)
711 if ( n_quad[nro]==NULL && h_quad[nro] != NULL
712 && h_quad[nro]->getNbrParents()>1)
716 for (int ned=0 ; ned<QUAD4 ; ned++)
718 int ndup = glob->QuadEdge (nro, (EnumQuad)ned);
719 if (n_edge [ndup] ==NULL)
720 qedge [ned] = h_edge[ndup];
723 qedge [ned] = n_edge[ndup];
728 n_quad[nro] = new Quad (qedge[Q_A], qedge[Q_B],
729 qedge[Q_C], qedge[Q_D]);
732 Elements* nouveaux = new Elements (el_root);
733 for (int nro=0 ; nro<HQ_MAXI ; nro++)
734 if (n_quad[nro]!=NULL)
736 replaceQuad (h_quad[nro], n_quad[nro]);
737 nouveaux->addQuad (n_quad[nro]);
740 for (int nro=0 ; nro<HE_MAXI ; nro++)
741 if (n_edge[nro]!=NULL)
743 replaceEdge (h_edge[nro], n_edge[nro]);
744 nouveaux->addEdge (n_edge[nro]);
747 for (int nro=0 ; nro<HV_MAXI ; nro++)
748 if (n_vertex[nro]!=NULL)
750 replaceVertex (h_vertex[nro], n_vertex[nro]);
751 nouveaux->addVertex (n_vertex[nro]);
756 printf (" ... Apres disconnectEdge\n");
760 nouveaux->moveDisco (this);
763 // ========================================================= disconnectVertex
764 Elements* Hexa::disconnectVertex (Vertex* noeud)
768 printf (" ... Avant disconnectVertex, vertex=");
769 noeud->printName ("\n");
773 int node = findVertex (noeud);
777 Vertex* new_node = new Vertex (noeud);
778 Quad* new_quad [HQ_MAXI];
779 Edge* new_edge [HE_MAXI];
781 for (int nro=0 ; nro<HE_MAXI ; nro++) new_edge [nro] = NULL;
782 for (int nro=0 ; nro<HQ_MAXI ; nro++)
784 new_quad [nro] = NULL;
785 // Cete face contient le sommet et est commune a 2 hexas
786 if ( h_quad[nro]->indexVertex(noeud) >= 0
787 && h_quad[nro]->getNbrParents () >= 2)
791 for (int qed=0 ; qed<QUAD4 ; qed++)
793 Edge* arete = tedge[qed] = h_quad[nro]->getEdge (qed);
794 int indv = arete->index (noeud);
798 int hed = findEdge (arete);
801 if (new_edge [hed]==NULL)
802 new_edge [hed] = new Edge (new_node,
803 arete->getVertex(1-indv));
804 tedge [qed] = new_edge [hed];
809 new_quad [nro] = new Quad (tedge[0], tedge[1], tedge[2], tedge[3]);
813 Elements* nouveaux = new Elements (el_root);
815 for (int nro=0 ; nro<HQ_MAXI ; nro++)
816 if (new_quad [nro] != NULL)
818 replaceQuad (h_quad [nro], new_quad [nro]);
819 nouveaux->addQuad (new_quad[nro]);
822 for (int nro=0 ; nro<HE_MAXI ; nro++)
823 if (new_edge [nro] != NULL)
825 replaceEdge (h_edge [nro], new_edge [nro]);
826 nouveaux->addEdge (new_edge[nro]);
829 replaceVertex (noeud, new_node);
830 nouveaux->addVertex (new_node);
835 printf (" ... Apres disconnectVertex\n");
839 nouveaux->moveDisco (this);
842 // ========================================================= getBase
843 int Hexa::getBase (Vertex* orig, Edge* normale)
845 for (int nq=0 ; nq<HQ_MAXI ; nq++)
847 if ( h_quad[nq]->indexVertex(orig) >= 0
848 && h_quad[nq]->indexEdge (normale) < 0)
853 // ======================================================== replaceQuad
854 void Hexa::replaceQuad (Quad* old, Quad* par)
856 for (int nro=0 ; nro<HQ_MAXI ; nro++)
858 if (h_quad[nro]==old)
865 printf (" [%d], ", nro);
866 old->printName (" est remplace par ");
867 par->printName ("\n");
873 // ======================================================== replaceEdge
874 void Hexa::replaceEdge (Edge* old, Edge* par)
876 for (int nro=0 ; nro<HE_MAXI ; nro++)
878 if (h_edge[nro]==old)
885 printf (" [%d], ", nro);
886 old->printName (" est remplace par ");
887 par->printName ("\n");
892 for (int nro=0 ; nro<HQ_MAXI ; nro++)
894 h_quad[nro]->replaceEdge (old, par);
897 // ======================================================== replaceVertex
898 void Hexa::replaceVertex (Vertex* old, Vertex* par)
900 for (int nro=0 ; nro<HV_MAXI ; nro++)
902 if (h_vertex [nro]==old)
904 h_vertex [nro] = par;
909 printf (" [%d], ", nro);
910 old->printName (" est remplace par ");
911 par->printName ("\n");
916 for (int nro=0 ; nro<HE_MAXI ; nro++)
918 h_edge[nro]->replaceVertex (old, par);
921 for (int nro=0 ; nro<HQ_MAXI ; nro++)
923 h_quad[nro]->replaceVertex (old, par);
926 // ======================================================== removeConnected
927 void Hexa::removeConnected ()
930 if (el_type == EL_REMOVED)
935 for (int nro=0 ; nro<HQ_MAXI ; nro++)
937 Quad* face = h_quad [nro];
938 int nbhexas = face->getNbrParents ();
940 for (int nc=0 ; nc<nbhexas ; nc++)
942 Hexa* cell = face->getParent(nc);
943 if (cell!=NULL && cell->isValid ())
944 cell->removeConnected ();
948 for (int nro=0 ; nro<HQ_MAXI ; nro++)
949 h_quad [nro]->remove();
950 for (int nro=0 ; nro<HE_MAXI ; nro++)
951 h_edge [nro]->remove();
952 for (int nro=0 ; nro<HV_MAXI ; nro++)
953 h_vertex [nro]->remove();
955 // ======================================================== findOpposedQuad
956 int Hexa::findOpposedQuad (Quad* face, Edge* arete)
958 for (int nro=0 ; nro<HQ_MAXI ; nro++)
960 Quad* quad = h_quad [nro];
961 if (quad!=face && quad->indexEdge (arete) >=0)
967 // ========================================================= dump
973 printf ("*** deleted ***)\n");
977 for (int nro=0; nro<HQ_MAXI ; nro++)
978 PrintName (h_quad[nro]);
983 for (int nro=0; nro<HE_MAXI ; nro++)
985 PrintName (h_edge[nro]);
986 if (nro==3 || nro ==7)
992 for (int nro=0; nro<HV_MAXI ; nro++)
993 PrintName (h_vertex[nro]);
997 printf ("cg = (%g, %g, %g)\n", cg[0], cg[1], cg[2]);
1000 // ======================================================== dumpPlus
1001 void Hexa::dumpPlus ()
1004 for (int nro=0 ; nro < HV_MAXI ; nro++)
1006 Vertex* pv = h_vertex[nro];
1011 printf ( " (%g, %g, %g)\n", pv->getX(), pv->getY(), pv->getZ());
1019 // ======================================================== dumpFull
1020 void Hexa::dumpFull ()
1023 Globale* glob = Globale::getInstance ();
1026 for (int nro=0; nro<HQ_MAXI ; nro++)
1028 printf (" quad(%s) = ", glob->namofHexaQuad(nro));
1029 if (h_quad[nro] ==NULL)
1033 h_quad[nro]->printName (" = (");
1034 for (int nc=0; nc<QUAD4 ; nc++)
1035 h_quad[nro]->getEdge(nc)->printName ();
1038 for (int nc=0; nc<QUAD4 ; nc++)
1039 h_quad[nro]->getVertex(nc)->printName ();
1045 for (int nro=0; nro<HE_MAXI ; nro++)
1047 printf (" edge(%s) = ", glob->namofHexaEdge(nro));
1048 if (h_edge[nro] ==NULL)
1052 h_edge[nro]->printName (" = (");
1053 for (int nc=0; nc<V_TWO ; nc++)
1054 h_edge[nro]->getVertex(nc)->printName ();
1060 for (int nro=0; nro<HV_MAXI ; nro++)
1062 Vertex* pv = h_vertex[nro];
1063 printf (" vertex(%s) = ", glob->namofHexaVertex(nro));
1068 pv->printName (" = (");
1069 printf ("%g, %g, %g)\n", pv->getX(), pv->getY(), pv->getZ());
1074 // ======================================================== getOpposedQuad
1075 Quad* Hexa::getOpposedQuad (Quad* face)
1077 if (face == h_quad [Q_A]) return h_quad [Q_B];
1078 else if (face == h_quad [Q_B]) return h_quad [Q_A];
1079 else if (face == h_quad [Q_C]) return h_quad [Q_D];
1080 else if (face == h_quad [Q_D]) return h_quad [Q_C];
1081 else if (face == h_quad [Q_E]) return h_quad [Q_F];
1082 else if (face == h_quad [Q_F]) return h_quad [Q_F];
1085 // ========================================================= findQuad
1086 Quad* Hexa::findQuad (Edge* ed1, Edge* ed2)
1088 for (int nro=0 ; nro<HQ_MAXI ; nro++)
1090 if ( h_quad[nro]->indexEdge (ed1) >= 0
1091 && h_quad[nro]->indexEdge (ed2) >= 0)
1092 return h_quad [nro];
1097 // ========================================================= findEdge
1098 Edge* Hexa::findEdge (Vertex* v1, Vertex* v2)
1100 for (int nro=0 ; nro<HE_MAXI ; nro++)
1102 if ( h_edge[nro]->index (v1) >= 0
1103 && h_edge[nro]->index (v2) >= 0)
1104 return h_edge [nro];
1109 // ====================================================== opposedVertex
1110 Vertex* Hexa::opposedVertex (Quad* quad, Vertex* vertex)
1112 if (quad==NULL || vertex==NULL)
1115 int nv = quad->indexVertex (vertex);
1116 int nq = findQuad (quad);
1120 for (int nro=0 ; nro<HE_MAXI ; nro++)
1122 Edge* edge = h_edge [nro];
1123 int nv = edge->index (vertex);
1124 if (nv>=0 && quad->indexEdge(edge) <0)
1125 return edge->getVertex (1-nv);
1130 // ====================================================== perpendicularEdge
1131 Edge* Hexa::perpendicularEdge (Quad* quad, Vertex* vertex)
1133 if (quad==NULL || vertex==NULL)
1136 int nv = quad->indexVertex (vertex);
1137 int nq = findQuad (quad);
1141 for (int nro=0 ; nro<HE_MAXI ; nro++)
1143 if (quad->indexEdge (h_edge[nro])<0 && h_edge[nro]->index(vertex)>=0)
1144 return h_edge [nro];
1149 // ====================================================== perpendicularQuad
1150 Quad* Hexa::perpendicularQuad (Quad* quad, Edge* edge)
1152 if (BadElement (quad) || BadElement (edge))
1155 int qed = quad->indexEdge (edge);
1156 int ned = findEdge (edge);
1157 int nq = findQuad (quad);
1158 if (qed <0 || ned<0 || nq<0)
1161 for (int nro=0 ; nro<HQ_MAXI ; nro++)
1165 Quad* face = h_quad[nro];
1166 if (EltIsValid(face) && face->indexEdge (edge)>=0)
1172 // ============================================================ getQuad
1173 Quad* Hexa::getQuad (int nro)
1176 if (nro >=0 && nro < HQ_MAXI && el_status == HOK && h_quad [nro]->isValid())
1181 // ============================================================ getEdge
1182 Edge* Hexa::getEdge (int nro)
1185 if (nro >=0 && nro < HE_MAXI && el_status == HOK && h_edge [nro]->isValid())
1190 // ============================================================ getVertex
1191 Vertex* Hexa::getVertex (int nro)
1194 if (nro >=0 && nro < HV_MAXI && el_status == HOK && h_vertex [nro]->isValid())
1195 elt = h_vertex [nro];
1199 // ============================================================ getCenter
1200 double* Hexa::getCenter (double centre[])
1202 centre [dir_x] = centre [dir_y] = centre [dir_z] = 0;
1204 for (int nv=0 ; nv<HV_MAXI ; nv++)
1206 centre [dir_x] += h_vertex[nv]->getX ();
1207 centre [dir_y] += h_vertex[nv]->getY ();
1208 centre [dir_z] += h_vertex[nv]->getZ ();
1211 centre [dir_x] /= HV_MAXI;
1212 centre [dir_y] /= HV_MAXI;
1213 centre [dir_z] /= HV_MAXI;
1216 // =============================================================== definedBy
1217 bool Hexa::definedBy (Vertex* v1, Vertex* v2)
1219 for (int n1=0 ; n1< HV_MAXI ; n1++)
1221 // ( Diagonale ) Dessus
1222 int n2 = (n1 + 2) MODULO HV_MAXI + HV_MAXI;
1223 if ( (v1 == h_vertex[n1] && v2 == h_vertex[n2])
1224 || (v1 == h_vertex[n2] && v2 == h_vertex[n1])) return true;
1228 // =============================================================== definedBy
1229 bool Hexa::definedBy (Quad* qa, Quad* qb)
1231 if (qa==qb || BadElement (qa) || BadElement (qb))
1234 bool p1 = false, p2 = false;
1235 for (int nq=0 ; nq< HQ_MAXI ; nq++)
1237 if (qa == h_quad[nq])
1239 else if (qb == h_quad[nq])
1244 // =============================================================== setColor
1245 void Hexa::setColor (double val)
1247 for (int nc=0 ; nc< HV_MAXI ; nc++)
1248 h_vertex[nc] -> setColor (val);
1250 // ============================================================== markElements
1251 void Hexa::markElements (int marque)
1253 for (int nc=0 ; nc< HQ_MAXI ; nc++) h_quad [nc] -> setMark (marque);
1254 for (int nc=0 ; nc< HE_MAXI ; nc++) h_edge [nc] -> setMark (marque);
1255 for (int nc=0 ; nc< HV_MAXI ; nc++) h_vertex[nc] -> setMark (marque);
1257 // =============================================================== duplicate
1258 void Hexa::duplicate ()
1260 h_clone = new Hexa (GetClone (h_quad [Q_A]),
1261 GetClone (h_quad [Q_B]),
1262 GetClone (h_quad [Q_C]),
1263 GetClone (h_quad [Q_D]),
1264 GetClone (h_quad [Q_E]),
1265 GetClone (h_quad [Q_F]));