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 "Hex_defines.hxx"
  27 #include "HexEltBase.hxx"
  28 #include "HexMatrix.hxx"
  29
  30 #include <map>
  31
  32 BEGIN_NAMESPACE_HEXA
  33
  34 class HEXABLOCKENGINE_EXPORT 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 makeCartesianGrid (Vertex* orig, Vector* v1, Vector* v2, Vector* v3,
  92                       int px, int py, int pz, int mx=0, int my=0, int mz=0);
  93
  94    int makeCylinder (Cylinder* cyl, Vector* base, int nr, int na, int nl);
  95    int makePipe     (Cylinder* cyl, Vector* base, int nr, int na, int nl);
  96
  97    int makeCylindricalGrid (Vertex* c, Vector* b, Vector* h,
  98          double dr, double da, double dl, int nr, int na, int nl, bool fill);
  99
 100    int makeSphericalGrid (Vertex* v, Vector* dv, int nb, double k=1); // perime
 101    int makeSphericalGrid (Vertex* v, double rayon, int nb, double k=1); // perime
 102
 103    int  joinQuads (Quads& q0, int nb, Vertex* v1, Vertex* v2, Vertex* v3,
 104                    Vertex* v4, Quad* dest);
 105    int coupler  (int nro, Quad* other, StrOrient* orient);
 106
 107    int  prismQuads (Quads& start, Vector* dv, int nb);
 108    int  prismQuadsVec (Quads& start, Vector* dv, RealVector& tlen, int crit);
 109
 110    int  cutHexas   (const Edges& edges, int nbcuts);
 111
 112    void setVertex (Vertex* node, int nx, int ny, int nz);
 113
 114    void transfoVertices (double* orig, double* base, double* haut);
 115                              // DELETE les 2 suivants
 116    void transfoVertices (Vertex* orig, Vector* vi, Vector* vj, Vector* vk);
 117    void transfoVertices (Vertex* orig, Vector* base, Vector* haut);
 118
 119
 120    void setVertex (Vertex* node, int nro);
 121    void setEdge   (Edge*   edge, int nro);
 122    void setQuad   (Quad*   quad, int nro);
 123    void setHexa   (Hexa*   cell, int nro);
 124
 125    int nroVertex (int nsommet,  int nquad, int nh);
 126
 127               // Evols Hexa3
 128
 129    int getCylPoint (int nr, int na, int nh, double& px, double& py, double& pz);
 130    int revolutionQuads (Quads& start, Vertex* center, Vector* axis,
 131                         RealVector &angles);
 132
 133    int makeRind (EnumGrid type, Vertex* center, Vector* vx, Vector* vz,
 134                  double rext, double rint,  double radhole,
 135                  Vertex* plorig, double angle, int nrad, int nang, int nhaut);
 136
 137    static int controlRind (EnumGrid type, Vertex* cx, Vector* vx, Vector* vz,
 138                            double rext, double rint, double radhole,
 139                            Vertex* plorig, double angle,
 140                            int nrad, int nang, int nhaut,
 141                            double &phi0, double &phi1);
 142
 143    int makeCylindricalGrid (Vertex* c, Vector* b, Vector* h,
 144                             RealVector& tdr, RealVector& tda, RealVector& tdh,
 145                             bool fill=false);
 146
 147    int replaceHexas (Quads& pattern, Vertex* p1, Vertex* c1,
 148                      Vertex* p2, Vertex* c2,  Vertex* p3, Vertex* c3);
 149
 150    int replaceHexa  (int nh, Pattern* pat, Hexa* hexa);
 151    int replaceQuad  (int nh, Pattern* pat, Quad* quad, Vertex* tvert[]);
 152    int extrudeQuad  (Pattern* pat);
 153
 154    void repVertex (int nh, int nro, Vertex* node);
 155    void repEdgeH  (int nh, int nro, Edge* node);
 156    void repEdgeV  (int nh, int nro, Edge* node);
 157    void repQuadH  (int nh, int nro, Quad* node);
 158    void repQuadV  (int nh, int nro, Quad* node);
 159
 160    Vertex* repVertex (int nh, int nro, double px, double py, double pz);
 161    Edge*   repEdgeV  (int nh, int nro, Vertex* v1, Vertex*v2);
 162    Edge*   repEdgeH  (int nh, int nro, Vertex* v1, Vertex*v2);
 163    Quad*   repQuadH  (int nh, int nro, Edge* ea, Edge* eb, Edge* ec, Edge* ed);
 164    Quad*   repQuadV  (int nh, int nro, Edge* ea, Edge* eb, Edge* ec, Edge* ed);
 165    Hexa*   repHexa   (int nh, int nro, Quad* qa, Quad* qb, Quad* qc,
 166                                        Quad* qd, Quad* qe, Quad* qf);
 167
 168    Vertex* repVertex (int nh, int nro);
 169    Edge*   repEdgeV  (int nh, int nro);
 170    Edge*   repEdgeH  (int nh, int nro);
 171    Quad*   repQuadH  (int nh, int nro);
 172    Quad*   repQuadV  (int nh, int nro);
 173
 174    virtual Hexa*   getKerHexa   (int nro) { return ker_hexa  [nro] ; }
 175    virtual Quad*   getKerHQuad  (int nro) { return ker_hquad [nro] ; }
 176    virtual Quad*   getKerVQuad  (int nro) { return ker_vquad [nro] ; }
 177    virtual Edge*   getKerHEdge  (int nro) { return ker_hedge [nro] ; }
 178    virtual Edge*   getKerVEdge  (int nro) { return ker_vedge [nro] ; }
 179
 180    void moveDisco (Hexa* hexa);
 181
 182
 183    // Hexa v6
 184    int makeCartesian (Vertex* origine, double* vx, double* vy, double* vz,
 185                       RealVector& lx, RealVector& ly, RealVector& lz);
 186    int makeCylinder (Vertex* origine, double* vx, double* vz,
 187                      RealVector& rayon, RealVector& angle, RealVector& hauteur,
 188                      bool fill);
 189    int makeSpherical (double* centre, double* vx, double* vz, RealVector& ray,
 190                       int critere);
 191    int makeRind (EnumGrid type, double* centre, double* vx, double* vz,
 192                  RealVector& rayon, RealVector& angle, RealVector& hauteur);
 193
 194    int extrudeQuads (Quads& quads, double* axe, RealVector& val,
 195                      bool revol=false, Vertex* center=NULL);
 196
 197    int joinQuads (Quads& quadsa, Quad* quadb, Vertex* va1, Vertex* vb1,
 198                   Vertex* va2, Vertex* vb2, RealVector& longueur);
 199
 200    int cutEdge (Edge* edge, RealVector& longueur);
 201
 202    // Internal Hexa v6
 203    void checkSystem (int nro, Vector* vx, Vector* vy, Vector* vz,
 204                      double* ux, double* uy, double* uz);
 205    void checkSystem (int nro, Vector* vx, Vector* vz, double* ux, double* uz);
 206    void checkSize   (int nro, int nx, int ny, int nz, bool rad=false);
 207    void checkVector (int nro, RealVector& table, int lgmin=1, bool relative=false);
 208    void checkPipe   (int nro, double rint, double rext, double ang, double hot);
 209    void checkOrig   (int nro, Vertex* orig);
 210    void checkDiams  (int nro, double rint, double rext);
 211
 212    int  checkPhi (bool sphere, double* orig, double* norm, double rmax,
 213                   double rhole, Vertex* plan, double& phi0, double& phi1);
 214
 215    int  checkInter (double* pa, double* ua, double raya, double lga,
 216                     double* pb, double* ub, double rayb, double lgb,
 217                     double* center, bool& left, bool& right);
 218
 219    void makeNormale (Quads& tquads, double* normale, double& larg) { } // TODO
 220    void checkQuads  (Quads& tquads);
 221    void checkQuad   (Quad*  quad, int nro=0);
 222    void checkAxis   (Vector* vect, double* axe);
 223    void checkSense  (int nro, Vertex* v1, Vertex* v2, Quad* quad);
 224
 225    void checkDisco  (Hexas& thexas, Edges&  tedges);
 226    void checkDisco  (Hexa* cell,    Quad*   element);
 227    void checkDisco  (Hexa* cell,    Edge*   element);
 228    void checkDisco  (Hexa* cell,    Vertex* element);
 229
 230 protected :
 231                                         // Evols Hexa3
 232    void cutAssociation (Shapes& tshapes, Edges& tedges, bool exist=true);
 233    void cutAssociation (Edge* orig, Edges& tedges);
 234    void assoCylinder   (Vertex* center, Vector* vz, double rayon);
 235    void assoCylinders  (Vertex* center, Vector* vz, double ray, RealVector& ta);
 236    void assoCylinders  (double* orig, double* vz, double ray, RealVector& ta);
 237
 238    void assoRind       (double* center, double* vx, int nx, NewShape* geom);
 239
 240    void assoSphere     (double* center, Edge* t_edge[], Quad* t_quad[]);
 241    void assoCircle     (double* center, Edge* ed1, Edge* ed2, NewShape* geom);
 242    void assoResiduelle ();
 243
 244    int makeBasicCylinder (RealVector& tdr, RealVector& tda, RealVector& tdh,
 245                           bool fill=false);
 246
 247    int  propagateAssociation (Edge* orig, Edge* dest, Edge* dir);
 248
 249                                         // Evols Hexa4
 250    void  updateMatrix (int hauteur);
 251    void  endPrism ();
 252                                         // Evols Hexa5
 253    int  prismAssociation     (Edge* orig, Edge* dest, int nh);
 254
 255                                         // Evols Hexa6
 256    int makeRindPoint (double ray, double ang, double haut, double& px,
 257                                               double& py,  double& pz);
 258
 259
 260 protected :
 261
 262    int   fillGrid ();
 263    void  fillCenter    ();
 264    void  fillCenter4   ();
 265    void  fillCenter6   ();
 266    void  fillCenterOdd ();
 267
 268    int  prismHexas (int nro, Quad* sol, int hauteur);
 269
 270    void setVertex (int nx, int ny, int nz, double px, double py, double pz);
 271    void setEdge   (Edge*   edge, EnumCoord dir, int nx, int ny, int nz);
 272    void setQuad   (Quad*   quad, EnumCoord dir, int nx, int ny, int nz);
 273    void setHexa   (Hexa*   cell, int nx, int ny, int nz);
 274
 275    Edge* newEdge (Vertex* v1, Vertex* v2);
 276    Quad* newQuad (Edge* e1, Edge* e2, Edge* e3, Edge* e4);
 277    Hexa* newHexa (Quad* e1, Quad* e2, Quad* e3, Quad* e4, Quad* e5, Quad* e6);
 278
 279    void resize (EnumGrid type, int nx, int ny=0, int nz=0, int nplus=0);
 280
 281    int makeCartesianNodes (Vertex* orig, Vector* v1, Vector* v2, Vector* v3,
 282                       int px, int py, int pz, int mx=0, int my=0, int mz=0);
 283
 284    int makeCylindricalNodes (Vertex* c, Vector* b, Vector* h,
 285          double dr, double da, double dl, int nr, int na, int nl, bool fill);
 286
 287    int makeBasicCylinder (double dr, double da, double dl, int nr, int na,
 288                                                            int nl, bool fill);
 289
 290    int addStrate (Quad* i_quad[], Edge* i_edge[], Vertex* i_node[],  // DEL
 291                   Vertex* center,  double lambda);
 292
 293    int addStrate (Quad* i_quad[], Edge* i_edge[], Vertex* i_node[],
 294                   double* center,  double lambda);
 295
 296    int indVertex (int nsommet,  int nquad, int nh);
 297    int indVertex (int ref_vert, int nh);
 298    int nroEdgeH  (int nvertex);
 299    int nroEdgeH  (int nsommet,  int nquad, int nh);
 300    int nroHexa   (int nquad, int nh);
 301
 302    void copyVertex (Elements* other, int px, int py, int pz,
 303                                      int nx, int ny, int nz);
 304    void completerGrille  (double hauteur);
 305    NewShape* getShape   ();
 306    void      closeShape ();
 307
 308 protected :
 309     Globale* glob;
 310     EnumGrid grid_type;
 311
 312     std::vector<Hexa*>   tab_hexa;
 313     std::vector<Quad*>   tab_quad;
 314     std::vector<Edge*>   tab_edge;
 315     std::vector<Edge*>   tab_pilier;
 316     std::vector<Vertex*> tab_vertex;
 317
 318     std::vector<Quad*>   tab_orig;
 319
 320     int size_hx, size_hy, size_hz, size_hplus;
 321     int size_qx, size_qy, size_qz, size_qhplus, size_qvplus;
 322     int size_ex, size_ey, size_ez, size_ehplus, size_evplus;
 323     int size_vx, size_vy, size_vz;
 324
 325     int nbr_hexas, nbr_quads, nbr_edges, nbr_vertex;
 326     int nbr_orig, nbr_piliers, ker_vertex;
 327
 328     int   gr_rayon;              // Spheric
 329     int   gr_hauteur;            // Joint
 330     int   nbr_secteurs;          // Cyl
 331
 332     bool     cyl_closed;         // Angle = 180 degres
 333     bool     cyl_fill;           // Interieur rempli
 334     bool     val_absolues;       // Version Hexa6
 335     EnumCyl  cyl_dispo;          // Type de remplissage
 336
 337                                  // Evols Hexa3
 338     bool       revo_lution;  // Number 9 ...
 339     Vertex*    revo_center;
 340     Real3      revo_axe;
 341     bool       under_v6;
 342
 343     RealVector gen_values;    // Angle pour la revolution
 344     RealVector cum_values;    // Valeurs cumulees
 345     Matrix     gen_matrix;
 346     Matrix     cum_matrix;    // Matrice angles cumules
 347                                  // Evols Hexa4
 348     bool       prism_vec ;
 349     Real3      prism_dir;
 350     double     prism_len;
 351
 352 //  EnumGrid grid_type;   // deja la
 353     bool    grid_nocart;   // Grille non cartesienne : no acces aux getTrucIJK
 354     double  cyl_length;
 355     double  cyl_radhole, cyl_radext, cyl_radint;
 356     double  cyl_dtheta;              // angle = na*dtheta
 357     double  cyl_phi0,    cyl_dphi;   // angle = phi0 + nh*dphi;
 358     double  cyl_phimax;
 359
 360     int pat_nbedges;
 361     int pat_nbvertex;
 362
 363     std::vector<Hexa*>   ker_hexa;
 364     std::vector<Quad*>   ker_hquad, ker_vquad;
 365     std::vector<Edge*>   ker_hedge, ker_vedge;
 366
 367     NewShape*                    grid_geom; // Utilise pour faire la revolution
 368     std::map <std::string, int>  map_shape;
 369 #endif
 370 };
 371 END_NAMESPACE_HEXA
 372 #endif