src/TEST_CPP/test_quads.cxx

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