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