src/HEXABLOCK/HexDocument.hxx

   1
   2 // class : Document
   3
   4 #ifndef __DOCUMENT_H_
   5 #define __DOCUMENT_H_
   6
   7 #include "hexa_base.hxx"
   8
   9 BEGIN_NAMESPACE_HEXA
  10
  11 class Document
  12 {
  13                                    // Fonctions utilisateur
  14 public :
  15                                    // Fonctions globales
  16    const char* getFile ()              { return doc_name.c_str() ; }
  17    bool        isSaved ()              { return NOT doc_modified ; }
  18    int setFile (const char* filename)  { doc_name = filename ; return HOK ; }
  19    int saveFile ();
  20
  21    int  getLevel ()                    { return doc_db ; }
  22    void setLevel (int niv)             { doc_db = niv  ; }
  23
  24    Hexa*   getHexa   (int nro);
  25    Quad*   getQuad   (int nro);
  26    Edge*   getEdge   (int nro);
  27    Vertex* getVertex (int nro);
  28
  29    int countHexa   ()   { return countElement (EL_HEXA); }
  30    int countQuad   ()   { return countElement (EL_QUAD); }
  31    int countEdge   ()   { return countElement (EL_EDGE); }
  32    int countVertex ()   { return countElement (EL_VERTEX); }
  33
  34                                    // Creation d'elements
  35    Vertex* addVertex (double x=0.0, double y=0.0, double z=0.0);
  36    Edge*   addEdge   (Vertex* va, Vertex* vb);
  37    Edge*   addEdge   (Vertex* va, Vector* vec);
  38
  39    Quad*   addQuadVertices   (Vertex* v1, Vertex* v2, Vertex* v3, Vertex* v4);
  40    Quad*   addQuad   (Edge* v1, Edge* v2, Edge* v3, Edge* v4);
  41
  42    Hexa*   addHexaVertices   (Vertex* v1, Vertex* v2, Vertex* v3, Vertex* v4,
  43                              Vertex* v5, Vertex* v6, Vertex* v7, Vertex* v8);
  44    Hexa*   addHexa (Quad* qa, Quad* qb, Quad* qc, Quad* qd, Quad* qe, Quad* qf);
  45
  46    Vector* addVector (double dx=0.0, double dy=0.0, double dz=0.0);
  47    Vector* addVectorVertices (Vertex* va, Vertex* vb);
  48
  49
  50    Elements* makeCartesian   (Vertex* v, Vector* v1,
  51                        int px, int py, int pz, int mx=0, int my=0, int mz=0);
  52    Elements* makeCartesian   (Vertex* v, Vector* v1, Vector* v2, Vector* v3,
  53                        int px, int py, int pz, int mx=0, int my=0, int mz=0);
  54
  55    Elements* makeCylindrical (Vertex* c, Vector* b, Vector* h, double dr,
  56              double da, double dl, int nr, int na, int nl, bool fill=false);
  57
  58    Elements* makeSpherical   (Vertex* v, Vector* dv, int nb, double k=1);
  59
  60    Elements* prismQuad  (Quad*  start, Vector* dv, int nb);
  61    Elements* prismQuads (Quads& start, Vector* dv, int nb);
  62
  63    Elements* joinQuad  (Quad*  start, Quad* dest, Vertex* v1, Vertex* v2,
  64                                       Vertex* v3, Vertex* v4, int nb);
  65    Elements* joinQuads (Quads& start, Quad* dest, Vertex* v1, Vertex* v2,
  66                                       Vertex* v3, Vertex* v4, int nb);
  67
  68    Cylinder* addCylinder   (Vertex* b, Vector* d, double r,  double h);
  69    Elements* makeCylinder  (Cylinder* cyl, Vector* vx, int nr, int na, int nl);
  70    CrossElements* makeCylinders (Cylinder* cyl1, Cylinder* cyl2);
  71
  72    Pipe*     addPipe   (Vertex* b, Vector* d, double ri, double re, double h);
  73    Elements* makePipe  (Pipe* pip, Vector* vx, int nr, int na, int nl);
  74    CrossElements* makePipes (Pipe* pipe1, Pipe* pipe2);
  75
  76    // CrossElements* makePipes (Pipe* pipe1, int nr1, int na1, int nl1,
  77    //                          Pipe* pipe2, int nr2, int na2, int nl2);
  78
  79    int     removeHexa (Hexa* maille);
  80    int     removeConnectedHexa (Hexa* maille);
  81
  82    Vertex* findVertex (double  vx, double  vy, double vz);
  83    Edge*   findEdge   (Vertex* va, Vertex* vb);
  84    Quad*   findQuad   (Vertex* va, Vertex* vb);
  85    Hexa*   findHexa   (Vertex* va, Vertex* vb);
  86
  87    int     mergeVertices (Vertex* v1, Vertex* v2);
  88    int     mergeEdges    (Edge* e1, Edge* e2, Vertex* v1, Vertex* v2);
  89    int     mergeQuads    (Quad* q1, Quad* q2, Vertex* v1, Vertex* v2,
  90                                               Vertex* v3, Vertex* v4);
  91
  92    Elements* makeTranslation   (Elements* elts, Vector* trans);
  93    Elements* makeScale         (Elements* elts, Vertex* ver, double k);
  94    Elements* makeRotation      (Elements* elts, Vertex* ver, Vector* vec,
  95                                 double angle);
  96    Elements* makeSymmetryPoint (Elements* elts, Vertex* ver);
  97    Elements* makeSymmetryLine  (Elements* elts, Vertex* ver, Vector* vec);
  98    Elements* makeSymmetryPlane (Elements* elts, Vertex* ver, Vector* vec);
  99
 100    int performTranslation (Elements* elts, Vector* trans);
 101    int performScale    (Elements* elts, Vertex* ver, double k);
 102    int performRotation (Elements* elts, Vertex* ver, Vector* vec, double angle);
 103    int performSymmetryPoint (Elements* elts, Vertex* ver);
 104    int performSymmetryLine  (Elements* elts, Vertex* ver, Vector* vec);
 105    int performSymmetryPlane (Elements* elts, Vertex* ver, Vector* vec);
 106
 107    void   setTolerance (double tol) { doc_tolerance = std::max (tol, 0.0); }
 108    double getTolerance ()           { return doc_tolerance; }
 109
 110    Elements* disconnectQuad   (Hexa* maille, Quad*   face);
 111    Elements* disconnectEdge   (Hexa* maille, Edge*   arete);
 112    Elements* disconnectVertex (Hexa* maille, Vertex* noeud);
 113
 114    Elements* cut (Edge* edge, int nbcuts);
 115
 116    Group* addGroup    (cpchar name, EnumGroup kind);
 117    Group* getGroup    (int nro)        { return doc_group [nro];  }
 118    Group* findGroup   (cpchar name);
 119    int    removeGroup (Group* grp);
 120    int    countGroup  ()               { return (int) doc_group.size(); }
 121
 122    // ---------------------------------------------------
 123
 124    Law* addLaw    (const char* name, int nbnodes);
 125    int  countLaw  ()                            { return nbr_laws ; }
 126    Law* getLaw    (int nro);
 127    Law* findLaw   (const char* name);
 128    int  removeLaw (Law* loi);
 129
 130    // ---------------------------------------------------
 131    int          countPropagation ();
 132    Propagation* getPropagation   (int nro);
 133    Propagation* findPropagation  (Edge* arete);
 134    void         dumpPropagation  ();
 135
 136    int countVector ()              { return doc_vector.size(); }
 137    int countCylinder ()            { return doc_cylinder.size(); }
 138    int countPipe ()                { return doc_pipe.size(); }
 139
 140    Vector*   getVector   (int nro)   { return doc_vector [nro]; }
 141    Cylinder* getCylinder (int nro)   { return doc_cylinder [nro]; }
 142    Pipe*     getPipe     (int nro)   { return doc_pipe [nro]; }
 143
 144    void  purge ();
 145
 146 public:
 147     Document (cpchar filename);
 148    ~Document ();
 149
 150     int loadXml ();
 151
 152     EltBase* getFirstEltBase (EnumElt type) { return doc_first_elt [type]; }
 153     EltBase* getLastEltBase  (EnumElt type) { return doc_last_elt  [type]; }
 154     void     setModified ()                 { doc_modified = true; }
 155     void     setDeprecated (int level=1);
 156
 157     void dump ();
 158     void markAll (int marque, int type=-1);
 159     int  saveVtk  (cpchar nomfic);
 160     int  saveVtk  (cpchar radical, int &nro);
 161
 162     void  putError (cpchar mess, cpchar info1=NULL, cpchar info2=NULL);
 163     void  majReferences  ();                  // M.A.J relation "utilise par"
 164     void  update ()            { if (maj_connection) majReferences (); }
 165     bool  debug (int niv=0)    { return doc_db > niv ; }
 166
 167 public:
 168    Globale* glob;
 169
 170 private :
 171    void  replaceVertex (Vertex* v1, Vertex* v2);
 172    void  replaceEdge   (Edge*   e1, Edge* e2);
 173    void  replaceQuad   (Quad*   q1, Quad* q2);
 174    int   countElement  (EnumElt type);
 175    EltBase* getElement (EnumElt type, int nro);
 176
 177    void  majPropagation ();
 178    void  renumeroter ();
 179
 180    Elements* clonerElements (Elements* table, Matrix* matrice);
 181
 182 private :
 183    friend class EltBase;
 184
 185    bool doc_modified;
 186    bool maj_connection;
 187    bool purge_elements;
 188    int  doc_db;
 189    int  nbr_errors;
 190
 191    string   doc_name;
 192    EltBase* doc_first_elt [EL_MAXI];
 193    EltBase* doc_last_elt  [EL_MAXI];
 194    int      doc_nbr_elt   [EL_MAXI];
 195    double   doc_tolerance;
 196
 197    std::vector <Law*> doc_laws;
 198    int                nbr_laws;
 199
 200    int  nbr_propagations;
 201    bool maj_propagation;
 202
 203    std::vector <Propagation*> doc_propagation;
 204    std::vector <Group*>       doc_group;
 205
 206    std::vector <Vector*>      doc_vector;
 207    std::vector <Cylinder*>    doc_cylinder;
 208    std::vector <Pipe*>        doc_pipe;
 209 };
 210 // ========================================================= saveVtk (avec nro)
 211 inline int Document::saveVtk  (cpchar radical, int &nro)
 212 {
 213    char num[8];
 214    sprintf (num, "%d", nro);
 215    nro ++;
 216
 217    string filename = radical;
 218    filename += num;
 219    filename += ".vtk";
 220    int ier = saveVtk (filename.c_str());
 221    return ier;
 222 }
 223 // ========================================================= setDeprecated
 224 inline void Document::setDeprecated (int level)
 225 {
 226    switch (level)
 227           {
 228                          // En cas de destruction  : parents invalides
 229           case 2 : maj_connection  = true;
 230                    purge_elements  = true;
 231                          // creation + destruction : propagations a revoir
 232           case 1 : maj_propagation = true;
 233                          // Par defaut :
 234           default: doc_modified    = true;
 235           }
 236
 237 }
 238
 239 END_NAMESPACE_HEXA
 240 #endif