src/HEXABLOCK/test_hexa1.cxx

   1
   2 // C++ : Tests unitaires
   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 "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_asso_line
 866 int test_asso_line (int nbargs, cpchar tabargs[])
 867 {
 868    Hex::Hex mon_ex;
 869    Hex::Document* doc = mon_ex.addDocument ();
 870
 871    Hex::Vertex* orig1 = doc->addVertex ( 0, 0,0);
 872
 873    Hex::Vector* vz = doc->addVector (0,0,1);
 874    Hex::Vector* vx = doc->addVector (1,0,0);
 875
 876    double dr = 1;
 877    double dl = 1;
 878    int    nr = 2;
 879    int    nl = 3;
 880    int    ntheta = 8;
 881
 882    Hex::Elements *c1 = NULL;
 883
 884    c1 = doc->makeCylindrical (orig1, vx,vz,dr, 360, dl,nr, ntheta, nl, true);
 885
 886    Hex::Edges m_line;
 887    Hex::Edge* m_start = c1->getEdgeJ (nr, 1, 0);
 888
 889    for (int na=2 ; na<ntheta ; na++)
 890        {
 891        Hex::Edge*  arete = c1->getEdgeJ (nr, na, 0);
 892        arete->setScalar (5);
 893        m_line.push_back (arete);
 894        }
 895
 896    // m_line.push_back (c1->getEdgeJ (nr, 0, 2));
 897    // m_line.push_back (NULL);
 898    Hex::Shape* gstart = NULL;
 899    Hex::Shapes gline;
 900    double pstart = 0 , pend = 0;
 901
 902    int ier = doc-> associateOpenedLine (m_start, m_line,
 903                                         gstart,  pstart, gline, pend);
 904    HexDisplay (ier);
 905    doc->saveVtk ("asso_line.vtk");
 906
 907   m_line.push_back (c1->getEdgeJ (nr, 0, 0));
 908    Hex::Vertex* m_first = m_start->getVertex (Hex::V_AMONT);
 909    ier = doc-> associateClosedLine (m_first, m_start, m_line,
 910                                         gstart, pstart, false, gline);
 911    HexDisplay (ier);
 912    // doc->dump ();
 913
 914    return HOK;
 915 }
 916 // ===================================================== test_cylindrical
 917 int test_cylindrical (int nbargs, cpchar tabargs[])
 918 {
 919    cpchar fic_vtk = "cylindre";
 920
 921    Hex::Hex mon_ex;
 922    Hex::Document* doc = mon_ex.addDocument ();
 923
 924    Hex::Vertex* orig = doc->addVertex (0, 0, 0);
 925    Hex::Vector* vx   = doc->addVector (1, 0, 0);
 926    Hex::Vector* vz   = doc->addVector (0, 0, 1);
 927
 928    double dr = 1;
 929    double da = 360;
 930    double dl = 1;
 931
 932    int nr = 1;
 933    int na = 8;
 934    int nl = 2;
 935
 936    if (nbargs>1)
 937       {
 938       na = atoi (tabargs[1]);
 939       HexDisplay (na);
 940       if (na <= 2)
 941           na = 8;
 942       }
 943
 944    if (nbargs>2)
 945       {
 946       da = atof (tabargs[2]);
 947       HexDisplay (da);
 948       }
 949
 950    // Hex::Cylinder* cyl  = doc->addCylinder   (orig, vz, nr, nl);
 951    // Hex::Elements* grid = doc->makeCylinder (cyl, vx, nr, na, nl);
 952    doc->makeCylindrical (orig,vx, vz, dr,da,dl, nr,na, nl, true);
 953    doc ->saveVtk (fic_vtk, na);
 954    return HOK;
 955 }
 956 // ===================================================== test_cylinder
 957 int test_cylinder (int nbargs, cpchar tabargs[])
 958 {
 959    int    nvtk    = 1;
 960    cpchar fic_vtk = "cylindre";
 961
 962    Hex::Hex mon_ex;
 963    Hex::Document* doc = mon_ex.addDocument ();
 964
 965    Hex::Vertex* orig = doc->addVertex (0, 0, 0);
 966    Hex::Vector* vx   = doc->addVector (1, 0, 0);
 967    Hex::Vector* vz   = doc->addVector (0, 0, 1);
 968
 969    double rayon   = 10;
 970    double hauteur = 6;
 971
 972    int nr = 2;
 973    int na = 8;
 974    int nl = 5;
 975
 976    Hex::Cylinder* cyl  = doc->addCylinder   (orig, vz, rayon, hauteur);
 977    doc->makeCylinder (cyl, vx, nr, na, nl);
 978    doc ->saveVtk (fic_vtk, nvtk);
 979    return HOK;
 980 }
 981 // ===================================================== test_xml_cylinder
 982 int test_xml_cylinder (int nbargs, cpchar tabargs[])
 983 {
 984    int    nvtk    = 0;
 985    cpchar fic_vtk = "cylindre";
 986
 987    Hex::Hex mon_ex;
 988    Hex::Document* doc = mon_ex.addDocument ();
 989
 990    Hex::Vertex* orig1 = doc->addVertex (0, 0,0);
 991    Hex::Vertex* orig2 = doc->addVertex (50,0,0);
 992    Hex::Vector* vz    = doc->addVector (0,0,1);
 993    Hex::Vector* vx    = doc->addVector (1,0,0);
 994
 995    vx->setName ("vx");
 996    vz->setName ("vz");
 997    orig1->setName ("orig1");
 998    orig2->setName ("orig2");
 999
1000    int nr  = 4;
1001    int nri = 3;
1002    int nre = nr;
1003    int na = 9;
1004    int nl = 5;
1005
1006    Hex::Cylinder* cyl  = doc->addCylinder   (orig1, vz, nr, nl);
1007    Hex::Pipe*     pipe = doc->addPipe       (orig2, vz, nri, nre, nl);
1008
1009    Hex::Elements* grid = doc->makeCylinder (cyl,  vx, nr, na, nl);
1010    doc ->saveVtk (fic_vtk, nvtk);
1011
1012    Hex::Group* groupe = doc->addGroup ("GroupeAMA", Hex::HexaCell);
1013    groupe->addElement (grid->getHexaIJK (0,0,0));
1014    groupe->addElement (grid->getHexaIJK (1,0,0));
1015    groupe->addElement (grid->getHexaIJK (0,1,0));
1016    groupe->addElement (grid->getHexaIJK (1,1,0));
1017    groupe->addElement (grid->getHexaIJK (2,1,0));
1018
1019    grid->getHexaIJK  (0,0,0)->setName ("Hexa0");
1020    grid->getQuadIJ   (0,0,0)->setName ("QuadIJ0");
1021    grid->getEdgeK    (0,0,0)->setName ("EdgeK0");
1022
1023    doc->makePipe     (pipe, vx, nr, na, nl);
1024    doc ->saveVtk (fic_vtk, nvtk);
1025    doc->save ("cylindre");
1026
1027    return HOK;
1028 }
1029 // ===================================================== test_pipe
1030 int test_pipe (int nbargs, cpchar tabargs[])
1031 {
1032    int    nvtk    = 0;
1033    cpchar fic_vtk = "cylindre";
1034
1035    Hex::Hex mon_ex;
1036    Hex::Document* doc = mon_ex.addDocument ();
1037
1038    Hex::Vertex* orig1 = doc->addVertex (0, 0,0);
1039    Hex::Vector* vx    = doc->addVector (1,0,0);
1040    Hex::Vector* vy    = doc->addVector (0,1,0);
1041
1042    int nr  = 1;
1043    int nri = 1;
1044    int nre = 2;
1045    int na = 2;
1046    int nl = 1;
1047
1048    Hex::Pipe*  pipe = doc->addPipe  (orig1, vx, nri, nre, nl);
1049    doc->makePipe     (pipe, vy, nr, na, nl);
1050    doc ->saveVtk (fic_vtk, nvtk);
1051
1052    return HOK;
1053 }
1054 // ======================================================== del_hexa
1055 void del_hexa (Hex::CrossElements* gr, int cyl, int ni, int nj, int nk, int dr)
1056 {
1057    Hex::Hexa* hexa = gr->getHexaIJK (cyl, ni, nj, nk);
1058    if (hexa!=NULL)
1059       {
1060       hexa->remove ();
1061       if (dr>1)
1062           save_vtk ();
1063       }
1064 }
1065 // ======================================================== del_tranche
1066 int del_tranche (Hex::CrossElements* grid, int cyl, int ni, int nk, int dr=1)
1067 {
1068    for (int nj = 0 ; nj < 8 ; nj++)
1069         del_hexa (grid, cyl, ni, nj, nk, dr);
1070
1071    if (dr==1)
1072       save_vtk ();
1073    printf ("del_tranche (g=%d, i=%d, k=%d) : fic = %d\n",
1074                          cyl, ni, nk, nbr_vtk-1);
1075    return nbr_vtk;
1076 }
1077 // ======================================================== test_joint2
1078 int test_joint2 (int nbargs, cpchar tabargs[])
1079 {
1080    Hex::Hex mon_ex;
1081    docu = mon_ex.addDocument ();
1082    case_name = "pb_joint";
1083
1084    Hex::Vector* vx    = docu->addVector (1, 0, 0);
1085    Hex::Vector* vz    = docu->addVector (0, 0, 1);
1086    Hex::Vertex* hori  = docu->addVertex (0, 0, 0);
1087
1088    double da = 360;
1089    double dr = 2;
1090    double dl = 1;
1091    int    nr = 1;
1092    int    na = 8;
1093    int    nl = 1;
1094    bool   fill = true;
1095
1096    Hex::Elements *bgrid=NULL, *hgrid=NULL;
1097
1098    hgrid = docu->makeCylindrical (hori, vx,vz, dr,da,dl, nr,na,nl, fill);
1099    docu->dump ();
1100    save_vtk ();
1101
1102    Hex::Vertex* bori  = docu->addVertex (0, 0, -5);
1103    bgrid = docu->makeCylindrical (bori, vx,vz, dr,da,dl, nr,na,nl, fill);
1104    save_vtk ();
1105
1106    Hex::Quads qsource, qdest;
1107    printf (" Source = ");
1108    for (int ny=0 ; ny< na ; ny++)
1109        {
1110        Hex::Quad* quad = hgrid->getQuadIJ (0, ny, 0);
1111        PrintName (quad);
1112        qsource.push_back (quad);
1113        }
1114    printf ("\n          ");
1115    for (int ny=0 ; ny<4 ; ny++)
1116        {
1117        Hex::Quad* quad = hgrid->getKerHQuad (ny);
1118        PrintName (quad);
1119        qsource.push_back (quad);
1120        }
1121    printf ("\n");
1122
1123
1124    printf (" Cible  = ");
1125    for (int ny=0 ; ny< na ; ny++)
1126        {
1127        Hex::Quad* quad = bgrid->getQuadIJ (0, ny, 1);
1128        PrintName (quad);
1129        qdest.push_back (quad);
1130        }
1131    printf ("\n          ");
1132    for (int ny=0 ; ny<4 ; ny++)
1133        {
1134        Hex::Quad* quad = bgrid->getKerHQuad (ny+4);
1135        PrintName (quad);
1136        qdest.push_back (quad);
1137        }
1138    printf ("\n");
1139    docu ->setLevel (1);
1140    Hex::Quad*   cible = bgrid->getQuadIJ    (0, 1, 1);
1141    Hex::Vertex* vc1   = bgrid->getVertexIJK (0, 1, 1);
1142    Hex::Vertex* vc2   = bgrid->getVertexIJK (1, 1, 1);
1143
1144    Hex::Vertex* vs1 = hgrid->getVertexIJK (0, 0, 0);
1145    Hex::Vertex* vs2 = hgrid->getVertexIJK (1, 0, 0);
1146
1147    docu->joinQuads (qsource, cible, vs1, vc1, vs2, vc2, 1);
1148    save_vtk ();
1149
1150    return HOK;
1151 }
1152 // ======================================================== test_croix
1153 int test_croix (int nbargs, cpchar tabargs[])
1154 {
1155    Hex::Hex mon_ex;
1156    docu = mon_ex.addDocument ();
1157
1158    Hex::Vertex* ori1 = docu->addVertex ( 100,0,0);
1159    Hex::Vertex* ori2 = docu->addVertex (-5,0,5);
1160    Hex::Vector* vz   = docu->addVector ( 0,0,1);
1161    Hex::Vector* vx   = docu->addVector ( 1,0,0);
1162
1163    double r1 = 2;
1164    double r2 = 3;
1165    double l1 = 5;
1166    double l2 = 10;
1167
1168    Hex::Cylinder*      cyl1 = docu->addCylinder (ori1, vz, r1, l1);
1169    Hex::Cylinder*      cyl2 = docu->addCylinder (ori2, vx, r2, l2);
1170    Hex::CrossElements* grid = docu->makeCylinders (cyl1, cyl2);
1171
1172    case_name = "croix";
1173    save_vtk ();
1174    PutData ((BadElement (grid)));
1175
1176
1177    Hex::Edge* pipo = docu->addEdge (ori1, ori1);
1178    PutData (pipo->isValid());
1179    PutData ((BadElement (pipo)));
1180    return HOK;
1181
1182    del_tranche (grid, 0, 1, 0);
1183    del_tranche (grid, 0, 1, 5);
1184
1185    del_tranche (grid, 1, 1, 0);
1186    del_tranche (grid, 1, 1, 3);
1187
1188    del_tranche (grid, 1, 0, 0);
1189    del_tranche (grid, 1, 0, 3);
1190                                   // Le trognon
1191    del_tranche (grid, 0, 0, 0);
1192    del_tranche (grid, 0, 0, 5);
1193    del_tranche (grid, 0, 0, 1);
1194    del_tranche (grid, 0, 0, 2);
1195    del_tranche (grid, 0, 0, 3);
1196    del_tranche (grid, 0, 0, 4);
1197                                   // Partie critique
1198
1199    del_tranche (grid, 1, 1, 1, 2);
1200
1201    del_tranche (grid, 0, 1, 1, 2);
1202    del_tranche (grid, 0, 1, 4, 2);
1203    del_tranche (grid, 0, 1, 3, 2);
1204    del_tranche (grid, 0, 1, 2, 2);
1205
1206    del_tranche (grid, 1, 1, 2, 2);
1207    return HOK;
1208 }
1209 // ======================================================== test_pipes
1210 int test_pipes (int nbargs, cpchar tabargs[])
1211 {
1212    Hex::Hex mon_ex;
1213    Hex::Document* doc = mon_ex.addDocument ();
1214
1215    Hex::Vertex* ori1 = doc->addVertex ( 0,0,0);
1216    Hex::Vertex* ori2 = doc->addVertex (-5,0,5);
1217    Hex::Vector* vz   = doc->addVector ( 0,0,1);
1218    Hex::Vector* vx   = doc->addVector ( 1,0,0);
1219
1220 // double h1  =  5, ri1 = 1, re1 = 2;
1221    double h1  = 10, ri1 = 1, re1 = 2;
1222    double h2  = 10, ri2 = 2, re2 = 3;
1223
1224    Hex::Pipe* pipe1  = doc->addPipe (ori1, vz, ri1, re1, h1);
1225    Hex::Pipe* pipe2  = doc->addPipe (ori2, vx, ri2, re2, h2);
1226    Hex::CrossElements* grid = doc->makePipes (pipe1, pipe2);
1227
1228    case_name = "pipe";
1229    docu      = doc;
1230    save_vtk ();
1231
1232    del_tranche (grid, 0, 1, 0);
1233    del_tranche (grid, 0, 1, 5);
1234
1235    del_tranche (grid, 1, 1, 0);
1236    del_tranche (grid, 1, 1, 3);
1237                                   // Partie critique
1238
1239    del_tranche (grid, 1, 1, 1, 2);
1240
1241    del_tranche (grid, 0, 1, 1, 2);
1242    del_tranche (grid, 0, 1, 4, 2);
1243    del_tranche (grid, 0, 1, 3, 2);
1244    del_tranche (grid, 0, 1, 2, 2);
1245
1246    del_tranche (grid, 1, 1, 2, 2);
1247    /* ***************************************************
1248
1249    int nbz [2] =  { 8, 4 };
1250    int ni = 1;
1251    for (int cyl = 0 ; cyl < 2 ; cyl++)
1252        for (int nk = 0 ; nk < nbz[cyl] ; nk++)
1253        for (int nj = 0 ; nj < 4 ; nj++)
1254            {
1255            int jj = nj;
1256            if (cyl==0) jj = (jj+6) MODULO 8 ;
1257            Hex::Hexa* hexa = grid->getHexaIJK (cyl, ni, jj, nk);
1258            if (hexa!=NULL)
1259               {
1260               hexa->remove ();
1261               doc->saveVtk (case_name,  nbr_vtk);
1262               }
1263            }
1264       *************************************************** */
1265    return HOK;
1266 }
1267 // ======================================================== test_lorraine
1268 int test_lorraine(int nbargs, cpchar tabargs[])
1269 {
1270    Hex::Hex mon_ex;
1271    Hex::Document* doc = mon_ex.addDocument ();
1272
1273    Hex::Vertex* ori1 = doc->addVertex ( 0,0,0);
1274    Hex::Vertex* ori2 = doc->addVertex (-5,0,5);
1275    Hex::Vertex* ori3 = doc->addVertex ( 0,0,12);
1276    Hex::Vertex* ori4 = doc->addVertex (-5,0,17);
1277
1278    Hex::Vector* vz   = doc->addVector ( 0,0,1);
1279    Hex::Vector* vx   = doc->addVector ( 1,0,0);
1280
1281    int nl1 = 10;
1282    int nl2 = 10;
1283
1284    double rsmall = 1;
1285    double rmoy   = 2;
1286    double rbig   = 3;
1287
1288    Hex::Cylinder* cyl1  = doc->addCylinder (ori1, vz, rmoy,   nl1);
1289    Hex::Cylinder* cyl2  = doc->addCylinder (ori2, vx, rsmall, nl2);
1290
1291    Hex::Cylinder* cyl3  = doc->addCylinder (ori3, vz, rmoy, nl1);
1292    Hex::Cylinder* cyl4  = doc->addCylinder (ori4, vx, rbig, nl2);
1293
1294    Hex::CrossElements* grid1 = doc->makeCylinders (cyl1, cyl2);
1295    Hex::CrossElements* grid2 = doc->makeCylinders (cyl4, cyl3);
1296
1297 #define Imprimer(x) printf (#x " = ") ; if (x) x->dump() ; else printf ("NULL\n")
1298    const int nx_int = 0;
1299    const int nx_ext = 1;
1300
1301    //           vc2 = grid1->getVertexIJK (Hex::CylBig, 0,0,0);
1302    //           vc3 = grid2->getVertexIJK (Hex::CylSmall, 0,0,0);
1303                                      //    Cyl     i     j     k
1304    Hex::Quad* qb = grid1-> getQuadIJ (Hex::CylBig, nx_ext, Hex::S_E, 4);
1305    Hex::Quad* qh = grid2-> getQuadIJ (Hex::CylSmall, nx_ext, Hex::S_N, 0);
1306
1307    Hex::Vertex* vb0 = qb->getVertex (3);
1308    Hex::Vertex* vb1 = qb->getVertex (2);
1309    Hex::Vertex* vh0 = qh->getVertex (0);
1310    Hex::Vertex* vh1 = qh->getVertex (1);
1311
1312    vb0 = grid1->getVertexIJK (Hex::CylBig, 2, Hex::S_E,  4);  // cible
1313    vb1 = grid1->getVertexIJK (Hex::CylBig, 2, Hex::S_NE, 4);
1314    vh0 = grid2->getVertexIJK (Hex::CylSmall, 2, Hex::S_N,  0);   // depart
1315    vh1 = grid2->getVertexIJK (Hex::CylSmall, 2, Hex::S_NW, 0);
1316
1317    Imprimer (vh0);
1318    Imprimer (vh1);
1319    Imprimer (vb0);
1320    Imprimer (vb1);
1321
1322    // qb->remove ();
1323    // qh->remove ();
1324    Hex::Quads hliste;
1325
1326    hliste.push_back (qh);
1327    for (int ny=1; ny<Hex::S_MAXI; ny++)
1328        {
1329        int ns = (ny + Hex::S_N) MODULO Hex::S_MAXI;
1330        hliste.push_back (grid2->getQuadIJ (Hex::CylSmall, nx_ext, ns, 0));
1331        }
1332
1333    for (int ny=0; ny<4 ;  ny++)
1334        hliste.push_back (grid2->getQuadIJ (Hex::CylSmall, nx_int, ny, 0));
1335
1336    int hauteur = 3;
1337    doc->joinQuads  (hliste, qb, vh0, vb0, vh1, vb1, hauteur);
1338    doc->saveVtk ("lorraine.vtk");
1339
1340    // doc->dump ();
1341    return HOK;
1342 }
1343 // ======================================================== test_disconnect2
1344 // === Disconnect Edge seul
1345 int test_disconnect2 (int nbargs, cpchar tabargs[])
1346 {
1347    const int size_x = 2;
1348    const int size_y = 2;
1349    const int size_z = 1;
1350
1351    Hex::Hex mon_ex;
1352    Hex::Document* doc = mon_ex.addDocument ();
1353
1354    Hex::Vertex*   orig2 = doc->addVertex (0,0,0);
1355    Hex::Vector*   dir   = doc->addVector (1,1,1);
1356    Hex::Elements* grid2 = doc->makeCartesian (orig2, dir, size_x,size_y,size_z);
1357
1358    doc->dump ();
1359
1360    int nvtk = 0;
1361    doc->setLevel (1);
1362    Hex::Matrix  matrice;
1363    Hex::Vector* ecart  = doc->addVector (0.5,0.5,0);
1364    matrice.defTranslation (ecart);
1365
1366    Hex::Hexa* hexa2 = grid2->getHexaIJK (1,1,0);
1367    Hex::Edge* edge  = grid2->getEdgeK   (1,2,0);
1368
1369    hexa2->setScalar  (2);
1370    edge->setScalar   (5);
1371
1372    doc->saveVtk ("test_disco", nvtk);
1373
1374    doc->setLevel (4);
1375
1376    Hex::Elements* disco_edges =  doc->disconnectEdge (hexa2, edge);
1377    HexDisplay (disco_edges->countVertex());
1378    HexDisplay (disco_edges->countEdge());
1379    HexDisplay (disco_edges->countQuad());
1380    HexDisplay (disco_edges->countHexa());
1381
1382    // hexa2->transform (&matrice);
1383  /**********************************
1384    for (int ns=0; ns<disco_edges->countVertex(); ns++)
1385        {
1386        Hex::Vertex* sommet = disco_edges->getVertex(ns);
1387        sommet->setX (sommet->getX()+0.5);
1388        sommet->setY (sommet->getY()+0.5);
1389        }
1390    ********************************* */
1391
1392    doc->saveVtk ("test_disco", nvtk);
1393    doc->save ("test_disco");
1394    doc->dump ();
1395    hexa2->dumpFull ();
1396
1397    doc->setLevel (4);
1398    return HOK;
1399 }
1400 // ======================================================== test_disconnect4
1401 // === Disconnect Edges
1402 int test_disconnect4 (int nbargs, cpchar tabargs[])
1403 {
1404    const int size_x = 1;
1405    const int size_y = 2;
1406    const int size_z = 2;
1407
1408    Hex::Hex mon_ex;
1409    Hex::Document* doc = mon_ex.addDocument ();
1410
1411    Hex::Vertex*   orig2 = doc->addVertex (0,0,0);
1412    Hex::Vector*   vx    = doc->addVector (1,0,0);
1413    Hex::Vector*   vy    = doc->addVector (0,1,0);
1414    Hex::Vector*   vz    = doc->addVector (0,0,1);
1415    Hex::Elements* grid2 = doc->makeCartesian (orig2, vx,vy,vz, size_x,size_y,size_z);
1416
1417    int nvtk = 0;
1418    doc->setLevel (1);
1419
1420    Hex::Hexas t_hexas;
1421    Hex::Edges t_edges;
1422    for (int nk=0 ; nk< size_z; nk++)
1423        {
1424        Hex::Hexa* hexa2 = grid2->getHexaIJK (0,0,nk);
1425        Hex::Edge* edge  = grid2->getEdgeK   (0,1,nk);
1426
1427        hexa2->setScalar  (2);
1428        edge->setScalar   (5);
1429        t_hexas.push_back (hexa2);
1430        t_edges.push_back (edge);
1431
1432        doc->setLevel (4);
1433        }
1434
1435    doc->dump ();
1436    doc->saveVtk ("test_disco", nvtk);
1437    /* Hex::Elements* disco_edges = */  doc->disconnectEdges (t_hexas, t_edges);
1438    doc->saveVtk ("test_disco", nvtk);
1439    doc->dump ();
1440    // hexa2->dumpFull ();
1441
1442    doc->setLevel (4);
1443    return HOK;
1444 }
1445 // ======================================================== test_disconnect
1446 // ==== Disconnect Quad
1447 int test_disconnect1 (int nbargs, cpchar tabargs[])
1448 {
1449    const int size_x = 2;
1450    const int size_y = 2;
1451    const int size_z = 1;
1452
1453    Hex::Hex mon_ex;
1454    Hex::Document* doc = mon_ex.addDocument ();
1455
1456    Hex::Vertex*   orig1 = doc->addVertex (0,0,0);
1457    Hex::Vector*   dir   = doc->addVector (1,1,1);
1458    Hex::Elements* grid1 = doc->makeCartesian (orig1, dir, size_x,size_y,size_z);
1459
1460    int nvtk = 0;
1461    doc->setLevel (1);
1462    Hex::Matrix  matrice;
1463    Hex::Vector* ecart  = doc->addVector (0.5,0.5,0);
1464    matrice.defTranslation (ecart);
1465
1466    Hex::Hexa* hexa1 = grid1->getHexaIJK (1,1,0);
1467    Hex::Quad* quad  = grid1->getQuadJK  (1,1,0);
1468
1469    quad->setScalar   (5);
1470
1471    doc->saveVtk ("test_disco", nvtk);
1472    doc->disconnectQuad (hexa1, quad);
1473    // hexa1 ->transform (&matrice);
1474    doc->saveVtk ("test_disco", nvtk);
1475
1476    // doc->dumpPropagation ();
1477    // doc->dump  ();
1478
1479    doc->save  ("disco_all");
1480    return HOK;
1481 }
1482 // ======================================================== test_disconnect3
1483 // ==== disconnectVertex
1484 int test_disconnect3 (int nbargs, cpchar tabargs[])
1485 {
1486    const int size_x = 2;
1487    const int size_y = 2;
1488    const int size_z = 1;
1489
1490    Hex::Hex mon_ex;
1491    Hex::Document* doc = mon_ex.addDocument ();
1492
1493    Hex::Vertex*   orig1 = doc->addVertex (0,0,0);
1494
1495    Hex::Vector*   dir   = doc->addVector (1,1,1);
1496    Hex::Elements* grid1 = doc->makeCartesian (orig1, dir, size_x,size_y,size_z);
1497
1498    int nvtk = 0;
1499    doc->setLevel (1);
1500    Hex::Matrix  matrice;
1501    Hex::Vector* ecart  = doc->addVector (0.5,0.5,0);
1502    matrice.defTranslation (ecart);
1503
1504    Hex::Hexa* hexa1 = grid1->getHexaIJK (1,1,0);
1505    Hex::Vertex* vertex = grid1->getVertexIJK (1,1,1);
1506
1507    vertex->setScalar (5);
1508
1509    doc->saveVtk ("test_disco", nvtk);
1510
1511    doc->disconnectVertex (hexa1, vertex);
1512    // hexa1->transform (&matrice);
1513    doc->saveVtk ("test_disco", nvtk);
1514
1515    // doc->dumpPropagation ();
1516    // doc->dump  ();
1517
1518    doc->save  ("disco_all");
1519    return HOK;
1520 }
1521 // ======================================================== contraction
1522 void contraction (Hex::Hexa* hexa, Hex::Elements* grid)
1523 {
1524    return;
1525    Hex::Real3 cg = { 0, 0, 0 };
1526
1527    for (int nro=0; nro<Hex::HV_MAXI ; nro++)
1528        {
1529        cg [0] += hexa->getVertex(nro)->getX()/Hex::HV_MAXI;
1530        cg [1] += hexa->getVertex(nro)->getY()/Hex::HV_MAXI;
1531        cg [2] += hexa->getVertex(nro)->getZ()/Hex::HV_MAXI;
1532        }
1533
1534    int nbvertex = grid->countVertex();
1535    const double coeff = 0.5;
1536    for (int nro=0; nro<nbvertex ; nro++)
1537        {
1538        Hex::Vertex* pv = grid->getVertex(nro);
1539        Hex::Real3 pold = { pv->getX(), pv->getY(), pv->getZ() };
1540        Hex::Real3 pnew;
1541        for (int dd=0; dd<3 ; dd++)
1542            pnew [dd] = cg[dd] + coeff * (pold[dd]-cg[dd]);
1543
1544        pv->setX (pnew[0]);
1545        pv->setY (pnew[1]);
1546        pv->setZ (pnew[2]);
1547        }
1548 }
1549 // ======================================================== test_disconnect
1550 // ==== Les 3 disconnect
1551 int test_disconnect (int nbargs, cpchar tabargs[])
1552 {
1553    const int size_x = 2;
1554    const int size_y = 2;
1555    const int size_z = 1;
1556
1557    Hex::Hex mon_ex;
1558    Hex::Document* doc = mon_ex.addDocument ();
1559
1560    Hex::Vertex*   orig1 = doc->addVertex (0,0,0);
1561    Hex::Vertex*   orig2 = doc->addVertex (4,0,0);
1562    Hex::Vertex*   orig3 = doc->addVertex (8,0,0);
1563
1564    Hex::Vector*   dir   = doc->addVector (1,1,1);
1565    Hex::Elements* grid1 = doc->makeCartesian (orig1, dir, size_x,size_y,size_z);
1566    Hex::Elements* grid2 = doc->makeCartesian (orig2, dir, size_x,size_y,size_z);
1567    Hex::Elements* grid3 = doc->makeCartesian (orig3, dir, size_x,size_y,size_z);
1568
1569    int nvtk = 0;
1570    doc->setLevel (1);
1571    Hex::Matrix  matrice;
1572    Hex::Vector* ecart  = doc->addVector (0.5,0.5,0);
1573    matrice.defTranslation (ecart);
1574
1575    Hex::Hexa* hexa1 = grid1->getHexaIJK (1,1,0);
1576    Hex::Hexa* hexa2 = grid2->getHexaIJK (1,1,0);
1577    Hex::Hexa* hexa3 = grid3->getHexaIJK (1,1,0);
1578
1579    Hex::Quad* quad  = grid1->getQuadJK  (1,1,0);
1580    Hex::Edge* edge  = grid2->getEdgeK   (1,2,0);
1581    Hex::Vertex* vertex = grid3->getVertexIJK (1,1,1);
1582
1583    quad->setScalar   (5);
1584    edge->setScalar   (5);
1585    vertex->setScalar (5);
1586
1587    doc->saveVtk ("test_disco", nvtk);
1588    doc->disconnectQuad (hexa1, quad);
1589    doc->saveVtk ("test_disco", nvtk);
1590
1591    doc->disconnectEdge (hexa2, edge);
1592    doc->saveVtk ("test_disco", nvtk);
1593
1594    doc->disconnectVertex (hexa3, vertex);
1595    doc->saveVtk ("test_disco", nvtk);
1596
1597    // doc->dumpPropagation ();
1598    // doc->dump  ();
1599
1600    doc->save  ("disco_all");
1601    return HOK;
1602 }
1603 // ======================================================== test_propagation
1604 int test_propagation ()
1605 {
1606    const int size_x = 2;
1607    const int size_y = 1;
1608    const int size_z = 1;
1609
1610    Hex::Hex mon_ex;
1611    Hex::Document* doc = mon_ex.addDocument ();
1612
1613    Hex::Vertex*   orig = doc->addVertex (0,0,0);
1614    Hex::Vector*   dir  = doc->addVector (1,1,1);
1615    //  Hex::Elements* grid =
1616    doc->makeCartesian (orig, dir, size_x,size_y,size_z);
1617
1618    int nb = doc->countPropagation ();
1619    for (int nro=0 ; nro<nb ; nro++)
1620        {
1621        Hex::Propagation*  prop  = doc ->getPropagation (nro);
1622        const Hex::Edges&  table = prop->getEdges ();
1623        printf (" ____________________________________ Prop nro %d\n", nro);
1624        for (int ned=0 ; ned<(int)table.size() ; ned++)
1625            {
1626            bool way = table [ned]->getWay ();
1627
1628            if (way)
1629               {
1630               printf ("     (");
1631               table [ned]->getVertex (0)->printName (", ");
1632               table [ned]->getVertex (1)->printName (")\n");
1633               }
1634           else
1635               {
1636               printf ("     (");
1637               table [ned]->getVertex (1)->printName (", ");
1638               table [ned]->getVertex (0)->printName (")\n");
1639               }
1640            }
1641        }
1642
1643    doc->dump  ();
1644    doc->saveVtk ("test_propagation.vtk");
1645    doc->save ("test_propagation");
1646
1647    return HOK;
1648 }
1649 // ======================================================== test_move
1650 int test_move ()
1651 {
1652    const int size_x = 1;
1653    const int size_y = 1;
1654    const int size_z = 2;
1655
1656    Hex::Hex mon_ex;
1657    Hex::Document* doc = mon_ex.addDocument ();
1658
1659    Hex::Vertex* orig = doc->addVertex (0,0,0);
1660    Hex::Vector* dir  = doc->addVector (1,1,1);
1661    Hex::Elements*  grid = doc->makeCartesian (orig, dir, size_x,size_y,size_z);
1662
1663    Hex::Vector*   enhaut  = doc->addVector (0, 0, 5);
1664    Hex::Vector*   devant  = doc->addVector (5, 0, 0);
1665    // Hex::Vector*   agauche = doc->addVector (0, 5, 0);
1666
1667    Hex::Matrix matrice;
1668    matrice.defTranslation (enhaut);
1669
1670    Hex::Hexa* cube    = grid->getHexa (1);
1671    Hex::Quad* dessous = cube->getQuad (Hex::Q_A);
1672    dessous->dump();
1673
1674    Hex::Elements* grid2 = doc->makeTranslation (grid, devant);
1675    /* Hex::Elements* grid3 = doc->makeTranslation (grid, agauche); */
1676    Hex::Hexa* cube2     = grid2->getHexa (1);
1677
1678    doc ->saveVtk ("move0.vtk");
1679
1680    cube ->disconnectQuad (dessous);
1681    cube ->transform (&matrice);
1682    cube2->transform (&matrice);
1683
1684    doc ->saveVtk ("move1.vtk");
1685    doc ->dump();
1686
1687    return HOK;
1688 }
1689 // ======================================================== test_transfo2
1690 int test_transfo2 (int nbargs, cpchar tabargs[])
1691 {
1692    const int size_x = 1;
1693    const int size_y = 1;
1694    const int size_z = 2;
1695
1696    int    nvtk    = 0;
1697    cpchar fic_vtk = "transfo";
1698
1699    Hex::Hex mon_ex;
1700    Hex::Document* doc = mon_ex.addDocument ();
1701    doc ->setLevel (1);
1702
1703    Hex::Vertex* orig = doc->addVertex (0,0,0);
1704    Hex::Vector* dir  = doc->addVector (1,1,1);
1705    Hex::Elements* grid = doc->makeCartesian (orig, dir, size_x, size_y,
1706                                                         size_z);
1707    if (grid==NULL)
1708       return HERR;
1709
1710    orig->setScalar(2);
1711
1712    doc ->saveVtk (fic_vtk, nvtk);
1713
1714    Hex::Vector*   devant  = doc->addVector (5, 0, 0);
1715
1716    Hex::Elements* grid2 = doc->makeTranslation (grid, devant);
1717    if (grid2==NULL)
1718       return HERR;
1719    doc ->saveVtk (fic_vtk, nvtk);
1720
1721    Hex::Elements* grid3  = doc->makeScale (grid2, orig, 2);
1722    if (grid3==NULL)
1723       return HERR;
1724    doc ->saveVtk (fic_vtk, nvtk);
1725
1726    Hex::Elements* grid4 = doc->makeRotation (grid2, orig, dir, 45);
1727    if (grid4==NULL)
1728       return HERR;
1729    doc ->saveVtk (fic_vtk, nvtk);
1730
1731    Hex::Elements* grid5 = doc->makeSymmetryPoint (grid4, orig);
1732    if (grid5==NULL)
1733       return HERR;
1734
1735    doc ->saveVtk (fic_vtk, nvtk);
1736
1737    Hex::Vector* dir1  = doc->addVector (1,0,0);
1738    Hex::Elements* grid6 = doc->makeSymmetryLine (grid4, orig, dir1);
1739    if (grid6==NULL)
1740       return HERR;
1741
1742    grid4->getHexa(0)->getVertex(0)->setScalar(3);
1743    grid6->getHexa(0)->getVertex(0)->setScalar(3);
1744    doc ->saveVtk (fic_vtk, nvtk);
1745
1746    grid4->getHexa(0)->getVertex(0)->setScalar(0);
1747    grid6->getHexa(0)->getVertex(0)->setScalar(0);
1748
1749    Hex::Elements* grid7 = doc->makeSymmetryLine (grid2, orig, dir1);
1750    if (grid7==NULL)
1751       return HERR;
1752
1753    grid2->getHexa(0)->getVertex(0)->setScalar(4);
1754    grid7->getHexa(0)->getVertex(0)->setScalar(4);
1755    doc ->saveVtk (fic_vtk, nvtk);
1756
1757    grid2->getHexa(0)->getVertex(0)->setScalar(0);
1758    grid7->getHexa(0)->getVertex(0)->setScalar(0);
1759
1760    Hex::Elements* grid8 = doc->makeSymmetryPlane (grid2, orig, dir1);
1761    if (grid8==NULL)
1762       return HERR;
1763
1764    grid2->getHexa(0)->getVertex(0)->setScalar(4);
1765    grid8->getHexa(0)->getVertex(0)->setScalar(4);
1766    doc ->saveVtk (fic_vtk, nvtk);
1767    grid2->getHexa(0)->getVertex(0)->setScalar(0);
1768    grid8->getHexa(0)->getVertex(0)->setScalar(0);
1769
1770    Hex::Elements* grid9 = doc->makeSymmetryPlane (grid3, orig, dir);
1771    if (grid9==NULL)
1772       return HERR;
1773
1774    grid3->getHexa(0)->getVertex(0)->setScalar(4);
1775    grid9->getHexa(0)->getVertex(0)->setScalar(4);
1776    doc ->saveVtk (fic_vtk, nvtk);
1777
1778    grid9->getHexa(0)->removeConnected ();
1779    doc ->saveVtk (fic_vtk, nvtk);
1780
1781    return HOK;
1782 }
1783 // ======================================================== test_transfo
1784 int test_transfo (int nbargs, cpchar tabargs[])
1785 {
1786    int    nvtk    = 0;
1787    cpchar fic_vtk = "transfo";
1788
1789    Hex::Hex mon_ex;
1790    Hex::Document* doc = mon_ex.addDocument ();
1791    doc ->setLevel (1);
1792
1793    Hex::Vertex* orig = doc->addVertex (0,0,0);
1794    Hex::Vector* vx   = doc->addVector (1,0,0);
1795    Hex::Vector* vz   = doc->addVector (0,0,1);
1796    double dr = 1;
1797    double da = 360;
1798    double dl = 1;
1799    int nr = 3;
1800    int na = 8;
1801    int nl = 3;
1802    Hex::Elements* grid = doc->makeCylindrical (orig, vx,vz, dr, da, dl,
1803                                                             nr, na, nl, false);
1804    if (grid==NULL)
1805       return HERR;
1806
1807    doc ->saveVtk (fic_vtk, nvtk);
1808    Hex::Vector*   devant  = doc->addVector (10, 0, 0);
1809
1810    Hex::Elements* grid2 = doc->makeTranslation (grid, devant);
1811    if (grid2==NULL)
1812       return HERR;
1813    doc ->saveVtk (fic_vtk, nvtk);
1814
1815    return HOK;
1816 }
1817 // ======================================================== test_copy_document
1818 int test_copy_document (int nbargs, cpchar tabargs[])
1819 {
1820    Hex::Hex mon_ex;
1821    Hex::Document* doc = mon_ex.loadDocument ("Essai");
1822    doc ->saveVtk ("restore1.vtk");
1823
1824    Hex::Document* clone = doc->copyDocument();
1825    clone->saveVtk ("restore2.vtk");
1826
1827    return HOK;
1828 }
1829 // ======================================================== test_remove
1830 int test_remove ()
1831 {
1832    const int size_x = 2;
1833    const int size_y = 2;
1834    const int size_z = 2;
1835
1836    Hex::Hex mon_ex;
1837    Hex::Document* doc = mon_ex.addDocument ();
1838
1839    Hex::Vertex* orig  = doc->addVertex (0,0,0);
1840    Hex::Vertex* orig1 = doc->addVertex (6,0,0);
1841    Hex::Vector* dir   = doc->addVector (1,1,1);
1842    Hex::Elements* grid  = doc->makeCartesian (orig, dir,  size_x,size_y,size_z);
1843    doc->makeCartesian (orig1, dir, 1,1,1);
1844    doc->saveVtk ("removeConn1.vtk");
1845
1846    Echo ("--------- Avant destruction");
1847    HexDisplay (doc->countVertex ());
1848    HexDisplay (doc->countEdge ());
1849    HexDisplay (doc->countQuad ());
1850    HexDisplay (doc->countHexa ());
1851    HexDisplay (doc->countUsedVertex ());
1852    HexDisplay (doc->countUsedEdge ());
1853    HexDisplay (doc->countUsedQuad ());
1854    HexDisplay (doc->countUsedHexa ());
1855
1856
1857    doc->removeConnectedHexa (grid->getHexaIJK (0,0,0));
1858
1859    Echo ("--------- Apres destruction");
1860    HexDisplay (doc->countVertex ());
1861    HexDisplay (doc->countEdge ());
1862    HexDisplay (doc->countQuad ());
1863    HexDisplay (doc->countHexa ());
1864
1865    HexDisplay (doc->countUsedVertex ());
1866    HexDisplay (doc->countUsedEdge ());
1867    HexDisplay (doc->countUsedQuad ());
1868    HexDisplay (doc->countUsedHexa ());
1869    doc->saveVtk ("removeConn2.vtk");
1870
1871    return HOK;
1872 }
1873 // ================================================== init_vec
1874 void init_vec (Hex::RealVector& tab, double n0=0, double n1=0, double n2=0,
1875                double n3=0, double n4=0, double n5=0, double n6=0,
1876                double n7=0, double n8=0, double n9=0, double n10=0,
1877                double n11=0, double n12=0, double n13=0, double n14=0,
1878                double n15=0, double n16=0)
1879 {
1880    if (n0>0.0) tab.push_back (n0);
1881    if (n1>0.0) tab.push_back (n1);
1882    if (n2>0.0) tab.push_back (n2);
1883    if (n3>0.0) tab.push_back (n3);
1884    if (n4>0.0) tab.push_back (n4);
1885    if (n5>0.0) tab.push_back (n5);
1886    if (n6>0.0) tab.push_back (n6);
1887    if (n7>0.0) tab.push_back (n7);
1888    if (n8>0.0) tab.push_back (n8);
1889    if (n9>0.0) tab.push_back (n9);
1890
1891    if (n10>0.0) tab.push_back (n10);
1892    if (n11>0.0) tab.push_back (n11);
1893    if (n12>0.0) tab.push_back (n12);
1894    if (n13>0.0) tab.push_back (n13);
1895    if (n14>0.0) tab.push_back (n14);
1896    if (n15>0.0) tab.push_back (n15);
1897    if (n16>0.0) tab.push_back (n16);
1898 }
1899 // ================================================== test_cylindricals
1900 int test_cylindricals (int nbargs, cpchar tabargs[])
1901 {
1902    Hex::Hex mon_ex;
1903    Hex::Document* doc = mon_ex.addDocument ();
1904
1905    Hex::Vertex* orig = doc->addVertex (0, 0, 0);
1906    Hex::Vector* vz   = doc->addVector (0, 0, 1);
1907    Hex::Vector* vx   = doc->addVector (1 ,0, 0);
1908
1909    Hex::RealVector tdr, tda, tdl;
1910
1911    /******************
1912    init_vec (tdr, 2, 1, 0.5);
1913    init_vec (tda, 40, 35, 30, 25, 20, 15, 10, 5,
1914                    5, 10, 15, 20, 25, 30, 35, 40);
1915    init_vec (tdl, 1, 2, 3 );
1916
1917    init_vec (tdr, 1, 1, 1, 1);
1918    init_vec (tda, 45,45, 45,45, 45,45, 45,45 );
1919    init_vec (tdl, 1, 1, 1 );
1920
1921     ****************** */
1922
1923
1924    init_vec (tdr, 1, 2, 1, 2);
1925    init_vec (tda, 20, 20, 20 );
1926    init_vec (tdl, 1 );
1927
1928    Hex::Elements* grid=doc->makeCylindricals (orig, vx,vz, tdr,tda,tdl, false);
1929
1930    doc->saveVtk ("cylindricals.vtk");
1931    doc->dump();
1932    grid->clearAssociation();
1933    doc->clearAssociation();
1934    return HOK;
1935 }
1936 // ======================================================== test_edge
1937 int test_edge (int nbargs, cpchar tabargs[])
1938 {
1939    Hex::Hex mon_ex;
1940    Hex::Document* doc = mon_ex.addDocument ();
1941
1942    Hex::Vertex* orig = doc->addVertex (0, 0, 0);
1943    Hex::Vector* vx   = doc->addVector (1 ,0, 0);
1944    doc->addEdge   (orig, vx);
1945
1946    HexDisplay (doc->countVertex());
1947    HexDisplay (doc->countEdge());
1948    doc->dump ();
1949    return HOK;
1950 }
1951 // ======================================================== test_hexa
1952 int test_hexa (int nbargs, cpchar tabargs[])
1953 {
1954    int ier = 0;
1955    Hex::Hex mon_ex;
1956    Hex::Document* doc1 = mon_ex.loadDocument ("bielle_triang");
1957    Hex::Document* doc2 = mon_ex.loadDocument ("bielle_triang");
1958    PutData (doc1->getName ());
1959    PutData (doc2->getName ());
1960    return ier;
1961
1962
1963    goto_workspace ();
1964    ier = test_cylindricals (nbargs, tabargs);
1965    ier = test_transfo (nbargs, tabargs);
1966    free_workspace ();
1967
1968    return ier;
1969 }