src/HEXABLOCK/HexDocument.hxx

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