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