src/HEXABLOCK/HexElements.hxx

   1
   2 // Class : Gestion des tableaux d'hexaedres
   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/ or email : webmaster.salome@opencascade.com
  21 //
  22
  23 #ifndef __ELEMENTS_H
  24 #define __ELEMENTS_H
  25
  26 #include "HexEltBase.hxx"
  27 #include "HexHexa.hxx"
  28 #include "HexMatrix.hxx"
  29
  30 BEGIN_NAMESPACE_HEXA
  31
  32 class Elements : public EltBase
  33 {
  34 public:
  35    virtual Hexa*   getHexa   (int nro);
  36    virtual Quad*   getQuad   (int nro);
  37    virtual Edge*   getEdge   (int nro);
  38    virtual Vertex* getVertex (int nro);
  39
  40    virtual int countHexa   () { return nbr_hexas ; }
  41    virtual int countQuad   () { return nbr_quads ; }
  42    virtual int countEdge   () { return nbr_edges ; }
  43    virtual int countVertex () { return nbr_vertex ; }
  44
  45    int findHexa   (Hexa*   elt);
  46    int findQuad   (Quad*   elt);
  47    int findEdge   (Edge*   elt);
  48    int findVertex (Vertex* elt);
  49
  50    int findVertex (double vx, double vy, double vz);
  51
  52
  53 public:
  54    Elements (Document* doc);
  55    Elements (Document* doc, int nx, int ny, int nz);
  56    Elements (Elements* orig);
  57
  58    virtual ~Elements () {}
  59    virtual void remove ();
  60    virtual void clearAssociation ();
  61
  62    Hexa*   getStrate (int couche, EnumHQuad face);
  63
  64    Hexa*   getHexaIJK   (int nx, int ny, int nz);
  65    Quad*   getQuadIJ    (int nx, int ny, int nz);
  66    Quad*   getQuadJK    (int nx, int ny, int nz);
  67    Quad*   getQuadIK    (int nx, int ny, int nz);
  68    Edge*   getEdgeI     (int nx, int ny, int nz);
  69    Edge*   getEdgeJ     (int nx, int ny, int nz);
  70    Edge*   getEdgeK     (int nx, int ny, int nz);
  71    Vertex* getVertexIJK (int nx, int ny, int nz);
  72
  73    int     getHexas (Hexas& liste);
  74
  75    void   addHexa (Hexa* element);
  76    void   addQuad (Quad* element);
  77    void   addEdge (Edge* element);
  78    void   addVertex (Vertex* element);
  79    int    transform (Matrix* matrice);
  80
  81    int saveVtk  (cpchar nomfic);
  82    int saveVtk  (cpchar nomfic, int& nro);
  83
  84    int makeCartesianGrid (Vertex* orig, Vector* v1, Vector* v2, Vector* v3,
  85                       int px, int py, int pz, int mx=0, int my=0, int mz=0);
  86
  87    int makeCylinder (Cylinder* cyl, Vector* base, int nr, int na, int nl);
  88    int makePipe     (Cylinder* cyl, Vector* base, int nr, int na, int nl);
  89
  90    int makeCylindricalGrid (Vertex* c, Vector* b, Vector* h,
  91          double dr, double da, double dl, int nr, int na, int nl, bool fill);
  92
  93    int makeSphericalGrid (Vertex* v, Vector* dv, int nb, double k=1); // perime
  94    int makeSphericalGrid (Vertex* v, double rayon, int nb, double k=1);
  95
  96    int  joinQuads (Quads& q0, int nb, Vertex* v1, Vertex* v2, Vertex* v3,
  97                    Vertex* v4, Quad* dest);
  98    int coupler  (int nro, Quad* other, StrOrient* orient);
  99
 100    int  prismQuads (Quads& start, Vector* dv, int nb);
 101    int  prismQuadsVec (Quads& start, Vector* dv, RealVector& tlen, int crit);
 102
 103    int  cutHexas   (const Edges& edges, int nbcuts);
 104
 105    void setVertex (Vertex* node, int nx, int ny, int nz);
 106
 107    void transfoVertices (Vertex* orig, Vector* vi, Vector* vj, Vector* vk);
 108    void transfoVertices (Vertex* orig, Vector* base, Vector* haut);
 109
 110
 111    void setVertex (Vertex* node, int nro);
 112    void setEdge   (Edge*   edge, int nro);
 113    void setQuad   (Quad*   quad, int nro);
 114    void setHexa   (Hexa*   cell, int nro);
 115
 116    int nroVertex (int nsommet,  int nquad, int nh);
 117
 118               // Evols Hexa3
 119
 120    int getCylPoint (int nr, int na, int nh, double& px, double& py, double& pz);
 121    int revolutionQuads (Quads& start, Vertex* center, Vector* axis,
 122                         RealVector &angles);
 123
 124    int makeRind (EnumGrid type, Vertex* center, Vector* vx, Vector* vz,
 125                  double rext, double rint,  double radhole,
 126                  Vertex* plorig, double angle, int nrad, int nang, int nhaut);
 127
 128    static int controlRind (EnumGrid type, Vertex* cx, Vector* vx, Vector* vz,
 129                            double rext, double rint, double radhole,
 130                            Vertex* plorig, double angle,
 131                            int nrad, int nang, int nhaut,
 132                            double &phi0, double &phi1);
 133
 134    int makeCylindricalGrid (Vertex* c, Vector* b, Vector* h,
 135                             RealVector& tdr, RealVector& tda, RealVector& tdh,
 136                             bool fill=false);
 137
 138    int replaceHexas (Quads& pattern, Vertex* p1, Vertex* c1,
 139                      Vertex* p2, Vertex* c2,  Vertex* p3, Vertex* c3);
 140
 141    int replaceHexa  (int nh, Pattern* pat, Hexa* hexa);
 142    int replaceQuad  (int nh, Pattern* pat, Quad* quad, Vertex* tvert[]);
 143    int extrudeQuad  (Pattern* pat);
 144
 145    void repVertex (int nh, int nro, Vertex* node);
 146    void repEdgeH  (int nh, int nro, Edge* node);
 147    void repEdgeV  (int nh, int nro, Edge* node);
 148    void repQuadH  (int nh, int nro, Quad* node);
 149    void repQuadV  (int nh, int nro, Quad* node);
 150
 151    Vertex* repVertex (int nh, int nro, double px, double py, double pz);
 152    Edge*   repEdgeV  (int nh, int nro, Vertex* v1, Vertex*v2);
 153    Edge*   repEdgeH  (int nh, int nro, Vertex* v1, Vertex*v2);
 154    Quad*   repQuadH  (int nh, int nro, Edge* ea, Edge* eb, Edge* ec, Edge* ed);
 155    Quad*   repQuadV  (int nh, int nro, Edge* ea, Edge* eb, Edge* ec, Edge* ed);
 156    Hexa*   repHexa   (int nh, int nro, Quad* qa, Quad* qb, Quad* qc,
 157                                        Quad* qd, Quad* qe, Quad* qf);
 158
 159    Vertex* repVertex (int nh, int nro);
 160    Edge*   repEdgeV  (int nh, int nro);
 161    Edge*   repEdgeH  (int nh, int nro);
 162    Quad*   repQuadH  (int nh, int nro);
 163    Quad*   repQuadV  (int nh, int nro);
 164
 165    virtual Hexa*   getKerHexa   (int nro) { return ker_hexa  [nro] ; }
 166    virtual Quad*   getKerHQuad  (int nro) { return ker_hquad [nro] ; }
 167    virtual Quad*   getKerVQuad  (int nro) { return ker_vquad [nro] ; }
 168    virtual Edge*   getKerHEdge  (int nro) { return ker_hedge [nro] ; }
 169    virtual Edge*   getKerVEdge  (int nro) { return ker_vedge [nro] ; }
 170
 171    void moveDisco (Hexa* hexa);
 172
 173 protected :
 174                                         // Evols Hexa3
 175    void cutAssociation (Shapes& tshapes, Edges& tedges, bool exist=true);
 176    void assoCylinder   (Vertex* center, Vector* vz, double rayon);
 177    void assoCylinders  (Vertex* center, Vector* vz, double ray, RealVector& ta);
 178    void assoRind       (double* center, double* vx, int nx, NewShape* geom);
 179
 180    void assoSphere     (Vertex* center, Edge* t_edge[], Quad* t_quad[]);
 181    void assoCircle     (double* center, Edge* ed1, Edge* ed2, NewShape* geom);
 182    void assoResiduelle ();
 183
 184    int makeBasicCylinder (RealVector& tdr, RealVector& tda, RealVector& tdh,
 185                           bool fill=false);
 186
 187    int  propagateAssociation (Edge* orig, Edge* dest, Edge* dir1);
 188    int  prismAssociation     (Edge* orig, Edge* dest, int nh, Edge* dir);
 189
 190                                         // Evols Hexa4
 191    void  updateMatrix (int hauteur);
 192    void  endPrism ();
 193
 194 protected :
 195
 196    int   fillGrid ();
 197    void  fillCenter    ();
 198    void  fillCenter4   ();
 199    void  fillCenter6   ();
 200    void  fillCenterOdd ();
 201
 202    int  prismHexas (int nro, Quad* sol, int hauteur);
 203
 204    void setVertex (int nx, int ny, int nz, double px, double py, double pz);
 205    void setEdge   (Edge*   edge, EnumCoord dir, int nx, int ny, int nz);
 206    void setQuad   (Quad*   quad, EnumCoord dir, int nx, int ny, int nz);
 207    void setHexa   (Hexa*   cell, int nx, int ny, int nz);
 208
 209    Edge* newEdge (Vertex* v1, Vertex* v2);
 210    Quad* newQuad (Edge* e1, Edge* e2, Edge* e3, Edge* e4);
 211    Hexa* newHexa (Quad* e1, Quad* e2, Quad* e3, Quad* e4, Quad* e5, Quad* e6);
 212
 213    void resize (EnumGrid type, int nx, int ny=0, int nz=0, int nplus=0);
 214
 215    int makeCartesianNodes (Vertex* orig, Vector* v1, Vector* v2, Vector* v3,
 216                       int px, int py, int pz, int mx=0, int my=0, int mz=0);
 217
 218    int makeCylindricalNodes (Vertex* c, Vector* b, Vector* h,
 219          double dr, double da, double dl, int nr, int na, int nl, bool fill);
 220
 221    int makeBasicCylinder (double dr, double da, double dl, int nr, int na,
 222                                                            int nl, bool fill);
 223
 224    int addStrate (Quad* i_quad[], Edge* i_edge[], Vertex* i_node[],
 225                   Vertex* center,  double lambda);
 226
 227    int indVertex (int nsommet,  int nquad, int nh);
 228    int indVertex (int ref_vert, int nh);
 229    int nroEdgeH  (int nvertex);
 230    int nroEdgeH  (int nsommet,  int nquad, int nh);
 231    int nroHexa   (int nquad, int nh);
 232
 233    void copyVertex (Elements* other, int px, int py, int pz,
 234                                      int nx, int ny, int nz);
 235    void completerGrille  (double hauteur);
 236
 237 protected :
 238     Globale* glob;
 239     EnumGrid grid_type;
 240
 241     std::vector<Hexa*>   tab_hexa;
 242     std::vector<Quad*>   tab_quad;
 243     std::vector<Edge*>   tab_edge;
 244     std::vector<Edge*>   tab_pilier;
 245     std::vector<Vertex*> tab_vertex;
 246
 247     std::vector<Quad*>   tab_orig;
 248
 249     int size_hx, size_hy, size_hz, size_hplus;
 250     int size_qx, size_qy, size_qz, size_qhplus, size_qvplus;
 251     int size_ex, size_ey, size_ez, size_ehplus, size_evplus;
 252     int size_vx, size_vy, size_vz;
 253
 254     int nbr_hexas, nbr_quads, nbr_edges, nbr_vertex;
 255     int nbr_orig, nbr_piliers, ker_vertex;
 256
 257     int   gr_rayon;              // Spheric
 258     int   gr_hauteur;            // Joint
 259     int   nbr_secteurs;          // Cyl
 260
 261     bool     cyl_closed;         // Angle = 180 degres
 262     bool     cyl_fill;           // Interieur rempli
 263     EnumCyl  cyl_dispo;          // Type de remplissage
 264
 265                                  // Evols Hexa3
 266     bool       revo_lution;  // Number 9 ...
 267     Vertex*    revo_center;
 268     Vector*    revo_axis;
 269
 270     RealVector gen_values;    // Angle pour la revolution
 271     Matrix     gen_matrix;
 272                                  // Evols Hexa4
 273     bool       prism_vec ;
 274     Real3      prism_dir;
 275
 276 //  EnumGrid grid_type;   // deja la
 277     bool    grid_nocart;   // Grille non cartesienne : no acces aux getTrucIJK
 278     double  cyl_length;
 279     double  cyl_radhole, cyl_radext, cyl_radint;
 280     double  cyl_dtheta;              // angle = na*dtheta
 281     double  cyl_phi0,    cyl_dphi;   // angle = phi0 + nh*dphi;
 282
 283     int pat_nbedges;
 284     int pat_nbvertex;
 285
 286     std::vector<Hexa*>   ker_hexa;
 287     std::vector<Quad*>   ker_hquad, ker_vquad;
 288     std::vector<Edge*>   ker_hedge, ker_vedge;
 289 };
 290 // =================================================== getStrate
 291 inline Hexa* Elements::getStrate (int couche, EnumHQuad nroface)
 292 {
 293    Hexa* cell = NULL;
 294    int   nro  = couche <= 0 ? 0 : (couche-1)*HQ_MAXI + nroface + 1;
 295
 296    if (nbr_hexas==0 || nro >= nbr_hexas)
 297       cell = NULL;
 298    else
 299       cell = tab_hexa [nro];
 300
 301    return cell;
 302 }
 303 // ============================================================  setHexa
 304 inline void Elements::setHexa (Hexa* elt, int nro)
 305 {
 306    if (nro >=0 && nro < nbr_hexas)
 307        tab_hexa [nro] = elt;
 308 }
 309 // ============================================================  setQuad
 310 inline void Elements::setQuad (Quad* elt, int nro)
 311 {
 312    if (nro >=0 && nro < nbr_quads)
 313        tab_quad [nro] = elt;
 314 }
 315 // ============================================================  setEdge
 316 inline void Elements::setEdge (Edge* elt, int nro)
 317 {
 318    if (nro >=0 && nro < nbr_edges)
 319        tab_edge [nro] = elt;
 320 }
 321 // ============================================================  setVertex
 322 inline void Elements::setVertex (Vertex* elt, int nro)
 323 {
 324    if (nro >=0 && nro < nbr_vertex)
 325        tab_vertex [nro] = elt;
 326 }
 327 // -----------------------------------------------------------------------
 328 // -----------------------------------------------------------------------
 329 // ============================================================  getHexa
 330 inline Hexa* Elements::getHexa (int nro)
 331 {
 332    Hexa* elt = NULL;
 333    int  nombre=tab_hexa.size();
 334    // if (nro >=0 && nro < nbr_hexas && el_status == HOK Abu 2010/05/06
 335    if (nro >=0 && nro < nombre && el_status == HOK
 336                && tab_hexa [nro] != NULL && tab_hexa [nro]->isValid())
 337       elt = tab_hexa [nro];
 338
 339    return elt;
 340 }
 341 // ============================================================  getQuad
 342 inline Quad* Elements::getQuad (int nro)
 343 {
 344    Quad* elt = NULL;
 345    if (nro >=0 && nro < nbr_quads && el_status == HOK
 346                && tab_quad [nro] != NULL && tab_quad [nro]->isValid())
 347       elt = tab_quad [nro];
 348
 349    return elt;
 350 }
 351 // ============================================================  getEdge
 352 inline Edge* Elements::getEdge (int nro)
 353 {
 354    Edge* elt = NULL;
 355    if (nro >=0 && nro < nbr_edges && el_status == HOK
 356                && tab_edge [nro] != NULL && tab_edge [nro]->isValid())
 357       elt = tab_edge [nro];
 358
 359    return elt;
 360 }
 361 // ============================================================  getVertex
 362 inline Vertex* Elements::getVertex (int nro)
 363 {
 364    Vertex* elt = NULL;
 365    if (nro >=0 && nro <  nbr_vertex && el_status == HOK
 366                && tab_vertex [nro] != NULL && tab_vertex [nro]->isValid())
 367       elt = tab_vertex [nro];
 368
 369    return elt;
 370 }
 371 // ============================================================  indVertex
 372 inline int Elements::indVertex (int nquad, int nsommet, int nh)
 373 {
 374    int nro = nsommet  + QUAD4*nquad + nbr_orig*QUAD4*(nh+1);
 375    return nro;
 376 }
 377 // ============================================================  nroVertex
 378 inline int Elements::nroVertex (int nquad, int nsommet, int nh)
 379 {
 380    int nro = nsommet  + QUAD4*nquad + nbr_orig*QUAD4*nh;
 381    return nro;
 382 }
 383 // ============================================================  indVertex
 384 inline int Elements::indVertex (int ref_edge, int nh)
 385 {
 386    int    nro = ref_edge + nbr_orig*QUAD4*nh;
 387    return nro;
 388 }
 389 // ============================================================  nroEdgeH
 390 inline int Elements::nroEdgeH (int nvertex)
 391 {
 392    return QUAD4*nbr_orig*gr_hauteur + nvertex;
 393 }
 394 // ============================================================  nroEdgeH
 395 inline int Elements::nroEdgeH (int nquad, int nsommet, int nh)
 396 {
 397    return QUAD4*nbr_orig*gr_hauteur + indVertex (nquad, nsommet, nh);
 398 }
 399 // ============================================================  nroHexa
 400 inline int Elements::nroHexa (int nquad, int nh)
 401 {
 402    int nro = gr_hauteur*nquad + nh;
 403    return nro;
 404 }
 405
 406 // ============================================================  addHexa
 407 inline void Elements::addHexa (Hexa* element)
 408 {
 409    tab_hexa.push_back (element);
 410    nbr_hexas ++;
 411 }
 412 // ============================================================  addQuad
 413 inline void Elements::addQuad (Quad* element)
 414 {
 415    tab_quad.push_back (element);
 416    nbr_quads ++;
 417 }
 418 // ============================================================  addEdge
 419 inline void Elements::addEdge (Edge* element)
 420 {
 421    tab_edge.push_back (element);
 422    nbr_edges ++;
 423 }
 424 // ============================================================  addVertex
 425 inline void Elements::addVertex (Vertex* element)
 426 {
 427    tab_vertex.push_back (element);
 428    nbr_vertex ++;
 429 }
 430 // ============================================================  findHexa
 431 inline int Elements::findHexa (Hexa* element)
 432 {
 433    int nbre = tab_hexa.size();
 434    for (int nro=0 ; nro<nbre ; nro++)
 435        if (tab_hexa [nro] == element)
 436           return nro;
 437    return NOTHING;
 438 }
 439 // ============================================================  findQuad
 440 inline int Elements::findQuad (Quad* element)
 441 {
 442    int nbre = tab_quad.size();
 443    for (int nro=0 ; nro<nbre ; nro++)
 444        if (tab_quad [nro] == element)
 445           return nro;
 446    return NOTHING;
 447 }
 448 // ============================================================  findEdge
 449 inline int Elements::findEdge (Edge* element)
 450 {
 451    int nbre = tab_edge.size();
 452    for (int nro=0 ; nro<nbre ; nro++)
 453        if (tab_edge [nro] == element)
 454           return nro;
 455    return NOTHING;
 456 }
 457 // ============================================================  findVertex
 458 inline int Elements::findVertex (Vertex* element)
 459 {
 460    int nbre = tab_vertex.size();
 461    for (int nro=0 ; nro<nbre ; nro++)
 462        if (tab_vertex [nro] == element)
 463           return nro;
 464    return NOTHING;
 465 }
 466 // ========================================================= saveVtk (avec nro)
 467 inline int Elements::saveVtk  (cpchar radical, int &nro)
 468 {
 469    char num[8];
 470    sprintf (num, "%d", nro);
 471    nro ++;
 472
 473    string filename = radical;
 474    filename += num;
 475    filename += ".vtk";
 476    int ier = saveVtk (filename.c_str());
 477    return ier;
 478 }
 479
 480 END_NAMESPACE_HEXA
 481 #endif