src/HEXABLOCK/HexDocument_v6.cxx

   1
   2 // C++ : Fonctions de creation HexaBlock v6
   3
   4 //  Copyright (C) 2009-2013  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 "HexDocument.hxx"
  24
  25 #include "HexElements.hxx"
  26 #include "HexBiCylinder.hxx"
  27 #include "HexVector.hxx"
  28 #include "HexQuad.hxx"
  29
  30 #include "HexGlobale.hxx"
  31
  32 BEGIN_NAMESPACE_HEXA
  33
  34
  35 // ======================================================== makeCartesianTop
  36 Elements* Document::makeCartesianTop (int nx, int ny, int nz)
  37 {
  38    DumpStart ("makeCartesianTop", nx << ny << nz );
  39    Elements* grid = new Elements (this);
  40
  41    RealVector tx, ty, tz;
  42    Real3 rx = { 1, 0, 0 };
  43    Real3 ry = { 0, 1, 0 };
  44    Real3 rz = { 0, 0, 1 };
  45
  46    grid->checkSize (1, nx, ny, nz, false);
  47    if (grid->isValid())
  48       {
  49       Vertex* orig = addVertex (0, 0, 0);
  50       for (int nro=1 ; nro<=nx; ++nro) tx.push_back (nro);
  51       for (int nro=1 ; nro<=ny; ++nro) ty.push_back (nro);
  52       for (int nro=1 ; nro<=nz; ++nro) tz.push_back (nro);
  53       grid->makeCartesian (orig, rx, ry, rz, tx, ty, tz);
  54       }
  55
  56    DumpReturn (grid);
  57    return grid;
  58 }
  59 // ======================================================== makeCartesianUni
  60 Elements* Document::makeCartesianUni (Vertex* orig,
  61                                       Vector* vx, Vector* vy, Vector* vz,
  62                                       double  dx, double  dy, double  dz,
  63                                       int     nx, int     ny, int     nz)
  64 {
  65    DumpStart ("makeCartesianUni", orig << vx << vy << vz
  66                                        << dx << dy << dz
  67                                        << nx << ny << nz);
  68
  69    Elements* grid = new Elements (this);
  70
  71    Real3 rx, ry, rz;
  72    grid->checkOrig   (1, orig);
  73    grid->checkSize   (8, nx, ny, nz, false);
  74    grid->checkSystem (2, vx, vy, vz, rx, ry, rz);
  75
  76    if (grid->isValid())
  77       {
  78       RealVector tx, ty, tz;
  79       for (int nro=1 ; nro<=nx; ++nro) tx.push_back (nro*dx);
  80       for (int nro=1 ; nro<=ny; ++nro) ty.push_back (nro*dy);
  81       for (int nro=1 ; nro<=nz; ++nro) tz.push_back (nro*dz);
  82
  83       grid->makeCartesian (orig, rx, ry, rz, tx, ty, tz);
  84       }
  85
  86    DumpReturn (grid);
  87    return grid;
  88 }
  89 // ======================================================== makeCartesian
  90 Elements* Document::makeCartesian (Vertex*    orig,
  91                                    Vector*    vx, Vector*    vy, Vector*    vz,
  92                                    RealVector tx, RealVector ty, RealVector tz)
  93 {
  94    DumpStart ("makeCartesian", orig << vx << vy << vz << tx << ty << tz);
  95
  96    Elements* grid = new Elements (this);
  97
  98    Real3 rx, ry, rz;
  99    grid->checkOrig   (1, orig);
 100    grid->checkSystem (2, vx, vy, vz, rx, ry, rz);
 101    grid->checkVector (5, tx);
 102    grid->checkVector (6, ty);
 103    grid->checkVector (7, tz);
 104
 105    if (grid->isValid())
 106        grid->makeCartesian (orig, rx, ry, rz, tx, ty, tz);
 107
 108    DumpReturn (grid);
 109    return grid;
 110 }
 111 // ======================================================== makeCylinderTop
 112 Elements* Document::makeCylinderTop (int nr, int na, int nh)
 113 {
 114    DumpStart ("makeCylinderTop", nr << na << nh);
 115
 116    Elements* grid = new Elements (this);
 117
 118    RealVector tray, tang, thaut;
 119    Real3 rx = { 1, 0, 0 };
 120    Real3 rz = { 0, 0, 1 };
 121
 122    grid->checkSize (1, nr, na, nh, true);
 123    if (grid->isValid())
 124       {
 125       double da = 360.0 / na;
 126       for (int nro=0 ; nro<=nr; ++nro) tray .push_back (nro+1);
 127       for (int nro=0 ; nro<=na; ++nro) tang .push_back (nro*da);
 128       for (int nro=0 ; nro<=nh; ++nro) thaut.push_back (nro);
 129       grid->makeCylinder (NULL, rx, rz, tray, tang, thaut, true);
 130       }
 131
 132    DumpReturn (grid);
 133    return grid;
 134 }
 135 // ======================================================== makeCylinderUni
 136 Elements* Document::makeCylinderUni (Vertex* orig, Vector* vx, Vector* vz,
 137                            double rint, double rext, double ang, double haut,
 138                            int nr, int na, int nh)
 139 {
 140    DumpStart ("makeCylinderUni", orig << vx << vz << rint << rext
 141                                       << ang << haut << nr << na << nh);
 142
 143    Elements* grid = new Elements (this);
 144
 145    Real3 rx, rz;
 146    grid->checkOrig   (1, orig);
 147    grid->checkSize   (8, nr, na, nh, true);
 148    grid->checkPipe   (4, rint, rext, ang, haut);
 149    grid->checkSystem (2, vx, vz, rx, rz);
 150
 151    if (grid->isValid())
 152       {
 153       double dray  = (rext-rint) / nr;
 154       double dang  = ang  / na;
 155       double dhaut = haut / nh;
 156       RealVector tang, tray, thaut;
 157
 158       for (int nro=0 ; nro<=nr; ++nro) tray .push_back (rint + nro*dray);
 159       for (int nro=0 ; nro<=na; ++nro) tang .push_back (nro*dang);
 160       for (int nro=0 ; nro<=nh; ++nro) thaut.push_back (nro*dhaut);
 161
 162       grid->makeCylinder (orig, rx, rz, tray, tang, thaut, true);
 163       }
 164
 165    DumpReturn (grid);
 166    return grid;
 167 }
 168 // ======================================================== makeCylinder
 169 Elements* Document::makeCylinder (Vertex* orig, Vector* vx, Vector* vz,
 170                         RealVector tray, RealVector tang, RealVector thaut)
 171 {
 172    DumpStart ("makeCylinder", orig << vx << vz << tray << tang << thaut);
 173
 174    Elements* grid = new Elements (this);
 175
 176    Real3 rx, rz;
 177    grid->checkOrig   (1, orig);
 178    grid->checkSystem (2, vx, vz, rx, rz);
 179    grid->checkVector (4, tray);
 180    grid->checkVector (5, tang,  3);
 181    grid->checkVector (6, thaut);
 182
 183    if (grid->isValid())
 184       grid->makeCylinder (orig, rx, rz, tray, tang, thaut, true);
 185
 186    DumpReturn (grid);
 187    return grid;
 188 }
 189 // ======================================================== makePipeTop
 190 Elements* Document::makePipeTop (int nr, int na, int nh)
 191 {
 192    DumpStart ("makePipeTop", nr << na << nh);
 193
 194    Elements* grid = new Elements (this);
 195
 196    RealVector tray, tang, thaut;
 197    Real3 rx = { 1, 0, 0 };
 198    Real3 rz = { 0, 0, 1 };
 199
 200    grid->checkSize (1,nr, na, nh, true);
 201    if (grid->isValid())
 202       {
 203       double da = 360.0 / na;
 204       for (int nro=0 ; nro<=nr; ++nro) tray .push_back (nro+1);
 205       for (int nro=0 ; nro<=na; ++nro) tang .push_back (nro*da);
 206       for (int nro=0 ; nro<=nh; ++nro) thaut.push_back (nro);
 207       grid->makeCylinder (NULL, rx, rz, tray, tang, thaut, false);
 208       }
 209
 210    DumpReturn (grid);
 211    return grid;
 212 }
 213 // ======================================================== makePipeUni
 214 Elements* Document::makePipeUni (Vertex* orig, Vector* vx, Vector* vz,
 215                        double rint, double rext, double angle, double hauteur,
 216                        int nr, int na, int nh)
 217 {
 218    DumpStart ("makePipeUni", orig << vx << vz << rint << rext
 219                                   << angle << hauteur << nr << na << nh);
 220
 221    Elements* grid = new Elements (this);
 222
 223    Real3 rx, rz;
 224    RealVector tray, tang, thaut;
 225    grid->checkOrig   (1, orig);
 226    grid->checkSize   (8, nr, na, nh, true);
 227    grid->checkPipe   (4, rint, rext, angle, hauteur);
 228    grid->checkSystem (1, vx, vz, rx, rz);
 229
 230    if (grid->isValid())
 231       {
 232       double dray  = (rext-rint) / nr;
 233       double dang  = angle   / na;
 234       double dhaut = hauteur / nh;
 235       for (int nro=0 ; nro<=nr; ++nro) tray .push_back (rint + nro*dray);
 236       for (int nro=0 ; nro<=na; ++nro) tang .push_back (nro  * dang);
 237       for (int nro=0 ; nro<=nh; ++nro) thaut.push_back (nro  * dhaut);
 238
 239       grid->makeCylinder (orig, rx, rz, tray, tang, thaut, false);
 240       }
 241    DumpReturn (grid);
 242    return grid;
 243 }
 244 // ======================================================== makePipe
 245 Elements* Document::makePipe (Vertex* orig, Vector* vx, Vector* vz,
 246                        RealVector tray, RealVector tang, RealVector thaut)
 247 {
 248    DumpStart ("makePipe", orig << vx << vz << tray << tang << thaut);
 249
 250    Elements* grid = new Elements (this);
 251
 252    Real3 rx, rz;
 253    grid->checkOrig   (1, orig);
 254    grid->checkSystem (2, vx, vz, rx, rz);
 255    grid->checkVector (4, tray,  2);
 256    grid->checkVector (5, tang,  3);
 257    grid->checkVector (6, thaut, 2);
 258
 259    if (grid->isValid())
 260       grid->makeCylinder (orig, rx, rz, tray, tang, thaut, false);
 261
 262    DumpReturn (grid);
 263    return grid;
 264 }
 265 // ======================================================== makeSphericalTop
 266 Elements* Document::makeSphericalTop (int nbre, int crit)
 267 {
 268    DumpStart ("makeSphericalTop", nbre << crit);
 269    Elements* grid = new Elements (this);
 270
 271    Real3 orig = { 0, 0, 0 };
 272    Real3 rx   = { 1, 0, 0 };
 273    Real3 rz   = { 0, 0, 1 };
 274
 275    if (nbre<2)
 276       {
 277       grid->setError (HERR);
 278       Mess << "Argument number 1 :";
 279       Mess << "Nbr slices must be greather or equal than 2";
 280       }
 281
 282    if (grid->isValid())
 283       {
 284       RealVector trayon;
 285       for (int nro=1 ; nro<=nbre; ++nro) trayon.push_back (nro);
 286       grid->makeSpherical (orig, rx, rz, trayon, crit);
 287       }
 288
 289    DumpReturn (grid);
 290    return grid;
 291 }
 292 // ======================================================== makeSphericalUni
 293 Elements* Document::makeSphericalUni (Vertex* center, Vector* vx, Vector* vz,
 294                                       double rayon, int nbre, int crit)
 295 {
 296    DumpStart ("makeSphericalUni", center << vx << vz << rayon << nbre << crit);
 297    Elements* grid = new Elements (this);
 298
 299    Real3 rx, rz;
 300    grid->checkOrig   (1, center);
 301    grid->checkSystem (2, vx, vz, rx, rz);
 302
 303    if (rayon<=1e-5)
 304       {
 305       grid->setError (HERR);
 306       Mess << "Argument number 4 :";
 307       Mess << "Radius must be positive";
 308       }
 309
 310    if (nbre<2)
 311       {
 312       grid->setError (HERR);
 313       Mess << "Argument number 5 :";
 314       Mess << "Nbr slices must be greather or equal than 2";
 315       }
 316
 317    if (grid->isValid())
 318       {
 319       Real3      orig;
 320       RealVector trayon;
 321       center->getPoint (orig);
 322       for (int nro=1 ; nro<=nbre; ++nro) trayon.push_back (nro*rayon);
 323       grid->makeSpherical (orig, rx, rz, trayon, crit);
 324       }
 325
 326    DumpReturn (grid);
 327    return grid;
 328 }
 329 // ======================================================== makeSpherical
 330 Elements* Document::makeSpherical (Vertex* center, Vector* vx, Vector* vz,
 331                                    RealVector trayon, int crit)
 332 {
 333    DumpStart ("makeSpherical", center << vx << vz << trayon << crit);
 334    Elements* grid = new Elements (this);
 335
 336    Real3 rx, rz;
 337    grid->checkOrig   (1, center);
 338    grid->checkSystem (2, vx, vz, rx, rz);
 339    grid->checkVector (4, trayon, 2);
 340
 341    if (grid->isValid())
 342       {
 343       Real3 orig;
 344       center->getPoint (orig);
 345       grid->makeSpherical (orig, rx, rz, trayon, crit);
 346       }
 347
 348
 349    DumpReturn (grid);
 350    return grid;
 351 }
 352 // ======================================================== makeSphereTop
 353 Elements* Document::makeSphereTop (int nr, int na, int nh)
 354 {
 355    DumpStart ("makeSphereTop", nr << na << nh);
 356    Elements* grid = new Elements (this);
 357
 358    Real3 orig = { 0, 0, 0 };
 359    Real3 rx   = { 1, 0, 0 };
 360    Real3 rz   = { 0, 0, 1 };
 361
 362    double rtrou = 1;
 363    double rext  = 10;
 364    double angle = 360;
 365    double phi0, phi1;
 366
 367    grid->checkPhi (true, orig, rz, rext, rtrou, NULL, phi0, phi1);
 368
 369    if (nr<2)
 370       {
 371       grid->setError (HERR);
 372       Mess << "Argument number 1 :";
 373       Mess << "Nbr slices must be greather or equal than 2";
 374       }
 375
 376    if (na<3)
 377       {
 378       grid->setError (HERR);
 379       Mess << "Argument number 2 :";
 380       Mess << "Nbr sectors must be greather or equal than 3";
 381       }
 382
 383    if (nh<2)
 384       {
 385       grid->setError (HERR);
 386       Mess << "Argument number 3 :";
 387       Mess << "Nbr slices must be greather or equal than 2";
 388       }
 389
 390    if (grid->isValid())
 391       {
 392       double dr = (rext-rtrou)/nr;
 393       double da = angle / na;
 394       double dh = (phi1-phi0) / nh;
 395       RealVector tray, tang, thaut;
 396       for (int nro=0 ; nro<=nr; ++nro) tray .push_back (rtrou + nro*dr);
 397       for (int nro=0 ; nro<=na; ++nro) tang .push_back (nro*da);
 398       for (int nro=0 ; nro<=nh; ++nro) thaut.push_back (phi0  + nro*dh);
 399       grid->makeRind (GR_HEMISPHERIC, orig, rx, rz, tray, tang, thaut);
 400       }
 401
 402    DumpReturn (grid);
 403    return grid;
 404 }
 405 // ======================================================== makeSphereUni
 406 Elements* Document::makeSphereUni (Vertex* center, Vector* vx, Vector* vz,
 407                             double rtrou, double rext, double ang,
 408                             Vertex* hplan, int nr, int na, int nh)
 409 {
 410    DumpStart ("makeSphereUni", center << vx << vz << rtrou << rext << ang
 411                                       << hplan << nr << na << nh);
 412    Elements* grid = new Elements (this);
 413
 414    Real3 rx, rz;
 415    grid->checkOrig   (1, center);
 416    grid->checkSystem (2, vx, vz, rx, rz);
 417
 418    Real3 orig = { 0, 0, 0 };
 419    if (center != NULL)
 420        center->getPoint (orig);
 421
 422    double phi0, phi1;
 423    grid->checkPhi (true, orig, rz, rext, rtrou, hplan, phi0, phi1);
 424
 425    if (rtrou<=1e-5)
 426       {
 427       grid->setError (HERR);
 428       Mess << "Argument number 4 :";
 429       Mess << "Hole radius must be positive";
 430       }
 431
 432    if (rext<rtrou)
 433       {
 434       grid->setError (HERR);
 435       Mess << "Argument number 5 :";
 436       Mess << "External radius must be greather than hole radius";
 437       }
 438
 439    if (ang<1.0)
 440       {
 441       grid->setError (HERR);
 442       Mess << "Argument number 6 :";
 443       Mess << "Angle must be positive";
 444       }
 445
 446    if (nr<2)
 447       {
 448       grid->setError (HERR);
 449       Mess << "Argument number 7 :";
 450       Mess << "Nbr slices must be greather or equal than 2";
 451       }
 452
 453    if (na<3)
 454       {
 455       grid->setError (HERR);
 456       Mess << "Argument number 8 :";
 457       Mess << "Nbr sectors must be greather or equal than 3";
 458       }
 459
 460    if (nh<2)
 461       {
 462       grid->setError (HERR);
 463       Mess << "Argument number 9 :";
 464       Mess << "Nbr slices must be greather or equal than 2";
 465       }
 466
 467    EnumGrid type = ang>= 359.9 ? GR_HEMISPHERIC : GR_PART_SPHERIC;
 468    if (grid->isValid())
 469       {
 470       double dr = (rext-rtrou)/nr;
 471       double dh = (phi1-phi0) /nh;
 472       double da = ang / na;
 473       RealVector tray, tang, thaut;
 474       for (int nro=0 ; nro<=nr; ++nro) tray .push_back (rtrou + nro*dr);
 475       for (int nro=0 ; nro<=na; ++nro) tang .push_back (nro*da);
 476       for (int nro=0 ; nro<=nh; ++nro) thaut.push_back (phi0  + nro*dh);
 477       grid->makeRind (type, orig, rx, rz, tray, tang, thaut);
 478       }
 479
 480    DumpReturn (grid);
 481    return grid;
 482 }
 483 // ======================================================== makeSphere
 484 Elements* Document::makeSphere (Vertex* center, Vector* vx, Vector* vz,
 485                             RealVector tray, RealVector tang, RealVector thaut)
 486 {
 487    DumpStart ("makeSphere", center << vx << vz << tray << tang << thaut );
 488    Elements* grid = new Elements (this);
 489
 490    Real3 rx, rz;
 491    grid->checkOrig   (1, center);
 492    grid->checkSystem (2, vx, vz, rx, rz);
 493    grid->checkVector (4, tray,  2);
 494    grid->checkVector (5, tang,  3);
 495    grid->checkVector (6, thaut, 2);
 496
 497    int    nb    = tang.size()-1;
 498    double angle = nb <0 ? 0 : tang[nb] ;
 499    EnumGrid type = angle >= 359.9 ? GR_HEMISPHERIC : GR_PART_SPHERIC;
 500    if (grid->isValid())
 501       {
 502       Real3 orig;
 503       center->getPoint (orig);
 504       grid->makeRind (type, orig, rx, rz, tray, tang, thaut);
 505       }
 506
 507
 508    DumpReturn (grid);
 509    return grid;
 510 }
 511
 512 // ======================================================== makeRindTop
 513 Elements* Document::makeRindTop (int nr, int na, int nh)
 514 {
 515    DumpStart ("makeRindTop", nr << na << nh);
 516    Elements* grid = new Elements (this);
 517
 518    Real3 orig = { 0, 0, 0 };
 519    Real3 rx   = { 1, 0, 0 };
 520    Real3 rz   = { 0, 0, 1 };
 521
 522    double rtrou = 1;
 523    double rint  = 8;
 524    double rext  = 10;
 525    double angle = 360;
 526    double phi0, phi1;
 527
 528    grid->checkPhi (false, orig, rz, rext, rtrou, NULL, phi0, phi1);
 529
 530    if (nr<2)
 531       {
 532       grid->setError (HERR);
 533       Mess << "Argument number 1 :";
 534       Mess << "Nbr slices must be greather or equal than 2";
 535       }
 536
 537    if (na<3)
 538       {
 539       grid->setError (HERR);
 540       Mess << "Argument number 2 :";
 541       Mess << "Nbr sectors must be greather or equal than 3";
 542       }
 543
 544    if (nh<2)
 545       {
 546       grid->setError (HERR);
 547       Mess << "Argument number 3 :";
 548       Mess << "Nbr slices must be greather or equal than 2";
 549       }
 550
 551    if (grid->isValid())
 552       {
 553       double dr = (rext-rint)/nr;
 554       double da = angle / na;
 555       double dh = (phi1-phi0) / nh;
 556       RealVector tray, tang, thaut;
 557       tray .push_back (rtrou);
 558       for (int nro=0 ; nro<=nr; ++nro) tray .push_back (rint + nro*dr);
 559       for (int nro=0 ; nro<=na; ++nro) tang .push_back (nro*da);
 560       for (int nro=0 ; nro<=nh; ++nro) thaut.push_back (phi0  + nro*dh);
 561       grid->makeRind (GR_RIND, orig, rx, rz, tray, tang, thaut);
 562       }
 563
 564    DumpReturn (grid);
 565    return grid;
 566 }
 567 // ======================================================== makeRindUni
 568 Elements* Document::makeRindUni (Vertex* center, Vector* vx, Vector* vz,
 569                           double rtrou, double rint, double rext,
 570                           double ang, Vertex* hplan, int nr, int na, int nh)
 571 {
 572    DumpStart ("makeRindUni", center << vx << vz << rtrou << rint << rext << ang
 573                                     << hplan << nr << na << nh);
 574    Elements* grid = new Elements (this);
 575
 576    Real3 rx, rz;
 577    grid->checkOrig   (1, center);
 578    grid->checkSystem (2, vx, vz, rx, rz);
 579    grid->checkDiams  (4, rtrou, rint);
 580    grid->checkDiams  (5, rint,  rext);
 581
 582    Real3 orig = { 0, 0, 0 };
 583    if (center != NULL)
 584        center->getPoint (orig);
 585
 586    double phi0, phi1;
 587    grid->checkPhi (false, orig, rz, rext, rtrou, hplan, phi0, phi1);
 588
 589    if (rtrou<=1e-5)
 590       {
 591       grid->setError (HERR);
 592       Mess << "Argument number 4 :";
 593       Mess << "Hole radius must be positive";
 594       }
 595
 596    if (rint<rtrou)
 597       {
 598       grid->setError (HERR);
 599       Mess << "Argument number 5 :";
 600       Mess << "Internal radius must be greather than hole radius";
 601       }
 602
 603    if (rext<rtrou)
 604       {
 605       grid->setError (HERR);
 606       Mess << "Argument number 6 :";
 607       Mess << "External radius must be greather than internal radius";
 608       }
 609
 610    if (ang<1.0)
 611       {
 612       grid->setError (HERR);
 613       Mess << "Argument number 7 :";
 614       Mess << "Angle must be positive";
 615       }
 616
 617    if (nr<2)
 618       {
 619       grid->setError (HERR);
 620       Mess << "Argument number 8 :";
 621       Mess << "Nbr slices must be greather or equal than 2";
 622       }
 623
 624    if (na<3)
 625       {
 626       grid->setError (HERR);
 627       Mess << "Argument number 9 :";
 628       Mess << "Nbr sectors must be greather or equal than 3";
 629       }
 630
 631    if (nh<2)
 632       {
 633       grid->setError (HERR);
 634       Mess << "Argument number 10 :";
 635       Mess << "Nbr slices must be greather or equal than 2";
 636       }
 637
 638    EnumGrid type = ang>= 359.9 ? GR_RIND : GR_PART_RIND;
 639    if (grid->isValid())
 640       {
 641       double dr = (rext-rint)/nr;
 642       double dh = (phi1-phi0) /nh;
 643       double da = ang / na;
 644       RealVector tray, tang, thaut;
 645       tray .push_back (rtrou);
 646       for (int nro=0 ; nro<=nr; ++nro) tray .push_back (rint + nro*dr);
 647       for (int nro=0 ; nro<=na; ++nro) tang .push_back (nro*da);
 648       for (int nro=0 ; nro<=nh; ++nro) thaut.push_back (phi0 + nro*dh);
 649       grid->makeRind (type, orig, rx, rz, tray, tang, thaut);
 650       }
 651
 652    DumpReturn (grid);
 653    return grid;
 654 }
 655 // ======================================================== makeRind
 656 Elements* Document::makeRind (Vertex* center, Vector* vx, Vector* vz,
 657                           RealVector tray, RealVector tang, RealVector thaut)
 658 {
 659    DumpStart ("makeRind", center << vx << vz << tray << tang << thaut );
 660    Elements* grid = new Elements (this);
 661
 662    Real3 rx, rz;
 663    grid->checkOrig   (1, center);
 664    grid->checkSystem (2, vx, vz, rx, rz);
 665    grid->checkVector (4, tray,  2);
 666    grid->checkVector (5, tang,  3);
 667    grid->checkVector (6, thaut, 2);
 668
 669    int    nb    = tang.size()-1;
 670    double angle = nb <0 ? 0 : tang[nb] ;
 671    EnumGrid type = angle >= 359.9 ? GR_RIND : GR_PART_RIND;
 672    if (grid->isValid())
 673       {
 674       Real3 orig;
 675       center->getPoint (orig);
 676       grid->makeRind (type, orig, rx, rz, tray, tang, thaut);
 677       }
 678
 679
 680    DumpReturn (grid);
 681    return grid;
 682 }
 683 // ======================================================== makeCylinders
 684 BiCylinder* Document::makeCylinders (Vertex* ori1, Vector* vz1, double ray1,
 685                 double h1, Vertex* ori2, Vector* vz2, double ray2, double h2)
 686 {
 687    DumpStart ("makeCylinders", ori1 << vz1 << ray1 << h1 << ori2 << vz2
 688                                            << ray2<< h2);
 689    BiCylinder* grid = new BiCylinder (this);
 690
 691    Real3 rz1, rz2;
 692    grid->checkOrig   (1, ori1);
 693    grid->checkOrig   (5, ori2);
 694    grid->checkSystem (2, vz1, vz2, rz1, rz2);
 695
 696    if (grid->isValid())
 697       {
 698       if (ray1 < ray2)
 699           grid->makeCylinders (ori1, rz1, ray1, h1, ori2, rz2, ray2, h2);
 700       else
 701           grid->makeCylinders (ori2, rz2, ray2, h2, ori1, rz1, ray1, h1);
 702       }
 703
 704
 705    DumpReturn (grid);
 706    return grid;
 707 }
 708 // ======================================================== makePipes
 709 BiCylinder* Document::makePipes (Vertex* ori1, Vector* vz1, double rint1,
 710                                  double rext1, double h1,
 711       Vertex* ori2, Vector* vz2, double rint2, double rext2, double h2)
 712 {
 713    DumpStart ("makePipes", ori1 << vz1 << rint1 << rext1 << h1
 714                         << ori2 << vz2 << rint2 << rext2 << h2);
 715    BiCylinder* grid = new BiCylinder (this);
 716
 717    Real3 rz1, rz2;
 718    grid->checkOrig   (1, ori1);
 719    grid->checkOrig   (6, ori2);
 720    grid->checkSystem (2, vz1, vz2, rz1, rz2);
 721    grid->checkDiams  (3, rint1,  rext1);
 722    grid->checkDiams  (8, rint2,  rext2);
 723
 724    if (grid->isValid())
 725       {
 726       if (rext1 < rext2)
 727           grid->makePipes (ori1,rz1,rint1,rext1,h1, ori2,rz2,rint2,rext2,h2);
 728       else
 729           grid->makePipes (ori2,rz2,rint2,rext2,h2, ori1,rz1,rint1,rext1,h1);
 730       }
 731
 732    DumpReturn (grid);
 733    return grid;
 734 }
 735 // ------------------------------------------------------------------------
 736 // ------------------------------------------------------------------------
 737 // ------------------------------------------------------------------------
 738 // ========================================================= extrudeQuadTop
 739 Elements* Document::extrudeQuadTop (Quad* start, int nbre)
 740 {
 741    DumpStart ("extrudeQuadTop", start << nbre);
 742
 743    Quads      tstart;
 744    RealVector tlen;
 745    Real3      axe  = { 0, 0, 1 };
 746    double     larg = 1;
 747    Elements*  grid = new Elements (this);
 748
 749    tstart.push_back (start);
 750
 751    grid->checkQuad   (start);
 752    grid->makeNormale (tstart, axe, larg);
 753    for (int nro=0 ; nro<nbre; ++nro) tlen.push_back ((nro+1)*larg);
 754
 755    if (grid->isValid())
 756       {
 757       grid->extrudeQuads  (tstart, axe, tlen);
 758       }
 759
 760    DumpReturn (grid);
 761    return grid;
 762 }
 763 // ========================================================= extrudeQuadUni
 764 Elements* Document::extrudeQuadUni (Quad* start, Vector* axis, double len,
 765                                     int nbre)
 766 {
 767    DumpStart ("extrudeQuadUni", start << axis << len << nbre);
 768
 769    Quads      tstart;
 770    RealVector tlen;
 771    Real3      axe;
 772    Elements*  grid = new Elements (this);
 773
 774    grid->checkQuad  (start);
 775    grid->checkAxis  (axis, axe);
 776
 777    tstart.push_back (start);
 778
 779    for (int nro=0 ; nro<nbre; ++nro) tlen.push_back ((nro+1)*len);
 780
 781    if (grid->isValid())
 782       {
 783       grid->extrudeQuads  (tstart, axe, tlen);
 784       }
 785
 786    DumpReturn (grid);
 787    return grid;
 788 }
 789 // ========================================================= extrudeQuad
 790 Elements* Document::extrudeQuad (Quad* start, Vector* axis, RealVector tlen)
 791 {
 792    DumpStart ("extrudeQuad", start << axis << tlen);
 793
 794    Quads     tstart;
 795    Real3     axe;
 796    Elements* grid = new Elements (this);
 797
 798    grid->checkQuad   (start);
 799    grid->checkAxis   (axis, axe);
 800    grid->checkVector (3, tlen);
 801
 802    tstart.push_back (start);
 803
 804    if (grid->isValid())
 805       {
 806       grid->extrudeQuads  (tstart, axe, tlen);
 807       }
 808
 809    DumpReturn (grid);
 810    return grid;
 811 }
 812
 813 // ========================================================= extrudeQuadsTop
 814 Elements* Document::extrudeQuadsTop (Quads tstart, int nbre)
 815 {
 816    DumpStart ("extrudeQuadsTop", tstart << nbre);
 817
 818    RealVector tlen;
 819    Real3      axe  = { 0, 0, 1 };
 820    double     larg = 1;
 821    Elements* grid = new Elements (this);
 822
 823    grid->checkQuads  (tstart);
 824    grid->makeNormale (tstart, axe, larg);
 825    for (int nro=0 ; nro<nbre; ++nro) tlen.push_back ((nro+1)*larg);
 826
 827    if (grid->isValid())
 828       {
 829       grid->extrudeQuads  (tstart, axe, tlen);
 830       }
 831
 832    DumpReturn (grid);
 833    return grid;
 834 }
 835 // ========================================================= extrudeQuadsUni
 836 Elements* Document::extrudeQuadsUni (Quads tstart, Vector* axis, double len,
 837                                      int nbre)
 838 {
 839    DumpStart ("extrudeQuadsUni", tstart << axis << len << nbre);
 840
 841    RealVector tlen;
 842    Real3      axe;
 843    Elements*  grid = new Elements (this);
 844
 845    grid->checkQuads (tstart);
 846    grid->checkAxis  (axis, axe);
 847
 848    for (int nro=0 ; nro<nbre; ++nro) tlen.push_back ((nro+1)*len);
 849
 850    if (grid->isValid())
 851       {
 852       grid->extrudeQuads  (tstart, axe, tlen);
 853       }
 854
 855    DumpReturn (grid);
 856    return grid;
 857 }
 858 // ========================================================= extrudeQuads
 859 Elements* Document::extrudeQuads (Quads tstart, Vector* axis, RealVector tlen)
 860 {
 861    DumpStart ("extrudeQuads", tstart << axis << tlen);
 862
 863    Real3     axe;
 864    Elements* grid = new Elements (this);
 865
 866    grid->checkQuads  (tstart);
 867    grid->checkAxis   (axis, axe);
 868    grid->checkVector (3, tlen);
 869
 870    if (grid->isValid())
 871       {
 872       grid->extrudeQuads  (tstart, axe, tlen);
 873       }
 874
 875    DumpReturn (grid);
 876    return grid;
 877 }
 878 // ========================================================= revolutionQuadUni
 879 Elements* Document::revolutionQuadUni (Quad* start, Vertex* center,
 880                                        Vector* axis, double angle, int nbre)
 881 {
 882    DumpStart ("revolutionQuadUni", start << center << axis << angle << nbre);
 883
 884    Quads      tstart;
 885    RealVector angles;
 886    Real3      axe;
 887    Elements* grid = new Elements (this);
 888    double   alpha = angle / std::max (nbre, 1);
 889
 890    grid->checkQuad (start);
 891    grid->checkOrig (2, center);
 892    grid->checkAxis (axis, axe);
 893
 894    tstart.push_back (start);
 895    for (int nro=0 ; nro<nbre; ++nro) angles.push_back ((nro+1)*alpha);
 896
 897    if (grid->isValid())
 898       {
 899       grid->extrudeQuads  (tstart, axe, angles, true, center);
 900       }
 901
 902    DumpReturn (grid);
 903    return grid;
 904 }
 905 // ========================================================= revolutionQuad
 906 Elements* Document::revolutionQuad (Quad* start, Vertex* center, Vector* axis,
 907                                     RealVector angles)
 908 {
 909    DumpStart ("revolutionQuads", start << center << axis << angles);
 910
 911    Quads      tstart;
 912    Real3      axe;
 913    Elements*  grid = new Elements (this);
 914
 915    grid->checkQuad (start);
 916    grid->checkOrig (2, center);
 917    grid->checkAxis (axis, axe);
 918
 919    tstart.push_back (start);
 920
 921    if (grid->isValid())
 922       {
 923       grid->extrudeQuads  (tstart, axe, angles, true, center);
 924       }
 925
 926    DumpReturn (grid);
 927    return grid;
 928 }
 929 // ========================================================= revolutionQuadsUni
 930 Elements* Document::revolutionQuadsUni (Quads tstart, Vertex* center,
 931                                         Vector* axis, double angle, int nbre)
 932 {
 933    DumpStart ("revolutionQuadsUni", tstart << center << axis << angle << nbre);
 934
 935    RealVector angles;
 936    Real3      axe;
 937    Elements* grid  = new Elements (this);
 938    double    alpha = angle / std::max (nbre, 1);
 939
 940    grid->checkQuads (tstart);
 941    grid->checkOrig  (2, center);
 942    grid->checkAxis  (axis, axe);
 943
 944    for (int nro=0 ; nro<nbre; ++nro) angles.push_back ((nro+1)*alpha);
 945
 946    if (grid->isValid())
 947       {
 948       grid->extrudeQuads  (tstart, axe, angles, true, center);
 949       }
 950
 951    DumpReturn (grid);
 952    return grid;
 953 }
 954 // ========================================================= revolutionQuads
 955 Elements* Document::revolutionQuads (Quads tstart, Vertex* center, Vector* axis,
 956                                      RealVector angles)
 957 {
 958    DumpStart ("revolutionQuads", tstart << center << axis << angles);
 959
 960    Real3     axe;
 961    Elements* grid = new Elements (this);
 962
 963    grid->checkQuads  (tstart);
 964    grid->checkOrig   (2, center);
 965    grid->checkAxis   (axis,   axe);
 966    grid->checkVector (4, angles);
 967
 968    if (grid->isValid())
 969       {
 970       grid->extrudeQuads  (tstart, axe, angles, true, center);
 971       }
 972
 973    DumpReturn (grid);
 974    return grid;
 975 }
 976 // ------------------------------------------------------------------------
 977 // ------------------------------------------------------------------------
 978 // ------------------------------------------------------------------------
 979 // ========================================================= joinQuadUni
 980 Elements* Document::joinQuadUni (Quad* quada, Quad* quadb, Vertex* va1,
 981                               Vertex* vb1, Vertex* va2, Vertex* vb2, int nbre)
 982 {
 983    DumpStart ("joinQuadUni", quada << quadb << va1<<vb1 << va2<<vb2 << nbre);
 984
 985    Quads      tquada;
 986    RealVector tlen;
 987    Elements*  grid = new Elements (this);
 988
 989    grid->checkQuad  (quada);
 990    grid->checkQuad  (quadb, -1);
 991    grid->checkSense (3, va1, va2, quada);
 992    grid->checkSense (6, vb1, vb2, quadb);
 993
 994    nbre = nbre < 0 ? 0 : nbre;
 995    double dist = 1.0 / (nbre+1);
 996
 997    tquada.push_back (quada);
 998    for (int nro=0 ; nro<nbre; ++nro) tlen.push_back ((nro+1)*dist);
 999
1000    if (grid->isValid())
1001       {
1002       grid->joinQuads  (tquada, quadb, va1, vb1, va2, vb2, tlen);
1003       }
1004
1005    DumpReturn (grid);
1006    return grid;
1007 }
1008 // ========================================================= joinQuad
1009 Elements* Document::joinQuad (Quad* quada, Quad* quadb, Vertex* va1,
1010                     Vertex* vb1, Vertex* va2, Vertex* vb2, RealVector& tlen)
1011 {
1012    DumpStart ("joinQuad", quada << quadb << va1 << vb1 << va2 << vb2 << tlen);
1013
1014    Quads      tquada;
1015    Elements*  grid = new Elements (this);
1016
1017    grid->checkQuad   (quada);
1018    grid->checkQuad   (quadb, -1);
1019    grid->checkSense  (3, va1, va2, quada);
1020    grid->checkSense  (6, vb1, vb2, quadb);
1021    grid->checkVector (7, tlen, 0, true);
1022
1023    tquada.push_back (quada);
1024
1025    if (grid->isValid())
1026       {
1027       grid->joinQuads  (tquada, quadb, va1, vb1, va2, vb2, tlen);
1028       }
1029
1030    DumpReturn (grid);
1031    return grid;
1032 }
1033 // ========================================================= joinQuadsUni
1034 Elements* Document::joinQuadsUni (Quads tquada, Quad* quadb, Vertex* va1,
1035                            Vertex* vb1, Vertex* va2, Vertex* vb2, int nbre)
1036 {
1037    DumpStart ("joinQuadsUni", tquada << quadb << va1 << vb1 << va2 << vb2
1038                                      << nbre);
1039    RealVector tlen;
1040    Elements* grid = new Elements (this);
1041
1042    grid->checkQuads (tquada);
1043    grid->checkQuad  (quadb, -1);
1044    if (tquada.size()>0)
1045        grid->checkSense (3, va1, va2, tquada[0]);
1046    grid->checkSense (6, vb1, vb2, quadb);
1047
1048    nbre = nbre < 0 ? 0 : nbre;
1049    double dist = 1.0 / (nbre+1);
1050
1051    for (int nro=0 ; nro<nbre; ++nro) tlen.push_back ((nro+1)*dist);
1052
1053    if (grid->isValid())
1054       {
1055       grid->joinQuads  (tquada, quadb, va1, vb1, va2, vb2, tlen);
1056       }
1057
1058    DumpReturn (grid);
1059    return grid;
1060 }
1061 // ========================================================= joinQuads
1062 Elements* Document::joinQuads (Quads tquada, Quad* quadb, Vertex* va1,
1063                       Vertex* vb1, Vertex* va2, Vertex* vb2, RealVector& tlen)
1064 {
1065    DumpStart ("joinQuads", tquada << quadb << va1 << vb1 << va2 << vb2 << tlen);
1066
1067    Elements* grid = new Elements (this);
1068
1069    grid->checkQuads (tquada);
1070    grid->checkQuad  (quadb, -1);
1071    if (tquada.size()>0)
1072        grid->checkSense (3, va1, va2, tquada[0]);
1073    grid->checkSense  (6, vb1, vb2, quadb);
1074    grid->checkVector (7, tlen, 1, true);
1075
1076    if (grid->isValid())
1077       {
1078       grid->joinQuads  (tquada, quadb, va1, vb1, va2, vb2, tlen);
1079       }
1080
1081    DumpReturn (grid);
1082    return grid;
1083 }
1084 // ========================================================= cutUni
1085 Elements* Document::cutUni (Edge* edge, int nbre)
1086 {
1087    DumpStart ("cutUni", edge << nbre);
1088
1089    Elements*  grid = new Elements (this);
1090
1091    if (BadElement (edge))
1092       {
1093       grid->setError (HERR);
1094       Mess << "Argument number 1 : edge is not valid";
1095       }
1096
1097    if (nbre <= 0)
1098       {
1099       grid->setError (HERR);
1100       Mess << "Argument number 2 : number od subdivisions must be positive";
1101       nbre = 0;
1102       }
1103
1104    double dist = 1.0 / (nbre+1);
1105
1106    RealVector tlen;
1107    for (int nro=0 ; nro<nbre; ++nro) tlen.push_back ((nro+1)*dist);
1108
1109    if (grid->isValid())
1110       {
1111       grid->cutEdge  (edge, tlen);
1112       }
1113
1114    DumpReturn (grid);
1115    return grid;
1116 }
1117 // ========================================================= cut
1118 Elements* Document::cut (Edge* edge, RealVector& tlen)
1119 {
1120    DumpStart ("cut", edge << tlen);
1121
1122    Elements* grid = new Elements (this);
1123
1124    if (BadElement (edge))
1125       {
1126       grid->setError (HERR);
1127       Mess << "Argument number 1 : edge is not valid";
1128       }
1129
1130    grid->checkVector (2, tlen, 1, true);
1131
1132    if (grid->isValid())
1133       {
1134       grid->cutEdge  (edge, tlen);
1135       }
1136
1137    DumpReturn (grid);
1138    return grid;
1139 }
1140 END_NAMESPACE_HEXA