src/HEXABLOCK/HexDocument.hxx

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