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