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