src/HEXABLOCK/test_hexa6.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 "HexBiCylinder.hxx"
  29 // #include "HexCrossElements.hxx"
  30
  31 #include "HexHexa.hxx"
  32 // #include "HexQuad.hxx"
  33 // #include "HexEdge.hxx"
  34 // #include "HexVertex.hxx"
  35
  36 static Hex::Hex         mon_ex;
  37 static Hex::Document*   docu = NULL;
  38 static cpchar           case_name = "hexa";
  39
  40 // ======================================================== get_document
  41 Hex::Document* get_document ()
  42 {
  43    if (docu==NULL)
  44       docu = mon_ex.addDocument ();
  45
  46    return docu;
  47 }
  48
  49 // ======================================================== save_file
  50 void save_file ()
  51 {
  52    static int nbr_files = 0;
  53    char filename[20];
  54
  55    nbr_files ++;
  56    sprintf (filename, "%s%02d.vtk", case_name, nbr_files);
  57    docu->saveVtk (filename);
  58 }
  59
  60 // ======================================================== nearest
  61 Hex::Vertex* nearest (Hex::Elements* grid, Hex::Vertex* vertex)
  62 {
  63     int          nbre   = grid->countVertex();
  64     double       dmin   = 1e+6;
  65     Hex::Vertex* result = NULL;
  66     double       px = vertex->getX();
  67     double       py = vertex->getY();
  68     double       pz = vertex->getZ();
  69     for (int nro=0 ; nro < nbre ; ++nro)
  70         {
  71         Hex::Vertex* v1 = grid->getVertex (nro);
  72         double       d2 = Hex::carre(px-v1->getX()) + Hex::carre(py-v1->getY())
  73                                                     + Hex::carre(pz-v1->getZ()) ;
  74         if (d2 < dmin)
  75            {
  76            result = v1;
  77            dmin   = d2;
  78            }
  79         }
  80
  81     cout << " nearest : " << vertex->getName()
  82          << " -> "        << result->getName()
  83          << " ( " << px << ",  " << py << ",  " << pz << ") " << endl;
  84     return result;
  85 }
  86
  87 // ======================================================== eplucher
  88 void eplucher (Hex::Document* doc, Hex::Elements* grid, string& radical)
  89 {
  90    int nbfic = 0;
  91    int nbre  = grid->countHexa();
  92    for (int nro=nbre-1 ; nro >0 ; nro--)
  93        {
  94        nbfic++;
  95        char name [32];
  96        sprintf (name, "%s%02d.vtk", radical.c_str(), nbfic);
  97        grid->saveVtk (name);
  98        doc->removeHexa (grid->getHexa(nro));
  99        }
 100 }
 101 // ======================================================== test_cartesian6
 102 int test_cartesian6 (int nbargs, cpchar tabargs[])
 103 {
 104    case_name = "cartesian_top";
 105    const int size_x = 3;
 106    const int size_y = 4;
 107    const int size_z = 5;
 108
 109    Hex::Document* doc  = get_document ();
 110
 111    Hex::Elements* grid1 = doc->makeCartesianTop (size_x, size_y, size_z);
 112    grid1->saveVtk ("makeCartesianTop.vtk");
 113    PutData (grid1->isValid());
 114    return HOK;
 115
 116    Hex::Vertex*   orig2 = doc->addVertex (10, 0, 0);
 117    Hex::Vector*   vx    = doc->addVector (1, 0, 0);
 118    Hex::Vector*   vy    = doc->addVector (0, 1, 0);
 119    Hex::Vector*   vz    = doc->addVector (0, 0, 1);
 120    double dx =1, dy=1, dz=1;
 121    Hex::Elements* grid2 = doc->makeCartesianUni (orig2, vx, vy, vz, dx, dy, dz,
 122                                                         size_x, size_y, size_z);
 123    grid2->saveVtk ("makeCartesianUni.vtk");
 124    PutData (grid2->isValid());
 125
 126    Hex::Vertex*   orig3 = doc->addVertex (20, 0, 0);
 127    Hex::RealVector tx, ty, tz;
 128    for (int nro=1 ; nro<6 ; nro++)
 129        {
 130        tx.push_back (nro);
 131        ty.push_back (nro);
 132        tz.push_back (nro);
 133        }
 134
 135    tz.push_back (1);
 136    Hex::Elements* grid3 = doc->makeCartesian (orig3, vx, vy, vz, tx, ty, tz);
 137    grid3->saveVtk ("makeCartesian.vtk");
 138    PutData (grid3->isValid());
 139
 140    // doc->dump ();
 141    return HOK;
 142 }
 143 // ======================================================== test_cylinder60
 144 int test_cylinder60 (int nbargs, cpchar tabargs[])
 145 {
 146    case_name = "cylinders";
 147    const int size_x = 1;
 148    const int size_y = 4;
 149    const int size_z = 1;
 150
 151    Hex::Document* doc = get_document ();
 152    Hex::Vertex*  orig = doc->addVertex (0, 0, 0);
 153    Hex::Vector*  vx   = doc->addVector (1, 0, 0);
 154    Hex::Vector*  vz   = doc->addVector (0, 0, 1);
 155    double rint =1, rext = 3, angle = 360, hauteur = 2;
 156    Hex::Elements* grid3 = doc->makePipeUni (orig, vx, vz,
 157                                                 rint, rext, angle, hauteur,
 158                                                 size_x, size_y, size_z);
 159    grid3->saveVtk ("makeCylinderUni.vtk");
 160    PutData (grid3->isValid());
 161    if (NOT (grid3->isValid()))
 162        Hex::what ();
 163
 164    doc->dump ();
 165    return HOK;
 166 }
 167 // ======================================================== test_cylinder_top
 168 int test_cylinder_top (int nbargs, cpchar tabargs[])
 169 {
 170    case_name = "cylinders";
 171    const int size_x = 1;
 172    const int size_y = 3;
 173    const int size_z = 1;
 174
 175    Hex::Document* doc   = get_document ();
 176    Hex::Elements* grid1 = doc->makeCylinderTop (size_x, size_y, size_z);
 177
 178    grid1->saveVtk ("makeCylinderTop.vtk");
 179    PutData (grid1->isValid());
 180    return HOK;
 181 }
 182 // ======================================================== test_cylinder6
 183 int test_cylinder6 (int nbargs, cpchar tabargs[])
 184 {
 185    case_name = "cylinders";
 186    const int size_x = 3;
 187    const int size_y = 8;
 188    const int size_z = 2;
 189
 190    Hex::Document* doc   = get_document ();
 191
 192    /********************
 193    Hex::Elements* grid1 = doc->makeCylinderTop (size_x, size_y, size_z);
 194    grid1->saveVtk ("makeCylinderTop.vtk");
 195    PutData (grid1->isValid());
 196
 197
 198    Hex::Elements* grid2 = doc->makePipeTop (size_x, size_y, size_z);
 199    grid2->saveVtk ("makePipeTop.vtk");
 200    PutData (grid2->isValid());
 201    ******************************/
 202
 203    Hex::Vertex*  orig2 = doc->addVertex (0, 0, 5);
 204    Hex::Vector*  vx    = doc->addVector (1, 0, 0);
 205    Hex::Vector*  vz    = doc->addVector (0, 0, 1);
 206    double rint =2, rext = 4, angle = 300, hauteur = 1;
 207    Hex::Elements* grid3 = doc->makeCylinderUni (orig2, vx, vz,
 208                                                 rint, rext, angle, hauteur,
 209                                                 2, 3, 2);
 210                                     //          size_x, size_y, size_z);
 211    grid3->saveVtk ("makeCylinderUni1.vtk");
 212    PutData (grid3->isValid());
 213    if (NOT (grid3->isValid()))
 214        Hex::what ();
 215    return HOK;
 216
 217 #if 0
 218    Hex::Vertex*   orig3 = doc->addVertex (20, 0, 0);
 219    Hex::RealVector tx, ty, tz;
 220    for (int nro=1 ; nro<6 ; nro++)
 221        {
 222        tx.push_back (nro);
 223        ty.push_back (nro);
 224        tz.push_back (nro);
 225        }
 226
 227    tz.push_back (1);
 228    Hex::Elements* grid3 = doc->makeCartesian (orig3, vx, vy, vz, tx, ty, tz);
 229    grid3->saveVtk ("makeCartesian.vtk");
 230    PutData (grid3->isValid());
 231
 232    // doc->dump ();
 233 #endif
 234    return HOK;
 235 }
 236 // ======================================================== test_spherical6
 237 int test_spherical6 (int nbargs, cpchar tabargs[])
 238 {
 239    case_name = "spherical";
 240    const int size_x = 3;
 241
 242    Hex::Document* doc  = get_document ();
 243
 244    Hex::Elements* grid1 = doc->makeSphericalTop (size_x);
 245    PutData (grid1->isValid());
 246
 247    int nbhexas = grid1->countHexa ();
 248    PutData (nbhexas);
 249    for (int nro=3 ; nro<nbhexas ; nro +=3)
 250        grid1->getHexa(nro)->remove();
 251
 252    grid1->saveVtk ("makeSphericalTop.vtk");
 253
 254    Hex::Vertex*  orig2 = doc->addVertex (0, 0, 10);
 255    Hex::Vector*  vx    = doc->addVector (1, 0, 0);
 256    Hex::Vector*  vz    = doc->addVector (0, 1, 1);
 257    double rayon = 1;
 258    Hex::Elements* grid2 = doc->makeSphericalUni (orig2, vx, vz, rayon, size_x);
 259    if (NOT (grid1->isValid()))
 260        Hex::what ();
 261
 262    PutData (grid2->isValid());
 263    if (NOT (grid2->isValid()))
 264        Hex::what ();
 265
 266    for (int nro=3 ; nro<nbhexas ; nro +=3)
 267        grid2->getHexa(nro)->remove();
 268
 269    grid2->saveVtk ("makeSphericalUni.vtk");
 270    return HOK;
 271 }
 272 // ======================================================== test_rind6
 273 int test_rind6 (int nbargs, cpchar tabargs[])
 274 {
 275    case_name = "rind";
 276    const int size_r = 4;
 277    const int size_a = 8;
 278    const int size_h = 12;
 279
 280    Hex::Document* doc  = get_document ();
 281
 282    Hex::Elements* grid1 = doc->makeSphereTop (size_r, size_a, size_h);
 283    PutData (grid1->isValid());
 284    if (NOT (grid1->isValid()))
 285        Hex::what ();
 286    else
 287        grid1->saveVtk ("makeSphereTop.vtk");
 288
 289    Hex::Elements* grid2 = doc->makeRindTop (size_r, size_a, size_h);
 290    PutData (grid2->isValid());
 291    if (NOT (grid2->isValid()))
 292        Hex::what ();
 293    else
 294        grid2->saveVtk ("makeRindTop.vtk");
 295
 296    Hex::Vertex* orig  = doc->addVertex (0, 0, 0);
 297    Hex::Vertex* vplan = doc->addVertex (0, 0, -0.5);
 298    Hex::Vector* vx    = doc->addVector (1, 0, 0);
 299    Hex::Vector* vz    = doc->addVector (0, 0, 1);
 300    double rtrou = 1;
 301    double rint  = 8;
 302    double rext  = 10;
 303    double angle = 180;
 304
 305    Hex::Elements* grid3 = doc->makeSphereUni (orig, vx, vz,
 306                                               rtrou, rext, angle, vplan,
 307                                               size_r, size_a, size_h);
 308    if (NOT (grid3->isValid()))
 309        Hex::what ();
 310    else
 311        grid3->saveVtk ("makeSphereUni.vtk");
 312
 313    Hex::Elements* grid4 = doc->makeRindUni (orig, vx, vz,
 314                                             rtrou, rext, rint, angle, vplan,
 315                                             size_r, size_a, size_h);
 316    if (NOT (grid4->isValid()))
 317        Hex::what ();
 318    else
 319        grid4->saveVtk ("makeRindUni.vtk");
 320
 321    Hex::Elements* grid5 = doc->makePartSphere (orig, vx, vz, rext, rtrou, vplan,
 322                                                angle, size_r, size_a, size_h);
 323    if (NOT (grid5->isValid()))
 324        Hex::what ();
 325    else
 326        grid5->saveVtk ("makeSphereOld.vtk");
 327
 328    Hex::RealVector trad, tang, tphi;
 329    double dr     = (rext-rtrou)/size_r;
 330    double dtheta = angle/size_a;
 331    double dphi   = 180.0/size_h;
 332    for (int nro=0 ; nro<=size_r ; nro++) trad.push_back (rtrou + nro*dr);
 333    for (int nro=0 ; nro<=size_a ; nro++) tang.push_back (        nro*dtheta);
 334    for (int nro=0 ; nro<=size_h ; nro++) tphi.push_back (-90   + nro*dphi);
 335
 336    Hex::Elements* grid6 = doc->makeSphere (orig, vx, vz, trad, tang, tphi);
 337    if (NOT (grid6->isValid()))
 338        Hex::what ();
 339    else
 340        grid6->saveVtk ("makeSphereNew.vtk");
 341
 342    trad.clear ();
 343    trad.push_back (rtrou);
 344    for (int nro=0 ; nro<=size_r ; nro++) trad.push_back (rint + nro*dr);
 345    Hex::Elements* grid7 = doc->makeRind (orig, vx, vz, trad, tang, tphi);
 346    if (NOT (grid7->isValid()))
 347        Hex::what ();
 348    else
 349        grid7->saveVtk ("makeRindNew.vtk");
 350    return HOK;
 351 }
 352 // ======================================================== test_pipes6
 353 int test_pipes6 (int nbargs, cpchar tabargs[])
 354 {
 355    case_name    = "pipes";
 356    bool t_left  = false;
 357    bool t_right = false;
 358    bool pipe    = true;
 359
 360    for (int narg=1 ; narg<nbargs ; narg++)
 361        {
 362        string arg = tabargs [narg];
 363        if (arg=="-cyl")        pipe    = false;
 364        else if (arg=="-pipe")  pipe    = true;
 365        else if (arg=="-left")  t_left  = true;
 366        else if (arg=="-right") t_right = true;
 367        else
 368           {
 369           cout << " Syntax : " << endl;
 370           cout << " $ " << tabargs[0]  << " <args> " << endl;
 371           cout << " avec args parmi :" << endl;
 372           cout << " -cyl   : croisement de 2 cylindres " << endl;
 373           cout << " -pipe  : croisement de 2 tuyaux "    << endl;
 374           cout << " -left  : Forme en T, barre a gauche " << endl;
 375           cout << " -right : Forme en T, barre a droite " << endl;
 376           return HOK;
 377           }
 378        }
 379
 380    string radical = pipe ? "makePipes" : "makeCylinders";
 381
 382    double rext1 =  2*sqrt (2.0);
 383    double rext2 =  3*sqrt (2.0);
 384    double rint2 =  rext1;
 385    double rint1 =  rext1/2;
 386    double h1   =  16;
 387    double h2   =  16;
 388    double xl1 =  -8;
 389
 390    if (t_left)
 391       {
 392       h1 = 10;
 393       radical += "_L";
 394       }
 395    else if (t_right)
 396       {
 397       xl1 = -2;
 398       h1   = 10;
 399       radical += "_R";
 400       }
 401
 402    Hex::Document* doc  = get_document ();
 403
 404    Hex::Vertex* ori1  = doc->addVertex ( 0, 0,  xl1);
 405    Hex::Vertex* ori2  = doc->addVertex (-8, 0,  0);
 406    Hex::Vector* vz1   = doc->addVector ( 0, 0,  1);
 407    Hex::Vector* vz2   = doc->addVector ( 1, 0,  0);
 408
 409    Hex::BiCylinder* grid1 = NULL;
 410    if (pipe)
 411        grid1 = doc->makePipes (ori1, vz1, rint1, rext1, h1, ori2, vz2, rint2,
 412                                rext2, h2);
 413    else
 414        grid1 = doc->makeCylinders (ori1, vz1, rext1, h1, ori2, vz2, rext2, h2);
 415
 416    PutData (grid1->isValid());
 417    Hex::what ();
 418    if (grid1->isValid())
 419        eplucher (doc, grid1, radical);
 420
 421    return HOK;
 422 }
 423 // ======================================================== test_extrude6
 424 int test_extrude6 (int nbargs, cpchar tabargs[])
 425 {
 426    const int dimx = 11;
 427    const int dimy = 11;
 428    const int dimz = 2;
 429
 430    Hex::Document* doc = get_document ();
 431
 432    Hex::Vertex* orig1 = doc->addVertex ( 0,0,0);
 433    Hex::Vector* vx    = doc->addVector ( 1,0,0);
 434    Hex::Vector* vy    = doc->addVector ( 0,1,0);
 435    Hex::Vector* vz    = doc->addVector ( 0,0,1);
 436    Hex::Vector* dir1  = doc->addVector ( 1,1,1);
 437    Hex::Vector* dir2  = doc->addVector ( 1,1,-1);
 438
 439    double dx =1, dy=1, dz=1;
 440    Hex::Elements* grid1 = doc->makeCartesianUni (orig1, vx,vy,vz, dx,dy,dz,
 441                                                  dimx,dimy,dimz);
 442
 443    int mx = dimx/2;
 444    int my = dimy/2;
 445    Hex::Quads liste1, liste2;
 446
 447    liste1.push_back (grid1->getQuadIJ (mx, my, dimz));
 448    liste2.push_back (grid1->getQuadIJ (mx, my, 0));
 449    for (int nx=0; nx<dimx; nx++)
 450        if (nx!=mx)
 451           {
 452           liste1.push_back (grid1->getQuadIJ (nx, my, dimz));
 453           liste2.push_back (grid1->getQuadIJ (nx, my, 0));
 454           }
 455
 456    for (int ny=0; ny<dimy; ny++)
 457        if (ny!=my)
 458           {
 459           liste1.push_back (grid1->getQuadIJ (mx, ny, dimz));
 460           liste2.push_back (grid1->getQuadIJ (mx, ny, 0));
 461           }
 462
 463    Hex::RealVector tlen;
 464    double dh0 = 1;
 465    double dh  = 0.02;
 466    double lh = 0;
 467    for (int nro=0; nro<5; nro++)
 468        {
 469        dh = 1.5*dh + 1;
 470        lh += dh;
 471        tlen.push_back (lh);
 472        }
 473
 474    const int nbiter = 5;
 475    doc->saveVtk ("prisme1.vtk");
 476    Hex::Elements* prisme2 = doc->extrudeQuadsUni (liste2, dir2, dh0, nbiter);
 477    doc->saveVtk ("prisme2.vtk");
 478
 479    Hex::Elements* prisme1 = doc->extrudeQuads (liste1, dir1, tlen);
 480
 481    PutData (liste1.size());
 482    PutData (tlen.size());
 483    PutData (prisme1->countHexa());
 484    PutData (prisme1->countQuad());
 485    PutData (prisme1->countEdge());
 486    PutData (prisme1->countVertex());
 487
 488    for (int nro=0 ; nro <nbiter  ; nro++)
 489        {
 490        Hex::Hexa* cell = prisme2-> getHexa (nbiter+nro);
 491        cell->setScalar (5);
 492        }
 493
 494    doc->saveVtk ("prisme3.vtk");
 495    return HOK;
 496 }
 497 // ======================================================== test_revolution6
 498 int test_revolution6 (int nbargs, cpchar tabargs[])
 499 {
 500    Hex::Document* doc = get_document ();
 501
 502    Hex::Vertex* centre = doc->addVertex (0, 0, 0);
 503    Hex::Vector* vz     = doc->addVector (0, 0, 1);
 504
 505    Hex::Vertex* v1     = doc->addVertex (10, 0, 0);
 506    Hex::Vertex* v2     = doc->addVertex (11, 0, 0);
 507    Hex::Vertex* v3     = doc->addVertex (11, 0, 2);
 508    Hex::Vertex* v4     = doc->addVertex (10, 0, 2);
 509    Hex::Quad* quad     = doc->addQuadVertices (v1, v2, v3, v4);
 510
 511    Hex::Elements* grid0 = doc->revolutionQuadUni  (quad, centre, vz, 180, 8);
 512    doc->saveVtk ("revolution1.vtk");
 513    return HOK;
 514
 515    int nr = 1;
 516    int na = 6;
 517    int nl = 1;
 518
 519    Hex::Elements* grid = doc->makeCylinderTop (nr,na,nl);
 520
 521    Hex::Quads liste;
 522    for (int nx=0; nx<nr; nx++)
 523        for (int ny=0; ny<na; ny++)
 524            {
 525            Hex::Quad* cell = grid->getQuadIJ (nx, ny, nl);
 526            liste.push_back (cell);
 527            cell -> setScalar (5);
 528            }
 529
 530    Hex::Vertex* center = doc->addVertex (0, -10, 0);
 531    center -> setScalar (6);
 532    Hex::Vector* axis   = doc->addVector (1,   0, 0);
 533
 534    doc->saveVtk ("revolution1.vtk");
 535
 536    Hex::Elements* grid1 = doc->revolutionQuadsUni  (liste, center, axis, 180, 9);
 537    Hex::what ();
 538    if (grid1->isValid())
 539        doc->saveVtk ("revolution2.vtk");
 540
 541    return HOK;
 542 }
 543 // ======================================================== test_joint6
 544 int test_joint6 (int nbargs, cpchar tabargs[])
 545 {
 546    const int dimx = 11;
 547    const int dimy = 11;
 548    const int dimz = 2;
 549
 550    Hex::Document* doc   = get_document ();
 551
 552    Hex::Elements* grid1 = doc->makeCartesianTop (dimx,dimy,dimz);
 553
 554    Hex::Vertex*   orig2 = doc->addVertex  (dimx/2.0,0,8);
 555    Hex::Vector*   vectj = doc->addVector (0,1,0);
 556    Hex::Vector*   vecti = doc->addVector (1,0,0);
 557    Hex::Elements* grid2 = doc->makeCylinderUni (orig2, vecti, vectj,
 558                    1.0, 2.0, 180.0, 11.0,        dimz,dimy,dimx);
 559
 560    int mx = dimx/2;
 561    int my = dimy/2;
 562    Hex::Quad* prems = grid1->getQuadIJ (mx, my, dimz);
 563    Hex::Quad* cible = grid2->getQuadJK (dimz, mx, my);
 564
 565    Hex::Vertex* va1 = prems->getVertex (0);
 566    Hex::Vertex* va2 = prems->getVertex (1);
 567
 568    Hex::Vertex* vb1 = cible->getVertex (1);
 569    Hex::Vertex* vb2 = cible->getVertex (2);
 570
 571
 572    Hex::Quads liste;
 573
 574    liste.push_back (prems);
 575    for (int nx=0; nx<dimx; nx++)
 576        if (nx!=mx)
 577           liste.push_back (grid1->getQuadIJ (nx, my, dimz));
 578
 579    for (int ny=0; ny<dimy; ny++)
 580        if (ny!=my)
 581           liste.push_back (grid1->getQuadIJ (mx, ny, dimz));
 582
 583    doc->saveVtk ("jointQuad1.vtk");
 584    const int hauteur = 5;
 585    Hex::Elements* joint = doc->joinQuadsUni (liste, cible, va1,vb1,va2,vb2,
 586                                              hauteur);
 587    // for (int nh=0 ; nh<hauteur ; nh++) joint->getHexa(nh)->setScalar (5);
 588
 589    Hex::what ();
 590    if (NOT joint->isValid ())
 591       return HERR;
 592
 593    doc->saveVtk ("jointQuad2.vtk");
 594    int nbr_joint_vertex =  joint->countVertex ();
 595    int nbr_surf_vertex  =  nbr_joint_vertex/(hauteur+1);
 596
 597    HexDisplay (nbr_joint_vertex);
 598    HexDisplay (nbr_surf_vertex);
 599
 600    int indice0 = joint->findVertex (va1);
 601    HexDisplay (indice0);
 602
 603    for (int nh=0 ; nh<nbr_surf_vertex ; nh++)
 604        joint->getVertex(nh)->setScalar (5);
 605
 606    for (int nh=0 ; nh<=hauteur ; nh++)
 607        joint->getVertex(nh*nbr_surf_vertex)->setScalar (3);
 608
 609    doc->saveVtk ("jointQuad3.vtk");
 610    return HOK;
 611 }
 612 // ======================================================== test_cut6
 613 int test_cut6 (int nbargs, cpchar tabargs[])
 614 {
 615    const int size_x = 2;
 616    const int size_y = 1;
 617    const int size_z = 1;
 618
 619    Hex::Document* doc = get_document ();
 620
 621    Hex::Elements* grid  = doc->makeCartesianTop (size_x,size_y,size_z);
 622    Hex::Edge*     arete = grid->getEdgeK (0, 0, 0);
 623
 624    //  doc ->dump ();
 625    int nvtk=0;
 626    doc ->saveVtk ("decoupe", nvtk);
 627    Hex::Elements* grid2 = doc->cutUni (arete, 2);
 628    Hex::what ();
 629    if (NOT grid2->isValid ())
 630       return HERR;
 631    doc ->saveVtk ("decoupe", nvtk);
 632
 633    Hex::RealVector tablen;
 634    double reste     = 1;
 635    double abscisse  = 0;
 636    for (int nl=0 ; nl < 5 ; nl++)
 637        {
 638        reste     /= 2;
 639        abscisse  += reste;
 640        tablen.push_back (abscisse);
 641        }
 642    arete = grid2->getEdge (0);
 643    Hex::Elements* grid3 = doc->cut (arete, tablen);
 644    if (NOT grid3->isValid ())
 645       return HERR;
 646
 647    doc ->saveVtk ("decoupe", nvtk);
 648    return HOK;
 649 }
 650 // ======================================================== test_six
 651 void test_six (Hex::Document* doc, int action)
 652 {
 653    cpchar tabargs[] = { "salome" };
 654    int    nbargs    = 1;
 655
 656    docu = doc;
 657    switch (action)
 658        {
 659        case 101 : test_cartesian6 (nbargs, tabargs);
 660             break;
 661
 662        case 102 : test_cylinder6 (nbargs, tabargs);
 663             break;
 664
 665        case 103 : test_spherical6 (nbargs, tabargs);
 666             break;
 667
 668        case 104 : test_rind6 (nbargs, tabargs);
 669             break;
 670
 671        case 105 : test_pipes6 (nbargs, tabargs);
 672             break;
 673
 674        case 106 : test_extrude6 (nbargs, tabargs);
 675             break;
 676
 677        case 107 : test_joint6 (nbargs, tabargs);
 678             break;
 679
 680        case 108 : test_cut6 (nbargs, tabargs);
 681             break;
 682
 683        default  : ;
 684  }
 685 }
 686 // ======================================================== test_monica
 687 int test_monica (int nbargs, cpchar tabargs[])
 688 {
 689    case_name = "monica";
 690
 691    Hex::Document* doc   = get_document ();
 692    Hex::Vertex*   orig  = doc->addVertex (0, 0, 0);
 693    Hex::Vertex*   orig2 = doc->addVertex (1.5, 1.5, -1);
 694
 695    Hex::Vector*   vx  = doc->addVector (1, 0, 0);
 696    Hex::Vector*   vy  = doc->addVector (0, 1, 0);
 697    Hex::Vector*   vz  = doc->addVector (0, 0, 1);
 698    Hex::Vector*   vxy = doc->addVector (1, 1, 0);
 699
 700    Hex::Elements* plaque = doc->makeCartesianUni (orig, vx,vy,vz, 1,1,1, 3,3,1);
 701    save_file ();
 702
 703    Hex::Hexa* trou = plaque->getHexaIJK (1, 1, 0);
 704    vector <Hex::Vertex*> tabv0, tabv1;
 705    for (int nv=0 ; nv<8 ; nv++)
 706        tabv1.push_back (trou->getVertex(nv));
 707
 708    doc->dump ();
 709    doc->removeHexa (trou);
 710    Hex::what ();
 711    save_file ();
 712
 713    Hex::Elements* pipe = doc->makePipeUni (orig2, vxy, vz, 0.15, 0.5, 360, 3,
 714                                            1, 4, 3);
 715    doc->dump ();
 716    Hex::what ();
 717    for (int nv=0 ; nv<8 ; nv++)
 718        tabv0.push_back (nearest (pipe, tabv1[nv]));
 719
 720    doc->setLevel (1);
 721    for (int nv=0 ; nv<8 ; nv++)
 722        {
 723        int ier = doc->mergeVertices (tabv0[nv], tabv1[nv]);
 724        cout << " nro = " << nv << ", ier = " << ier << endl;
 725        Hex::what ();
 726        save_file ();
 727        }
 728
 729    doc->dump ();
 730    return HOK;
 731 }
 732 // ======================================================== test_abu
 733 int test_abu (int nbargs, cpchar tabargs[])
 734 {
 735    case_name = "abu";
 736
 737    Hex::Document* doc   = get_document ();
 738    doc->makeCylinderTop (1,3,1);
 739    Hex::what ();
 740    PutData (doc->countVertex());
 741    save_file ();
 742    save_file ();
 743    doc->save (case_name);
 744    // doc->dump ();
 745    return HOK;
 746 }