src/TEST_CPP/ModelTest.cxx

   1 // Copyright (C) 2009-2023  CEA, EDF
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19
  20 #include <cppunit/extensions/HelperMacros.h>
  21
  22
  23 #include "hexa_base.hxx"
  24 #include "Hex.hxx"
  25 #include "HexDocument.hxx"
  26 #include "HexElements.hxx"
  27 #include "HexCrossElements.hxx"
  28
  29 #include "HexHexa.hxx"
  30 #include "HexQuad.hxx"
  31 #include "HexEdge.hxx"
  32 #include "HexVertex.hxx"
  33
  34 #include "HexPropagation.hxx"
  35 #include "HexLaw.hxx"
  36 #include "HexMatrix.hxx"
  37
  38 #include "ModelTest.hxx"
  39
  40 CPPUNIT_TEST_SUITE_REGISTRATION( ModelTest );
  41
  42
  43 ModelTest::ModelTest(void)
  44 {
  45 //   _myHexEngine = new HEXA_NS::Hex();
  46 //   _myDoc= _myHexEngine->addDocument();
  47 }
  48
  49 ModelTest::~ModelTest(void)
  50 {
  51 //   delete _myDoc;
  52 //   delete _myHexEngine; //CS_TODO : Crash
  53 }
  54
  55
  56 // ======================================================== print_propagations
  57 void ModelTest::_print_propagations (Hex::Document* doc)
  58 {
  59    int nb = doc->countPropagation ();
  60    HexDisplay (nb);
  61    for (int nro=0 ; nro<nb ; nro++)
  62        {
  63        Hex::Propagation*  prop  = doc ->getPropagation (nro);
  64        const Hex::Edges&  table = prop->getEdges ();
  65        printf (" ____________________________________ Prop nro %d\n", nro);
  66        for (int ned=0 ; ned<(int)table.size() ; ned++)
  67            {
  68            bool way = table [ned]->getWay ();
  69            Hex::Edge*   edge = table [ned];
  70            Hex::Vertex* v0   = edge->getVertex (0);
  71            Hex::Vertex* v1   = edge->getVertex (1);
  72
  73            if (way)
  74               {
  75               printf ("     (");
  76               v0->printName (", ");
  77               v1->printName (")\n");
  78               }
  79           else
  80               {
  81               v1->printName (", ");
  82               v0->printName (")\n");
  83               printf ("     (");
  84               }
  85            }
  86        }
  87 }
  88 // // ======================================================== Test_sphere
  89 // void ModelTest::Test_sphere ()
  90 // {
  91 //    Hex::Hex mon_ex;
  92 //    Hex::Document* doc = mon_ex.addDocument ();
  93 //    Hex::Vertex*  orig = doc->addVertex (0,0,0);
  94 //
  95 //    int    ncouches = 1;
  96 //    double k = 0.8;
  97 //    Hex::Vector*   decal  = doc->addVector (1,1,1);
  98 //    Hex::Elements* sphere = doc->makeSpherical (orig, decal, ncouches, k);
  99 //
 100 //    for (int nc=0 ; nc <= ncouches ; nc++)
 101 //        {
 102 //        Hex::Hexa* cell = sphere->getStrate (nc, Hex::Q_A);
 103 //        cell->remove ();
 104 //        // sphere->getStrate (nc, Hex::Q_A)->remove ();
 105 //        // sphere->getStrate (nc, Hex::Q_B)->remove ();
 106 //        }
 107 //
 108 //    sphere->saveVtk ("sphere.vtk");
 109 //    CPPUNIT_ASSERT( true );
 110 // }
 111 // ======================================================== Test_cartesi1
 112 void ModelTest::Test_cartesi1 ()
 113 {
 114
 115    const int size_x = 15;
 116    const int size_y = 12;
 117    const int size_z = 8;
 118
 119    Hex::Hex mon_ex;
 120    Hex::Document* doc = mon_ex.addDocument ("foo");
 121    Hex::Vertex* orig = doc->addVertex (0,0,0);
 122
 123    Hex::Vector*   dir  = doc->addVector (1,1,1);
 124    Hex::Elements* grid = doc->makeCartesian (orig, dir, size_x,size_y,size_z);
 125
 126    //  print_propagations (doc);
 127
 128    for (int nz=0; nz<size_z ; nz++)
 129        for (int ny=nz+1; ny<size_y-nz-1 ; ny++)
 130            for (int nx=nz+1; nx<size_x-nz-1 ; nx++)
 131                {
 132                Hex::Hexa* cell = grid->getHexaIJK (nx, ny, nz);
 133                cell->remove ();
 134                }
 135
 136    doc->setLevel (1);
 137    _print_propagations (doc);
 138    grid->saveVtk ("grid_cart.vtk");
 139
 140    // doc->dump ();
 141    CPPUNIT_ASSERT( true );
 142 }
 143 // ======================================================== afficher
 144 #define Afficher(elt) _afficher (#elt, elt)
 145 int ModelTest::_afficher (cpchar nom, Hex::EltBase* elt)
 146 {
 147    if (elt==NULL)
 148       {
 149       printf (" .... %s = 0x0\n", nom);
 150       return HOK;
 151       }
 152
 153    printf (" .... %s = 0x%08lx = %03d\n", nom, (unsigned long) elt, elt->getId());
 154    return HOK;
 155 }
 156 // ======================================================== Test_find
 157 void ModelTest::Test_find ()
 158 {
 159
 160    const int size_x = 2;
 161    const int size_y = 2;
 162    const int size_z = 2;
 163
 164    Hex::Hex mon_ex;
 165    Hex::Document* doc = mon_ex.addDocument ("foo");
 166
 167    Hex::Vertex* orig = doc->addVertex (0,0,0);
 168    Hex::Vector* dir  = doc->addVector (1,1,1);
 169    Hex::Elements*  grid = doc->makeCartesian (orig, dir, size_x,size_y,size_z);
 170
 171    grid->saveVtk ("mini1.vtk");
 172    doc->dump ();
 173
 174    Hex::Vertex *v00, *v02, *v06, *v08, *v10, *v22, *v26;
 175
 176    Afficher ( v00 = doc->findVertex (0, 0, 0));
 177    Afficher ( v02 = doc->findVertex (1, 1, 0));
 178    Afficher ( v06 = doc->findVertex (1, 1, 1));
 179    Afficher ( v08 = doc->findVertex (2, 1, 0));
 180    Afficher ( v10 = doc->findVertex (2, 1, 1));
 181    Afficher ( v22 = doc->findVertex (2, 1, 2));
 182    Afficher ( v26 = doc->findVertex (2, 2, 2));
 183
 184    printf ("\n");
 185
 186    Afficher (doc->findEdge (v06, v10));
 187    Afficher (doc->findEdge (v10, v06));
 188    printf ("\n");
 189
 190    Afficher (doc->findQuad (v02, v10));
 191    Afficher (doc->findQuad (v06, v08));
 192    Afficher (doc->findQuad (v02, v06));
 193
 194    printf ("\n");
 195    Afficher (doc->findHexa (v00, v06));
 196    Afficher (doc->findHexa (v06, v26));
 197    Afficher (doc->findHexa (v26, v06));
 198
 199    CPPUNIT_ASSERT( true );
 200 }
 201 // ======================================================== Test_joint
 202 void ModelTest::Test_joint ()
 203 {
 204
 205    const int dimx = 11;
 206    const int dimy = 11;
 207    const int dimz = 2;
 208
 209    Hex::Hex mon_ex;
 210    Hex::Document* doc = mon_ex.addDocument ("foo");
 211
 212    Hex::Vertex* orig1 = doc->addVertex (0,0,0);
 213    Hex::Vector* dir   = doc->addVector (1,1,1);
 214
 215    Hex::Elements* grid1 = doc->makeCartesian   (orig1, dir, dimx,dimy,dimz);
 216
 217    Hex::Vertex*   orig2 = doc->addVertex  (dimx/2.0,0,8);
 218    Hex::Vector*   vectj = doc->addVector (0,1,0);
 219    Hex::Vector*   vecti = doc->addVector (1,0,0);
 220    Hex::Elements* grid2 = doc->makeCylindrical (orig2, vecti, vectj,
 221                    1, 180, 1,        dimz,dimy,dimx, true);
 222
 223    int mx = dimx/2;
 224    int my = dimy/2;
 225    Hex::Quad* prems = grid1->getQuadIJ (mx, my, dimz);
 226    Hex::Quad* cible = grid2->getQuadJK (dimz, mx, my);
 227
 228
 229    Hex::Vertex* v1 = prems->getVertex (0);
 230    Hex::Vertex* v2 = cible->getVertex (0);
 231    Hex::Vertex* v3 = prems->getVertex (1);
 232    Hex::Vertex* v4 = cible->getVertex (3);
 233
 234    Hex::Quads liste;
 235    Hex::Quads miroir;
 236
 237    liste.push_back (prems);
 238    for (int nx=0; nx<dimx; nx++)
 239        if (nx!=mx)
 240           liste.push_back (grid1->getQuadIJ (nx, my, dimz));
 241
 242    for (int ny=0; ny<dimy; ny++)
 243        if (ny!=my)
 244           liste.push_back (grid1->getQuadIJ (mx, ny, dimz));
 245
 246    // Hex::Elements* joint =
 247    //
 248    doc->joinQuads  (liste, cible, v1, v2, v3, v4, 5);
 249    doc->saveVtk ("joint.vtk");
 250
 251    CPPUNIT_ASSERT( true );
 252 }
 253 // ======================================================== Test_prism
 254 void ModelTest::Test_prism ()
 255 {
 256
 257    const int dimx = 11;
 258    const int dimy = 11;
 259    const int dimz = 2;
 260
 261    Hex::Hex mon_ex;
 262    Hex::Document* doc = mon_ex.addDocument ("foo");
 263
 264    Hex::Vertex* orig1 = doc->addVertex (0,0,0);
 265    Hex::Vector* dir   = doc->addVector (1,1,1);
 266
 267    Hex::Elements* grid1 = doc->makeCartesian   (orig1, dir, dimx,dimy,dimz);
 268
 269    int mx = dimx/2;
 270    int my = dimy/2;
 271    Hex::Quad* prems = grid1->getQuadIJ (mx, my, dimz);
 272    Hex::Quads liste;
 273
 274    liste.push_back (prems);
 275    for (int nx=0; nx<dimx; nx++)
 276        if (nx!=mx)
 277           liste.push_back (grid1->getQuadIJ (nx, my, dimz));
 278
 279    for (int ny=0; ny<dimy; ny++)
 280        if (ny!=my)
 281           liste.push_back (grid1->getQuadIJ (mx, ny, dimz));
 282
 283    doc->prismQuads  (liste, dir, 5);
 284    doc->saveVtk ("prisme.vtk");
 285
 286    CPPUNIT_ASSERT( true );
 287 }
 288
 289
 290 // ======================================================== Test_prism2
 291 void ModelTest::Test_prism2 ()
 292 {
 293
 294     const int dimx = 11;
 295     const int dimy = 11;
 296     const int dimz = 2;
 297
 298     Hex::Hex mon_ex;
 299     Hex::Document* doc = mon_ex.addDocument ("foo");
 300
 301     Hex::Vertex* orig1 = doc->addVertex (0,0,0);
 302     Hex::Vector* dir   = doc->addVector (1,1,1);
 303
 304     Hex::Elements* grid1 = doc->makeCartesian   (orig1, dir, dimx,dimy,dimz);
 305
 306     int mx = dimx/2;
 307     int my = dimy/2;
 308     Hex::Quad* prems = grid1->getQuadIJ (mx, my, dimz);
 309     Hex::Elements*  prism = doc->prismQuad(prems, dir, 5);
 310
 311     int nbHexa = prism->countHexa();
 312     std::cout << "nbHexa " << nbHexa << std::endl;
 313     Hex::Hexa*     hp1 = prism->getHexa(1);
 314     std::cout << "getHexa(1) " << hp1 << std::endl;
 315     Hex::Vertex*   hp1_v0 = hp1->getVertex(0);
 316     std::cout << "getVertex ->" << hp1_v0 << std::endl;
 317     doc->saveVtk ("prisme2.vtk");
 318
 319     CPPUNIT_ASSERT( true );
 320 }
 321
 322
 323
 324
 325
 326
 327
 328
 329 // ======================================================== Test_hexa1
 330 void ModelTest::Test_hexa1 ()
 331 {
 332
 333    const int size_x = 1;
 334    const int size_y = 1;
 335    const int size_z = 1;
 336
 337    Hex::Hex mon_ex;
 338    Hex::Document* doc = mon_ex.addDocument ("foo");
 339    Hex::Vertex* orig = doc->addVertex (0,0,0);
 340    Hex::Vector* dir  = doc->addVector (1,1,1);
 341    //  Hex::Elements*  grid =
 342    doc->makeCartesian (orig, dir, size_x,size_y,size_z);
 343
 344    doc ->dump ();
 345
 346    CPPUNIT_ASSERT( true );
 347 }
 348 // ======================================================== Test_decoupage
 349 void ModelTest::Test_decoupage ()
 350 {
 351
 352    const int size_x = 2;
 353    const int size_y = 1;
 354    const int size_z = 1;
 355
 356    Hex::Hex mon_ex;
 357    Hex::Document* doc = mon_ex.addDocument ("foo");
 358
 359    Hex::Vertex* orig = doc->addVertex (0,0,0);
 360    Hex::Vector* dir  = doc->addVector (1,1,1);
 361
 362    Hex::Elements* grid  = doc->makeCartesian (orig, dir, size_x,size_y,size_z);
 363    Hex::Edge*     arete = grid->getEdgeK (0, 0, 0);
 364
 365    doc ->dump ();
 366    doc ->saveVtk ("no_decoupe.vtk");
 367 /* Hex::Elements* grid2 = */  doc->cut (arete, 1);
 368
 369    doc ->dump ();
 370    doc ->saveVtk ("decoupe.vtk");
 371    // doc ->saveFile ();
 372
 373    CPPUNIT_ASSERT( true );
 374 }
 375 // ======================================================== Test_gen_xml
 376 void ModelTest::Test_gen_xml ()
 377 {
 378
 379    const int size_x = 2;
 380    const int size_y = 2;
 381    const int size_z = 2;
 382
 383    Hex::Hex mon_ex;
 384    Hex::Document* doc = mon_ex.addDocument ("foo");
 385
 386    Hex::Vertex* orig = doc->addVertex (0,0,0);
 387    Hex::Vector* dir  = doc->addVector (1,1,1);
 388    Hex::Elements*  grid = doc->makeCartesian (orig, dir, size_x,size_y,size_z);
 389
 390    Hex::Hexa*   cell    = grid->getHexa (0);
 391    Hex::Quad*   face    = cell->getQuad (0);
 392    Hex::Edge*   arete   = cell->getEdge (0);
 393    Hex::Vertex* noeud   = cell->getVertex (0);
 394
 395    Hex::Law* law1 = doc->addLaw("loi1", 1);
 396    Hex::Law* law2 = doc->addLaw("loi2", 2);
 397    Hex::Law* law3 = doc->addLaw("loi3", 3);
 398
 399    law1->setKind (Hex::Uniform);
 400    law2->setKind (Hex::Arithmetic);
 401    law3->setKind (Hex::Geometric);
 402
 403    Hex::Propagation* prop1 = doc->getPropagation (0);
 404    Hex::Propagation* prop2 = doc->getPropagation (1);
 405    Hex::Propagation* prop3 = doc->getPropagation (2);
 406
 407    prop1->setLaw (law1);
 408    prop2->setLaw (law2);
 409    prop3->setLaw (law3);
 410
 411    prop1->setWay (true);
 412    prop2->setWay (false);
 413    prop3->setWay (true);
 414
 415    doc ->saveVtk ("mini.vtk");
 416    doc ->save ("Essai");
 417
 418    CPPUNIT_ASSERT( true );
 419 }
 420 // ======================================================== Test_relecture
 421 void ModelTest::Test_relecture ()
 422 {
 423
 424    Hex::Hex mon_ex;
 425    Hex::Document* doc = mon_ex.loadDocument ("Essai");
 426
 427    doc ->dump ();
 428    doc ->saveVtk ("restore.vtk");
 429
 430    CPPUNIT_ASSERT( true );
 431 }
 432
 433
 434 // ======================================================== Test_clone
 435 void ModelTest::Test_clone ()
 436 {
 437
 438    const int size_x = 2;
 439    const int size_y = 2;
 440    const int size_z = 2;
 441
 442    Hex::Hex mon_ex;
 443    Hex::Document* doc = mon_ex.addDocument ("foo");
 444
 445    Hex::Vertex* orig = doc->addVertex (0,0,0);
 446    Hex::Vector* dir  = doc->addVector (1,1,1);
 447    Hex::Elements* grid = doc->makeCartesian (orig, dir, size_x,size_y,size_z);
 448
 449    Hex::Vector*   bond  = doc->addVector (0, 0, 7);
 450    Hex::Elements* grid2 = doc->makeTranslation (grid, bond);
 451
 452    doc ->saveVtk ("clonage.vtk");
 453    doc ->dump();
 454
 455    HexDump (grid2->getHexa      (1));
 456    HexDump (grid2->getHexaIJK   (1,1,1));
 457    HexDump (grid2->getVertexIJK (1,1,1));
 458
 459    CPPUNIT_ASSERT( true );
 460 }
 461 // ======================================================== Test_separ
 462 void ModelTest::Test_separ ()
 463 {
 464
 465    const int size_x = 2;
 466    const int size_y = 2;
 467    const int size_z = 2;
 468
 469    Hex::Hex mon_ex;
 470    Hex::Document* doc = mon_ex.addDocument ("foo");
 471
 472    Hex::Vertex* orig = doc->addVertex (0,0,0);
 473    Hex::Vector* dir  = doc->addVector (1,1,1);
 474    //  Hex::Elements*  grid =
 475    doc->makeCartesian (orig, dir, size_x,size_y,size_z);
 476
 477    doc ->saveVtk ("separ.vtk");
 478    doc ->dump();
 479
 480    CPPUNIT_ASSERT( true );
 481 }
 482 // // ======================================================== Test_cyl_karima
 483 // void ModelTest::Test_cyl_karima ()
 484 // {
 485 //
 486 //    Hex::Hex mon_ex;
 487 //    Hex::Document* doc = mon_ex.addDocument ("foo");
 488 //
 489 //    Hex::Vertex* c2 = doc->addVertex (0,0,0);
 490 //    Hex::Vector* dz = doc->addVector (0,0,1);
 491 //    Hex::Vector* dx = doc->addVector (1,0,0);
 492 //
 493 //    double dr = 4.12;
 494 //
 495 //    double a2 = 180;
 496 //    int    l2 = 70;
 497 //
 498 //    int nr2 = 5;
 499 //    int na2 = 5;
 500 //    int nl2 = 1;
 501 //
 502 // /* Hex::Elements* cyl2 = */ doc->makeCylindrical (c2, dx, dz, dr, a2, l2,
 503 //                                                   nr2, na2, nl2, false );
 504 //    doc->saveVtk ("cyl_karima.vtk");
 505 //    // doc->dump ();
 506 //
 507 //    CPPUNIT_ASSERT( true );
 508 // }
 509 // ================================================== Test_grille_cyl
 510 void ModelTest::Test_grille_cyl ()
 511 {
 512
 513    Hex::Hex mon_ex;
 514    Hex::Document* doc = mon_ex.addDocument ("foo");
 515
 516    Hex::Vertex* orig1 = doc->addVertex ( 0, 0,0);
 517    Hex::Vertex* orig2 = doc->addVertex (10, 0,0);
 518
 519    Hex::Vertex* orig3 = doc->addVertex ( 0,10,0);
 520    Hex::Vertex* orig4 = doc->addVertex (10,10,0);
 521
 522    Hex::Vertex* orig5 = doc->addVertex ( 0,20,0);
 523    Hex::Vertex* orig6 = doc->addVertex (10,20,0);
 524
 525    Hex::Vector* vz = doc->addVector (0,0,1);
 526    Hex::Vector* vx = doc->addVector (1,0,0);
 527
 528    double dr = 1;
 529    double dl = 1;
 530    int    nr = 2;
 531    int    nl = 5;
 532    nl = 1;
 533
 534    doc->makeCylindrical(orig1,vx,vz,dr, 360, dl,nr,4,nl, true);
 535    doc->makeCylindrical(orig2,vx,vz,dr, 360, dl,nr,8,nl, true);
 536    doc->makeCylindrical(orig3,vx,vz,dr, 270, dl,nr,8,nl, true);
 537    doc->makeCylindrical(orig6,vx,vz,dr, 360, dl,nr,6,nl, true);
 538    doc->makeCylindrical(orig4,vx,vz,dr, 270, dl,nr,7,nl, true);
 539    doc->makeCylindrical(orig5,vx,vz,dr, 360, dl,nr,5,nl, true);
 540    doc->saveVtk ("cylindres.vtk");
 541    // doc->dump ();
 542
 543    CPPUNIT_ASSERT( true );
 544 }
 545 // ===================================================== Test_cylinder
 546 void ModelTest::Test_cylinder ()
 547 {
 548
 549    int    nvtk    = 0;
 550    cpchar fic_vtk = "cylindre";
 551
 552    Hex::Hex mon_ex;
 553    Hex::Document* doc = mon_ex.addDocument ("foo");
 554
 555    Hex::Vertex* orig1 = doc->addVertex (0, 0,0);
 556    Hex::Vertex* orig2 = doc->addVertex (50,0,0);
 557    Hex::Vector* vz    = doc->addVector (0,0,1);
 558    Hex::Vector* vx    = doc->addVector (1,0,0);
 559
 560    int nr  = 4;
 561    int nri = 3;
 562    int nre = nr;
 563    int na = 9;
 564    int nl = 5;
 565
 566    Hex::Cylinder* cyl  = doc->addCylinder   (orig1, vz, nr, nl);
 567    Hex::Pipe*     pipe = doc->addPipe       (orig2, vz, nri, nre, nl);
 568
 569    doc->makeCylinder (cyl,  vx, nr, na, nl);
 570    doc ->saveVtk (fic_vtk, nvtk);
 571
 572    doc->makePipe     (pipe, vx, nr, na, nl);
 573    doc ->saveVtk (fic_vtk, nvtk);
 574
 575    CPPUNIT_ASSERT( true );
 576 }
 577
 578
 579
 580 void ModelTest::myTest_croix ()
 581 {
 582   Hex::Hex mon_ex;
 583   Hex::Document* doc = mon_ex.addDocument ("foo");
 584
 585
 586 //   Hex::Vector* dx1 = doc->addVector( -1, 0, 0 );
 587 //   Hex::Vector* dz1 = doc->addVector( 0, 0, 1 );
 588 //
 589 //   Hex::Vertex* c_pte_1 = doc->addVertex ( 195., 0., 220. );
 590 //   Hex::Vertex* c_grd_1 = doc->addVertex ( 300., 0., 400. );
 591 //   Hex::Cylinder* cyl_pte_1 = doc->addCylinder( c_pte_1 , dz1 , 25 , 360 );
 592 //   Hex::Cylinder* cyl_grd_1 = doc->addCylinder( c_grd_1 , dx1 , 50 , 140 );
 593 //   Hex::CrossElements* cross1 = doc->makeCylinders( cyl_pte_1 , cyl_grd_1 );
 594
 595   Hex::Vector* dx2 = doc->addVector(-1, 0, 0 );
 596   Hex::Vector* dz2 = doc->addVector( 0, 0, 1 );
 597
 598   Hex::Vertex* c_pte_2 = doc->addVertex( 110., 0. , 400. );
 599   Hex::Vertex* c_grd_2 = doc->addVertex( 0.  , 0. , 0. );
 600
 601   Hex::Cylinder* cyl_pte_2 = doc->addCylinder( c_pte_2 , dx2 , 50, 220 );
 602   Hex::Cylinder* cyl_grd_2 = doc->addCylinder( c_grd_2 , dz2 , 100, 800 );
 603   Hex::CrossElements* cross2    = doc->makeCylinders( cyl_pte_2, cyl_grd_2 );
 604
 605
 606 /*
 607   Hex::Vector* dx2 = doc->addVector( 1, 0, 0 );
 608   Hex::Vector* dz2 = doc->addVector( 0, 0, 1 );
 609
 610   Hex::Vertex* c_pte_2 = doc->addVertex( -130. , 0. , 400. );
 611   Hex::Vertex* c_grd_2 = doc->addVertex( 0. , 0. , 0. );
 612
 613   Hex::Cylinder* cyl_pte_2 = doc->addCylinder( c_pte_2 , dx2 , 50, 260 );
 614   Hex::Cylinder* cyl_grd_2 = doc->addCylinder( c_grd_2 , dz2 , 100, 800 );
 615
 616   Hex::CrossElements* cross2 = doc->makeCylinders( cyl_pte_2, cyl_grd_2 );*/
 617   doc->saveVtk ("/tmp/ffffffff.vtk");
 618   doc->dump ();
 619
 620   CPPUNIT_ASSERT( true );
 621 }
 622
 623
 624
 625
 626 // ======================================================== Test_croix
 627 void ModelTest::Test_croix ()
 628 {
 629
 630    Hex::Hex mon_ex;
 631    Hex::Document* doc = mon_ex.addDocument ("foo");
 632
 633    Hex::Vertex* ori1 = doc->addVertex ( 0,0,0);
 634    Hex::Vertex* ori2 = doc->addVertex (-5,0,5);
 635    Hex::Vector* vz   = doc->addVector ( 0,0,1);
 636    Hex::Vector* vx   = doc->addVector ( 1,0,0);
 637
 638    int nr1 = 2;
 639    int nl1 = 10;
 640    int nr2 = 1;
 641    int nl2 = 10;
 642
 643    Hex::Cylinder* cyl1  = doc->addCylinder (ori1, vz, nr1, nl1);
 644    Hex::Cylinder* cyl2  = doc->addCylinder (ori2, vx, nr2, nl2);
 645    Hex::CrossElements* grid = doc->makeCylinders (cyl1, cyl2);
 646
 647    grid->dump();
 648    grid->dumpVertex();
 649
 650 #if 0
 651    for (int ny=0; ny<Hex::S_MAXI; ny++)
 652        {
 653        grid->getHexaIJK (Hex::Cyl1, 1, ny, 0)->remove ();
 654        grid->getHexaIJK (Hex::Cyl1, 1, ny, 1)->remove ();
 655        grid->getHexaIJK (Hex::Cyl1, 1, ny, 2)->remove ();
 656        grid->getHexaIJK (Hex::Cyl1, 1, ny, 3)->remove ();
 657        grid->getHexaIJK (Hex::Cyl1, 1, ny, 4)->remove ();
 658        grid->getHexaIJK (Hex::Cyl1, 1, ny, 5)->remove ();
 659
 660        grid->getHexaIJK (Hex::Cyl2, 1, ny, 0)->remove ();
 661        // grid->getHexaIJK (Hex::Cyl2, 1, ny, 1)->remove ();
 662        // grid->getHexaIJK (Hex::Cyl2, 1, ny, 2)->remove ();
 663        grid->getHexaIJK (Hex::Cyl2, 1, ny, 3)->remove ();
 664        }
 665
 666    for (int ny=0; ny<4 ;  ny++)
 667        {
 668        grid->getHexaIJK (Hex::Cyl1, 0, ny, 0)->remove ();
 669        grid->getHexaIJK (Hex::Cyl1, 0, ny, 1)->remove ();
 670        grid->getHexaIJK (Hex::Cyl1, 0, ny, 2)->remove ();
 671        grid->getHexaIJK (Hex::Cyl1, 0, ny, 3)->remove ();
 672        grid->getHexaIJK (Hex::Cyl1, 0, ny, 4)->remove ();
 673        grid->getHexaIJK (Hex::Cyl1, 0, ny, 5)->remove ();
 674
 675        // grid->getHexaIJK (Hex::Cyl2, 0, ny, 0)->remove ();
 676        // grid->getHexaIJK (Hex::Cyl2, 0, ny, 1)->remove ();
 677        // grid->getHexaIJK (Hex::Cyl2, 0, ny, 2)->remove ();
 678        // grid->getHexaIJK (Hex::Cyl2, 0, ny, 3)->remove ();
 679        }
 680
 681    /*********************************
 682    grid->getHexaIJK (Hex::Cyl2, 0, 3, 1)->remove ();
 683    grid->getHexaIJK (Hex::Cyl2, 1, Hex::S_SE, 2)->remove ();
 684    grid->getHexaIJK (Hex::Cyl2, 1, Hex::S_SE, 1)->remove ();
 685
 686    grid->getHexaIJK (Hex::Cyl1, 1, Hex::S_SE, 3)->remove ();
 687    grid->getHexaIJK (Hex::Cyl1, 1, Hex::S_SE, 2)->remove ();
 688    grid->getHexaIJK (Hex::Cyl1, 1, Hex::S_SE, 1)->remove ();
 689     ********************************* */
 690 #endif
 691
 692    doc->saveVtk ("croix.vtk");
 693    doc->dump ();
 694
 695    CPPUNIT_ASSERT( true );
 696 }
 697 // ======================================================== Test_pipes
 698 void ModelTest::Test_pipes ()
 699 {
 700
 701    Hex::Hex mon_ex;
 702    Hex::Document* doc = mon_ex.addDocument ("foo");
 703
 704    Hex::Vertex* ori1 = doc->addVertex ( 0,0,0);
 705    Hex::Vertex* ori2 = doc->addVertex (-5,0,5);
 706    Hex::Vector* vz   = doc->addVector ( 0,0,1);
 707    Hex::Vector* vx   = doc->addVector ( 1,0,0);
 708
 709    double h1  = 10, h2  = 10;
 710    double ri1 = 1,  ri2 = 1.5;
 711    double re1 = 2,  re2 = 3;
 712
 713    Hex::Pipe* pipe1  = doc->addPipe (ori1, vz, ri1, re1, h1);
 714    Hex::Pipe* pipe2  = doc->addPipe (ori2, vx, ri2, re2, h2);
 715    Hex::CrossElements* grid = doc->makePipes (pipe1, pipe2);
 716
 717    grid->dump();
 718    grid->dumpVertex();
 719
 720    doc->saveVtk ("pipes.vtk");
 721    doc->dump ();
 722    CPPUNIT_ASSERT( true );
 723 }
 724 // ======================================================== Test_lorraine
 725 void ModelTest::Test_lorraine()
 726 {
 727
 728    Hex::Hex mon_ex;
 729    Hex::Document* doc = mon_ex.addDocument ("foo");
 730
 731    Hex::Vertex* ori1 = doc->addVertex ( 0,0,0);
 732    Hex::Vertex* ori2 = doc->addVertex (-5,0,5);
 733    Hex::Vertex* ori3 = doc->addVertex ( 0,0,12);
 734    Hex::Vertex* ori4 = doc->addVertex (-5,0,17);
 735
 736    Hex::Vector* vz   = doc->addVector ( 0,0,1);
 737    Hex::Vector* vx   = doc->addVector ( 1,0,0);
 738
 739    int nl1 = 10;
 740    int nl2 = 10;
 741
 742    double rsmall = 1;
 743    double rmoy   = 2;
 744    double rbig   = 3;
 745
 746    Hex::Cylinder* cyl1  = doc->addCylinder (ori1, vz, rmoy,   nl1);
 747    Hex::Cylinder* cyl2  = doc->addCylinder (ori2, vx, rsmall, nl2);
 748
 749    Hex::Cylinder* cyl3  = doc->addCylinder (ori3, vz, rmoy, nl1);
 750    Hex::Cylinder* cyl4  = doc->addCylinder (ori4, vx, rbig, nl2);
 751
 752    Hex::CrossElements* grid1 = doc->makeCylinders (cyl1, cyl2);
 753    Hex::CrossElements* grid2 = doc->makeCylinders (cyl4, cyl3);
 754
 755 #define Imprimer(x) printf (#x " = ") ; if (x) x->dump() ; else printf ("NULL\n")
 756    const int nx_int = 0;
 757    const int nx_ext = 1;
 758
 759    //           vc2 = grid1->getVertexIJK (Hex::Cyl2, 0,0,0);
 760    //           vc3 = grid2->getVertexIJK (Hex::Cyl1, 0,0,0);
 761                                      //    Cyl     i     j     k
 762    Hex::Quad* qb = grid1-> getQuadIJ (Hex::Cyl2, nx_ext, Hex::S_E, 4);
 763    Hex::Quad* qh = grid2-> getQuadIJ (Hex::Cyl1, nx_ext, Hex::S_N, 0);
 764
 765    Hex::Vertex* vb0 = qb->getVertex (3);
 766    Hex::Vertex* vb1 = qb->getVertex (2);
 767    Hex::Vertex* vh0 = qh->getVertex (0);
 768    Hex::Vertex* vh1 = qh->getVertex (1);
 769
 770    vb0 = grid1->getVertexIJK (Hex::Cyl2, 2, Hex::S_E,  4);  // cible
 771    vb1 = grid1->getVertexIJK (Hex::Cyl2, 2, Hex::S_NE, 4);
 772    vh0 = grid2->getVertexIJK (Hex::Cyl1, 2, Hex::S_N,  0);   // depart
 773    vh1 = grid2->getVertexIJK (Hex::Cyl1, 2, Hex::S_NW, 0);
 774
 775    Imprimer (vh0);
 776    Imprimer (vh1);
 777    Imprimer (vb0);
 778    Imprimer (vb1);
 779
 780    // qb->remove ();
 781    // qh->remove ();
 782    Hex::Quads hliste;
 783
 784    hliste.push_back (qh);
 785    for (int ny=1; ny<Hex::S_MAXI; ny++)
 786        {
 787        int ns = (ny + Hex::S_N) MODULO Hex::S_MAXI;
 788        hliste.push_back (grid2->getQuadIJ (Hex::Cyl1, nx_ext, ns, 0));
 789        }
 790
 791    for (int ny=0; ny<4 ;  ny++)
 792        hliste.push_back (grid2->getQuadIJ (Hex::Cyl1, nx_int, ny, 0));
 793
 794    doc->joinQuads  (hliste, qb, vh0, vb0, vh1, vb1, 5);
 795    doc->saveVtk ("lorraine.vtk");
 796    // doc->dump ();
 797    CPPUNIT_ASSERT( true );
 798 }
 799 // ======================================================== Test_disconnect
 800 void ModelTest::Test_disconnect ()
 801 {
 802
 803    const int size_x = 2;
 804    const int size_y = 2;
 805    const int size_z = 1;
 806
 807    Hex::Hex mon_ex;
 808    Hex::Document* doc = mon_ex.addDocument ("foo");
 809
 810    Hex::Vertex*   orig1 = doc->addVertex (0,0,0);
 811    Hex::Vertex*   orig2 = doc->addVertex (4,0,0);
 812    Hex::Vertex*   orig3 = doc->addVertex (8,0,0);
 813
 814    Hex::Vector*   dir  = doc->addVector (1,1,1);
 815    Hex::Elements* grid1 = doc->makeCartesian (orig1, dir, size_x,size_y,size_z);
 816    Hex::Elements* grid2 = doc->makeCartesian (orig2, dir, size_x,size_y,size_z);
 817    Hex::Elements* grid3 = doc->makeCartesian (orig3, dir, size_x,size_y,size_z);
 818
 819    int nvtk = 0;
 820    doc->setLevel (1);
 821    Hex::Matrix  matrice;
 822    Hex::Vector* ecart  = doc->addVector (0.5,0.5,0);
 823    matrice.defTranslation (ecart);
 824
 825    Hex::Hexa* hexa1 = grid1->getHexaIJK (1,1,0);
 826    Hex::Hexa* hexa2 = grid2->getHexaIJK (1,1,0);
 827    Hex::Hexa* hexa3 = grid3->getHexaIJK   (1,1,0);
 828
 829    Hex::Quad* quad  = grid1->getQuadJK  (1,1,0);
 830    Hex::Edge* edge  = grid2->getEdgeK   (1,2,0);
 831    Hex::Vertex* vertex = grid3->getVertexIJK (1,1,1);
 832
 833    quad->setScalar   (5);
 834    edge->setScalar   (5);
 835    vertex->setScalar (5);
 836
 837    doc->saveVtk ("Test_disco", nvtk);
 838    doc->disconnectQuad (hexa1, quad);
 839
 840    hexa1 ->transform (&matrice);
 841    doc->saveVtk ("Test_disco", nvtk);
 842
 843    doc->disconnectEdge (hexa2, edge);
 844
 845    hexa2->transform (&matrice);
 846    doc->saveVtk ("Test_disco", nvtk);
 847
 848    doc->disconnectVertex (hexa3, vertex);
 849
 850    hexa3->transform (&matrice);
 851    doc->saveVtk ("Test_disco", nvtk);
 852
 853    doc->dumpPropagation ();
 854    // doc->dump  ();
 855
 856    CPPUNIT_ASSERT( true );
 857 }
 858 // ======================================================== Test_propagation
 859 void ModelTest::Test_propagation ()
 860 {
 861
 862    const int size_x = 2;
 863    const int size_y = 1;
 864    const int size_z = 1;
 865
 866    Hex::Hex mon_ex;
 867    Hex::Document* doc = mon_ex.addDocument ("foo");
 868
 869    Hex::Vertex*   orig = doc->addVertex (0,0,0);
 870    Hex::Vector*   dir  = doc->addVector (1,1,1);
 871    //  Hex::Elements* grid =
 872    doc->makeCartesian (orig, dir, size_x,size_y,size_z);
 873
 874    int nb = doc->countPropagation ();
 875    for (int nro=0 ; nro<nb ; nro++)
 876        {
 877        Hex::Propagation*  prop  = doc ->getPropagation (nro);
 878        const Hex::Edges&  table = prop->getEdges ();
 879        printf (" ____________________________________ Prop nro %d\n", nro);
 880        for (int ned=0 ; ned<(int)table.size() ; ned++)
 881            {
 882            bool way = table [ned]->getWay ();
 883
 884            if (way)
 885               {
 886               printf ("     (");
 887               table [ned]->getVertex (0)->printName (", ");
 888               table [ned]->getVertex (1)->printName (")\n");
 889               }
 890           else
 891               {
 892               printf ("     (");
 893               table [ned]->getVertex (1)->printName (", ");
 894               table [ned]->getVertex (0)->printName (")\n");
 895               }
 896            }
 897        }
 898
 899    doc->dump  ();
 900    doc->saveVtk ("Test_propagation.vtk");
 901    doc->save    ("Test_propagation");
 902
 903    CPPUNIT_ASSERT( true );
 904 }
 905 // ======================================================== Test_move
 906 void ModelTest::Test_move ()
 907 {
 908
 909    const int size_x = 1;
 910    const int size_y = 1;
 911    const int size_z = 2;
 912
 913    Hex::Hex mon_ex;
 914    Hex::Document* doc = mon_ex.addDocument ("foo");
 915
 916    Hex::Vertex* orig = doc->addVertex (0,0,0);
 917    Hex::Vector* dir  = doc->addVector (1,1,1);
 918    Hex::Elements*  grid = doc->makeCartesian (orig, dir, size_x,size_y,size_z);
 919
 920    Hex::Vector*   enhaut  = doc->addVector (0, 0, 5);
 921    Hex::Vector*   devant  = doc->addVector (5, 0, 0);
 922    // Hex::Vector*   agauche = doc->addVector (0, 5, 0);
 923
 924    Hex::Matrix matrice;
 925    matrice.defTranslation (enhaut);
 926
 927    Hex::Hexa* cube    = grid->getHexa (1);
 928    Hex::Quad* dessous = cube->getQuad (Hex::Q_A);
 929    dessous->dump();
 930
 931    Hex::Elements* grid2 = doc->makeTranslation (grid, devant);
 932    /* Hex::Elements* grid3 = doc->makeTranslation (grid, agauche); */
 933    Hex::Hexa* cube2     = grid2->getHexa (1);
 934
 935    doc ->saveVtk ("move0.vtk");
 936
 937    cube ->disconnectQuad (dessous);
 938    cube ->transform (&matrice);
 939    cube2->transform (&matrice);
 940
 941    doc ->saveVtk ("move1.vtk");
 942    doc ->dump();
 943
 944    CPPUNIT_ASSERT( true );
 945 }
 946 // ======================================================== Test_deux_cyl
 947 void ModelTest::Test_deux_cyl ()
 948 {
 949
 950    Hex::Hex mon_ex;
 951    Hex::Document* doc = mon_ex.addDocument ("foo");
 952
 953    Hex::Vertex* orig1 = doc->addVertex (0,0,-5);
 954    Hex::Vertex* orig2 = doc->addVertex (-5,0,0);
 955
 956    Hex::Vector* vx = doc->addVector (1,0,0);
 957    Hex::Vector* vy = doc->addVector (0,1,0);
 958    Hex::Vector* vz = doc->addVector (0,0,1);
 959
 960    double dr = 1;
 961    double da = 360; // degres
 962    double dl = 1.0;
 963    int    nr = 2;
 964    int    na = 6;
 965    int    nl = 10;
 966
 967    /* Hex::Elements* cyl1 = */ doc->makeCylindrical(orig1, vy,vz, dr, da,
 968                                        dl,nr,na,nl, false);
 969
 970    /* Hex::Elements* cyl2 = */ doc->makeCylindrical(orig2, vz,vx, dr/2, da,
 971                                        dl,nr,na,nl, false);
 972    doc->saveVtk ("deux_cylindres.vtk");
 973    CPPUNIT_ASSERT( true );
 974 }
 975 // ======================================================== Test_move2
 976 void ModelTest::Test_transfo ()
 977 {
 978
 979    const int size_x = 1;
 980    const int size_y = 1;
 981    const int size_z = 2;
 982
 983    int    nvtk    = 0;
 984    cpchar fic_vtk = "transfo";
 985
 986    Hex::Hex mon_ex;
 987    Hex::Document* doc = mon_ex.addDocument ("foo");
 988    doc ->setLevel (1);
 989
 990    Hex::Vertex* orig = doc->addVertex (0,0,0);
 991    Hex::Vector* dir  = doc->addVector (1,1,1);
 992    Hex::Elements* grid = doc->makeCartesian (orig, dir, size_x, size_y,
 993                                                         size_z);
 994    if (grid==NULL)
 995       CPPUNIT_ASSERT( false );
 996
 997    orig->setScalar(2);
 998
 999    doc ->saveVtk (fic_vtk, nvtk);
1000
1001    Hex::Vector*   devant  = doc->addVector (5, 0, 0);
1002
1003    Hex::Elements* grid2 = doc->makeTranslation (grid, devant);
1004    if (grid2==NULL)
1005       CPPUNIT_ASSERT( false );
1006    doc ->saveVtk (fic_vtk, nvtk);
1007
1008    Hex::Elements* grid3  = doc->makeScale (grid2, orig, 2);
1009    if (grid3==NULL)
1010       CPPUNIT_ASSERT( false );
1011    doc ->saveVtk (fic_vtk, nvtk);
1012
1013    Hex::Elements* grid4 = doc->makeRotation (grid2, orig, dir, 45);
1014    if (grid4==NULL)
1015       CPPUNIT_ASSERT( false );
1016    doc ->saveVtk (fic_vtk, nvtk);
1017
1018    Hex::Elements* grid5 = doc->makeSymmetryPoint (grid4, orig);
1019    if (grid5==NULL)
1020       CPPUNIT_ASSERT( false );
1021
1022    doc ->saveVtk (fic_vtk, nvtk);
1023
1024    Hex::Vector* dir1  = doc->addVector (1,0,0);
1025    Hex::Elements* grid6 = doc->makeSymmetryLine (grid4, orig, dir1);
1026    if (grid6==NULL)
1027       CPPUNIT_ASSERT( false );
1028
1029    grid4->getHexa(0)->getVertex(0)->setScalar(3);
1030    grid6->getHexa(0)->getVertex(0)->setScalar(3);
1031    doc ->saveVtk (fic_vtk, nvtk);
1032
1033    grid4->getHexa(0)->getVertex(0)->setScalar(0);
1034    grid6->getHexa(0)->getVertex(0)->setScalar(0);
1035
1036    Hex::Elements* grid7 = doc->makeSymmetryLine (grid2, orig, dir1);
1037    if (grid7==NULL)
1038       CPPUNIT_ASSERT( false );
1039
1040    grid2->getHexa(0)->getVertex(0)->setScalar(4);
1041    grid7->getHexa(0)->getVertex(0)->setScalar(4);
1042    doc ->saveVtk (fic_vtk, nvtk);
1043
1044    grid2->getHexa(0)->getVertex(0)->setScalar(0);
1045    grid7->getHexa(0)->getVertex(0)->setScalar(0);
1046
1047    Hex::Elements* grid8 = doc->makeSymmetryPlane (grid2, orig, dir1);
1048    if (grid8==NULL)
1049       CPPUNIT_ASSERT( false );
1050
1051    grid2->getHexa(0)->getVertex(0)->setScalar(4);
1052    grid8->getHexa(0)->getVertex(0)->setScalar(4);
1053    doc ->saveVtk (fic_vtk, nvtk);
1054    grid2->getHexa(0)->getVertex(0)->setScalar(0);
1055    grid8->getHexa(0)->getVertex(0)->setScalar(0);
1056
1057    Hex::Elements* grid9 = doc->makeSymmetryPlane (grid3, orig, dir);
1058    if (grid9==NULL)
1059       CPPUNIT_ASSERT( false );
1060
1061    grid3->getHexa(0)->getVertex(0)->setScalar(4);
1062    grid9->getHexa(0)->getVertex(0)->setScalar(4);
1063    doc ->saveVtk (fic_vtk, nvtk);
1064
1065    grid9->getHexa(0)->removeConnected ();
1066    doc ->saveVtk (fic_vtk, nvtk);
1067
1068    CPPUNIT_ASSERT( true );
1069 }
1070
1071
1072
1073
1074