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