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