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 #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
 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    Quad*   findQuad   (Edge*   ea, Edge*   eb);
 165    Hexa*   findHexa   (Vertex* va, Vertex* vb);
 166
 167    Group*       findGroup   (cpchar name);
 168    Law*         findLaw     (cpchar name);
 169    Propagation* findPropagation  (Edge* arete);
 170
 171                                  // ----------------- Suppressions
 172    int  removeHexa          (Hexa* maille);
 173    int  removeQuad          (Quad* maille);
 174    int  removeConnectedHexa (Hexa* maille);
 175    int  removeElements      (Elements* bloc);
 176    int  removeGroup         (Group* grp);
 177    int  removeLaw           (Law*   lau);
 178
 179 public :
 180                                  // ----------------- Creations Hexav6
 181    Elements* makeCartesianTop (int nx, int ny, int nz);
 182    Elements* makeCartesianUni (Vertex* ori, Vector* vx, Vector* vy, Vector* vz,
 183                                double lx, double ly, double lz,
 184                                int    nx, int    ny, int    nz);
 185    Elements* makeCartesian    (Vertex* ori, Vector* vx, Vector* vy, Vector* vz,
 186                                RealVector tlx, RealVector tly, RealVector tlz);
 187
 188    Elements* makeCylinderTop (int nr, int na, int nh);
 189    Elements* makeCylinderUni (Vertex* orig, Vector* vx, Vector* vz,
 190                               double rint, double rext, double ang, double haut,
 191                               int nr, int na, int nh);
 192    Elements* makeCylinder (Vertex* orig, Vector* vx, Vector* vz,
 193                            RealVector tray, RealVector tang, RealVector thaut);
 194
 195    Elements* makePipeTop (int nr, int na, int nh);
 196    Elements* makePipeUni (Vertex* orig, Vector* vx, Vector* vz,
 197                           double rint, double rext, double angle, double haut,
 198                           int nr, int na, int nh);
 199    Elements* makePipe    (Vertex* orig, Vector* vx, Vector* vz,
 200                           RealVector tray, RealVector tang, RealVector thaut);
 201
 202    Elements* makeSphericalTop (int nbre, int crit=0);
 203    Elements* makeSphericalUni (Vertex* centre, Vector* vx, Vector* vz,
 204                                double rayon, int nbre, int crit=0);
 205    Elements* makeSpherical    (Vertex* centre, Vector* vx, Vector* vz,
 206                                RealVector rayon, int crit=0);
 207    Elements* makeSphereTop (int nr, int na, int nh);
 208    Elements* makeSphereUni (Vertex* centre, Vector* vx, Vector* vz,
 209                             double rtrou, double rext, double ang,
 210                             Vertex* vplan, int nr, int na, int nh);
 211    Elements* makeSphere    (Vertex* centre, Vector* vx, Vector* vz,
 212                             RealVector tray, RealVector tang, RealVector thaut);
 213
 214    Elements* makeRindTop (int nr, int na, int nh);
 215    Elements* makeRindUni (Vertex* centre, Vector* vx, Vector* vz,
 216                           double raytrou, double rint, double rext,
 217                           double ang, Vertex* vplan, int nr, int na, int nh);
 218    Elements* makeRind    (Vertex* centre, Vector* vx, Vector* vz,
 219                           RealVector tray, RealVector tang, RealVector thaut);
 220
 221    BiCylinder* makeCylinders (Vertex* ori1, Vector* z1, double r1, double h1,
 222                               Vertex* ori2, Vector* z2, double r2, double h2);
 223    BiCylinder* makePipes (Vertex* ori1, Vector* z1, double rint1, double rex1,
 224                           double h1, Vertex* ori2, Vector* z2, double rint2,
 225                           double rex2, double h2);
 226
 227    Elements* extrudeQuadTop (Quad* start, int nbre);
 228    Elements* extrudeQuadUni (Quad* start, Vector* dv, double len, int nbre);
 229    Elements* extrudeQuad    (Quad* start, Vector* dv, RealVector tlen);
 230
 231    Elements* extrudeQuadsTop (Quads start, int nbre);
 232    Elements* extrudeQuadsUni (Quads start, Vector* axis, double len, int nbre);
 233    Elements* extrudeQuads    (Quads start, Vector* axis, RealVector tlen);
 234
 235    Elements* revolutionQuadUni  (Quad* start, Vertex* center, Vector* axis,
 236                                  double angle, int nbre);
 237    Elements* revolutionQuad     (Quad* start, Vertex* center, Vector* axis,
 238                                  RealVector angles);
 239    Elements* revolutionQuadsUni (Quads start, Vertex* center, Vector* axis,
 240                                  double angle, int nbre);
 241    Elements* revolutionQuads    (Quads start, Vertex* center, Vector* axis,
 242                                  RealVector angles);
 243
 244    Elements* joinQuadUni  (Quad*  start, Quad* dest, Vertex* v1, Vertex* v2,
 245                            Vertex* v3, Vertex* v4, int nb);
 246
 247    Elements* joinQuadsUni (Quads start, Quad* dest, Vertex* v1, Vertex* v2,
 248                            Vertex* v3, Vertex* v4, int nb);
 249
 250    Elements* joinQuad     (Quad*  start, Quad* dest, Vertex* va1, Vertex* vb1,
 251                            Vertex* va2, Vertex* vb2, RealVector& tlen);
 252
 253    Elements* joinQuads    (Quads start, Quad* dest, Vertex* va1, Vertex* vb1,
 254                            Vertex* va2, Vertex* vb2, RealVector& tlen);
 255
 256    Elements* cutUni     (Edge* eddge, int nbre);
 257    Elements* cut        (Edge* eddge, RealVector& tlen);
 258
 259    Group*    addGroup  (cpchar name, EnumGroup kind);
 260                                    // Fonctions globales
 261    bool        isSaved ()              { return doc_saved ; }
 262
 263    int appendXml (pfile fstudy);       // Genere le xml dans un fichier ouvert
 264    cpchar getXml ();                   // Genere le xml et rend un flux
 265
 266    int  getLevel ()                    { return doc_db ; }
 267
 268    Vertex* findVertex (int id);
 269
 270    int     closeQuads    (Quad* q1, Quad* q2);
 271
 272    // ---------------------------------------------------
 273
 274    Law* addLaw    (Law* law); // lo-add-lololo
 275
 276    // ---------------------------------------------------
 277
 278    int  checkAssociations ();
 279                                                         // addShape version Python
 280    NewShape* addShape (long forme, const char* name);
 281
 282 #ifndef SWIG
 283                                                         // addShape HorsPython
 284    NewShape* addShape (TopoDS_Shape& forme, const char* name);
 285
 286 public :
 287    void         dumpPropagation  ();
 288
 289    Document* copyDocument ();
 290
 291    NewShape*  getCloud ()          { return doc_cloud ; }
 292    NewShape*  addShape (const char* name, EnumShape type);
 293    NewShape*  findShape  (rcstring name);
 294
 295    int associateLine (Vertex* mfirst, Edges& mline,
 296                       NewShapes& gline, IntVector& tabid,
 297                       double pstart, double pend, bool inv);
 298
 299    int  clearAssociation  (EnumElt type);
 300    void clearAssoVertices ();
 301    void clearAssoEdges   ();
 302    void clearAssoQuads   ();
 303
 304                                // PERIMES
 305    Elements* replaceHexa (Quads pattern, Vertex* p1, Vertex* c1, Vertex* p2,
 306                           Vertex* c2,  Vertex* p3, Vertex* c3);
 307    Elements* replace (Quads pattern, Vertex* p1, Vertex* c1, Vertex* p2,
 308                       Vertex* c2,  Vertex* p3, Vertex* c3)
 309    { return  replaceHexa (pattern, p1, c1, p2, c2, p3, c3);  }
 310
 311    Elements* replaceHexas (Quads pattern, Quads cible, Vertex* p1, Vertex* c1,
 312                            Vertex* p2, Vertex* c2, Vertex* p3, Vertex* c3)
 313    { return  replace (pattern, cible, p1, c1, p2, c2); }
 314
 315
 316 public:
 317    ~Document ();
 318
 319     int    loadXml (cpchar name);
 320     int    setXml  (cpchar flux);
 321     int    setXml  (cpchar flux, int& position);
 322
 323     EltBase* getFirstEltBase (EnumElt type) { return doc_first_elt [type]; }
 324     EltBase* getLastEltBase  (EnumElt type) { return doc_last_elt  [type]; }
 325     int      getNbrElt  (EnumElt type)      { return doc_nbr_elt   [type]; }
 326     void     setDeprecated (int level=1);
 327
 328     void markAll (int marque, int type=-1);
 329     int  saveVtk0 (cpchar nomfic);
 330     int  saveVtk  (cpchar radical, int &nro);
 331
 332     void  putError  (cpchar mess, cpchar info1=NULL, cpchar info2=NULL);
 333     void  hputError (cpchar mess, EltBase* e1, EltBase* e2=NULL);
 334
 335     void  majReferences  ();                  // M.A.J relation "utilise par"
 336     void  update ()            { if (maj_connection) majReferences (); }
 337     bool  debug (int niv=0)    { return doc_db > niv ; }
 338
 339     void  reorderFaces ();
 340     void  reorderQuads ();
 341
 342    // --------------------------------------------------- Evols Hexa5
 343    cpchar getNextName (EnumElt type, string& name);
 344    string getNextName (EnumElt type);
 345
 346    virtual char* makeVarName (char* name);
 347    void    lockDump();
 348    void    restoreDump();
 349    bool    isEmpty ();
 350
 351    // --------------------------------------------------- Evols Hexa6
 352
 353    void addHexa   (Hexa* elt)      { doc_hexas .push_back (elt) ; }
 354    void addQuad   (Quad* elt)      { doc_quads .push_back (elt) ; }
 355    void addEdge   (Edge* elt)      { doc_edges .push_back (elt) ; }
 356    void addVertex (Vertex* elt)    { doc_vertex.push_back (elt) ; }
 357
 358 public:
 359    Globale* glob;
 360
 361 private :
 362    int   genXml   ();
 363    int   parseXml (XmlTree& xml);
 364
 365    void  replaceVertex (Vertex* v1, Vertex* v2);
 366    void  replaceEdge   (Edge*   e1, Edge* e2);
 367    int   replaceQuad   (Quad*   q1, Quad* q2);
 368
 369    int   countElement  (EnumElt type);
 370    EltBase* getElement (EnumElt type, int nro);
 371
 372    void  majPropagation ();
 373    void  recountUsed ();
 374    void  renumeroter ();
 375
 376    Elements* clonerElements (Elements* table, Matrix* matrice);
 377
 378    // --------------------------------------------------- Evols Hexa3
 379    Hexa* addHexaQuadsAB   (AnaQuads& strquads);
 380    Hexa* addHexaQuadsAC   (AnaQuads& strquads);
 381    Hexa* addHexaQuadsACE  (AnaQuads& strquads);
 382    Hexa* addHexaQuadsACD  (AnaQuads& strquads);
 383    Hexa* addHexaQuadsABCD (AnaQuads& strquads);
 384    Hexa* addHexaQuadsACDE (AnaQuads& strquads);
 385
 386    EltBase* findElement (EnumElt type, int ident);
 387    // --------------------------------------------------- Evols Hexa5
 388    void addCloud ();
 389    int  sortShapes (NewShapes& tshapes, IntVector& subid,
 390                     bool closed, bool inv, double pstart, double pend,
 391                     EdgeShapes& glines, IntVector& sens, double& lgtotale);
 392    int sortEdges (Vertex* vfirst, Edges& mline, Edges& edges, IntVector& sens);
 393
 394    void parseShapes         (XmlTree& root);
 395    void parseAssociation    (XmlTree* root, Quad* elt);
 396    void parseAssociation    (XmlTree* root, Edge* elt);
 397    void parseAssociation    (XmlTree* root, Vertex* elt);
 398    SubShape* parseSubShape (XmlTree* root);
 399
 400 private :
 401    friend class EltBase;
 402
 403    bool doc_modified;
 404    bool count_modified;
 405    bool doc_saved;
 406    bool maj_connection;
 407    bool purge_elements;
 408    bool holes_elements;
 409    int  doc_db;
 410    int  nbr_errors;
 411
 412    EltBase* doc_first_elt [EL_MAXI];
 413    EltBase* doc_last_elt  [EL_MAXI];
 414    int      doc_nbr_elt   [EL_MAXI];
 415    double   doc_tolerance;
 416
 417    std::vector <Law*> doc_laws;
 418    int                nbr_laws;
 419    Law* defaultLaw;
 420
 421    int  nbr_propagations;
 422    bool maj_propagation;
 423
 424    std::vector <Propagation*> doc_propagation;
 425    std::vector <Group*>       doc_group;
 426    std::vector <Vector*>      doc_vector;
 427    XmlWriter*                 doc_xml;
 428
 429    // --------------------------------------------------- Evols Hexa3
 430
 431    std::vector <Hexa*>   doc_used_hexas;
 432    std::vector <Quad*>   doc_used_quads;
 433    std::vector <Edge*>   doc_used_edges;
 434    std::vector <Vertex*> doc_used_vertex;
 435
 436    int nbr_used_hexas;
 437    int nbr_used_quads;
 438    int nbr_used_edges;
 439    int nbr_used_vertex;
 440
 441    // --------------------------------------------------- Evols Hexa5
 442
 443    static int doc_number;
 444    char      doc_ident [8];
 445    Hex*      hex_parent;
 446
 447    NewShape*   doc_cloud;                     // Nuage de points du doc;
 448    std::vector <NewShape*> doc_tab_shape;
 449
 450    // --------------------------------------------------- Evols internes Hexa6
 451    std::vector <Hexa*>   doc_hexas;
 452    std::vector <Quad*>   doc_quads;
 453    std::vector <Edge*>   doc_edges;
 454    std::vector <Vertex*> doc_vertex;
 455 #endif
 456 };
 457 END_NAMESPACE_HEXA
 458 #endif