src/HEXABLOCK/HexElements.hxx

   1
   2 // Class : Gestion des tableaux d'hexaedres
   3
   4 // Copyright (C) 2009-2024  CEA, EDF
   5 //
   6 // This library is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU Lesser General Public
   8 // License as published by the Free Software Foundation; either
   9 // version 2.1 of the License, or (at your option) any later version.
  10 //
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // Lesser General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU Lesser General Public
  17 // License along with this library; if not, write to the Free Software
  18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22
  23 #ifndef __ELEMENTS_H
  24 #define __ELEMENTS_H
  25
  26 #include "HexEltBase.hxx"
  27 #include "HexMatrix.hxx"
  28
  29 #include <map>
  30
  31 BEGIN_NAMESPACE_HEXA
  32
  33 class Qpattern;
  34 class HexaExport Elements : public EltBase
  35 {
  36 public:
  37    virtual Hexa*   getHexa   (int nro);
  38    virtual Quad*   getQuad   (int nro);
  39    virtual Edge*   getEdge   (int nro);
  40    virtual Vertex* getVertex (int nro);
  41
  42    Hexa*   getHexaIJK   (int nx, int ny, int nz);
  43    Quad*   getQuadIJ    (int nx, int ny, int nz);
  44    Quad*   getQuadJK    (int nx, int ny, int nz);
  45    Quad*   getQuadIK    (int nx, int ny, int nz);
  46    Edge*   getEdgeI     (int nx, int ny, int nz);
  47    Edge*   getEdgeJ     (int nx, int ny, int nz);
  48    Edge*   getEdgeK     (int nx, int ny, int nz);
  49    Vertex* getVertexIJK (int nx, int ny, int nz);
  50
  51    virtual int countHexa   () { return nbr_hexas ; }
  52    virtual int countQuad   () { return nbr_quads ; }
  53    virtual int countEdge   () { return nbr_edges ; }
  54    virtual int countVertex () { return nbr_vertex ; }
  55
  56    Vertex* nearestVertex (Vertex* other);
  57
  58    int findVertex (Vertex* elt);
  59    virtual void clearAssociation ();
  60    int saveVtk  (cpchar nomfic);
  61    Elements (Document* doc);
  62
  63 #ifndef SWIG
  64 public:
  65    int findHexa   (Hexa*   elt);
  66    int findQuad   (Quad*   elt);   // indexQuad   ?
  67    int findEdge   (Edge*   elt);   // indexVertex ?
  68
  69    int findVertex (double vx, double vy, double vz);
  70    Edge* findEdge   (Vertex* v1, Vertex* v2);
  71    Quad* findQuad   (Edge*   e1, Edge*   e2);
  72
  73    Elements (Document* doc, int nx, int ny, int nz);
  74    Elements (Elements* orig);
  75
  76    virtual ~Elements () {}
  77    virtual void remove ();
  78
  79    Hexa*   getStrate (int couche, EnumHQuad face);
  80
  81    int     getHexas (Hexas& liste);
  82
  83    void   addHexa (Hexa* element);
  84    void   addQuad (Quad* element);
  85    void   addEdge (Edge* element);
  86    void   addVertex (Vertex* element);
  87    int    transform (Matrix* matrice);
  88
  89    int saveVtk  (cpchar nomfic, int& nro);
  90
  91    int coupler  (int nro, Quad* other, StrOrient* orient);
  92
  93    int  cutHexas   (const Edges& edges, int nbcuts);
  94
  95    void setVertex (Vertex* node, int nx, int ny, int nz);
  96
  97    void transfoVertices (double* orig, double* base, double* haut);
  98
  99    void setVertex (Vertex* node, int nro);
 100    void setEdge   (Edge*   edge, int nro);
 101    void setQuad   (Quad*   quad, int nro);
 102    void setHexa   (Hexa*   cell, int nro);
 103
 104    int nroVertex (int nsommet,  int nquad, int nh);
 105
 106               // Evols Hexa3
 107
 108    int getCylPoint (int nr, int na, int nh, double& px, double& py, double& pz);
 109
 110    static int controlRind (EnumGrid type, Vertex* cx, Vector* vx, Vector* vz,
 111                            double rext, double rint, double radhole,
 112                            Vertex* plorig, double angle,
 113                            int nrad, int nang, int nhaut,
 114                            double &phi0, double &phi1);
 115
 116    int replaceHexas (Quads& pattern, Vertex* p1, Vertex* c1, // To Delete
 117                      Vertex* p2, Vertex* c2,  Vertex* p3, Vertex* c3);
 118
 119    int replaceHexas (Quads& pattern, Quads& target, Vertex* p1, Vertex* c1,
 120                      Vertex* p2, Vertex* c2);
 121
 122    int replaceHexa  (int nh, Pattern* pat, Hexa* hexa);
 123    int replaceQuad  (int nh, Pattern* pat, Quad* quad, Vertex* tvert[]);
 124    int extrudeQuad  (Pattern* pat);
 125
 126    int replaceHexa  (int nh, Qpattern* pat);
 127    int replaceQuad  (int nh, Qpattern* pat);
 128    int extrudeQuad  (Qpattern* pat);
 129
 130    void repVertex (int nh, int nro, Vertex* node);
 131    void repEdgeH  (int nh, int nro, Edge* node);
 132    void repEdgeV  (int nh, int nro, Edge* node);
 133    void repQuadH  (int nh, int nro, Quad* node);
 134    void repQuadV  (int nh, int nro, Quad* node);
 135
 136    Vertex* repVertex (int nh, int nro, double px, double py, double pz);
 137    Edge*   repEdgeV  (int nh, int nro, Vertex* v1, Vertex*v2);
 138    Edge*   repEdgeH  (int nh, int nro, Vertex* v1, Vertex*v2);
 139    Quad*   repQuadH  (int nh, int nro, Edge* ea, Edge* eb, Edge* ec, Edge* ed);
 140    Quad*   repQuadV  (int nh, int nro, Edge* ea, Edge* eb, Edge* ec, Edge* ed);
 141    Hexa*   repHexa   (int nh, int nro, Quad* qa, Quad* qb, Quad* qc,
 142                                        Quad* qd, Quad* qe, Quad* qf);
 143
 144    Vertex* repVertex (int nh, int nro);
 145    Edge*   repEdgeV  (int nh, int nro);
 146    Edge*   repEdgeH  (int nh, int nro);
 147    Quad*   repQuadH  (int nh, int nro);
 148    Quad*   repQuadV  (int nh, int nro);
 149
 150    virtual Hexa*   getKerHexa   (int nro) { return ker_hexa  [nro] ; }
 151    virtual Quad*   getKerHQuad  (int nro) { return ker_hquad [nro] ; }
 152    virtual Quad*   getKerVQuad  (int nro) { return ker_vquad [nro] ; }
 153    virtual Edge*   getKerHEdge  (int nro) { return ker_hedge [nro] ; }
 154    virtual Edge*   getKerVEdge  (int nro) { return ker_vedge [nro] ; }
 155
 156    void moveDisco (Hexa* hexa);
 157
 158
 159    // Hexa v6
 160    int makeCartesian (Vertex* origine, double* vx, double* vy, double* vz,
 161                       RealVector& lx, RealVector& ly, RealVector& lz);
 162    int makeCylinder (Vertex* origine, double* vx, double* vz,
 163                      RealVector& rayon, RealVector& angle, RealVector& hauteur,
 164                      bool fill);
 165    int makeSpherical (double* centre, double* vx, double* vz, RealVector& ray,
 166                       int critere);
 167    int makeRind (EnumGrid type, double* centre, double* vx, double* vz,
 168                  RealVector& rayon, RealVector& angle, RealVector& hauteur);
 169
 170    int extrudeQuads (Quads& quads, double* axe, RealVector& val,
 171                      bool revol=false, Vertex* center=NULL);
 172
 173    int joinQuads (Quads& quadsa, Quad* quadb, Vertex* va1, Vertex* vb1,
 174                   Vertex* va2, Vertex* vb2, RealVector& longueur);
 175
 176    int cutEdge (Edge* edge, RealVector& longueur);
 177
 178    // Internal Hexa v6
 179    void checkSystem (int nro, Vector* vx, Vector* vy, Vector* vz,
 180                      double* ux, double* uy, double* uz);
 181    void checkSystem (int nro, Vector* vx, Vector* vz, double* ux, double* uz);
 182    void checkSize   (int nro, int nx, int ny, int nz, bool rad=false);
 183    void checkVector (int nro, RealVector& table, int lgmin=1, bool relative=false);
 184    void checkPipe   (int nro, double rint, double rext, double ang, double hot);
 185    void checkOrig   (int nro, Vertex* orig);
 186    void checkDiams  (int nro, double rint, double rext);
 187
 188    int  checkPhi (bool sphere, double* orig, double* norm, double rmax,
 189                   double rhole, Vertex* plan, double& phi0, double& phi1);
 190
 191    int  checkInter (double* pa, double* ua, double raya, double lga,
 192                     double* pb, double* ub, double rayb, double lgb,
 193                     double* center, bool& left, bool& right);
 194
 195    void makeNormale (Quads& tquads, double* normale, double& larg) { } // TODO
 196    void checkQuads  (Quads& tquads);
 197    void checkQuad   (Quad*  quad, int nro=0);
 198    void checkAxis   (Vector* vect, double* axe);
 199    void checkSense  (int nro, Vertex* v1, Vertex* v2, Quad* quad);
 200
 201    void checkDisco  (Hexas& thexas, Edges&  tedges);
 202    void checkDisco  (Hexa* cell,    Quad*   element);
 203    void checkDisco  (Hexa* cell,    Edge*   element);
 204    void checkDisco  (Hexa* cell,    Vertex* element);
 205    void checkContour (Quads& tquad, Vertex* v1, Vertex* v2, bool target,
 206                       Edges& tedge);
 207    void checkContour (Quads& tquad, Vertex* v1, Vertex* v2, bool target,
 208                       Vertices& tvertex);
 209
 210 protected :
 211                                         // Evols Hexa3
 212    void cutAssociation (Shapes& tshapes, Edges& tedges, bool exist=true);
 213    void cutAssociation (Edge* orig, Edges& tedges);
 214    void assoCylinder   (Vertex* center, Vector* vz, double rayon);
 215    void assoCylinders  (Vertex* center, Vector* vz, double ray, RealVector& ta);
 216    void assoCylinders  (double* orig, double* vz, double ray, RealVector& ta);
 217
 218    void assoRind       (double* center, double* vx, int nx, NewShape* geom);
 219
 220    void assoSphere     (double* center, Edge* t_edge[], Quad* t_quad[]);
 221    void assoCircle     (double* center, Edge* ed1, Edge* ed2, NewShape* geom);
 222    void assoResiduelle ();
 223
 224    int makeBasicCylinder (RealVector& tdr, RealVector& tda, RealVector& tdh,
 225                           bool fill=false);
 226
 227    int  propagateAssociation (Edge* orig, Edge* dest, Edge* dir);
 228
 229                                         // Evols Hexa4
 230    void  updateMatrix (int hauteur);
 231    void  endPrism ();
 232                                         // Evols Hexa5
 233    int  prismAssociation     (Edge* orig, Edge* dest, int nh);
 234
 235                                         // Evols Hexa6
 236    int makeRindPoint (double ray, double ang, double haut, double& px,
 237                                               double& py,  double& pz);
 238
 239
 240 protected :
 241
 242    int   fillGrid ();
 243    void  fillCenter    ();
 244    void  fillCenter4   ();
 245    void  fillCenter6   ();
 246    void  fillCenterOdd ();
 247
 248    int  prismHexas (int nro, Quad* sol, int hauteur);
 249
 250    void setVertex (int nx, int ny, int nz, double px, double py, double pz);
 251    void setEdge   (Edge*   edge, EnumCoord dir, int nx, int ny, int nz);
 252    void setQuad   (Quad*   quad, EnumCoord dir, int nx, int ny, int nz);
 253    void setHexa   (Hexa*   cell, int nx, int ny, int nz);
 254
 255    Edge* newEdge (Vertex* v1, Vertex* v2);
 256    Quad* newQuad (Edge* e1, Edge* e2, Edge* e3, Edge* e4);
 257    Hexa* newHexa (Quad* e1, Quad* e2, Quad* e3, Quad* e4, Quad* e5, Quad* e6);
 258
 259    void resize (EnumGrid type, int nx, int ny=0, int nz=0, int nplus=0);
 260
 261    int makeCylindricalNodes (Vertex* c, Vector* b, Vector* h,
 262          double dr, double da, double dl, int nr, int na, int nl, bool fill);
 263
 264    int addStrate (Quad* i_quad[], Edge* i_edge[], Vertex* i_node[],
 265                   double* center,  double lambda);
 266
 267    int indVertex (int nsommet,  int nquad, int nh);
 268    int indVertex (int ref_vert, int nh);
 269    int nroEdgeH  (int nvertex);
 270    int nroEdgeH  (int nsommet,  int nquad, int nh);
 271    int nroHexa   (int nquad, int nh);
 272
 273    void copyVertex (Elements* other, int px, int py, int pz,
 274                                      int nx, int ny, int nz);
 275    void completerGrille  (double hauteur);
 276    NewShape* getShape   ();
 277    void      closeShape ();
 278
 279 protected :
 280     Globale* glob;
 281     EnumGrid grid_type;
 282
 283     std::vector<Hexa*>   tab_hexa;
 284     std::vector<Quad*>   tab_quad;
 285     std::vector<Edge*>   tab_edge;
 286     std::vector<Edge*>   tab_pilier;
 287     std::vector<Vertex*> tab_vertex;
 288
 289     std::vector<Quad*>   tab_orig;
 290
 291     int size_hx, size_hy, size_hz, size_hplus;
 292     int size_qx, size_qy, size_qz, size_qhplus, size_qvplus;
 293     int size_ex, size_ey, size_ez, size_ehplus, size_evplus;
 294     int size_vx, size_vy, size_vz;
 295
 296     int nbr_hexas, nbr_quads, nbr_edges, nbr_vertex;
 297     int nbr_orig, nbr_piliers, ker_vertex;
 298
 299     int   gr_rayon;              // Spheric
 300     int   gr_hauteur;            // Joint
 301     int   nbr_secteurs;          // Cyl
 302
 303     bool     cyl_closed;         // Angle = 180 degres
 304     bool     cyl_fill;           // Interieur rempli
 305     bool     val_absolues;       // Version Hexa6
 306     EnumCyl  cyl_dispo;          // Type de remplissage
 307
 308                                  // Evols Hexa3
 309     bool       revo_lution;  // Number 9 ...
 310     Vertex*    revo_center;
 311     Real3      revo_axe;
 312     bool       under_v6;
 313
 314     RealVector gen_values;    // Angle pour la revolution
 315     RealVector cum_values;    // Valeurs cumulees
 316     Matrix     gen_matrix;
 317     Matrix     cum_matrix;    // Matrice angles cumules
 318                                  // Evols Hexa4
 319     bool       prism_vec ;
 320     Real3      prism_dir;
 321     double     prism_len;
 322
 323 //  EnumGrid grid_type;   // deja la
 324     bool    grid_nocart;   // Grille non cartesienne : no acces aux getTrucIJK
 325     double  cyl_length;
 326     double  cyl_radhole, cyl_radext, cyl_radint;
 327     double  cyl_dtheta;              // angle = na*dtheta
 328     double  cyl_phi0,    cyl_dphi;   // angle = phi0 + nh*dphi;
 329     double  cyl_phimax;
 330
 331     int pat_nbedges;
 332     int pat_nbvertex;
 333
 334     std::vector<Hexa*>   ker_hexa;
 335     std::vector<Quad*>   ker_hquad, ker_vquad;
 336     std::vector<Edge*>   ker_hedge, ker_vedge;
 337
 338     NewShape*                    grid_geom; // Utilise pour faire la revolution
 339     std::map <std::string, int>  map_shape;
 340 #endif
 341 };
 342 END_NAMESPACE_HEXA
 343 #endif