src/HEXABLOCK/test_hexa6.cxx

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