src/HEXABLOCK/test_quads.cxx

   1
   2 // C++ : Tests unitaires sur les creations h'hexaedres
   3
   4 // Copyright (C) 2009-2024  CEA, EDF
   5 //
   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.
  10 //
  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.
  15 //
  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
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22 #include "Hex.hxx"
  23
  24 #include <unistd.h>
  25
  26 #include "HexDocument.hxx"
  27 #include "HexElements.hxx"
  28
  29 #include "HexHexa.hxx"
  30 #include "HexQuad.hxx"
  31 #include "HexEdge.hxx"
  32 #include "HexVertex.hxx"
  33
  34 #include "HexCramer.hxx"
  35
  36 // ======================================================== test_hexa_quads_5
  37 int test_hexa_quads_5 (int nbargs, cpchar tabargs[])
  38 {
  39    const int size_x = 3;
  40    const int size_y = 3;
  41    const int size_z = 2;
  42
  43    Hex::Hex mon_ex;
  44    Hex::Document* doc = mon_ex.addDocument ();
  45
  46    Hex::Elements* grid  = doc->makeCartesianTop (size_x,size_y,size_z);
  47
  48    int nvtk = 0;
  49    cpchar fic_vtk = "HexaQuad_5";
  50    doc->saveVtk (fic_vtk, nvtk);
  51
  52    Hex::Hexa* hexa = grid->getHexaIJK (1,1,1);
  53
  54    Hex::Quad* qa = hexa->getQuad (Hex::Q_A);
  55    Hex::Quad* qb = hexa->getQuad (Hex::Q_B);
  56    Hex::Quad* qc = hexa->getQuad (Hex::Q_C);
  57    Hex::Quad* qd = hexa->getQuad (Hex::Q_D);
  58    Hex::Quad* qe = hexa->getQuad (Hex::Q_E);
  59    Hex::Quad* qf = hexa->getQuad (Hex::Q_F);
  60
  61    qb->setColor (5);
  62    doc->saveVtk (fic_vtk, nvtk);
  63
  64    qb->remove ();
  65    doc->saveVtk (fic_vtk, nvtk);
  66
  67    doc->addHexa5Quads (qa, qc, qd, qe, qf);
  68    doc->saveVtk (fic_vtk, nvtk);
  69
  70    grid->remove ();
  71    HexDisplay (doc->countHexa ());
  72    HexDisplay (doc->countQuad ());
  73    HexDisplay (doc->countEdge ());
  74    HexDisplay (doc->countVertex ());
  75
  76    doc->saveVtk (fic_vtk, nvtk);
  77    return HOK;
  78 }
  79 // ====================================================== test_hexa_quads_ab
  80 int test_hexa_quads_ab (int nbargs, cpchar tabargs[])
  81 {
  82    const int size_x = 1;
  83    const int size_y = 1;
  84    const int size_z = 3;
  85
  86    Hex::Hex mon_ex;
  87    Hex::Document* doc = mon_ex.addDocument ();
  88
  89    Hex::Elements* grid  = doc->makeCartesianTop (size_x,size_y,size_z);
  90
  91    int nvtk = 0;
  92    cpchar fic_vtk = "HexaQuad_ab";
  93    doc->saveVtk (fic_vtk, nvtk);
  94
  95    Hex::Hexa* hexa = grid->getHexaIJK (0, 0, 1);
  96
  97    Hex::Quad* qa = hexa->getQuad (Hex::Q_A);
  98    Hex::Quad* qb = hexa->getQuad (Hex::Q_B);
  99    Hex::Quad* qc = hexa->getQuad (Hex::Q_C);
 100    Hex::Quad* qd = hexa->getQuad (Hex::Q_D);
 101    Hex::Quad* qe = hexa->getQuad (Hex::Q_E);
 102    Hex::Quad* qf = hexa->getQuad (Hex::Q_F);
 103
 104    qc->remove ();
 105    qd->remove ();
 106    qe->remove ();
 107    qf->remove ();
 108    doc->saveVtk (fic_vtk, nvtk);
 109
 110    doc->addHexa2Quads (qa, qb);
 111    doc->saveVtk (fic_vtk, nvtk);
 112
 113    grid->remove ();
 114    HexDisplay (doc->countHexa ());
 115    HexDisplay (doc->countQuad ());
 116    HexDisplay (doc->countEdge ());
 117    HexDisplay (doc->countVertex ());
 118
 119    doc->saveVtk (fic_vtk, nvtk);
 120    return HOK;
 121 }
 122 // ====================================================== test_hexa_quads_ac
 123 int test_hexa_quads_ac (int nbargs, cpchar tabargs[])
 124 {
 125    const int size_x = 2;
 126    const int size_y = 1;
 127    const int size_z = 2;
 128
 129    Hex::Hex mon_ex;
 130    Hex::Document* doc = mon_ex.addDocument ();
 131
 132    Hex::Elements* grid  = doc->makeCartesianTop (size_x,size_y,size_z);
 133    int nvtk = 0;
 134    cpchar fic_vtk = "HexaQuad_ac";
 135    doc->saveVtk (fic_vtk, nvtk);
 136
 137    Hex::Hexa* hexa = grid->getHexaIJK (1,0,1);
 138
 139    Hex::Quad* qa = hexa->getQuad (Hex::Q_A);
 140    Hex::Quad* qb = hexa->getQuad (Hex::Q_B);
 141    Hex::Quad* qc = hexa->getQuad (Hex::Q_C);
 142    Hex::Quad* qd = hexa->getQuad (Hex::Q_D);
 143    Hex::Quad* qe = hexa->getQuad (Hex::Q_E);
 144    Hex::Quad* qf = hexa->getQuad (Hex::Q_F);
 145
 146    qb->remove ();
 147    qc->remove ();
 148    qd->remove ();
 149    qf->remove ();
 150    doc->saveVtk (fic_vtk, nvtk);
 151
 152    doc->addHexa2Quads (qa, qe);
 153    doc->saveVtk (fic_vtk, nvtk);
 154
 155    grid->remove ();
 156    HexDisplay (doc->countHexa ());
 157    HexDisplay (doc->countQuad ());
 158    HexDisplay (doc->countEdge ());
 159    HexDisplay (doc->countVertex ());
 160
 161    HexDisplay (doc->countUsedHexa ());
 162    HexDisplay (doc->countUsedQuad ());
 163    HexDisplay (doc->countUsedEdge ());
 164    HexDisplay (doc->countUsedVertex ());
 165
 166    doc->saveVtk (fic_vtk, nvtk);
 167    return HOK;
 168 }
 169 // ====================================================== test_hexa_quads_ace
 170 int test_hexa_quads_ace (int nbargs, cpchar tabargs[])
 171 {
 172    const int size_x = 2;
 173    const int size_y = 2;
 174    const int size_z = 2;
 175
 176    Hex::Hex mon_ex;
 177    Hex::Document* doc = mon_ex.addDocument ();
 178
 179    Hex::Elements* grid  = doc->makeCartesianTop (size_x,size_y,size_z);
 180    int nvtk = 0;
 181    cpchar fic_vtk = "HexaQuad_ace";
 182    doc->saveVtk (fic_vtk, nvtk);
 183
 184    Hex::Hexa* hexa = grid->getHexaIJK (1,0,1);
 185
 186    Hex::Quad* qa = hexa->getQuad (Hex::Q_A);
 187    Hex::Quad* qb = hexa->getQuad (Hex::Q_B);
 188    Hex::Quad* qc = hexa->getQuad (Hex::Q_C);
 189    Hex::Quad* qd = hexa->getQuad (Hex::Q_D);
 190    Hex::Quad* qe = hexa->getQuad (Hex::Q_E);
 191    Hex::Quad* qf = hexa->getQuad (Hex::Q_F);
 192
 193    qb->remove ();
 194    qf->remove ();
 195    qc->remove ();
 196    doc->saveVtk (fic_vtk, nvtk);
 197
 198    doc->addHexa3Quads (qa, qd, qe);
 199    doc->saveVtk (fic_vtk, nvtk);
 200
 201    grid->remove ();
 202    HexDisplay (doc->countHexa ());
 203    HexDisplay (doc->countQuad ());
 204    HexDisplay (doc->countEdge ());
 205    HexDisplay (doc->countVertex ());
 206
 207    HexDisplay (doc->countUsedHexa ());
 208    HexDisplay (doc->countUsedQuad ());
 209    HexDisplay (doc->countUsedEdge ());
 210    HexDisplay (doc->countUsedVertex ());
 211
 212    doc->saveVtk (fic_vtk, nvtk);
 213    return HOK;
 214 }
 215 // ====================================================== test_hexa_quads_acd
 216 int test_hexa_quads_acd (int nbargs, cpchar tabargs[])
 217 {
 218    const int size_x = 3;
 219    const int size_y = 1;
 220    const int size_z = 2;
 221
 222    Hex::Hex mon_ex;
 223    Hex::Document* doc = mon_ex.addDocument ();
 224
 225    Hex::Elements* grid  = doc->makeCartesianTop (size_x,size_y,size_z);
 226    int nvtk = 0;
 227    cpchar fic_vtk = "HexaQuad_acd";
 228    doc->saveVtk (fic_vtk, nvtk);
 229
 230    Hex::Hexa* hexa = grid->getHexaIJK (1,0,1);
 231
 232    Hex::Quad* qa = hexa->getQuad (Hex::Q_A);
 233    Hex::Quad* qb = hexa->getQuad (Hex::Q_B);
 234    Hex::Quad* qc = hexa->getQuad (Hex::Q_C);
 235    Hex::Quad* qd = hexa->getQuad (Hex::Q_D);
 236    Hex::Quad* qe = hexa->getQuad (Hex::Q_E);
 237    Hex::Quad* qf = hexa->getQuad (Hex::Q_F);
 238
 239    qb->remove ();
 240    qc->remove ();
 241    qd->remove ();
 242    doc->saveVtk (fic_vtk, nvtk);
 243
 244    doc->addHexa3Quads (qa, qe, qf);
 245    doc->saveVtk (fic_vtk, nvtk);
 246
 247    grid->remove ();
 248    HexDisplay (doc->countHexa ());
 249    HexDisplay (doc->countQuad ());
 250    HexDisplay (doc->countEdge ());
 251    HexDisplay (doc->countVertex ());
 252
 253    HexDisplay (doc->countUsedHexa ());
 254    HexDisplay (doc->countUsedQuad ());
 255    HexDisplay (doc->countUsedEdge ());
 256    HexDisplay (doc->countUsedVertex ());
 257
 258    doc->saveVtk (fic_vtk, nvtk);
 259    return HOK;
 260 }
 261 // ====================================================== test_hexa_quads_abcd
 262 int test_hexa_quads_abcd (int nbargs, cpchar tabargs[])
 263 {
 264    const int size_x = 3;
 265    const int size_y = 1;
 266    const int size_z = 3;
 267
 268    Hex::Hex mon_ex;
 269    Hex::Document* doc = mon_ex.addDocument ();
 270
 271    Hex::Elements* grid  = doc->makeCartesianTop (size_x,size_y,size_z);
 272    int nvtk = 0;
 273    cpchar fic_vtk = "HexaQuad_abcd";
 274    doc->saveVtk (fic_vtk, nvtk);
 275
 276    Hex::Hexa* hexa = grid->getHexaIJK (1,0,1);
 277
 278    Hex::Quad* qa = hexa->getQuad (Hex::Q_A);
 279    Hex::Quad* qb = hexa->getQuad (Hex::Q_B);
 280    Hex::Quad* qc = hexa->getQuad (Hex::Q_C);
 281    Hex::Quad* qd = hexa->getQuad (Hex::Q_D);
 282    Hex::Quad* qe = hexa->getQuad (Hex::Q_E);
 283    Hex::Quad* qf = hexa->getQuad (Hex::Q_F);
 284
 285    qc->remove ();
 286    qd->remove ();
 287    doc->saveVtk (fic_vtk, nvtk);
 288
 289    doc->addHexa4Quads (qa, qe, qf, qb);
 290    doc->saveVtk (fic_vtk, nvtk);
 291
 292    grid->remove ();
 293    HexDisplay (doc->countHexa ());
 294    HexDisplay (doc->countQuad ());
 295    HexDisplay (doc->countEdge ());
 296    HexDisplay (doc->countVertex ());
 297
 298    HexDisplay (doc->countUsedHexa ());
 299    HexDisplay (doc->countUsedQuad ());
 300    HexDisplay (doc->countUsedEdge ());
 301    HexDisplay (doc->countUsedVertex ());
 302
 303    doc->saveVtk (fic_vtk, nvtk);
 304    return HOK;
 305 }
 306 // ====================================================== test_hexa_quads_abce
 307 int test_hexa_quads_abce (int nbargs, cpchar tabargs[])
 308 {
 309    const int size_x = 3;
 310    const int size_y = 2;
 311    const int size_z = 2;
 312
 313    Hex::Hex mon_ex;
 314    Hex::Document* doc = mon_ex.addDocument ();
 315
 316    Hex::Elements* grid = doc->makeCartesianTop (size_x,size_y,size_z);
 317    int nvtk = 0;
 318    cpchar fic_vtk = "HexaQuad_abce";
 319    doc->saveVtk (fic_vtk, nvtk);
 320
 321    Hex::Hexa* hexa = grid->getHexaIJK (1,0,1);
 322
 323    Hex::Quad* qa = hexa->getQuad (Hex::Q_A);
 324    Hex::Quad* qb = hexa->getQuad (Hex::Q_B);
 325    Hex::Quad* qc = hexa->getQuad (Hex::Q_C);
 326    Hex::Quad* qd = hexa->getQuad (Hex::Q_D);
 327    Hex::Quad* qe = hexa->getQuad (Hex::Q_E);
 328    Hex::Quad* qf = hexa->getQuad (Hex::Q_F);
 329
 330    qc->remove ();
 331    qb->remove ();
 332    doc->saveVtk (fic_vtk, nvtk);
 333
 334    doc->addHexa4Quads (qa, qe, qf, qd);
 335    doc->saveVtk (fic_vtk, nvtk);
 336
 337    grid->remove ();
 338    HexDisplay (doc->countHexa ());
 339    HexDisplay (doc->countQuad ());
 340    HexDisplay (doc->countEdge ());
 341    HexDisplay (doc->countVertex ());
 342
 343    HexDisplay (doc->countUsedHexa ());
 344    HexDisplay (doc->countUsedQuad ());
 345    HexDisplay (doc->countUsedEdge ());
 346    HexDisplay (doc->countUsedVertex ());
 347
 348    doc->saveVtk (fic_vtk, nvtk);
 349    return HOK;
 350 }
 351 // ======================================================== test_cramer
 352 int test_cramer (int nbargs, cpchar tabargs[])
 353 {
 354    double matrice [] = { 2, 7, 1,
 355                          0, 3, 0,
 356                          1, 9, 5 };
 357    double second  [] = { 1, 1, 1 };
 358
 359    Hex::Real3  solution;
 360    Hex::Cramer systeme(3);
 361
 362    int ier = systeme.resoudre (matrice, second, solution);
 363    HexDisplay (ier);
 364    cout << endl;
 365    cout << " Second membre = (" << second[Hex::dir_x] << ", "
 366         << second[Hex::dir_y] << ", " << second[Hex::dir_z] << ")"
 367         << endl;
 368
 369    cout << " Solution      = (" << solution[Hex::dir_x] << ", "
 370         << solution[Hex::dir_y] << ", " << solution[Hex::dir_z] << ")"
 371         << endl;
 372
 373    Hex::Real3 produit;
 374    systeme.multiply (solution, produit);
 375    cout << " Produit       = (" << produit[Hex::dir_x] << ", "
 376         << produit[Hex::dir_y] << ", " << produit[Hex::dir_z] << ")"
 377         << endl;
 378
 379    return HOK;
 380 }
 381 // ====================================================== test_hexa_quads_ac1
 382 int test_hexa_quads_ac1 (int nbargs, cpchar tabargs[])
 383 {
 384    int nbtraces = 0;
 385    cout << "test_hexa_quads_ac1, trace nro " << ++nbtraces <<endl;
 386    Hex::Hex mon_ex;
 387    Hex::Document* doc = mon_ex.addDocument ();
 388
 389    Hex::Vertex* ace = doc->addVertex (0,0,0);
 390    Hex::Vertex* acf = doc->addVertex (1,0,0);
 391
 392    /****************************************
 393    Hex::Vertex* ade = doc->addVertex (0,1,0);
 394    Hex::Vertex* adf = doc->addVertex (1,1,0);
 395
 396    Hex::Vertex* bce = doc->addVertex (0,0,1);
 397    Hex::Vertex* bcf = doc->addVertex (1,0,1);
 398    Hex::Vertex* bde = doc->addVertex (0,1,1);
 399    Hex::Vertex* bdf = doc->addVertex (1,1,1);
 400    *****************************************/
 401
 402    Hex::Vertex* ade = doc->addVertex (-2,2,0);
 403    Hex::Vertex* adf = doc->addVertex ( 2,1,0);
 404    Hex::Vertex* bce = doc->addVertex ( 1,0,1);
 405    Hex::Vertex* bcf = doc->addVertex ( 2,0,1);
 406
 407    Hex::Edge* ac = doc->addEdge (ace, acf);
 408    Hex::Edge* af = doc->addEdge (adf, acf);
 409    Hex::Edge* ad = doc->addEdge (ade, adf);
 410    Hex::Edge* ae = doc->addEdge (ace, ade);
 411
 412    Hex::Edge* bc = doc->addEdge (bce, bcf);
 413    // Hex::Edge* bf = doc->addEdge (bdf, bcf);
 414    // Hex::Edge* bd = doc->addEdge (bde, bdf);
 415    // Hex::Edge* be = doc->addEdge (bce, bde);
 416
 417    Hex::Edge* ce = doc->addEdge (ace, bce);
 418    Hex::Edge* cf = doc->addEdge (acf, bcf);
 419    // Hex::Edge* de = doc->addEdge (ade, bde);
 420    // Hex::Edge* df = doc->addEdge (adf, bdf);
 421
 422    Hex::Quad* qa = doc->addQuad (ac, af, ad, ae);
 423    Hex::Quad* qc = doc->addQuad (ac, cf, bc, ce);
 424
 425    /* Hex::Hexa* hexa = */  doc->addHexa2Quads (qa, qc);
 426
 427    // doc->dump();
 428    doc->saveVtk ("hexa_quads.vtk");
 429    return HOK;
 430 }
 431 // ======================================================== test_piquage
 432 int test_piquage (int nbargs, cpchar tabargs[])
 433 {
 434    const int size_x = 3;
 435    const int size_y = 3;
 436    const int size_z = 3;
 437
 438    Hex::Hex mon_ex;
 439    Hex::Document* doc = mon_ex.addDocument ();
 440
 441    Hex::Vector* vx   = doc->addVector (1,0,0);
 442    Hex::Vector* vz   = doc->addVector (0,0,1);
 443
 444    Hex::Elements* grid    = doc->makeCartesianTop (size_x,size_y,size_z);
 445
 446    double dl = 1;
 447
 448    int nr = 1;
 449    int na = 4;
 450    int nl = 1;
 451
 452    Hex::Vertex*   orig2 = doc->addVertex (0,0,5);
 453    Hex::Elements* grid2 = doc->makeCylinderUni (orig2, vx,vz, 1.0, 5.0,
 454                                                 360, dl, nr, na, nl);
 455
 456    Hex::Vertex* c1 = grid->getVertexIJK (1, 2, size_z);
 457    Hex::Vertex* c2 = grid->getVertexIJK (1, 1, size_z);
 458    Hex::Vertex* c3 = grid->getVertexIJK (2, 1, size_z);
 459
 460    Hex::Vertex* p1 = grid2->getVertexIJK (1, 0, 1);
 461    Hex::Vertex* p2 = grid2->getVertexIJK (1, 1, 1);
 462    Hex::Vertex* p3 = grid2->getVertexIJK (1, 2, 1);
 463
 464    c1->setColor (4);
 465    c2->setColor (6);
 466    c3->setColor (6);
 467
 468    p1->setColor (4);
 469    p2->setColor (6);
 470    p3->setColor (6);
 471
 472    int nvtk=0;
 473    doc->saveVtk ("piquage", nvtk);
 474
 475    Hex::Quads qpattern;
 476    for (int ny=0; ny<4 ; ny++)
 477        {
 478        Hex::Quad* quad = grid2->getQuadIJ (0, ny, 1);
 479        quad->setColor(5);
 480        qpattern.push_back (quad);
 481        }
 482
 483    doc->saveVtk ("piquage", nvtk);
 484    doc->replace (qpattern, p1,c1, p2,c2, p3,c3);
 485
 486    doc->saveVtk ("piquage", nvtk);
 487
 488    return HOK;
 489 }
 490 // ======================================================== test_replace0
 491 int test_replace0 (int nbargs, cpchar tabargs[])
 492 {
 493    const int size_x = 3;
 494    const int size_y = 3;
 495    const int size_z = 3;
 496
 497    Hex::Hex mon_ex;
 498    Hex::Document* doc = mon_ex.addDocument ();
 499
 500    Hex::Elements* grid    = doc->makeCartesianTop (size_x,size_y,size_z);
 501
 502    Hex::Vertex* c1 = grid->getVertexIJK (1, 2, size_z);
 503    Hex::Vertex* c2 = grid->getVertexIJK (1, 1, size_z);
 504    Hex::Vertex* c3 = grid->getVertexIJK (2, 1, size_z);
 505
 506    Hex::Vertex* pa1 = doc->addVertex (-1, -1);
 507    Hex::Vertex* pb1 = doc->addVertex ( 1, -1);
 508    Hex::Vertex* pc1 = doc->addVertex ( 1,  1);
 509    Hex::Vertex* pd1 = doc->addVertex (-1,  1);
 510
 511    Hex::Vertex* pa2 = doc->addVertex (-2, -2);
 512    Hex::Vertex* pb2 = doc->addVertex ( 2, -2);
 513    Hex::Vertex* pc2 = doc->addVertex ( 2,  2);
 514    Hex::Vertex* pd2 = doc->addVertex (-2,  2);
 515
 516    Hex::Edge* edab1 = doc->addEdge (pa1, pb1);
 517    Hex::Edge* edbc1 = doc->addEdge (pb1, pc1);
 518    Hex::Edge* edcd1 = doc->addEdge (pc1, pd1);
 519    Hex::Edge* edda1 = doc->addEdge (pd1, pa1);
 520
 521    Hex::Edge* edab2 = doc->addEdge (pa2, pb2);
 522    Hex::Edge* edbc2 = doc->addEdge (pb2, pc2);
 523    Hex::Edge* edcd2 = doc->addEdge (pc2, pd2);
 524    Hex::Edge* edda2 = doc->addEdge (pd2, pa2);
 525
 526    Hex::Edge* edaa = doc->addEdge (pa1, pa2);
 527    Hex::Edge* edbb = doc->addEdge (pb1, pb2);
 528    Hex::Edge* edcc = doc->addEdge (pc1, pc2);
 529    Hex::Edge* eddd = doc->addEdge (pd1, pd2);
 530
 531    Hex::Quads qpattern;
 532    // qpattern.push_back (doc->addQuad (edab1, edbc1, edcd1, edda1));
 533    qpattern.push_back (doc->addQuad (edab1, edbb,  edab2, edaa));
 534    qpattern.push_back (doc->addQuad (edbc1, edcc,  edbc2, edbb));
 535    qpattern.push_back (doc->addQuad (edcd1, eddd,  edcd2, edcc));
 536    qpattern.push_back (doc->addQuad (edda1, edaa,  edda2, eddd));
 537
 538    doc->saveVtk ("replace0.vtk");
 539
 540    doc->replace (qpattern, pd2,c1, pa2,c2, pb2,c3);
 541
 542    c1->setColor (4);
 543    c2->setColor (6);
 544    c3->setColor (6);
 545    doc->saveVtk ("replace1.vtk");
 546
 547    return HOK;
 548 }
 549 // ======================================================== test_replace1
 550 int test_replace1 (int nbargs, cpchar tabargs[])
 551 {
 552    const int size_x   = 3;
 553    const int size_y   = 3;
 554    const int size_z   = 3;
 555    const int size_cyl = 4;
 556
 557    Hex::Hex mon_ex;
 558    Hex::Document* doc = mon_ex.addDocument ();
 559    Hex::Vector*   vx  = doc->addVector (1, 0, 0);
 560    Hex::Vector*   vz  = doc->addVector (0, 0, 1);
 561    Hex::Vertex*   ori = doc->addVertex (8, 0, 0);
 562    const double   rint  = 1;
 563    const double   rext  = 3;
 564    const double   angle = 360;
 565    const double   haut  = 1;
 566    const int      nr    = 1;
 567    const int      nh    = 1;
 568
 569    Hex::Elements* grid = doc->makeCartesianTop (size_x,size_y,size_z);
 570    Hex::Elements* pipe = doc->makePipeUni  (ori, vx, vz, rint, rext, angle,
 571                                             haut, nr, size_cyl, nh);
 572
 573    Hex::Vertex* c1 = grid->getVertexIJK (1, 2, size_z);
 574    Hex::Vertex* c2 = grid->getVertexIJK (1, 1, size_z);
 575    Hex::Vertex* c3 = grid->getVertexIJK (2, 1, size_z);
 576
 577    Hex::Vertex* p1 = pipe->getVertexIJK (1, 1, 1);
 578    Hex::Vertex* p2 = pipe->getVertexIJK (1, 2, 1);
 579    Hex::Vertex* p3 = pipe->getVertexIJK (1, 3, 1);
 580
 581    Hex::Quads qpattern;
 582    for (int na=0; na<size_cyl;  ++na)
 583        {
 584        Hex::Quad* quad =pipe->getQuadIJ (0, na, 1);
 585        quad->setColor (2);
 586        qpattern.push_back (quad);
 587        }
 588
 589    c1->setColor (6);
 590    c2->setColor (4);
 591    c3->setColor (2);
 592
 593    p1->setColor (6);
 594    p2->setColor (5);
 595    p3->setColor (4);
 596    doc->saveVtk ("replace0.vtk");
 597
 598    Hex::Elements* rep = doc->replaceHexa (qpattern, p1,c1, p2,c2, p3,c3);
 599    HexDisplay (rep->isValid());
 600    Hex::what ();
 601
 602    doc->saveVtk ("replace1.vtk");
 603    doc->saveVtk ("replace2.vtk");
 604    doc->saveVtk ("replace3.vtk");
 605    return HOK;
 606 }
 607 // ======================================================== test_replace
 608 int test_replace (int nbargs, cpchar tabargs[])
 609 {
 610    const int size_x   = 5;
 611    const int size_y   = 5;
 612    const int size_z   = 3;
 613    const int size_cyl = 12;
 614
 615    Hex::Hex mon_ex;
 616    Hex::Document* doc = mon_ex.addDocument ();
 617    Hex::Vector*   vx  = doc->addVector (1, 0, 0);
 618    Hex::Vector*   vz  = doc->addVector (0, 0, 1);
 619    Hex::Vertex*   ori = doc->addVertex (8, 0, 0);
 620    const double   rint  = 2;
 621    const double   rext  = 3;
 622    const double   angle = 360;
 623    const double   haut  = 1;
 624    const int      nr    = 1;
 625    const int      nh    = 1;
 626
 627    Hex::Elements* grid = doc->makeCartesianTop (size_x,size_y,size_z);
 628    Hex::Elements* pipe = doc->makePipeUni  (ori, vx, vz, rint, rext, angle,
 629                                             haut, nr, size_cyl, nh);
 630
 631    Hex::Vertex* c1 = grid->getVertexIJK (2, 1, size_z);
 632    Hex::Vertex* c2 = grid->getVertexIJK (3, 1, size_z);
 633
 634    Hex::Vertex* p1 = pipe->getVertexIJK (1, 7, 1);
 635    Hex::Vertex* p2 = pipe->getVertexIJK (1, 8, 1);
 636
 637    Hex::Quads qpattern, qtarget;
 638    for (int na=0; na<size_cyl;  ++na)
 639        {
 640        Hex::Quad* quad =pipe->getQuadIJ (0, na, 1);
 641        quad->setColor (2);
 642        qpattern.push_back (quad);
 643        }
 644
 645    for (int ni=1; ni<size_x-1;  ++ni)
 646        for (int nj=1; nj<size_y-1;  ++nj)
 647            {
 648            cout << " grid->getQuad (" << ni << "," << nj << ")\n";
 649            Hex::Quad* quad = grid->getQuadIJ (ni, nj, size_z);
 650            quad->setColor (2);
 651            qtarget.push_back (quad);
 652            }
 653
 654    c1->setColor (6);
 655    c2->setColor (4);
 656
 657    p1->setColor (6);
 658    p2->setColor (4);
 659    doc->saveVtk ("replace0.vtk");
 660
 661    Hex::Elements* rep = doc->replace (qpattern, qtarget, p1,c1, p2,c2);
 662    HexDisplay (rep->isValid());
 663    Hex::what ();
 664
 665    doc->saveVtk ("replace1.vtk");
 666    doc->saveVtk ("replace2.vtk");
 667    return HOK;
 668 }
 669 // ======================================================== test_quads
 670 int test_quads (int nbargs, cpchar tabargs[])
 671 {
 672    cpchar option = "?";
 673    cpchar appel  = strrchr (tabargs[0], '/');
 674    if (appel != NULL)
 675       appel += 1;
 676    else
 677       {
 678       appel  = strrchr (tabargs[0], '\\');
 679       if (appel!=NULL)
 680          appel += 1;
 681       else
 682          appel = tabargs[0];
 683       }
 684
 685    if (nbargs>1)
 686       option = tabargs[1];
 687
 688    if (Cestegal (option, "-ab") || Cestegal (option, "-AB"))
 689       {
 690       printf (" __________________ Appel de test_hexa_quads_ab \n");
 691       test_hexa_quads_ab (nbargs, tabargs);
 692       }
 693
 694    else if (Cestegal (option, "-ac1") || Cestegal (option, "-AC1"))
 695       {
 696       printf (" __________________ Appel de test_hexa_quads_ac1 \n");
 697       test_hexa_quads_ac1 (nbargs, tabargs);
 698       }
 699    else if (Cestegal (option, "-ac") || Cestegal (option, "-AC"))
 700       {
 701       printf (" __________________ Appel de test_hexa_quads_ac \n");
 702       test_hexa_quads_ac (nbargs, tabargs);
 703       }
 704
 705    else if (Cestegal (option, "-ace") || Cestegal (option, "-ACE"))
 706       {
 707       printf (" __________________ Appel de test_hexa_quads_ace \n");
 708       test_hexa_quads_ace (nbargs, tabargs);
 709       }
 710
 711    else if (Cestegal (option, "-acd") || Cestegal (option, "-ACD"))
 712       {
 713       printf (" __________________ Appel de test_hexa_quads_acd \n");
 714       test_hexa_quads_acd (nbargs, tabargs);
 715       }
 716
 717    else if (Cestegal (option, "-abcd") || Cestegal (option, "-ABCD"))
 718       {
 719       printf (" __________________ Appel de test_hexa_quads_abcd \n");
 720       test_hexa_quads_abcd (nbargs, tabargs);
 721       }
 722
 723    else if (Cestegal (option, "-abce") || Cestegal (option, "-ABCE"))
 724       {
 725       printf (" __________________ Appel de test_hexa_quads_abce \n");
 726       test_hexa_quads_abce (nbargs, tabargs);
 727       }
 728
 729    else if (Cestegal (option, "-5") || Cestegal (option, "-abcde")
 730                                    || Cestegal (option, "-ABCDE"))
 731       {
 732       printf (" __________________ Appel de test_hexa_quads_abcde \n");
 733       test_hexa_quads_5 (nbargs, tabargs);
 734       }
 735
 736    else
 737       {
 738       printf (" +++ Veuillez indiquer votre cas-test en argument SVP\n");
 739       printf (" +++ Creation d'un hexadedre a partir de quadrangles :\n");
 740       printf (" %s -ab   : A partir des quadrangles A et B (opposes)\n", appel);
 741       printf (" %s -ac   : A partir des quadrangles A et C (diedre)\n",  appel);
 742       printf (" %s -acd  : A partir des quadrangles A, C et D (triedre)\n",
 743               appel);
 744       printf (" %s -ace  : A partir des quadrangles A, C et E (en U)\n",
 745               appel);
 746       printf (" %s -acbd : A partir des quadrangles A, B, C et D (tunnel)\n",
 747               appel);
 748       printf (" %s -acbe : A partir des quadrangles A, B, C et E (but)\n",
 749               appel);
 750       printf (" %s -5    : A partir de 5 quadrangles (boite sans couvercle)\n",
 751               appel);
 752       }
 753
 754    return HOK;
 755 }