src/HEXABLOCK/test_quads.cxx

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