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, rint, rext, 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::RealVector trad, tang, tphi;
 322    double dr     = (rext-rtrou)/size_r;
 323    double dtheta = angle/size_a;
 324    double dphi   = 180.0/size_h;
 325    for (int nro=0 ; nro<=size_r ; nro++) trad.push_back (rtrou + nro*dr);
 326    for (int nro=0 ; nro<=size_a ; nro++) tang.push_back (        nro*dtheta);
 327    for (int nro=0 ; nro<=size_h ; nro++) tphi.push_back (-90   + nro*dphi);
 328
 329    Hex::Elements* grid6 = doc->makeSphere (orig, vx, vz, trad, tang, tphi);
 330    if (NOT (grid6->isValid()))
 331        Hex::what ();
 332    else
 333        grid6->saveVtk ("makeSphereNew.vtk");
 334
 335    trad.clear ();
 336    trad.push_back (rtrou);
 337    for (int nro=0 ; nro<=size_r ; nro++) trad.push_back (rint + nro*dr);
 338    Hex::Elements* grid7 = doc->makeRind (orig, vx, vz, trad, tang, tphi);
 339    if (NOT (grid7->isValid()))
 340        Hex::what ();
 341    else
 342        grid7->saveVtk ("makeRindNew.vtk");
 343    return HOK;
 344 }
 345 // ======================================================== test_pipes6
 346 int test_pipes6 (int nbargs, cpchar tabargs[])
 347 {
 348    case_name    = "pipes";
 349    bool t_left  = false;
 350    bool t_right = false;
 351    bool pipe    = true;
 352
 353    for (int narg=1 ; narg<nbargs ; narg++)
 354        {
 355        string arg = tabargs [narg];
 356        if (arg=="-cyl")        pipe    = false;
 357        else if (arg=="-pipe")  pipe    = true;
 358        else if (arg=="-left")  t_left  = true;
 359        else if (arg=="-right") t_right = true;
 360        else
 361           {
 362           cout << " Syntax : " << endl;
 363           cout << " $ " << tabargs[0]  << " <args> " << endl;
 364           cout << " avec args parmi :" << endl;
 365           cout << " -cyl   : croisement de 2 cylindres " << endl;
 366           cout << " -pipe  : croisement de 2 tuyaux "    << endl;
 367           cout << " -left  : Forme en T, barre a gauche " << endl;
 368           cout << " -right : Forme en T, barre a droite " << endl;
 369           return HOK;
 370           }
 371        }
 372
 373    string radical = pipe ? "makePipes" : "makeCylinders";
 374
 375    double rext1 =  2*sqrt (2.0);
 376    double rext2 =  3*sqrt (2.0);
 377    double rint2 =  rext1;
 378    double rint1 =  rext1/2;
 379    double h1   =  16;
 380    double h2   =  16;
 381    double xl1 =  -8;
 382
 383    if (t_left)
 384       {
 385       h1 = 10;
 386       radical += "_L";
 387       }
 388    else if (t_right)
 389       {
 390       xl1 = -2;
 391       h1   = 10;
 392       radical += "_R";
 393       }
 394
 395    Hex::Document* doc  = get_document ();
 396
 397    Hex::Vertex* ori1  = doc->addVertex ( 0, 0,  xl1);
 398    Hex::Vertex* ori2  = doc->addVertex (-8, 0,  0);
 399    Hex::Vector* vz1   = doc->addVector ( 0, 0,  1);
 400    Hex::Vector* vz2   = doc->addVector ( 1, 0,  0);
 401
 402    Hex::BiCylinder* grid1 = NULL;
 403    if (pipe)
 404        grid1 = doc->makePipes (ori1, vz1, rint1, rext1, h1, ori2, vz2, rint2,
 405                                rext2, h2);
 406    else
 407        grid1 = doc->makeCylinders (ori1, vz1, rext1, h1, ori2, vz2, rext2, h2);
 408
 409    PutData (grid1->isValid());
 410    Hex::what ();
 411    if (grid1->isValid())
 412        eplucher (doc, grid1, radical);
 413
 414    return HOK;
 415 }
 416 // ======================================================== test_extrude6
 417 int test_extrude6 (int nbargs, cpchar tabargs[])
 418 {
 419    const int dimx = 11;
 420    const int dimy = 11;
 421    const int dimz = 2;
 422
 423    Hex::Document* doc = get_document ();
 424
 425    Hex::Vertex* orig1 = doc->addVertex ( 0,0,0);
 426    Hex::Vector* vx    = doc->addVector ( 1,0,0);
 427    Hex::Vector* vy    = doc->addVector ( 0,1,0);
 428    Hex::Vector* vz    = doc->addVector ( 0,0,1);
 429    Hex::Vector* dir1  = doc->addVector ( 1,1,1);
 430    Hex::Vector* dir2  = doc->addVector ( 1,1,-1);
 431
 432    double dx =1, dy=1, dz=1;
 433    Hex::Elements* grid1 = doc->makeCartesianUni (orig1, vx,vy,vz, dx,dy,dz,
 434                                                  dimx,dimy,dimz);
 435
 436    int mx = dimx/2;
 437    int my = dimy/2;
 438    Hex::Quads liste1, liste2;
 439
 440    liste1.push_back (grid1->getQuadIJ (mx, my, dimz));
 441    liste2.push_back (grid1->getQuadIJ (mx, my, 0));
 442    for (int nx=0; nx<dimx; nx++)
 443        if (nx!=mx)
 444           {
 445           liste1.push_back (grid1->getQuadIJ (nx, my, dimz));
 446           liste2.push_back (grid1->getQuadIJ (nx, my, 0));
 447           }
 448
 449    for (int ny=0; ny<dimy; ny++)
 450        if (ny!=my)
 451           {
 452           liste1.push_back (grid1->getQuadIJ (mx, ny, dimz));
 453           liste2.push_back (grid1->getQuadIJ (mx, ny, 0));
 454           }
 455
 456    Hex::RealVector tlen;
 457    double dh0 = 1;
 458    double dh  = 0.02;
 459    double lh = 0;
 460    for (int nro=0; nro<5; nro++)
 461        {
 462        dh = 1.5*dh + 1;
 463        lh += dh;
 464        tlen.push_back (lh);
 465        }
 466
 467    const int nbiter = 5;
 468    doc->saveVtk ("prisme1.vtk");
 469    Hex::Elements* prisme2 = doc->extrudeQuadsUni (liste2, dir2, dh0, nbiter);
 470    doc->saveVtk ("prisme2.vtk");
 471
 472    Hex::Elements* prisme1 = doc->extrudeQuads (liste1, dir1, tlen);
 473
 474    PutData (liste1.size());
 475    PutData (tlen.size());
 476    PutData (prisme1->countHexa());
 477    PutData (prisme1->countQuad());
 478    PutData (prisme1->countEdge());
 479    PutData (prisme1->countVertex());
 480
 481    for (int nro=0 ; nro <nbiter  ; nro++)
 482        {
 483        Hex::Hexa* cell = prisme2-> getHexa (nbiter+nro);
 484        cell->setScalar (5);
 485        }
 486
 487    doc->saveVtk ("prisme3.vtk");
 488    return HOK;
 489 }
 490 // ======================================================== test_revolution6
 491 int test_revolution6 (int nbargs, cpchar tabargs[])
 492 {
 493    Hex::Document* doc = get_document ();
 494
 495    Hex::Vertex* centre = doc->addVertex (0, 0, 0);
 496    Hex::Vector* vz     = doc->addVector (0, 0, 1);
 497
 498    Hex::Vertex* v1     = doc->addVertex (10, 0, 0);
 499    Hex::Vertex* v2     = doc->addVertex (11, 0, 0);
 500    Hex::Vertex* v3     = doc->addVertex (11, 0, 2);
 501    Hex::Vertex* v4     = doc->addVertex (10, 0, 2);
 502    Hex::Quad* quad     = doc->addQuadVertices (v1, v2, v3, v4);
 503
 504    Hex::Elements* grid0 = doc->revolutionQuadUni  (quad, centre, vz, 180, 8);
 505    doc->saveVtk ("revolution1.vtk");
 506    return HOK;
 507
 508    int nr = 1;
 509    int na = 6;
 510    int nl = 1;
 511
 512    Hex::Elements* grid = doc->makeCylinderTop (nr,na,nl);
 513
 514    Hex::Quads liste;
 515    for (int nx=0; nx<nr; nx++)
 516        for (int ny=0; ny<na; ny++)
 517            {
 518            Hex::Quad* cell = grid->getQuadIJ (nx, ny, nl);
 519            liste.push_back (cell);
 520            cell -> setScalar (5);
 521            }
 522
 523    Hex::Vertex* center = doc->addVertex (0, -10, 0);
 524    center -> setScalar (6);
 525    Hex::Vector* axis   = doc->addVector (1,   0, 0);
 526
 527    doc->saveVtk ("revolution1.vtk");
 528
 529    Hex::Elements* grid1 = doc->revolutionQuadsUni  (liste, center, axis, 180, 9);
 530    Hex::what ();
 531    if (grid1->isValid())
 532        doc->saveVtk ("revolution2.vtk");
 533
 534    return HOK;
 535 }
 536 // ======================================================== test_joint6
 537 int test_joint6 (int nbargs, cpchar tabargs[])
 538 {
 539    const int dimx = 11;
 540    const int dimy = 11;
 541    const int dimz = 2;
 542
 543    Hex::Document* doc   = get_document ();
 544
 545    Hex::Elements* grid1 = doc->makeCartesianTop (dimx,dimy,dimz);
 546
 547    Hex::Vertex*   orig2 = doc->addVertex  (dimx/2.0,0,8);
 548    Hex::Vector*   vectj = doc->addVector (0,1,0);
 549    Hex::Vector*   vecti = doc->addVector (1,0,0);
 550    Hex::Elements* grid2 = doc->makeCylinderUni (orig2, vecti, vectj,
 551                    1.0, 2.0, 180.0, 11.0,        dimz,dimy,dimx);
 552
 553    int mx = dimx/2;
 554    int my = dimy/2;
 555    Hex::Quad* prems = grid1->getQuadIJ (mx, my, dimz);
 556    Hex::Quad* cible = grid2->getQuadJK (dimz, mx, my);
 557
 558    Hex::Vertex* va1 = prems->getVertex (0);
 559    Hex::Vertex* va2 = prems->getVertex (1);
 560
 561    Hex::Vertex* vb1 = cible->getVertex (1);
 562    Hex::Vertex* vb2 = cible->getVertex (2);
 563
 564
 565    Hex::Quads liste;
 566
 567    liste.push_back (prems);
 568    for (int nx=0; nx<dimx; nx++)
 569        if (nx!=mx)
 570           liste.push_back (grid1->getQuadIJ (nx, my, dimz));
 571
 572    for (int ny=0; ny<dimy; ny++)
 573        if (ny!=my)
 574           liste.push_back (grid1->getQuadIJ (mx, ny, dimz));
 575
 576    doc->saveVtk ("jointQuad1.vtk");
 577    const int hauteur = 5;
 578    Hex::Elements* joint = doc->joinQuadsUni (liste, cible, va1,vb1,va2,vb2,
 579                                              hauteur);
 580    // for (int nh=0 ; nh<hauteur ; nh++) joint->getHexa(nh)->setScalar (5);
 581
 582    Hex::what ();
 583    if (NOT joint->isValid ())
 584       return HERR;
 585
 586    doc->saveVtk ("jointQuad2.vtk");
 587    int nbr_joint_vertex =  joint->countVertex ();
 588    int nbr_surf_vertex  =  nbr_joint_vertex/(hauteur+1);
 589
 590    HexDisplay (nbr_joint_vertex);
 591    HexDisplay (nbr_surf_vertex);
 592
 593    int indice0 = joint->findVertex (va1);
 594    HexDisplay (indice0);
 595
 596    for (int nh=0 ; nh<nbr_surf_vertex ; nh++)
 597        joint->getVertex(nh)->setScalar (5);
 598
 599    for (int nh=0 ; nh<=hauteur ; nh++)
 600        joint->getVertex(nh*nbr_surf_vertex)->setScalar (3);
 601
 602    doc->saveVtk ("jointQuad3.vtk");
 603    return HOK;
 604 }
 605 // ======================================================== test_cut6
 606 int test_cut6 (int nbargs, cpchar tabargs[])
 607 {
 608    const int size_x = 2;
 609    const int size_y = 1;
 610    const int size_z = 1;
 611
 612    Hex::Document* doc = get_document ();
 613
 614    Hex::Elements* grid  = doc->makeCartesianTop (size_x,size_y,size_z);
 615    Hex::Edge*     arete = grid->getEdgeK (0, 0, 0);
 616
 617    //  doc ->dump ();
 618    int nvtk=0;
 619    doc ->saveVtk ("decoupe", nvtk);
 620    Hex::Elements* grid2 = doc->cutUni (arete, 2);
 621    Hex::what ();
 622    if (NOT grid2->isValid ())
 623       return HERR;
 624    doc ->saveVtk ("decoupe", nvtk);
 625
 626    Hex::RealVector tablen;
 627    double reste     = 1;
 628    double abscisse  = 0;
 629    for (int nl=0 ; nl < 5 ; nl++)
 630        {
 631        reste     /= 2;
 632        abscisse  += reste;
 633        tablen.push_back (abscisse);
 634        }
 635    arete = grid2->getEdge (0);
 636    Hex::Elements* grid3 = doc->cut (arete, tablen);
 637    if (NOT grid3->isValid ())
 638       return HERR;
 639
 640    doc ->saveVtk ("decoupe", nvtk);
 641    return HOK;
 642 }
 643 // ======================================================== test_six
 644 void test_six (Hex::Document* doc, int action)
 645 {
 646    cpchar tabargs[] = { "salome" };
 647    int    nbargs    = 1;
 648
 649    docu = doc;
 650    switch (action)
 651        {
 652        case 101 : test_cartesian6 (nbargs, tabargs);
 653             break;
 654
 655        case 102 : test_cylinder6 (nbargs, tabargs);
 656             break;
 657
 658        case 103 : test_spherical6 (nbargs, tabargs);
 659             break;
 660
 661        case 104 : test_rind6 (nbargs, tabargs);
 662             break;
 663
 664        case 105 : test_pipes6 (nbargs, tabargs);
 665             break;
 666
 667        case 106 : test_extrude6 (nbargs, tabargs);
 668             break;
 669
 670        case 107 : test_joint6 (nbargs, tabargs);
 671             break;
 672
 673        case 108 : test_cut6 (nbargs, tabargs);
 674             break;
 675
 676        default  : ;
 677  }
 678 }
 679 // ======================================================== test_monica
 680 int test_monica (int nbargs, cpchar tabargs[])
 681 {
 682    case_name = "monica";
 683
 684    Hex::Document* doc   = get_document ();
 685    Hex::Vertex*   orig  = doc->addVertex (0, 0, 0);
 686    Hex::Vertex*   orig2 = doc->addVertex (1.5, 1.5, -1);
 687
 688    Hex::Vector*   vx  = doc->addVector (1, 0, 0);
 689    Hex::Vector*   vy  = doc->addVector (0, 1, 0);
 690    Hex::Vector*   vz  = doc->addVector (0, 0, 1);
 691    Hex::Vector*   vxy = doc->addVector (1, 1, 0);
 692
 693    Hex::Elements* plaque = doc->makeCartesianUni (orig, vx,vy,vz, 1,1,1, 3,3,1);
 694    save_file ();
 695
 696    Hex::Hexa* trou = plaque->getHexaIJK (1, 1, 0);
 697    vector <Hex::Vertex*> tabv0, tabv1;
 698    for (int nv=0 ; nv<8 ; nv++)
 699        tabv1.push_back (trou->getVertex(nv));
 700
 701    doc->dump ();
 702    doc->removeHexa (trou);
 703    Hex::what ();
 704    save_file ();
 705
 706    Hex::Elements* pipe = doc->makePipeUni (orig2, vxy, vz, 0.15, 0.5, 360, 3,
 707                                            1, 4, 3);
 708    doc->dump ();
 709    Hex::what ();
 710    for (int nv=0 ; nv<8 ; nv++)
 711        tabv0.push_back (nearest (pipe, tabv1[nv]));
 712
 713    doc->setLevel (1);
 714    for (int nv=0 ; nv<8 ; nv++)
 715        {
 716        int ier = doc->mergeVertices (tabv0[nv], tabv1[nv]);
 717        cout << " nro = " << nv << ", ier = " << ier << endl;
 718        Hex::what ();
 719        save_file ();
 720        }
 721
 722    doc->dump ();
 723    return HOK;
 724 }
 725 // ======================================================== test_abu
 726 int test_abu (int nbargs, cpchar tabargs[])
 727 {
 728    case_name = "abu";
 729
 730    Hex::Document* doc   = get_document ();
 731    doc->makeCylinderTop (1,3,1);
 732    Hex::what ();
 733    PutData (doc->countVertex());
 734    save_file ();
 735    save_file ();
 736    doc->save (case_name);
 737    // doc->dump ();
 738    return HOK;
 739 }