src/TEST_CPP/test_hexa1.cxx

   1
   2 // C++ : Tests unitaires
   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
  23 #include "test_unit.hxx"
  24
  25 #include "Hex.hxx"
  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 "HexPropagation.hxx"
  36 #include "HexOldShape.hxx"
  37 #include "HexLaw.hxx"
  38 #include "HexMatrix.hxx"
  39 #include "HexCramer.hxx"
  40 #include "HexGroup.hxx"
  41
  42
  43 #include <cstdlib>
  44
  45 static int nbr_vtk = 0;
  46 static cpchar case_name = "hexa";
  47 static Hex::Document*   docu = NULL;
  48
  49 // ======================================================== print_propagations
  50 void print_propagations (Hex::Document* doc)
  51 {
  52    int nb = doc->countPropagation ();
  53    HexDisplay (nb);
  54    for (int nro=0 ; nro<nb ; nro++)
  55        {
  56        Hex::Propagation*  prop  = doc ->getPropagation (nro);
  57        const Hex::Edges&  table = prop->getEdges ();
  58        printf (" ____________________________________ Prop nro %d\n", nro);
  59        for (int ned=0 ; ned<(int)table.size() ; ned++)
  60            {
  61            bool way = table [ned]->getWay ();
  62            Hex::Edge*   edge = table [ned];
  63            Hex::Vertex* v0   = edge->getVertex (0);
  64            Hex::Vertex* v1   = edge->getVertex (1);
  65
  66            if (way)
  67               {
  68               printf ("     (");
  69               v0->printName (", ");
  70               v1->printName (")\n");
  71               }
  72           else
  73               {
  74               v1->printName (", ");
  75               v0->printName (")\n");
  76               printf ("     (");
  77               }
  78            }
  79        }
  80 }
  81 // ======================================================== save_vtk
  82 void save_vtk ()
  83 {
  84    if (docu==NULL)
  85       return;
  86
  87    docu->saveVtk (case_name, nbr_vtk);
  88 }
  89 // ======================================================== remove_hexa
  90 void remove_hexa (Hex::Hexa* hexa)
  91 {
  92    if (hexa==NULL)
  93       return;
  94
  95    hexa->remove();
  96
  97    if (docu==NULL)
  98       return;
  99
 100    docu->saveVtk (case_name, nbr_vtk);
 101 }
 102 // ======================================================== test_sphere
 103 int test_sphere (int nbargs, cpchar tabargs[])
 104 {
 105    Hex::Hex mon_ex;
 106    Hex::Document* doc = mon_ex.addDocument ();
 107    Hex::Vertex*  orig = doc->addVertex (0,0,0);
 108
 109    int    ncouches = 2;
 110    double k      = 1;
 111    double rayon  = 1;
 112    Hex::Elements* sphere = doc->makeSpherical (orig, rayon, ncouches, k);
 113
 114    if (ncouches>0)
 115       {
 116    for (int nc=0 ; nc <= ncouches ; nc++)
 117        {
 118        Hex::Hexa* cell = sphere->getStrate (nc, Hex::Q_A);
 119        if (nc==0)
 120           cell->dumpFull();
 121        cell->remove ();
 122        // sphere->getStrate (nc, Hex::Q_A)->remove ();
 123        // sphere->getStrate (nc, Hex::Q_B)->remove ();
 124        }
 125        }
 126
 127    sphere->saveVtk ("sphere.vtk");
 128    return HOK;
 129 }
 130 // ======================================================== test_cartesi1
 131 int test_cartesi1 ()
 132 {
 133    const int size_x = 15;
 134    const int size_y = 12;
 135    const int size_z = 8;
 136
 137    Hex::Hex mon_ex;
 138    Hex::Document* doc = mon_ex.addDocument ();
 139    Hex::Vertex* orig = doc->addVertex (0,0,0);
 140
 141    Hex::Vector*   dir  = doc->addVector (1,1,1);
 142    Hex::Elements* grid = doc->makeCartesian (orig, dir, size_x,size_y,size_z);
 143
 144    //  print_propagations (doc);
 145
 146    for (int nz=0; nz<size_z ; nz++)
 147        for (int ny=nz+1; ny<size_y-nz-1 ; ny++)
 148            for (int nx=nz+1; nx<size_x-nz-1 ; nx++)
 149                {
 150                Hex::Hexa* cell = grid->getHexaIJK (nx, ny, nz);
 151                cell->remove ();
 152                }
 153
 154    doc->setLevel (1);
 155    print_propagations (doc);
 156    grid->saveVtk ("grid_cart.vtk");
 157
 158    // doc->dump ();
 159    return HOK;
 160 }
 161 // ======================================================== afficher
 162 #define Afficher(elt) afficher (#elt, elt)
 163 int afficher (cpchar nom, Hex::EltBase* elt)
 164 {
 165    if (elt==NULL)
 166       {
 167       printf (" .... %s = 0x0\n", nom);
 168       return HOK;
 169       }
 170
 171    printf (" .... %s = 0x%08lx = %03d\n", nom, (unsigned long) elt, elt->getId());
 172    return HOK;
 173 }
 174 // ======================================================== test_find
 175 int test_find ()
 176 {
 177    const int size_x = 2;
 178    const int size_y = 2;
 179    const int size_z = 2;
 180
 181    Hex::Hex mon_ex;
 182    Hex::Document* doc = mon_ex.addDocument ();
 183
 184    Hex::Vertex* orig = doc->addVertex (0,0,0);
 185    Hex::Vector* dir  = doc->addVector (1,1,1);
 186    Hex::Elements*  grid = doc->makeCartesian (orig, dir, size_x,size_y,size_z);
 187
 188    grid->saveVtk ("mini1.vtk");
 189    doc->dump ();
 190
 191    Hex::Vertex *v00, *v02, *v06, *v08, *v10, *v22, *v26;
 192
 193    Afficher ( v00 = doc->findVertex (0, 0, 0));
 194    Afficher ( v02 = doc->findVertex (1, 1, 0));
 195    Afficher ( v06 = doc->findVertex (1, 1, 1));
 196    Afficher ( v08 = doc->findVertex (2, 1, 0));
 197    Afficher ( v10 = doc->findVertex (2, 1, 1));
 198    Afficher ( v22 = doc->findVertex (2, 1, 2));
 199    Afficher ( v26 = doc->findVertex (2, 2, 2));
 200
 201    printf ("\n");
 202
 203    Afficher (doc->findEdge (v06, v10));
 204    Afficher (doc->findEdge (v10, v06));
 205    printf ("\n");
 206
 207    Afficher (doc->findQuad (v02, v10));
 208    Afficher (doc->findQuad (v06, v08));
 209    Afficher (doc->findQuad (v02, v06));
 210
 211    printf ("\n");
 212    Afficher (doc->findHexa (v00, v06));
 213    Afficher (doc->findHexa (v06, v26));
 214    Afficher (doc->findHexa (v26, v06));
 215
 216    return HOK;
 217 }
 218 // ======================================================== test_joint
 219 int test_joint (int nbargs, cpchar tabargs[])
 220 {
 221    const int dimx = 11;
 222    const int dimy = 11;
 223    const int dimz = 2;
 224
 225    Hex::Hex mon_ex;
 226    Hex::Document* doc = mon_ex.addDocument ();
 227
 228    Hex::Vertex* orig1 = doc->addVertex (0,0,0);
 229    Hex::Vector* dir   = doc->addVector (1,1,1);
 230
 231    Hex::Elements* grid1 = doc->makeCartesian   (orig1, dir, dimx,dimy,dimz);
 232
 233    Hex::Vertex*   orig2 = doc->addVertex  (dimx/2.0,0,8);
 234    Hex::Vector*   vectj = doc->addVector (0,1,0);
 235    Hex::Vector*   vecti = doc->addVector (1,0,0);
 236    Hex::Elements* grid2 = doc->makeCylindrical (orig2, vecti, vectj,
 237                    1, 180, 1,        dimz,dimy,dimx);
 238
 239    int mx = dimx/2;
 240    int my = dimy/2;
 241    Hex::Quad* prems = grid1->getQuadIJ (mx, my, dimz);
 242    Hex::Quad* cible = grid2->getQuadJK (dimz, mx, my);
 243
 244    Hex::Vertex* v1 = prems->getVertex (0);
 245    Hex::Vertex* v3 = prems->getVertex (1);
 246
 247    Hex::Vertex* v2 = cible->getVertex (1);
 248    Hex::Vertex* v4 = cible->getVertex (2);
 249
 250    // v1->setScalar (3);
 251    // v2->setScalar (3);
 252    // v3->setScalar (6);
 253    // v4->setScalar (6);
 254
 255    Hex::Quads liste;
 256
 257    liste.push_back (prems);
 258    for (int nx=0; nx<dimx; nx++)
 259        if (nx!=mx)
 260           liste.push_back (grid1->getQuadIJ (nx, my, dimz));
 261
 262    for (int ny=0; ny<dimy; ny++)
 263        if (ny!=my)
 264           liste.push_back (grid1->getQuadIJ (mx, ny, dimz));
 265
 266    doc->saveVtk ("joint1.vtk");
 267    const int hauteur = 5;
 268    Hex::Elements* joint = doc->joinQuads(liste, cible, v1,v2,v3,v4, hauteur);
 269    // for (int nh=0 ; nh<hauteur ; nh++) joint->getHexa(nh)->setScalar (5);
 270
 271    int nbr_joint_vertex =  joint->countVertex ();
 272    int nbr_surf_vertex  =  nbr_joint_vertex/(hauteur+1);
 273
 274    HexDisplay (nbr_joint_vertex);
 275    HexDisplay (nbr_surf_vertex);
 276
 277    int indice0 = joint->findVertex (v1);
 278    HexDisplay (indice0);
 279
 280    for (int nh=0 ; nh<nbr_surf_vertex ; nh++)
 281        joint->getVertex(nh)->setScalar (5);
 282
 283    for (int nh=0 ; nh<=hauteur ; nh++)
 284        joint->getVertex(nh*nbr_surf_vertex)->setScalar (3);
 285
 286    doc->saveVtk ("joint2.vtk");
 287    return HOK;
 288 }
 289 // ======================================================== test_prism
 290 int test_prism (int nbargs, cpchar tabargs[])
 291 {
 292    const int dimx = 11;
 293    const int dimy = 11;
 294    const int dimz = 2;
 295
 296    Hex::Hex mon_ex;
 297    Hex::Document* doc = mon_ex.addDocument ();
 298
 299    Hex::Vertex* orig1 = doc->addVertex ( 0,0,0);
 300    Hex::Vector* dir1  = doc->addVector ( 1,1,1);
 301    Hex::Vector* dir2  = doc->addVector ( 1,1,-1);
 302
 303    Hex::Elements* grid1 = doc->makeCartesian (orig1, dir1, dimx,dimy,dimz);
 304
 305    int mx = dimx/2;
 306    int my = dimy/2;
 307    Hex::Quads liste1, liste2;
 308
 309    liste1.push_back (grid1->getQuadIJ (mx, my, dimz));
 310    liste2.push_back (grid1->getQuadIJ (mx, my, 0));
 311    for (int nx=0; nx<dimx; nx++)
 312        if (nx!=mx)
 313           {
 314           liste1.push_back (grid1->getQuadIJ (nx, my, dimz));
 315           liste2.push_back (grid1->getQuadIJ (nx, my, 0));
 316           }
 317
 318    for (int ny=0; ny<dimy; ny++)
 319        if (ny!=my)
 320           {
 321           liste1.push_back (grid1->getQuadIJ (mx, ny, dimz));
 322           liste2.push_back (grid1->getQuadIJ (mx, ny, 0));
 323           }
 324
 325    Hex::RealVector tlen;
 326    double dh = 2;
 327    for (int nro=0; nro<5; nro++)
 328        {
 329        dh = 2*dh + 1;
 330        tlen.push_back (dh);
 331        }
 332
 333    const int nbiter = 5;
 334    doc->saveVtk ("prisme1.vtk");
 335    Hex::Elements* prisme2 = doc->prismQuads    (liste2, dir2, nbiter);
 336    doc->saveVtk ("prisme2.vtk");
 337
 338    Hex::Elements* prisme1 = doc->prismQuadsVec (liste1, dir1, tlen, 0);
 339
 340    PutData (liste1.size());
 341    PutData (tlen.size());
 342    PutData (prisme1->countHexa());
 343    PutData (prisme1->countQuad());
 344    PutData (prisme1->countEdge());
 345    PutData (prisme1->countVertex());
 346
 347    for (int nro=0 ; nro <nbiter  ; nro++)
 348        {
 349        Hex::Hexa* cell = prisme2-> getHexa (nbiter+nro);
 350        cell->setScalar (5);
 351        }
 352
 353    doc->saveVtk ("prisme3.vtk");
 354    return HOK;
 355 }
 356 // ======================================================== test_revolution9
 357 int test_revolution9 (int nbargs, cpchar tabargs[])
 358 {
 359    const int dimx = 11;
 360    const int dimy = 11;
 361    const int dimz = 2;
 362
 363    Hex::Hex mon_ex;
 364    Hex::Document* doc = mon_ex.addDocument ();
 365
 366    Hex::Vertex* orig1 = doc->addVertex (0,0,0);
 367    Hex::Vector* dir   = doc->addVector (1,1,1);
 368
 369    Hex::Elements* grid1 = doc->makeCartesian   (orig1, dir, dimx,dimy,dimz);
 370
 371    int mx = dimx/2;
 372    int my = dimy/2;
 373    Hex::Quad* prems = grid1->getQuadIJ (mx, my, dimz);
 374    Hex::Quads liste;
 375
 376    liste.push_back (prems);
 377    prems -> setScalar (5);
 378    for (int nx=0; nx<dimx; nx++)
 379        if (nx!=mx)
 380           {
 381           Hex::Quad* cell = grid1->getQuadIJ (nx, my, dimz);
 382           liste.push_back (cell);
 383           cell -> setScalar (5);
 384           }
 385
 386    for (int ny=0; ny<dimy; ny++)
 387        if (ny!=my)
 388           {
 389           Hex::Quad* cell = grid1->getQuadIJ (mx, ny, dimz);
 390           liste.push_back (cell);
 391           cell -> setScalar (5);
 392           }
 393
 394    Hex::Vertex* center = doc->addVertex (0, -10, 0);
 395    Hex::Vector* axis   = doc->addVector (1,   0, 0);
 396    Hex::RealVector  angles;
 397
 398    Hex::Vector*   dir1  = doc->addVector (10,0.3,0.3);
 399    Hex::Elements* grid2 = doc->makeCartesian (center, dir1, 1,1,1);
 400    Hex::Hexa*     cell  = grid2->getHexaIJK (0,0,0);
 401    cell->setScalar (5);
 402
 403    doc->saveVtk ("revolution1.vtk");
 404
 405    double alpha = 5;
 406    int niter    = 5;
 407    double coeff = 1.5;
 408    for (int na=0 ; na<niter ; na++)
 409        {
 410        angles.push_back (alpha);
 411        alpha *= coeff;
 412        }
 413    for (int na=1 ; na<niter ; na++)
 414        {
 415        alpha /= coeff;
 416        angles.push_back (alpha);
 417        }
 418
 419    Hex::Elements* bloc = doc->revolutionQuads  (liste, center, axis, angles);
 420    if (bloc != NULL)
 421        doc->saveVtk ("revolution2.vtk");
 422
 423    return HOK;
 424 }
 425 // ======================================================== test_revolution
 426 int test_revolution (int nbargs, cpchar tabargs[])
 427 {
 428    Hex::Hex mon_ex;
 429    Hex::Document* doc = mon_ex.addDocument ();
 430
 431    Hex::Vertex* ori = doc->addVertex (0,0,0);
 432    Hex::Vector* vx  = doc->addVector (1,0,0);
 433    Hex::Vector* vz  = doc->addVector (0,0,1);
 434
 435    int dr = 1;
 436    int da = 360;
 437    int dl = 1;
 438
 439    int nr = 1;
 440    int na = 6;
 441    int nl = 1;
 442
 443    Hex::Elements* grid = doc->makeCylindrical (ori, vx,vz, dr,da,dl,
 444                                                nr,na,nl, false);
 445
 446    Hex::Quads liste;
 447    for (int nx=0; nx<nr; nx++)
 448        for (int ny=0; ny<na; ny++)
 449            {
 450            Hex::Quad* cell = grid->getQuadIJ (nx, ny, nl);
 451            liste.push_back (cell);
 452            cell -> setScalar (5);
 453            }
 454
 455    Hex::Vertex* center = doc->addVertex (0, -10, 0);
 456    Hex::Vector* axis   = doc->addVector (1, 0, 0);
 457    Hex::RealVector  angles;
 458
 459    Hex::Vector*   dir1  = doc->addVector (10,0.3,0.3);
 460    Hex::Elements* grid2 = doc->makeCartesian (center, dir1, 1,1,1);
 461    Hex::Hexa*     cell  = grid2->getHexaIJK (0,0,0);
 462    cell->setScalar (5);
 463
 464    doc->saveVtk ("revolution1.vtk");
 465
 466    double alpha = 5;
 467    int niter    = 5;
 468    double coeff = 1.5;
 469    for (int na=0 ; na<niter ; na++)
 470        {
 471        angles.push_back (alpha);
 472        alpha *= coeff;
 473        }
 474    for (int na=1 ; na<niter ; na++)
 475        {
 476        alpha /= coeff;
 477        angles.push_back (alpha);
 478        }
 479
 480    Hex::Elements* bloc = doc->revolutionQuads  (liste, center, axis, angles);
 481    if (bloc != NULL)
 482        doc->saveVtk ("revolution2.vtk");
 483
 484    return HOK;
 485 }
 486 // ======================================================== test_coude
 487 int test_coude (int nbargs, cpchar tabargs[])
 488 {
 489 #if 0
 490    const int dimx = 11;
 491    const int dimy = 11;
 492    const int dimz = 2;
 493
 494    Hex::Hex mon_ex;
 495    Hex::Document* doc = mon_ex.addDocument ();
 496
 497    Hex::Vertex* orig = doc->addVertex (0,0,0);
 498    Hex::Vector* vx   = doc->addVector (1,0,0);
 499    Hex::Vector* vz   = doc->addVector (0,0,1);
 500
 501    //   grid1 = doc->makeCartesian   (orig1, dir, dimx,dimy,dimz);
 502    double dr = 1;
 503    int    dl = 5;
 504    int    nr = 4;
 505    int    na = 8;
 506
 507    Hex::Elements* grid1 = doc->makeCylindrical (orig1, vx,vz,dr,360, dl,
 508                                                 nr, 10, nl, false);
 509    int mx = dimx/2;
 510    int my = dimy/2;
 511    Hex::Quad* prems = grid1->getQuadIJ (mx, my, dimz);
 512    Hex::Quads liste;
 513
 514    liste.push_back (prems);
 515    prems -> setScalar (5);
 516    for (int nx=0; nx<dimx; nx++)
 517        if (nx!=mx)
 518           {
 519           Hex::Quad* cell = grid1->getQuadIJ (nx, my, dimz);
 520           liste.push_back (cell);
 521           cell -> setScalar (5);
 522           }
 523
 524    for (int ny=0; ny<dimy; ny++)
 525        if (ny!=my)
 526           {
 527           Hex::Quad* cell = grid1->getQuadIJ (mx, ny, dimz);
 528           liste.push_back (cell);
 529           cell -> setScalar (5);
 530           }
 531
 532
 533    Hex::Vertex* center = doc->addVertex (0, -10, 0);
 534    Hex::Vector* axis   = doc->addVector (1, 0, 0);
 535    Hex::RealVector  angles;
 536
 537    Hex::Vector*   dir1  = doc->addVector (10,0.3,0.3);
 538    Hex::Elements* grid2 = doc->makeCartesian (center, dir1, 1,1,1);
 539    Hex::Hexa*     cell  = grid2->getHexaIJK (0,0,0);
 540    cell->setScalar (5);
 541
 542    doc->saveVtk ("revolution1.vtk");
 543
 544    double alpha = 5;
 545    int niter    = 5;
 546    double coeff = 1.5;
 547    for (int na=0 ; na<niter ; na++)
 548        {
 549        angles.push_back (alpha);
 550        alpha *= coeff;
 551        }
 552    for (int na=1 ; na<niter ; na++)
 553        {
 554        alpha /= coeff;
 555        angles.push_back (alpha);
 556        }
 557
 558    Hex::Elements* bloc = doc->revolutionQuads  (liste, center, axis, angles);
 559    if (bloc != NULL)
 560        doc->saveVtk ("revolution2.vtk");
 561 #endif
 562    return HOK;
 563 }
 564 // ======================================================== test_count
 565 int test_count (int nbargs, cpchar tabargs[])
 566 {
 567    Hex::Hex mon_ex;
 568    Hex::Document* doc = mon_ex.addDocument ();
 569
 570    Hex::Vertex* orig1 = doc->addVertex ( 0, 0,0);
 571    Hex::Vector* vx    = doc->addVector (1,0,0);
 572    Hex::Vector* vz    = doc->addVector (0,0,1);
 573
 574    double dr = 1;
 575    double dl = 1;
 576    int    nr = 2;
 577    int    nl = 3;
 578
 579    Hex::Elements* c1;
 580
 581    c1 = doc->makeCylindrical (orig1, vx,vz,dr, 360, dl,nr, 10, nl, false);
 582
 583    HexDisplay (doc->countVertex ());
 584    HexDisplay (doc->countUsedVertex ());
 585    doc ->saveVtk ("hexa1.vtk");
 586
 587    return HOK;
 588 }
 589 // ======================================================== test_decoupage
 590 int test_decoupage (int nbargs, cpchar tabargs[])
 591 {
 592    const int size_x = 2;
 593    const int size_y = 1;
 594    const int size_z = 1;
 595
 596    Hex::Hex mon_ex;
 597    Hex::Document* doc = mon_ex.addDocument ();
 598
 599    Hex::Vertex* orig = doc->addVertex (0,0,0);
 600    Hex::Vector* dir  = doc->addVector (1,1,1);
 601
 602    Hex::Elements* grid  = doc->makeCartesian (orig, dir, size_x,size_y,size_z);
 603    Hex::Edge*     arete = grid->getEdgeK (0, 0, 0);
 604
 605    //  doc ->dump ();
 606    int nvtk=0;
 607    doc ->saveVtk ("decoupe", nvtk);
 608 /* Hex::Elements* grid2 = */  doc->cut (arete, 1);
 609
 610    ///  doc ->dump ();
 611    doc ->saveVtk ("decoupe", nvtk);
 612
 613    return HOK;
 614 }
 615 // ======================================================== test_gen_xml
 616 int test_gen_xml (int nbargs, cpchar tabargs[])
 617 {
 618    const int size_x = 2;
 619    const int size_y = 2;
 620    const int size_z = 2;
 621
 622    Hex::Hex mon_ex;
 623    Hex::Document* doc = mon_ex.addDocument ();
 624
 625    Hex::Vertex* orig = doc->addVertex (0,0,0);
 626    Hex::Vector* dir  = doc->addVector (1,1,1);
 627    Hex::Elements*  grid = doc->makeCartesian (orig, dir, size_x,size_y,size_z);
 628
 629    Hex::Hexa*   cell    = grid->getHexa (0);
 630    // Hex::Quad*   face    = cell->getQuad (0);
 631    // Hex::Edge*   arete   = cell->getEdge (0);
 632    // Hex::Vertex* noeud   = cell->getVertex (0);
 633
 634    // Hex::Shape* shape1 = new Hex::Shape("riri");
 635    // Hex::Shape* shape2 = new Hex::Shape("fifi");
 636    // Hex::Shape* shape3 = new Hex::Shape("loulou");
 637
 638    // noeud->setAssociation (shape1);
 639    // arete->setAssociation (shape2);
 640    // face ->setAssociation (shape3);
 641
 642    Hex::Law* law1 = doc->addLaw("loi1", 1);
 643    Hex::Law* law2 = doc->addLaw("loi2", 2);
 644    Hex::Law* law3 = doc->addLaw("loi3", 3);
 645
 646    law1->setKind (Hex::Uniform);
 647    law2->setKind (Hex::Arithmetic);
 648    law3->setKind (Hex::Geometric);
 649
 650    Hex::Propagation* prop1 = doc->getPropagation (0);
 651    Hex::Propagation* prop2 = doc->getPropagation (1);
 652    Hex::Propagation* prop3 = doc->getPropagation (2);
 653
 654    prop1->setLaw (law1);
 655    prop2->setLaw (law2);
 656    prop3->setLaw (law3);
 657
 658    prop1->setWay (true);
 659    prop2->setWay (false);
 660    prop3->setWay (true);
 661
 662    doc ->saveVtk ("mini.vtk");
 663    doc ->save ("Essai");
 664
 665    return HOK;
 666 }
 667 // ======================================================== test_string_xml
 668 int test_string_xml (int nbargs, cpchar tabargs[])
 669 {
 670    const int size_x = 2;
 671    const int size_y = 2;
 672    const int size_z = 2;
 673
 674    Hex::Hex mon_ex;
 675    Hex::Document* doc = mon_ex.addDocument ();
 676
 677    Hex::Vertex* orig = doc->addVertex (0,0,0);
 678    Hex::Vector* dir  = doc->addVector (1,1,1);
 679    Hex::Elements*  grid = doc->makeCartesian (orig, dir, size_x,size_y,size_z);
 680
 681    Hex::Hexa*   cell    = grid->getHexa (0);
 682    // Hex::Quad*   face    = cell->getQuad (0);
 683    // Hex::Edge*   arete   = cell->getEdge (0);
 684    // Hex::Vertex* noeud   = cell->getVertex (0);
 685
 686    // Hex::Shape* shape1 = new Hex::Shape("riri");
 687    // Hex::Shape* shape2 = new Hex::Shape("fifi");
 688    // Hex::Shape* shape3 = new Hex::Shape("loulou");
 689
 690    // noeud->setAssociation (shape1);
 691    // arete->setAssociation (shape2);
 692    // face ->setAssociation (shape3);
 693
 694    Hex::Law* law1 = doc->addLaw("loi1", 1);
 695    Hex::Law* law2 = doc->addLaw("loi2", 2);
 696    Hex::Law* law3 = doc->addLaw("loi3", 3);
 697
 698    law1->setKind (Hex::Uniform);
 699    law2->setKind (Hex::Arithmetic);
 700    law3->setKind (Hex::Geometric);
 701
 702    Hex::Propagation* prop1 = doc->getPropagation (0);
 703    Hex::Propagation* prop2 = doc->getPropagation (1);
 704    Hex::Propagation* prop3 = doc->getPropagation (2);
 705
 706    prop1->setLaw (law1);
 707    prop2->setLaw (law2);
 708    prop3->setLaw (law3);
 709
 710    prop1->setWay (true);
 711    prop2->setWay (false);
 712    prop3->setWay (true);
 713
 714    doc ->saveVtk ("mini.vtk");
 715    doc ->save ("Essai");
 716
 717    cpchar flux = doc ->getXml ();
 718    Hex::Document* docbis = mon_ex.addDocument ();
 719    docbis->setXml  (flux);
 720    docbis->saveVtk ("clone.vtk");
 721
 722    return HOK;
 723 }
 724 // ======================================================== test_relecture
 725 int test_relecture (int nbargs, cpchar tabargs[])
 726 {
 727    Hex::Hex mon_ex;
 728    cpchar nomdoc = "Essai";
 729    if (nbargs>1)
 730       nomdoc = tabargs[1];
 731    Hex::Document* doc = mon_ex.loadDocument (nomdoc);
 732
 733 /*********************
 734    Hex::Vertex* v4 = doc->findVertex (80.0, 0.0,  0.0);
 735    Hex::Vertex* v5 = doc->findVertex (80.0, 0.0, 40.0);
 736    Hex::Edge*   e4 = doc->findEdge   (v4, v5);
 737
 738    HexDump (v4);
 739    HexDump (v5);
 740    HexDump (e4);
 741
 742    e4->setScalar (5);
 743 ***********************/
 744
 745    doc ->dump ();
 746    doc ->saveVtk ("restore.vtk");
 747    doc ->save ("restore");
 748
 749    // doc ->reorderFaces ();
 750    // doc ->dump ();
 751
 752    // Hex::Elements* grid2 = doc->cut (e4, 2);
 753    return HOK;
 754 }
 755 // ======================================================== test_clone
 756 int test_clone ()
 757 {
 758    const int size_x = 2;
 759    const int size_y = 2;
 760    const int size_z = 2;
 761
 762    Hex::Hex mon_ex;
 763    Hex::Document* doc = mon_ex.addDocument ();
 764
 765    Hex::Vertex* orig = doc->addVertex (0,0,0);
 766    Hex::Vector* dir  = doc->addVector (1,1,1);
 767    Hex::Elements* grid = doc->makeCartesian (orig, dir, size_x,size_y,size_z);
 768
 769    Hex::Vector*   bond  = doc->addVector (0, 0, 7);
 770    Hex::Elements* grid2 = doc->makeTranslation (grid, bond);
 771
 772    doc ->saveVtk ("clonage.vtk");
 773    doc ->dump();
 774
 775    HexDump (grid2->getHexa      (1));
 776    HexDump (grid2->getHexaIJK   (1,1,1));
 777    HexDump (grid2->getVertexIJK (1,1,1));
 778
 779    return HOK;
 780 }
 781 // ======================================================== test_separ
 782 int test_separ ()
 783 {
 784    const int size_x = 2;
 785    const int size_y = 2;
 786    const int size_z = 2;
 787
 788    Hex::Hex mon_ex;
 789    Hex::Document* doc = mon_ex.addDocument ();
 790
 791    Hex::Vertex* orig = doc->addVertex (0,0,0);
 792    Hex::Vector* dir  = doc->addVector (1,1,1);
 793    //  Hex::Elements*  grid =
 794    doc->makeCartesian (orig, dir, size_x,size_y,size_z);
 795
 796    doc ->saveVtk ("separ.vtk");
 797    doc ->dump();
 798
 799    return HOK;
 800 }
 801 // ======================================================== test_shperical
 802 int test_spherical (int nbargs, const char* tabargs[])
 803 {
 804    Hex::Hex mon_ex;
 805    Hex::Document* doc = mon_ex.addDocument ();
 806
 807    Hex::Vertex* orig = doc->addVertex (0,0,0);
 808    double       rayon  = 1;
 809    int          nbr    = 3;
 810
 811    Hex::Elements* grid = doc->makeSpherical (orig, rayon, nbr);
 812
 813    int nbhexas = grid->countHexa ();
 814    HexDisplay (nbhexas);
 815    for (int nro=0 ; nro<nbhexas ; nro +=3)
 816        grid->getHexa(nro)->remove();
 817    HexDisplay (doc->countHexa ());
 818    doc->saveVtk ("shperical.vtk");
 819    // doc->dump ();
 820
 821    return HOK;
 822 }
 823 // ================================================== test_grille_cyl
 824 int test_grille_cyl (int nbargs, cpchar tabargs[])
 825 {
 826    Hex::Hex mon_ex;
 827    Hex::Document* doc = mon_ex.addDocument ();
 828
 829    Hex::Vertex* orig1 = doc->addVertex ( 0, 0,0);
 830    Hex::Vertex* orig2 = doc->addVertex (10, 0,0);
 831
 832    Hex::Vertex* orig3 = doc->addVertex ( 0,10,0);
 833    Hex::Vertex* orig4 = doc->addVertex (10,10,0);
 834
 835    Hex::Vertex* orig5 = doc->addVertex ( 0,20,0);
 836    Hex::Vertex* orig6 = doc->addVertex (10,20,0);
 837
 838    Hex::Vector* vz = doc->addVector (0,0,1);
 839    Hex::Vector* vx = doc->addVector (1,0,0);
 840
 841    double dr = 1;
 842    double dl = 1;
 843    int    nr = 2;
 844    int    nl = 3;
 845
 846    Hex::Elements *c1, *c2, *c3, *c4, *c5, *c6;
 847
 848    c1 = doc->makeCylindrical (orig1, vx,vz,dr, 360, dl,nr, 4, nl, true);
 849    c2 = doc->makeCylindrical (orig2, vx,vz,dr, 360, dl,nr, 8, nl, true);
 850    c3 = doc->makeCylindrical (orig3, vx,vz,dr, 270, dl,nr, 8, nl, true);
 851    c4 = doc->makeCylindrical (orig4, vx,vz,dr, 270, dl,nr, 7, nl, true);
 852    c5 = doc->makeCylindrical (orig5, vx,vz,dr, 360, dl,nr, 5, nl, true);
 853    c6 = doc->makeCylindrical (orig6, vx,vz,dr, 360, dl,nr, 6, nl, true);
 854
 855    int base2 = nr*nl*8;
 856    c2->getHexa(base2 + 0)->setScalar (5);
 857    c2->getHexa(base2 + 1)->setScalar (5);
 858    c2->getHexa(base2 + 2)->setScalar (5);
 859
 860    doc->saveVtk ("cylindres.vtk");
 861    // doc->dump ();
 862
 863    return HOK;
 864 }
 865 // ===================================================== test_cylindrical
 866 int test_cylindrical (int nbargs, cpchar tabargs[])
 867 {
 868    cpchar fic_vtk = "cylindre";
 869
 870    Hex::Hex mon_ex;
 871    Hex::Document* doc = mon_ex.addDocument ();
 872
 873    Hex::Vertex* orig = doc->addVertex (0, 0, 0);
 874    Hex::Vector* vx   = doc->addVector (1, 0, 0);
 875    Hex::Vector* vz   = doc->addVector (0, 0, 1);
 876
 877    double dr = 1;
 878    double da = 360;
 879    double dl = 1;
 880
 881    int nr = 1;
 882    int na = 8;
 883    int nl = 2;
 884
 885    if (nbargs>1)
 886       {
 887       na = atoi (tabargs[1]);
 888       HexDisplay (na);
 889       if (na <= 2)
 890           na = 8;
 891       }
 892
 893    if (nbargs>2)
 894       {
 895       da = atof (tabargs[2]);
 896       HexDisplay (da);
 897       }
 898
 899    // Hex::Cylinder* cyl  = doc->addCylinder   (orig, vz, nr, nl);
 900    // Hex::Elements* grid = doc->makeCylinder (cyl, vx, nr, na, nl);
 901    doc->makeCylindrical (orig,vx, vz, dr,da,dl, nr,na, nl, true);
 902    doc ->saveVtk (fic_vtk, na);
 903    return HOK;
 904 }
 905 // ===================================================== test_cylinder
 906 int test_cylinder (int nbargs, cpchar tabargs[])
 907 {
 908    int    nvtk    = 1;
 909    cpchar fic_vtk = "cylindre";
 910
 911    Hex::Hex mon_ex;
 912    Hex::Document* doc = mon_ex.addDocument ();
 913
 914    Hex::Vertex* orig = doc->addVertex (0, 0, 0);
 915    Hex::Vector* vx   = doc->addVector (1, 0, 0);
 916    Hex::Vector* vz   = doc->addVector (0, 0, 1);
 917
 918    double rayon   = 10;
 919    double hauteur = 6;
 920
 921    int nr = 2;
 922    int na = 8;
 923    int nl = 5;
 924
 925    Hex::Cylinder* cyl  = doc->addCylinder   (orig, vz, rayon, hauteur);
 926    doc->makeCylinder (cyl, vx, nr, na, nl);
 927    doc ->saveVtk (fic_vtk, nvtk);
 928    return HOK;
 929 }
 930 // ===================================================== test_xml_cylinder
 931 int test_xml_cylinder (int nbargs, cpchar tabargs[])
 932 {
 933    int    nvtk    = 0;
 934    cpchar fic_vtk = "cylindre";
 935
 936    Hex::Hex mon_ex;
 937    Hex::Document* doc = mon_ex.addDocument ();
 938
 939    Hex::Vertex* orig1 = doc->addVertex (0, 0,0);
 940    Hex::Vertex* orig2 = doc->addVertex (50,0,0);
 941    Hex::Vector* vz    = doc->addVector (0,0,1);
 942    Hex::Vector* vx    = doc->addVector (1,0,0);
 943
 944    vx->setName ("vx");
 945    vz->setName ("vz");
 946    orig1->setName ("orig1");
 947    orig2->setName ("orig2");
 948
 949    int nr  = 4;
 950    int nri = 3;
 951    int nre = nr;
 952    int na = 9;
 953    int nl = 5;
 954
 955    Hex::Cylinder* cyl  = doc->addCylinder   (orig1, vz, nr, nl);
 956    Hex::Pipe*     pipe = doc->addPipe       (orig2, vz, nri, nre, nl);
 957
 958    Hex::Elements* grid = doc->makeCylinder (cyl,  vx, nr, na, nl);
 959    doc ->saveVtk (fic_vtk, nvtk);
 960
 961    Hex::Group* groupe = doc->addGroup ("GroupeAMA", Hex::HexaCell);
 962    groupe->addElement (grid->getHexaIJK (0,0,0));
 963    groupe->addElement (grid->getHexaIJK (1,0,0));
 964    groupe->addElement (grid->getHexaIJK (0,1,0));
 965    groupe->addElement (grid->getHexaIJK (1,1,0));
 966    groupe->addElement (grid->getHexaIJK (2,1,0));
 967
 968    grid->getHexaIJK  (0,0,0)->setName ("Hexa0");
 969    grid->getQuadIJ   (0,0,0)->setName ("QuadIJ0");
 970    grid->getEdgeK    (0,0,0)->setName ("EdgeK0");
 971
 972    doc->makePipe     (pipe, vx, nr, na, nl);
 973    doc ->saveVtk (fic_vtk, nvtk);
 974    doc->save ("cylindre");
 975
 976    return HOK;
 977 }
 978 // ===================================================== test_pipe
 979 int test_pipe (int nbargs, cpchar tabargs[])
 980 {
 981    int    nvtk    = 0;
 982    cpchar fic_vtk = "cylindre";
 983
 984    Hex::Hex mon_ex;
 985    Hex::Document* doc = mon_ex.addDocument ();
 986
 987    Hex::Vertex* orig1 = doc->addVertex (0, 0,0);
 988    Hex::Vector* vx    = doc->addVector (1,0,0);
 989    Hex::Vector* vy    = doc->addVector (0,1,0);
 990
 991    int nr  = 1;
 992    int nri = 1;
 993    int nre = 2;
 994    int na = 2;
 995    int nl = 1;
 996
 997    Hex::Pipe*  pipe = doc->addPipe  (orig1, vx, nri, nre, nl);
 998    doc->makePipe     (pipe, vy, nr, na, nl);
 999    doc ->saveVtk (fic_vtk, nvtk);
1000
1001    return HOK;
1002 }
1003 // ======================================================== del_hexa
1004 void del_hexa (Hex::CrossElements* gr, int cyl, int ni, int nj, int nk, int dr)
1005 {
1006    Hex::Hexa* hexa = gr->getHexaIJK (cyl, ni, nj, nk);
1007    if (hexa!=NULL)
1008       {
1009       hexa->remove ();
1010       if (dr>1)
1011           save_vtk ();
1012       }
1013 }
1014 // ======================================================== del_tranche
1015 int del_tranche (Hex::CrossElements* grid, int cyl, int ni, int nk, int dr=1)
1016 {
1017    for (int nj = 0 ; nj < 8 ; nj++)
1018         del_hexa (grid, cyl, ni, nj, nk, dr);
1019
1020    if (dr==1)
1021       save_vtk ();
1022    printf ("del_tranche (g=%d, i=%d, k=%d) : fic = %d\n",
1023                          cyl, ni, nk, nbr_vtk-1);
1024    return nbr_vtk;
1025 }
1026 // ======================================================== test_joint2
1027 int test_joint2 (int nbargs, cpchar tabargs[])
1028 {
1029    Hex::Hex mon_ex;
1030    docu = mon_ex.addDocument ();
1031    case_name = "pb_joint";
1032
1033    Hex::Vector* vx    = docu->addVector (1, 0, 0);
1034    Hex::Vector* vz    = docu->addVector (0, 0, 1);
1035    Hex::Vertex* hori  = docu->addVertex (0, 0, 0);
1036
1037    double da = 360;
1038    double dr = 2;
1039    double dl = 1;
1040    int    nr = 1;
1041    int    na = 8;
1042    int    nl = 1;
1043    bool   fill = true;
1044
1045    Hex::Elements *bgrid=NULL, *hgrid=NULL;
1046
1047    hgrid = docu->makeCylindrical (hori, vx,vz, dr,da,dl, nr,na,nl, fill);
1048    docu->dump ();
1049    save_vtk ();
1050
1051    Hex::Vertex* bori  = docu->addVertex (0, 0, -5);
1052    bgrid = docu->makeCylindrical (bori, vx,vz, dr,da,dl, nr,na,nl, fill);
1053    save_vtk ();
1054
1055    Hex::Quads qsource, qdest;
1056    printf (" Source = ");
1057    for (int ny=0 ; ny< na ; ny++)
1058        {
1059        Hex::Quad* quad = hgrid->getQuadIJ (0, ny, 0);
1060        PrintName (quad);
1061        qsource.push_back (quad);
1062        }
1063    printf ("\n          ");
1064    for (int ny=0 ; ny<4 ; ny++)
1065        {
1066        Hex::Quad* quad = hgrid->getKerHQuad (ny);
1067        PrintName (quad);
1068        qsource.push_back (quad);
1069        }
1070    printf ("\n");
1071
1072
1073    printf (" Cible  = ");
1074    for (int ny=0 ; ny< na ; ny++)
1075        {
1076        Hex::Quad* quad = bgrid->getQuadIJ (0, ny, 1);
1077        PrintName (quad);
1078        qdest.push_back (quad);
1079        }
1080    printf ("\n          ");
1081    for (int ny=0 ; ny<4 ; ny++)
1082        {
1083        Hex::Quad* quad = bgrid->getKerHQuad (ny+4);
1084        PrintName (quad);
1085        qdest.push_back (quad);
1086        }
1087    printf ("\n");
1088    docu ->setLevel (1);
1089    Hex::Quad*   cible = bgrid->getQuadIJ    (0, 1, 1);
1090    Hex::Vertex* vc1   = bgrid->getVertexIJK (0, 1, 1);
1091    Hex::Vertex* vc2   = bgrid->getVertexIJK (1, 1, 1);
1092
1093    Hex::Vertex* vs1 = hgrid->getVertexIJK (0, 0, 0);
1094    Hex::Vertex* vs2 = hgrid->getVertexIJK (1, 0, 0);
1095
1096    docu->joinQuads (qsource, cible, vs1, vc1, vs2, vc2, 1);
1097    save_vtk ();
1098
1099    return HOK;
1100 }
1101 // ======================================================== test_croix
1102 int test_croix (int nbargs, cpchar tabargs[])
1103 {
1104    Hex::Hex mon_ex;
1105    docu = mon_ex.addDocument ();
1106
1107    Hex::Vertex* ori1 = docu->addVertex ( 100,0,0);
1108    Hex::Vertex* ori2 = docu->addVertex (-5,0,5);
1109    Hex::Vector* vz   = docu->addVector ( 0,0,1);
1110    Hex::Vector* vx   = docu->addVector ( 1,0,0);
1111
1112    double r1 = 2;
1113    double r2 = 3;
1114    double l1 = 5;
1115    double l2 = 10;
1116
1117    Hex::Cylinder*      cyl1 = docu->addCylinder (ori1, vz, r1, l1);
1118    Hex::Cylinder*      cyl2 = docu->addCylinder (ori2, vx, r2, l2);
1119    Hex::CrossElements* grid = docu->makeCylinders (cyl1, cyl2);
1120
1121    case_name = "croix";
1122    save_vtk ();
1123    PutData ((BadElement (grid)));
1124
1125
1126    Hex::Edge* pipo = docu->addEdge (ori1, ori1);
1127    PutData (pipo->isValid());
1128    PutData ((BadElement (pipo)));
1129    return HOK;
1130
1131    del_tranche (grid, 0, 1, 0);
1132    del_tranche (grid, 0, 1, 5);
1133
1134    del_tranche (grid, 1, 1, 0);
1135    del_tranche (grid, 1, 1, 3);
1136
1137    del_tranche (grid, 1, 0, 0);
1138    del_tranche (grid, 1, 0, 3);
1139                                   // Le trognon
1140    del_tranche (grid, 0, 0, 0);
1141    del_tranche (grid, 0, 0, 5);
1142    del_tranche (grid, 0, 0, 1);
1143    del_tranche (grid, 0, 0, 2);
1144    del_tranche (grid, 0, 0, 3);
1145    del_tranche (grid, 0, 0, 4);
1146                                   // Partie critique
1147
1148    del_tranche (grid, 1, 1, 1, 2);
1149
1150    del_tranche (grid, 0, 1, 1, 2);
1151    del_tranche (grid, 0, 1, 4, 2);
1152    del_tranche (grid, 0, 1, 3, 2);
1153    del_tranche (grid, 0, 1, 2, 2);
1154
1155    del_tranche (grid, 1, 1, 2, 2);
1156    return HOK;
1157 }
1158 // ======================================================== test_pipes
1159 int test_pipes (int nbargs, cpchar tabargs[])
1160 {
1161    Hex::Hex mon_ex;
1162    Hex::Document* doc = mon_ex.addDocument ();
1163
1164    Hex::Vertex* ori1 = doc->addVertex ( 0,0,0);
1165    Hex::Vertex* ori2 = doc->addVertex (-5,0,5);
1166    Hex::Vector* vz   = doc->addVector ( 0,0,1);
1167    Hex::Vector* vx   = doc->addVector ( 1,0,0);
1168
1169 // double h1  =  5, ri1 = 1, re1 = 2;
1170    double h1  = 10, ri1 = 1, re1 = 2;
1171    double h2  = 10, ri2 = 2, re2 = 3;
1172
1173    Hex::Pipe* pipe1  = doc->addPipe (ori1, vz, ri1, re1, h1);
1174    Hex::Pipe* pipe2  = doc->addPipe (ori2, vx, ri2, re2, h2);
1175    Hex::CrossElements* grid = doc->makePipes (pipe1, pipe2);
1176
1177    case_name = "pipe";
1178    docu      = doc;
1179    save_vtk ();
1180
1181    del_tranche (grid, 0, 1, 0);
1182    del_tranche (grid, 0, 1, 5);
1183
1184    del_tranche (grid, 1, 1, 0);
1185    del_tranche (grid, 1, 1, 3);
1186                                   // Partie critique
1187
1188    del_tranche (grid, 1, 1, 1, 2);
1189
1190    del_tranche (grid, 0, 1, 1, 2);
1191    del_tranche (grid, 0, 1, 4, 2);
1192    del_tranche (grid, 0, 1, 3, 2);
1193    del_tranche (grid, 0, 1, 2, 2);
1194
1195    del_tranche (grid, 1, 1, 2, 2);
1196    /* ***************************************************
1197
1198    int nbz [2] =  { 8, 4 };
1199    int ni = 1;
1200    for (int cyl = 0 ; cyl < 2 ; cyl++)
1201        for (int nk = 0 ; nk < nbz[cyl] ; nk++)
1202        for (int nj = 0 ; nj < 4 ; nj++)
1203            {
1204            int jj = nj;
1205            if (cyl==0) jj = (jj+6) MODULO 8 ;
1206            Hex::Hexa* hexa = grid->getHexaIJK (cyl, ni, jj, nk);
1207            if (hexa!=NULL)
1208               {
1209               hexa->remove ();
1210               doc->saveVtk (case_name,  nbr_vtk);
1211               }
1212            }
1213       *************************************************** */
1214    return HOK;
1215 }
1216 // ======================================================== test_lorraine
1217 int test_lorraine(int nbargs, cpchar tabargs[])
1218 {
1219    Hex::Hex mon_ex;
1220    Hex::Document* doc = mon_ex.addDocument ();
1221
1222    Hex::Vertex* ori1 = doc->addVertex ( 0,0,0);
1223    Hex::Vertex* ori2 = doc->addVertex (-5,0,5);
1224    Hex::Vertex* ori3 = doc->addVertex ( 0,0,12);
1225    Hex::Vertex* ori4 = doc->addVertex (-5,0,17);
1226
1227    Hex::Vector* vz   = doc->addVector ( 0,0,1);
1228    Hex::Vector* vx   = doc->addVector ( 1,0,0);
1229
1230    int nl1 = 10;
1231    int nl2 = 10;
1232
1233    double rsmall = 1;
1234    double rmoy   = 2;
1235    double rbig   = 3;
1236
1237    Hex::Cylinder* cyl1  = doc->addCylinder (ori1, vz, rmoy,   nl1);
1238    Hex::Cylinder* cyl2  = doc->addCylinder (ori2, vx, rsmall, nl2);
1239
1240    Hex::Cylinder* cyl3  = doc->addCylinder (ori3, vz, rmoy, nl1);
1241    Hex::Cylinder* cyl4  = doc->addCylinder (ori4, vx, rbig, nl2);
1242
1243    Hex::CrossElements* grid1 = doc->makeCylinders (cyl1, cyl2);
1244    Hex::CrossElements* grid2 = doc->makeCylinders (cyl4, cyl3);
1245
1246 #define Imprimer(x) printf (#x " = ") ; if (x) x->dump() ; else printf ("NULL\n")
1247    const int nx_int = 0;
1248    const int nx_ext = 1;
1249
1250    //           vc2 = grid1->getVertexIJK (Hex::CylBig, 0,0,0);
1251    //           vc3 = grid2->getVertexIJK (Hex::CylSmall, 0,0,0);
1252                                      //    Cyl     i     j     k
1253    Hex::Quad* qb = grid1-> getQuadIJ (Hex::CylBig, nx_ext, Hex::S_E, 4);
1254    Hex::Quad* qh = grid2-> getQuadIJ (Hex::CylSmall, nx_ext, Hex::S_N, 0);
1255
1256    Hex::Vertex* vb0 = qb->getVertex (3);
1257    Hex::Vertex* vb1 = qb->getVertex (2);
1258    Hex::Vertex* vh0 = qh->getVertex (0);
1259    Hex::Vertex* vh1 = qh->getVertex (1);
1260
1261    vb0 = grid1->getVertexIJK (Hex::CylBig, 2, Hex::S_E,  4);  // cible
1262    vb1 = grid1->getVertexIJK (Hex::CylBig, 2, Hex::S_NE, 4);
1263    vh0 = grid2->getVertexIJK (Hex::CylSmall, 2, Hex::S_N,  0);   // depart
1264    vh1 = grid2->getVertexIJK (Hex::CylSmall, 2, Hex::S_NW, 0);
1265
1266    Imprimer (vh0);
1267    Imprimer (vh1);
1268    Imprimer (vb0);
1269    Imprimer (vb1);
1270
1271    // qb->remove ();
1272    // qh->remove ();
1273    Hex::Quads hliste;
1274
1275    hliste.push_back (qh);
1276    for (int ny=1; ny<Hex::S_MAXI; ny++)
1277        {
1278        int ns = (ny + Hex::S_N) MODULO Hex::S_MAXI;
1279        hliste.push_back (grid2->getQuadIJ (Hex::CylSmall, nx_ext, ns, 0));
1280        }
1281
1282    for (int ny=0; ny<4 ;  ny++)
1283        hliste.push_back (grid2->getQuadIJ (Hex::CylSmall, nx_int, ny, 0));
1284
1285    int hauteur = 3;
1286    doc->joinQuads  (hliste, qb, vh0, vb0, vh1, vb1, hauteur);
1287    doc->saveVtk ("lorraine.vtk");
1288
1289    // doc->dump ();
1290    return HOK;
1291 }
1292 // ======================================================== test_disconnect2
1293 // === Disconnect Edge seul
1294 int test_disconnect2 (int nbargs, cpchar tabargs[])
1295 {
1296    const int size_x = 2;
1297    const int size_y = 2;
1298    const int size_z = 1;
1299
1300    Hex::Hex mon_ex;
1301    Hex::Document* doc = mon_ex.addDocument ();
1302
1303    Hex::Vertex*   orig2 = doc->addVertex (0,0,0);
1304    Hex::Vector*   dir   = doc->addVector (1,1,1);
1305    Hex::Elements* grid2 = doc->makeCartesian (orig2, dir, size_x,size_y,size_z);
1306
1307    doc->dump ();
1308
1309    int nvtk = 0;
1310    doc->setLevel (1);
1311    Hex::Matrix  matrice;
1312    Hex::Vector* ecart  = doc->addVector (0.5,0.5,0);
1313    matrice.defTranslation (ecart);
1314
1315    Hex::Hexa* hexa2 = grid2->getHexaIJK (1,1,0);
1316    Hex::Edge* edge  = grid2->getEdgeK   (1,2,0);
1317
1318    hexa2->setScalar  (2);
1319    edge->setScalar   (5);
1320
1321    doc->saveVtk ("test_disco", nvtk);
1322
1323    doc->setLevel (4);
1324
1325    Hex::Elements* disco_edges =  doc->disconnectEdge (hexa2, edge);
1326    HexDisplay (disco_edges->countVertex());
1327    HexDisplay (disco_edges->countEdge());
1328    HexDisplay (disco_edges->countQuad());
1329    HexDisplay (disco_edges->countHexa());
1330
1331    // hexa2->transform (&matrice);
1332  /**********************************
1333    for (int ns=0; ns<disco_edges->countVertex(); ns++)
1334        {
1335        Hex::Vertex* sommet = disco_edges->getVertex(ns);
1336        sommet->setX (sommet->getX()+0.5);
1337        sommet->setY (sommet->getY()+0.5);
1338        }
1339    ********************************* */
1340
1341    doc->saveVtk ("test_disco", nvtk);
1342    doc->save ("test_disco");
1343    doc->dump ();
1344    hexa2->dumpFull ();
1345
1346    doc->setLevel (4);
1347    return HOK;
1348 }
1349 // ======================================================== test_disconnect4
1350 // === Disconnect Edges
1351 int test_disconnect4 (int nbargs, cpchar tabargs[])
1352 {
1353    const int size_x = 1;
1354    const int size_y = 2;
1355    const int size_z = 2;
1356
1357    Hex::Hex mon_ex;
1358    Hex::Document* doc = mon_ex.addDocument ();
1359
1360    Hex::Vertex*   orig2 = doc->addVertex (0,0,0);
1361    Hex::Vector*   vx    = doc->addVector (1,0,0);
1362    Hex::Vector*   vy    = doc->addVector (0,1,0);
1363    Hex::Vector*   vz    = doc->addVector (0,0,1);
1364    Hex::Elements* grid2 = doc->makeCartesian (orig2, vx,vy,vz, size_x,size_y,size_z);
1365
1366    int nvtk = 0;
1367    doc->setLevel (1);
1368
1369    Hex::Hexas t_hexas;
1370    Hex::Edges t_edges;
1371    for (int nk=0 ; nk< size_z; nk++)
1372        {
1373        Hex::Hexa* hexa2 = grid2->getHexaIJK (0,0,nk);
1374        Hex::Edge* edge  = grid2->getEdgeK   (0,1,nk);
1375
1376        hexa2->setScalar  (2);
1377        edge->setScalar   (5);
1378        t_hexas.push_back (hexa2);
1379        t_edges.push_back (edge);
1380
1381        doc->setLevel (4);
1382        }
1383
1384    doc->dump ();
1385    doc->saveVtk ("test_disco", nvtk);
1386    /* Hex::Elements* disco_edges = */  doc->disconnectEdges (t_hexas, t_edges);
1387    doc->saveVtk ("test_disco", nvtk);
1388    doc->dump ();
1389    // hexa2->dumpFull ();
1390
1391    doc->setLevel (4);
1392    return HOK;
1393 }
1394 // ======================================================== test_disconnect
1395 // ==== Disconnect Quad
1396 int test_disconnect1 (int nbargs, cpchar tabargs[])
1397 {
1398    const int size_x = 2;
1399    const int size_y = 2;
1400    const int size_z = 1;
1401
1402    Hex::Hex mon_ex;
1403    Hex::Document* doc = mon_ex.addDocument ();
1404
1405    Hex::Vertex*   orig1 = doc->addVertex (0,0,0);
1406    Hex::Vector*   dir   = doc->addVector (1,1,1);
1407    Hex::Elements* grid1 = doc->makeCartesian (orig1, dir, size_x,size_y,size_z);
1408
1409    int nvtk = 0;
1410    doc->setLevel (1);
1411    Hex::Matrix  matrice;
1412    Hex::Vector* ecart  = doc->addVector (0.5,0.5,0);
1413    matrice.defTranslation (ecart);
1414
1415    Hex::Hexa* hexa1 = grid1->getHexaIJK (1,1,0);
1416    Hex::Quad* quad  = grid1->getQuadJK  (1,1,0);
1417
1418    quad->setScalar   (5);
1419
1420    doc->saveVtk ("test_disco", nvtk);
1421    doc->disconnectQuad (hexa1, quad);
1422    // hexa1 ->transform (&matrice);
1423    doc->saveVtk ("test_disco", nvtk);
1424
1425    // doc->dumpPropagation ();
1426    // doc->dump  ();
1427
1428    doc->save  ("disco_all");
1429    return HOK;
1430 }
1431 // ======================================================== test_disconnect3
1432 // ==== disconnectVertex
1433 int test_disconnect3 (int nbargs, cpchar tabargs[])
1434 {
1435    const int size_x = 2;
1436    const int size_y = 2;
1437    const int size_z = 1;
1438
1439    Hex::Hex mon_ex;
1440    Hex::Document* doc = mon_ex.addDocument ();
1441
1442    Hex::Vertex*   orig1 = doc->addVertex (0,0,0);
1443
1444    Hex::Vector*   dir   = doc->addVector (1,1,1);
1445    Hex::Elements* grid1 = doc->makeCartesian (orig1, dir, size_x,size_y,size_z);
1446
1447    int nvtk = 0;
1448    doc->setLevel (1);
1449    Hex::Matrix  matrice;
1450    Hex::Vector* ecart  = doc->addVector (0.5,0.5,0);
1451    matrice.defTranslation (ecart);
1452
1453    Hex::Hexa* hexa1 = grid1->getHexaIJK (1,1,0);
1454    Hex::Vertex* vertex = grid1->getVertexIJK (1,1,1);
1455
1456    vertex->setScalar (5);
1457
1458    doc->saveVtk ("test_disco", nvtk);
1459
1460    doc->disconnectVertex (hexa1, vertex);
1461    // hexa1->transform (&matrice);
1462    doc->saveVtk ("test_disco", nvtk);
1463
1464    // doc->dumpPropagation ();
1465    // doc->dump  ();
1466
1467    doc->save  ("disco_all");
1468    return HOK;
1469 }
1470 // ======================================================== contraction
1471 void contraction (Hex::Hexa* hexa, Hex::Elements* grid)
1472 {
1473    return;
1474    Hex::Real3 cg = { 0, 0, 0 };
1475
1476    for (int nro=0; nro<Hex::HV_MAXI ; nro++)
1477        {
1478        cg [0] += hexa->getVertex(nro)->getX()/Hex::HV_MAXI;
1479        cg [1] += hexa->getVertex(nro)->getY()/Hex::HV_MAXI;
1480        cg [2] += hexa->getVertex(nro)->getZ()/Hex::HV_MAXI;
1481        }
1482
1483    int nbvertex = grid->countVertex();
1484    const double coeff = 0.5;
1485    for (int nro=0; nro<nbvertex ; nro++)
1486        {
1487        Hex::Vertex* pv = grid->getVertex(nro);
1488        Hex::Real3 pold = { pv->getX(), pv->getY(), pv->getZ() };
1489        Hex::Real3 pnew;
1490        for (int dd=0; dd<3 ; dd++)
1491            pnew [dd] = cg[dd] + coeff * (pold[dd]-cg[dd]);
1492
1493        pv->setX (pnew[0]);
1494        pv->setY (pnew[1]);
1495        pv->setZ (pnew[2]);
1496        }
1497 }
1498 // ======================================================== test_disconnect
1499 // ==== Les 3 disconnect
1500 int test_disconnect (int nbargs, cpchar tabargs[])
1501 {
1502    const int size_x = 2;
1503    const int size_y = 2;
1504    const int size_z = 1;
1505
1506    Hex::Hex mon_ex;
1507    Hex::Document* doc = mon_ex.addDocument ();
1508
1509    Hex::Vertex*   orig1 = doc->addVertex (0,0,0);
1510    Hex::Vertex*   orig2 = doc->addVertex (4,0,0);
1511    Hex::Vertex*   orig3 = doc->addVertex (8,0,0);
1512
1513    Hex::Vector*   dir   = doc->addVector (1,1,1);
1514    Hex::Elements* grid1 = doc->makeCartesian (orig1, dir, size_x,size_y,size_z);
1515    Hex::Elements* grid2 = doc->makeCartesian (orig2, dir, size_x,size_y,size_z);
1516    Hex::Elements* grid3 = doc->makeCartesian (orig3, dir, size_x,size_y,size_z);
1517
1518    int nvtk = 0;
1519    doc->setLevel (1);
1520    Hex::Matrix  matrice;
1521    Hex::Vector* ecart  = doc->addVector (0.5,0.5,0);
1522    matrice.defTranslation (ecart);
1523
1524    Hex::Hexa* hexa1 = grid1->getHexaIJK (1,1,0);
1525    Hex::Hexa* hexa2 = grid2->getHexaIJK (1,1,0);
1526    Hex::Hexa* hexa3 = grid3->getHexaIJK (1,1,0);
1527
1528    Hex::Quad* quad  = grid1->getQuadJK  (1,1,0);
1529    Hex::Edge* edge  = grid2->getEdgeK   (1,2,0);
1530    Hex::Vertex* vertex = grid3->getVertexIJK (1,1,1);
1531
1532    quad->setScalar   (5);
1533    edge->setScalar   (5);
1534    vertex->setScalar (5);
1535
1536    doc->saveVtk ("test_disco", nvtk);
1537    doc->disconnectQuad (hexa1, quad);
1538    doc->saveVtk ("test_disco", nvtk);
1539
1540    doc->disconnectEdge (hexa2, edge);
1541    doc->saveVtk ("test_disco", nvtk);
1542
1543    doc->disconnectVertex (hexa3, vertex);
1544    doc->saveVtk ("test_disco", nvtk);
1545
1546    // doc->dumpPropagation ();
1547    // doc->dump  ();
1548
1549    doc->save  ("disco_all");
1550    return HOK;
1551 }
1552 // ======================================================== test_propagation
1553 int test_propagation ()
1554 {
1555    const int size_x = 2;
1556    const int size_y = 1;
1557    const int size_z = 1;
1558
1559    Hex::Hex mon_ex;
1560    Hex::Document* doc = mon_ex.addDocument ();
1561
1562    Hex::Vertex*   orig = doc->addVertex (0,0,0);
1563    Hex::Vector*   dir  = doc->addVector (1,1,1);
1564    //  Hex::Elements* grid =
1565    doc->makeCartesian (orig, dir, size_x,size_y,size_z);
1566
1567    int nb = doc->countPropagation ();
1568    for (int nro=0 ; nro<nb ; nro++)
1569        {
1570        Hex::Propagation*  prop  = doc ->getPropagation (nro);
1571        const Hex::Edges&  table = prop->getEdges ();
1572        printf (" ____________________________________ Prop nro %d\n", nro);
1573        for (int ned=0 ; ned<(int)table.size() ; ned++)
1574            {
1575            bool way = table [ned]->getWay ();
1576
1577            if (way)
1578               {
1579               printf ("     (");
1580               table [ned]->getVertex (0)->printName (", ");
1581               table [ned]->getVertex (1)->printName (")\n");
1582               }
1583           else
1584               {
1585               printf ("     (");
1586               table [ned]->getVertex (1)->printName (", ");
1587               table [ned]->getVertex (0)->printName (")\n");
1588               }
1589            }
1590        }
1591
1592    doc->dump  ();
1593    doc->saveVtk ("test_propagation.vtk");
1594    doc->save ("test_propagation");
1595
1596    return HOK;
1597 }
1598 // ======================================================== test_move
1599 int test_move ()
1600 {
1601    const int size_x = 1;
1602    const int size_y = 1;
1603    const int size_z = 2;
1604
1605    Hex::Hex mon_ex;
1606    Hex::Document* doc = mon_ex.addDocument ();
1607
1608    Hex::Vertex* orig = doc->addVertex (0,0,0);
1609    Hex::Vector* dir  = doc->addVector (1,1,1);
1610    Hex::Elements*  grid = doc->makeCartesian (orig, dir, size_x,size_y,size_z);
1611
1612    Hex::Vector*   enhaut  = doc->addVector (0, 0, 5);
1613    Hex::Vector*   devant  = doc->addVector (5, 0, 0);
1614    // Hex::Vector*   agauche = doc->addVector (0, 5, 0);
1615
1616    Hex::Matrix matrice;
1617    matrice.defTranslation (enhaut);
1618
1619    Hex::Hexa* cube    = grid->getHexa (1);
1620    Hex::Quad* dessous = cube->getQuad (Hex::Q_A);
1621    dessous->dump();
1622
1623    Hex::Elements* grid2 = doc->makeTranslation (grid, devant);
1624    /* Hex::Elements* grid3 = doc->makeTranslation (grid, agauche); */
1625    Hex::Hexa* cube2     = grid2->getHexa (1);
1626
1627    doc ->saveVtk ("move0.vtk");
1628
1629    cube ->disconnectQuad (dessous);
1630    cube ->transform (&matrice);
1631    cube2->transform (&matrice);
1632
1633    doc ->saveVtk ("move1.vtk");
1634    doc ->dump();
1635
1636    return HOK;
1637 }
1638 // ======================================================== test_transfo2
1639 int test_transfo2 (int nbargs, cpchar tabargs[])
1640 {
1641    const int size_x = 1;
1642    const int size_y = 1;
1643    const int size_z = 2;
1644
1645    int    nvtk    = 0;
1646    cpchar fic_vtk = "transfo";
1647
1648    Hex::Hex mon_ex;
1649    Hex::Document* doc = mon_ex.addDocument ();
1650    doc ->setLevel (1);
1651
1652    Hex::Vertex* orig = doc->addVertex (0,0,0);
1653    Hex::Vector* dir  = doc->addVector (1,1,1);
1654    Hex::Elements* grid = doc->makeCartesian (orig, dir, size_x, size_y,
1655                                                         size_z);
1656    if (grid==NULL)
1657       return HERR;
1658
1659    orig->setScalar(2);
1660
1661    doc ->saveVtk (fic_vtk, nvtk);
1662
1663    Hex::Vector*   devant  = doc->addVector (5, 0, 0);
1664
1665    Hex::Elements* grid2 = doc->makeTranslation (grid, devant);
1666    if (grid2==NULL)
1667       return HERR;
1668    doc ->saveVtk (fic_vtk, nvtk);
1669
1670    Hex::Elements* grid3  = doc->makeScale (grid2, orig, 2);
1671    if (grid3==NULL)
1672       return HERR;
1673    doc ->saveVtk (fic_vtk, nvtk);
1674
1675    Hex::Elements* grid4 = doc->makeRotation (grid2, orig, dir, 45);
1676    if (grid4==NULL)
1677       return HERR;
1678    doc ->saveVtk (fic_vtk, nvtk);
1679
1680    Hex::Elements* grid5 = doc->makeSymmetryPoint (grid4, orig);
1681    if (grid5==NULL)
1682       return HERR;
1683
1684    doc ->saveVtk (fic_vtk, nvtk);
1685
1686    Hex::Vector* dir1  = doc->addVector (1,0,0);
1687    Hex::Elements* grid6 = doc->makeSymmetryLine (grid4, orig, dir1);
1688    if (grid6==NULL)
1689       return HERR;
1690
1691    grid4->getHexa(0)->getVertex(0)->setScalar(3);
1692    grid6->getHexa(0)->getVertex(0)->setScalar(3);
1693    doc ->saveVtk (fic_vtk, nvtk);
1694
1695    grid4->getHexa(0)->getVertex(0)->setScalar(0);
1696    grid6->getHexa(0)->getVertex(0)->setScalar(0);
1697
1698    Hex::Elements* grid7 = doc->makeSymmetryLine (grid2, orig, dir1);
1699    if (grid7==NULL)
1700       return HERR;
1701
1702    grid2->getHexa(0)->getVertex(0)->setScalar(4);
1703    grid7->getHexa(0)->getVertex(0)->setScalar(4);
1704    doc ->saveVtk (fic_vtk, nvtk);
1705
1706    grid2->getHexa(0)->getVertex(0)->setScalar(0);
1707    grid7->getHexa(0)->getVertex(0)->setScalar(0);
1708
1709    Hex::Elements* grid8 = doc->makeSymmetryPlane (grid2, orig, dir1);
1710    if (grid8==NULL)
1711       return HERR;
1712
1713    grid2->getHexa(0)->getVertex(0)->setScalar(4);
1714    grid8->getHexa(0)->getVertex(0)->setScalar(4);
1715    doc ->saveVtk (fic_vtk, nvtk);
1716    grid2->getHexa(0)->getVertex(0)->setScalar(0);
1717    grid8->getHexa(0)->getVertex(0)->setScalar(0);
1718
1719    Hex::Elements* grid9 = doc->makeSymmetryPlane (grid3, orig, dir);
1720    if (grid9==NULL)
1721       return HERR;
1722
1723    grid3->getHexa(0)->getVertex(0)->setScalar(4);
1724    grid9->getHexa(0)->getVertex(0)->setScalar(4);
1725    doc ->saveVtk (fic_vtk, nvtk);
1726
1727    grid9->getHexa(0)->removeConnected ();
1728    doc ->saveVtk (fic_vtk, nvtk);
1729
1730    return HOK;
1731 }
1732 // ======================================================== test_transfo
1733 int test_transfo (int nbargs, cpchar tabargs[])
1734 {
1735    int    nvtk    = 0;
1736    cpchar fic_vtk = "transfo";
1737
1738    Hex::Hex mon_ex;
1739    Hex::Document* doc = mon_ex.addDocument ();
1740    doc ->setLevel (1);
1741
1742    Hex::Vertex* orig = doc->addVertex (0,0,0);
1743    Hex::Vector* vx   = doc->addVector (1,0,0);
1744    Hex::Vector* vz   = doc->addVector (0,0,1);
1745    double dr = 1;
1746    double da = 360;
1747    double dl = 1;
1748    int nr = 3;
1749    int na = 8;
1750    int nl = 3;
1751    Hex::Elements* grid = doc->makeCylindrical (orig, vx,vz, dr, da, dl,
1752                                                             nr, na, nl, false);
1753    if (grid==NULL)
1754       return HERR;
1755
1756    doc ->saveVtk (fic_vtk, nvtk);
1757    Hex::Vector*   devant  = doc->addVector (10, 0, 0);
1758
1759    Hex::Elements* grid2 = doc->makeTranslation (grid, devant);
1760    if (grid2==NULL)
1761       return HERR;
1762    doc ->saveVtk (fic_vtk, nvtk);
1763
1764    return HOK;
1765 }
1766 // ======================================================== test_copy_document
1767 int test_copy_document (int nbargs, cpchar tabargs[])
1768 {
1769    Hex::Hex mon_ex;
1770    Hex::Document* doc = mon_ex.loadDocument ("Essai");
1771    doc ->saveVtk ("restore1.vtk");
1772
1773    Hex::Document* clone = doc->copyDocument();
1774    clone->saveVtk ("restore2.vtk");
1775
1776    return HOK;
1777 }
1778 // ======================================================== test_remove
1779 int test_remove ()
1780 {
1781    const int size_x = 2;
1782    const int size_y = 2;
1783    const int size_z = 2;
1784
1785    Hex::Hex mon_ex;
1786    Hex::Document* doc = mon_ex.addDocument ();
1787
1788    Hex::Vertex* orig  = doc->addVertex (0,0,0);
1789    Hex::Vertex* orig1 = doc->addVertex (6,0,0);
1790    Hex::Vector* dir   = doc->addVector (1,1,1);
1791    Hex::Elements* grid  = doc->makeCartesian (orig, dir,  size_x,size_y,size_z);
1792    doc->makeCartesian (orig1, dir, 1,1,1);
1793    doc->saveVtk ("removeConn1.vtk");
1794
1795    Echo ("--------- Avant destruction");
1796    HexDisplay (doc->countVertex ());
1797    HexDisplay (doc->countEdge ());
1798    HexDisplay (doc->countQuad ());
1799    HexDisplay (doc->countHexa ());
1800    HexDisplay (doc->countUsedVertex ());
1801    HexDisplay (doc->countUsedEdge ());
1802    HexDisplay (doc->countUsedQuad ());
1803    HexDisplay (doc->countUsedHexa ());
1804
1805
1806    doc->removeConnectedHexa (grid->getHexaIJK (0,0,0));
1807
1808    Echo ("--------- Apres destruction");
1809    HexDisplay (doc->countVertex ());
1810    HexDisplay (doc->countEdge ());
1811    HexDisplay (doc->countQuad ());
1812    HexDisplay (doc->countHexa ());
1813
1814    HexDisplay (doc->countUsedVertex ());
1815    HexDisplay (doc->countUsedEdge ());
1816    HexDisplay (doc->countUsedQuad ());
1817    HexDisplay (doc->countUsedHexa ());
1818    doc->saveVtk ("removeConn2.vtk");
1819
1820    return HOK;
1821 }
1822 // ================================================== init_vec
1823 void init_vec (Hex::RealVector& tab, double n0=0, double n1=0, double n2=0,
1824                double n3=0, double n4=0, double n5=0, double n6=0,
1825                double n7=0, double n8=0, double n9=0, double n10=0,
1826                double n11=0, double n12=0, double n13=0, double n14=0,
1827                double n15=0, double n16=0)
1828 {
1829    if (n0>0.0) tab.push_back (n0);
1830    if (n1>0.0) tab.push_back (n1);
1831    if (n2>0.0) tab.push_back (n2);
1832    if (n3>0.0) tab.push_back (n3);
1833    if (n4>0.0) tab.push_back (n4);
1834    if (n5>0.0) tab.push_back (n5);
1835    if (n6>0.0) tab.push_back (n6);
1836    if (n7>0.0) tab.push_back (n7);
1837    if (n8>0.0) tab.push_back (n8);
1838    if (n9>0.0) tab.push_back (n9);
1839
1840    if (n10>0.0) tab.push_back (n10);
1841    if (n11>0.0) tab.push_back (n11);
1842    if (n12>0.0) tab.push_back (n12);
1843    if (n13>0.0) tab.push_back (n13);
1844    if (n14>0.0) tab.push_back (n14);
1845    if (n15>0.0) tab.push_back (n15);
1846    if (n16>0.0) tab.push_back (n16);
1847 }
1848 // ================================================== test_cylindricals
1849 int test_cylindricals (int nbargs, cpchar tabargs[])
1850 {
1851    Hex::Hex mon_ex;
1852    Hex::Document* doc = mon_ex.addDocument ();
1853
1854    Hex::Vertex* orig = doc->addVertex (0, 0, 0);
1855    Hex::Vector* vz   = doc->addVector (0, 0, 1);
1856    Hex::Vector* vx   = doc->addVector (1 ,0, 0);
1857
1858    Hex::RealVector tdr, tda, tdl;
1859
1860    /******************
1861    init_vec (tdr, 2, 1, 0.5);
1862    init_vec (tda, 40, 35, 30, 25, 20, 15, 10, 5,
1863                    5, 10, 15, 20, 25, 30, 35, 40);
1864    init_vec (tdl, 1, 2, 3 );
1865
1866    init_vec (tdr, 1, 1, 1, 1);
1867    init_vec (tda, 45,45, 45,45, 45,45, 45,45 );
1868    init_vec (tdl, 1, 1, 1 );
1869
1870     ****************** */
1871
1872
1873    init_vec (tdr, 1, 2, 1, 2);
1874    init_vec (tda, 20, 20, 20 );
1875    init_vec (tdl, 1 );
1876
1877    Hex::Elements* grid=doc->makeCylindricals (orig, vx,vz, tdr,tda,tdl, false);
1878
1879    doc->saveVtk ("cylindricals.vtk");
1880    doc->dump();
1881    grid->clearAssociation();
1882    doc->clearAssociation();
1883    return HOK;
1884 }
1885 // ======================================================== test_edge
1886 int test_edge (int nbargs, cpchar tabargs[])
1887 {
1888    Hex::Hex mon_ex;
1889    Hex::Document* doc = mon_ex.addDocument ();
1890
1891    Hex::Vertex* orig = doc->addVertex (0, 0, 0);
1892    Hex::Vector* vx   = doc->addVector (1 ,0, 0);
1893    doc->addEdge   (orig, vx);
1894
1895    HexDisplay (doc->countVertex());
1896    HexDisplay (doc->countEdge());
1897    doc->dump ();
1898    return HOK;
1899 }
1900 // ======================================================== test_hexa
1901 int test_hexa (int nbargs, cpchar tabargs[])
1902 {
1903    int ier = 0;
1904    Hex::Hex mon_ex;
1905    Hex::Document* doc1 = mon_ex.loadDocument ("bielle_triang");
1906    Hex::Document* doc2 = mon_ex.loadDocument ("bielle_triang");
1907    PutData (doc1->getName ());
1908    PutData (doc2->getName ());
1909    return ier;
1910
1911
1912    goto_workspace ();
1913    ier = test_cylindricals (nbargs, tabargs);
1914    ier = test_transfo (nbargs, tabargs);
1915    free_workspace ();
1916
1917    return ier;
1918 }