src/HEXABLOCK/HexDocument.hxx

   1
   2 // class : Document
   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 __DOCUMENT_H_
  24 #define __DOCUMENT_H_
  25
  26 #include "HexEltBase.hxx"
  27
  28
  29 BEGIN_NAMESPACE_HEXA
  30
  31 class NewShape;
  32
  33 class Document : public EltBase
  34 {
  35                                    // Fonctions utilisateur
  36 public :
  37    Document (cpchar name, Hex* dad=NULL);
  38    void dump ();
  39    int  setName  (const char* name);
  40    void setLevel (int niv);
  41    int  save         (const char* ficxml); // Genere le xml dans un seul fichier
  42    int  saveVtk      (cpchar nomfic);
  43
  44    void purge ();
  45
  46    void   setTolerance (double tol) { doc_tolerance = std::max (tol, 0.0); }
  47    double getTolerance ()           { return doc_tolerance; }
  48
  49                                    // Creation d'elements
  50    Vertex* addVertex (double x=0.0, double y=0.0, double z=0.0);
  51
  52    Edge* addEdge       (Vertex* va, Vertex* vb);
  53    Edge* addEdgeVector (Vertex* va, Vector* vec);
  54
  55    Quad* addQuad   (Edge* v1, Edge* v2, Edge* v3, Edge* v4);
  56    Quad* addQuadVertices   (Vertex* v1, Vertex* v2, Vertex* v3, Vertex* v4);
  57
  58    Hexa* addHexa (Quad* qa, Quad* qb, Quad* qc, Quad* qd, Quad* qe, Quad* qf);
  59    Hexa* addHexaVertices   (Vertex* v1, Vertex* v2, Vertex* v3, Vertex* v4,
  60                              Vertex* v5, Vertex* v6, Vertex* v7, Vertex* v8);
  61
  62    Hexa* addHexa2Quads (Quad* q1, Quad* q2);
  63    Hexa* addHexa3Quads (Quad* q1, Quad* q2, Quad* q3);
  64    Hexa* addHexa4Quads (Quad* q1, Quad* q2, Quad* q3, Quad* q4);
  65    Hexa* addHexa5Quads (Quad* q1, Quad* q2, Quad* q3, Quad* q4, Quad* q5);
  66
  67    Vector*   addVector (double dx=0.0, double dy=0.0, double dz=0.0);
  68    Vector*   addVectorVertices (Vertex* va, Vertex* vb);
  69    Law*      addLaw    (const char* name, int nbnodes);
  70    int       addLaws   (double lgmoy, bool usemax=true);
  71
  72    Group*    addHexaGroup       (cpchar name);
  73    Group*    addQuadGroup       (cpchar name);
  74    Group*    addQuadNodeGroup   (cpchar name);
  75    Group*    addHexaNodeGroup   (cpchar name);
  76    Group*    addEdgeGroup       (cpchar name);
  77    Group*    addEdgeNodeGroup   (cpchar name);
  78    Group*    addVertexNodeGroup (cpchar name);
  79
  80
  81                                  // ----------------- Transformations
  82    Elements* makeTranslation   (Elements* elts, Vector* trans);
  83    Elements* makeScale         (Elements* elts, Vertex* ver, double k);
  84    Elements* makeRotation      (Elements* elts, Vertex* ver, Vector* vec,
  85                                 double angle);
  86    Elements* makeSymmetryPoint (Elements* elts, Vertex* ver);
  87    Elements* makeSymmetryLine  (Elements* elts, Vertex* ver, Vector* vec);
  88    Elements* makeSymmetryPlane (Elements* elts, Vertex* ver, Vector* vec);
  89
  90    int performTranslation (Elements* elts, Vector* trans);
  91    int performScale    (Elements* elts, Vertex* ver, double k);
  92    int performRotation (Elements* elts, Vertex* ver, Vector* vec, double angle);
  93    int performSymmetryPoint (Elements* elts, Vertex* ver);
  94    int performSymmetryLine  (Elements* elts, Vertex* ver, Vector* vec);
  95    int performSymmetryPlane (Elements* elts, Vertex* ver, Vector* vec);
  96
  97                                  // ----------------- Modifications
  98    Elements* cut (Edge* edge, int nbcuts);
  99    Elements* disconnectQuad   (Hexa* maille, Quad*   face);
 100    Elements* disconnectEdge   (Hexa* maille, Edge*   arete);
 101    Elements* disconnectVertex (Hexa* maille, Vertex* noeud);
 102    Elements* disconnectEdges  (Hexas thexas, Edges   edges);
 103
 104    Elements* replace (Quads pattern, Vertex* p1, Vertex* c1,
 105                       Vertex* p2, Vertex* c2,  Vertex* p3, Vertex* c3);
 106
 107    int     mergeVertices (Vertex* v1, Vertex* v2);
 108    int     mergeEdges    (Edge* e1, Edge* e2, Vertex* v1, Vertex* v2);
 109    int     mergeQuads    (Quad* q1, Quad* q2, Vertex* v1, Vertex* v2,
 110                                               Vertex* v3, Vertex* v4);
 111
 112                                  // ----------------- Associations
 113    void clearAssociation ();
 114    int  associateOpenedLine (Edges&  mline, NewShapes& gline, IntVector& tabid,
 115                              double pstart, double pend);
 116
 117    int  associateClosedLine (Vertex* mfirst,   Edges&  mline,
 118                              NewShapes& gline, IntVector& tabid,
 119                              double pstart, bool inv);
 120                                  // ----------------- count
 121    int countHexa   ();
 122    int countQuad   ();
 123    int countEdge   ();
 124    int countVertex ();
 125    int countVector ()               { return doc_vector.size(); }
 126
 127    int countGroup  ()               { return (int) doc_group.size(); }
 128    int countLaw  ()                 { return nbr_laws ; }
 129    int countPropagation ();
 130    int countShape ()                { return doc_tab_shape.size() ; }
 131
 132    int countUsedHexa   ();
 133    int countUsedQuad   ();
 134    int countUsedEdge   ();
 135    int countUsedVertex ();
 136
 137    int countCylinder ()             { return doc_cylinder.size(); }
 138    int countPipe ()                 { return doc_pipe.size(); }
 139
 140                                  // ----------------- get par indice
 141    Hexa*   getHexa   (int nro);
 142    Quad*   getQuad   (int nro);
 143    Edge*   getEdge   (int nro);
 144    Vertex* getVertex (int nro);
 145
 146    Hexa*   getUsedHexa   (int nro);
 147    Quad*   getUsedQuad   (int nro);
 148    Edge*   getUsedEdge   (int nro);
 149    Vertex* getUsedVertex (int nro);
 150
 151    Vector*      getVector   (int nro);
 152    Cylinder*    getCylinder (int nro);
 153    Pipe*        getPipe     (int nro);
 154    NewShape*    getShape    (int nro);
 155    Group*       getGroup    (int nro);
 156    Law*         getLaw      (int nro);
 157    Propagation* getPropagation   (int nro);
 158
 159                                  // ----------------- find
 160    Vertex* findVertex (double  vx, double  vy, double vz);
 161    Edge*   findEdge   (Vertex* va, Vertex* vb);
 162    Quad*   findQuad   (Vertex* va, Vertex* vb);
 163    Hexa*   findHexa   (Vertex* va, Vertex* vb);
 164
 165    Group*       findGroup   (cpchar name);
 166    Law*         findLaw     (cpchar name);
 167    Propagation* findPropagation  (Edge* arete);
 168
 169                                  // ----------------- Suppressions
 170    int  removeHexa          (Hexa* maille);
 171    int  removeQuad          (Quad* maille);
 172    int  removeConnectedHexa (Hexa* maille);
 173    int  removeElements      (Elements* bloc);
 174    int  removeGroup         (Group* grp);
 175    int  removeLaw           (Law*   lau);
 176
 177 public :
 178                                  // ----------------- Creations Hexav6
 179    Elements* makeCartesianTop (int nx, int ny, int nz);
 180    Elements* makeCartesianUni (Vertex* ori, Vector* vx, Vector* vy, Vector* vz,
 181                                double lx, double ly, double lz,
 182                                int    nx, int    ny, int    nz);
 183    Elements* makeCartesian    (Vertex* ori, Vector* vx, Vector* vy, Vector* vz,
 184                                RealVector tlx, RealVector tly, RealVector tlz);
 185
 186    Elements* makeCylinderTop (int nr, int na, int nh);
 187    Elements* makeCylinderUni (Vertex* orig, Vector* vx, Vector* vz,
 188                               double rint, double rext, double ang, double haut,
 189                               int nr, int na, int nh);
 190    Elements* makeCylinder (Vertex* orig, Vector* vx, Vector* vz,
 191                            RealVector tray, RealVector tang, RealVector thaut);
 192
 193    Elements* makePipeTop (int nr, int na, int nh);
 194    Elements* makePipeUni (Vertex* orig, Vector* vx, Vector* vz,
 195                           double rint, double rext, double angle, double haut,
 196                           int nr, int na, int nh);
 197    Elements* makePipe    (Vertex* orig, Vector* vx, Vector* vz,
 198                           RealVector tray, RealVector tang, RealVector thaut);
 199
 200    Elements* makeSphericalTop (int nbre, int crit=0);
 201    Elements* makeSphericalUni (Vertex* centre, Vector* vx, Vector* vz,
 202                                double rayon, int nbre, int crit=0);
 203    Elements* makeSpherical    (Vertex* centre, Vector* vx, Vector* vz,
 204                                RealVector rayon, int crit=0);
 205    Elements* makeSphereTop (int nr, int na, int nh);
 206    Elements* makeSphereUni (Vertex* centre, Vector* vx, Vector* vz,
 207                             double rtrou, double rext, double ang,
 208                             Vertex* vplan, int nr, int na, int nh);
 209    Elements* makeSphere    (Vertex* centre, Vector* vx, Vector* vz,
 210                             RealVector tray, RealVector tang, RealVector thaut);
 211
 212    Elements* makeRindTop (int nr, int na, int nh);
 213    Elements* makeRindUni (Vertex* centre, Vector* vx, Vector* vz,
 214                           double raytrou, double rint, double rext,
 215                           double ang, Vertex* vplan, int nr, int na, int nh);
 216    Elements* makeRind    (Vertex* centre, Vector* vx, Vector* vz,
 217                           RealVector tray, RealVector tang, RealVector thaut);
 218
 219    BiCylinder* makeCylinders (Vertex* ori1, Vector* z1, double r1, double h1,
 220                               Vertex* ori2, Vector* z2, double r2, double h2);
 221    BiCylinder* makePipes (Vertex* ori1, Vector* z1, double rint1, double rex1,
 222                           double h1, Vertex* ori2, Vector* z2, double rint2,
 223                           double rex2, double h2);
 224
 225    Elements* extrudeQuadTop (Quad* start, int nbre);
 226    Elements* extrudeQuadUni (Quad* start, Vector* dv, double len, int nbre);
 227    Elements* extrudeQuad    (Quad* start, Vector* dv, RealVector tlen);
 228
 229    Elements* extrudeQuadsTop (Quads start, int nbre);
 230    Elements* extrudeQuadsUni (Quads start, Vector* axis, double len, int nbre);
 231    Elements* extrudeQuads    (Quads start, Vector* axis, RealVector tlen);
 232
 233    Elements* revolutionQuadUni  (Quad* start, Vertex* center, Vector* axis,
 234                                  double angle, int nbre);
 235    Elements* revolutionQuad     (Quad* start, Vertex* center, Vector* axis,
 236                                  RealVector angles);
 237    Elements* revolutionQuadsUni (Quads start, Vertex* center, Vector* axis,
 238                                  double angle, int nbre);
 239    Elements* revolutionQuads    (Quads start, Vertex* center, Vector* axis,
 240                                  RealVector angles);
 241
 242    Elements* joinQuadUni  (Quad*  start, Quad* dest, Vertex* v1, Vertex* v2,
 243                            Vertex* v3, Vertex* v4, int nb);
 244
 245    Elements* joinQuadsUni (Quads start, Quad* dest, Vertex* v1, Vertex* v2,
 246                            Vertex* v3, Vertex* v4, int nb);
 247
 248    Elements* joinQuad     (Quad*  start, Quad* dest, Vertex* va1, Vertex* vb1,
 249                            Vertex* va2, Vertex* vb2, RealVector& tlen);
 250
 251    Elements* joinQuads    (Quads start, Quad* dest, Vertex* va1, Vertex* vb1,
 252                            Vertex* va2, Vertex* vb2, RealVector& tlen);
 253
 254    Elements* cutUni     (Edge* eddge, int nbre);
 255    Elements* cut        (Edge* eddge, RealVector& tlen);
 256
 257    Group*    addGroup  (cpchar name, EnumGroup kind);
 258                                    // Fonctions globales
 259    bool        isSaved ()              { return doc_saved ; }
 260
 261    int appendXml (pfile fstudy);       // Genere le xml dans un fichier ouvert
 262    cpchar getXml ();                   // Genere le xml et rend un flux
 263
 264    int  getLevel ()                    { return doc_db ; }
 265
 266    Elements* makeCartesian   (Vertex* v, Vector* v1,  // Obsolete
 267                        int px, int py, int pz, int mx=0, int my=0, int mz=0);
 268
 269    Vertex* findVertex (int id);
 270
 271    int     closeQuads    (Quad* q1, Quad* q2);
 272
 273    // ---------------------------------------------------
 274
 275    Law* addLaw    (Law* law); // lo-add-lololo
 276
 277    // ---------------------------------------------------
 278
 279    int  checkAssociations ();
 280                                                         // addShape version Python
 281    NewShape* addShape (long forme, const char* name);
 282
 283 #ifndef SWIG
 284                                                         // addShape HorsPython
 285    NewShape* addShape (TopoDS_Shape& forme, const char* name);
 286                                  // ----------------- Perimes Hexav6
 287    Cylinder* addCylinder   (Vertex* b, Vector* d, double r,  double h);
 288    Pipe*     addPipe  (Vertex* b, Vector* d, double ri, double re, double h);
 289    Elements* makeCartesian   (Vertex* v, Vector* v1, Vector* v2, Vector* v3,
 290                               int px, int py, int pz);
 291
 292    Elements* makeCartesian1  (Vertex* v, Vector* v1, Vector* v2, Vector* v3,
 293                               int px, int py, int pz, int mx, int my, int mz);
 294
 295    Elements* makeCylindrical (Vertex* c, Vector* b, Vector* h, double dr,
 296                               double da, double dl, int nr, int na, int nl,
 297                               bool fill);
 298    Elements* makeCylindricals (Vertex* c, Vector* b, Vector* h,
 299                             RealVector tdr, RealVector tda, RealVector tdh,
 300                             bool fill=false);
 301
 302    Elements* makeCylinder  (Cylinder* cyl, Vector* vx, int nr, int na, int nl);
 303    Elements* makePipe      (Pipe*     pip, Vector* vx, int nr, int na, int nl);
 304
 305    Elements* makeSpherical   (Vertex* center, double rayon, int nb, double k);
 306
 307    CrossElements* makeCylinders  (Cylinder* cyl1, Cylinder* cyl2);
 308    CrossElements* makePipes      (Pipe*    pipe1, Pipe* pipe2);
 309    BiCylinder*    makeBiCylinder (Cylinder* cyl1, Cylinder* cyl2);
 310    BiCylinder*    makeBiPipe     (Pipe*    pipe1, Pipe*    pipe2);
 311
 312    Elements* makeSphere (Vertex* center, Vector* vx, Vector* vz,
 313                          double radius, double radhole,
 314                          Vertex* plorig,
 315                          int nrad, int nang, int nhaut);
 316
 317    Elements* makePartSphere (Vertex* center, Vector* vx, Vector* vz,
 318                              double  radius, double radhole,
 319                              Vertex* plorig, double angle,
 320                              int nrad, int nang, int nhaut);
 321
 322    Elements* makeRind (Vertex* center, Vector* vx, Vector* vz,
 323                        double  radext, double radint, double radhole,
 324                        Vertex* plorig,
 325                        int nrad, int nang, int nhaut);
 326
 327    Elements* makePartRind (Vertex* center, Vector* vx, Vector* vz,
 328                            double  radext, double radint, double radhole,
 329                            Vertex* plorig, double angle,
 330                            int nrad, int nang, int nhaut);
 331
 332    Elements* prismQuad     (Quad* start, Vector* dv, int nb);
 333    Elements* prismQuads    (Quads start, Vector* dv, int nb);
 334    Elements* prismQuadsVec (Quads start, Vector* dv, RealVector th, int k);
 335
 336    Elements* revolutionQuadsVec (Quads start, Vertex* center, Vector* axis,
 337                               RealVector angles);
 338
 339    Elements* joinQuad  (Quad*  start, Quad* dest, Vertex* v1, Vertex* v2,
 340                                       Vertex* v3, Vertex* v4, int nb);
 341
 342    Elements* joinQuads (Quads start, Quad* dest, Vertex* v1, Vertex* v2,
 343                                      Vertex* v3, Vertex* v4, int nb);
 344
 345                                  // ----------------- Perimes (fin)
 346 public :
 347    void         dumpPropagation  ();
 348
 349    Document* copyDocument ();
 350
 351    NewShape*  getCloud ()          { return doc_cloud ; }
 352    NewShape*  addShape (const char* name, EnumShape type);
 353    NewShape*  findShape  (rcstring name);
 354
 355    int associateLine (Vertex* mfirst, Edges& mline,
 356                       NewShapes& gline, IntVector& tabid,
 357                       double pstart, double pend, bool inv);
 358
 359    int  clearAssociation  (EnumElt type);
 360    void clearAssoVertices ();
 361    void clearAssoEdges   ();
 362    void clearAssoQuads   ();
 363
 364    Quad*   findQuad   (Edge* ea, Edge* eb);
 365
 366 public:
 367    ~Document ();
 368
 369     int    loadXml (cpchar name);
 370     int    setXml  (cpchar flux);
 371     int    setXml  (cpchar flux, int& position);
 372
 373     EltBase* getFirstEltBase (EnumElt type) { return doc_first_elt [type]; }
 374     EltBase* getLastEltBase  (EnumElt type) { return doc_last_elt  [type]; }
 375     int      getNbrElt  (EnumElt type)      { return doc_nbr_elt   [type]; }
 376     void     setDeprecated (int level=1);
 377
 378     void markAll (int marque, int type=-1);
 379     int  saveVtk0 (cpchar nomfic);
 380     int  saveVtk  (cpchar radical, int &nro);
 381
 382     void  putError  (cpchar mess, cpchar info1=NULL, cpchar info2=NULL);
 383     void  hputError (cpchar mess, EltBase* e1, EltBase* e2=NULL);
 384
 385     void  majReferences  ();                  // M.A.J relation "utilise par"
 386     void  update ()            { if (maj_connection) majReferences (); }
 387     bool  debug (int niv=0)    { return doc_db > niv ; }
 388
 389     void  reorderFaces ();
 390     void  reorderQuads ();
 391
 392    // --------------------------------------------------- Evols Hexa5
 393    cpchar getNextName (EnumElt type, string& name);
 394    string getNextName (EnumElt type);
 395
 396    virtual char* makeVarName (char* name);
 397    void    lockDump();
 398    void    restoreDump();
 399    bool    isEmpty ();
 400
 401    // --------------------------------------------------- Evols Hexa6
 402
 403    void addHexa   (Hexa* elt)      { doc_hexas .push_back (elt) ; }
 404    void addQuad   (Quad* elt)      { doc_quads .push_back (elt) ; }
 405    void addEdge   (Edge* elt)      { doc_edges .push_back (elt) ; }
 406    void addVertex (Vertex* elt)    { doc_vertex.push_back (elt) ; }
 407
 408 public:
 409    Globale* glob;
 410
 411 private :
 412    int   genXml   ();
 413    int   parseXml (XmlTree& xml);
 414
 415    void  replaceVertex (Vertex* v1, Vertex* v2);
 416    void  replaceEdge   (Edge*   e1, Edge* e2);
 417    int   replaceQuad   (Quad*   q1, Quad* q2);
 418
 419    int   countElement  (EnumElt type);
 420    EltBase* getElement (EnumElt type, int nro);
 421
 422    void  majPropagation ();
 423    void  recountUsed ();
 424    void  renumeroter ();
 425
 426    Elements* clonerElements (Elements* table, Matrix* matrice);
 427
 428    // --------------------------------------------------- Evols Hexa3
 429    Hexa* addHexaQuadsAB   (AnaQuads& strquads);
 430    Hexa* addHexaQuadsAC   (AnaQuads& strquads);
 431    Hexa* addHexaQuadsACE  (AnaQuads& strquads);
 432    Hexa* addHexaQuadsACD  (AnaQuads& strquads);
 433    Hexa* addHexaQuadsABCD (AnaQuads& strquads);
 434    Hexa* addHexaQuadsACDE (AnaQuads& strquads);
 435
 436    EltBase* findElement (EnumElt type, int ident);
 437    // --------------------------------------------------- Evols Hexa5
 438    void addCloud ();
 439    int  sortShapes (NewShapes& tshapes, IntVector& subid,
 440                     bool closed, bool inv, double pstart, double pend,
 441                     EdgeShapes& glines, IntVector& sens, double& lgtotale);
 442    int sortEdges (Vertex* vfirst, Edges& mline, Edges& edges, IntVector& sens);
 443
 444    void parseShapes         (XmlTree& root);
 445    void parseAssociation    (XmlTree* root, Quad* elt);
 446    void parseAssociation    (XmlTree* root, Edge* elt);
 447    void parseAssociation    (XmlTree* root, Vertex* elt);
 448    SubShape* parseSubShape (XmlTree* root);
 449
 450 private :
 451    friend class EltBase;
 452
 453    bool doc_modified;
 454    bool count_modified;
 455    bool doc_saved;
 456    bool maj_connection;
 457    bool purge_elements;
 458    bool holes_elements;
 459    int  doc_db;
 460    int  nbr_errors;
 461
 462    EltBase* doc_first_elt [EL_MAXI];
 463    EltBase* doc_last_elt  [EL_MAXI];
 464    int      doc_nbr_elt   [EL_MAXI];
 465    double   doc_tolerance;
 466
 467    std::vector <Law*> doc_laws;
 468    int                nbr_laws;
 469    Law* defaultLaw;
 470
 471    int  nbr_propagations;
 472    bool maj_propagation;
 473
 474    std::vector <Propagation*> doc_propagation;
 475    std::vector <Group*>       doc_group;
 476
 477    std::vector <Vector*>      doc_vector;
 478    std::vector <Cylinder*>    doc_cylinder;
 479    std::vector <Pipe*>        doc_pipe;
 480    XmlWriter*                 doc_xml;
 481
 482    // --------------------------------------------------- Evols Hexa3
 483
 484    std::vector <Hexa*>   doc_used_hexas;
 485    std::vector <Quad*>   doc_used_quads;
 486    std::vector <Edge*>   doc_used_edges;
 487    std::vector <Vertex*> doc_used_vertex;
 488
 489    int nbr_used_hexas;
 490    int nbr_used_quads;
 491    int nbr_used_edges;
 492    int nbr_used_vertex;
 493
 494    // --------------------------------------------------- Evols Hexa5
 495
 496    static int doc_number;
 497    char      doc_ident [8];
 498    Hex*      hex_parent;
 499
 500    NewShape*   doc_cloud;                     // Nuage de points du doc;
 501    std::vector <NewShape*> doc_tab_shape;
 502
 503    // --------------------------------------------------- Evols internes Hexa6
 504    std::vector <Hexa*>   doc_hexas;
 505    std::vector <Quad*>   doc_quads;
 506    std::vector <Edge*>   doc_edges;
 507    std::vector <Vertex*> doc_vertex;
 508 #endif
 509 };
 510 END_NAMESPACE_HEXA
 511 #endif