src/HEXABLOCK/HexQuad.hxx

   1
   2 // class : Les Quadrangles
   3
   4 #ifndef __QUAD_H
   5 #define __QUAD_H
   6
   7 #include "HexEdge.hxx"
   8
   9 BEGIN_NAMESPACE_HEXA
  10
  11 struct StrOrient
  12 {
  13    Vertex* v11;     // 1er sommet 1er quad
  14    Vertex* v12;     // 2eme
  15    Vertex* v21;     // 1er sommet 2eme quad
  16    Vertex* v22;     // 2eme
  17    int dir;         // direction element suivant
  18
  19 StrOrient ( Vertex* n11, Vertex* n12, Vertex* n21, Vertex* n22, int d=0)
  20     : v11 (n11), v12 (n12), v21 (n21), v22 (n22), dir (d) {}
  21
  22 StrOrient ( StrOrient* s)
  23     : v11 (s->v11), v12(s->v12), v21(s->v21), v22(s->v22), dir(s->dir){}
  24
  25 };
  26
  27 class Quad : public EltBase
  28 {
  29 public:
  30     virtual Edge*   getEdge   (int  nro);
  31     virtual Vertex* getVertex (int  nro);
  32
  33     virtual int countEdge   () { return QUAD4; }
  34     virtual int countVertex () { return QUAD4; }
  35
  36 public:
  37     Quad (Vertex* va, Vertex* vb, Vertex* vc, Vertex* vd);
  38     Quad (Edge* ea, Edge* eb, Edge* ec, Edge* ed);
  39     Quad (Quad* other);
  40
  41     Hexa* getParent (int nro);
  42
  43     Edge* findEdge   (Vertex* v1, Vertex*v2);
  44     Edge* commonEdge (Quad* other);
  45     int   anaMerge (Vertex* v1, Vertex* v2, Vertex* tv[], Edge* te[]);
  46
  47     int   ordoVertex (Vertex* v1, Vertex* v2, Vertex* tv[]);
  48     int   prepaMerge (Vertex* tv1[], Vertex* tv2[], Edge* te1[]);
  49
  50     int   inter     (Quad* other, int& nro);
  51     bool  definedBy (Vertex* v1, Vertex* v2);
  52     bool  definedBy (Edge*   e1,  Edge*   e2);
  53
  54     int   indexVertex (Vertex* elt);
  55     int   indexEdge   (Edge*   elt);
  56
  57     int   getOrientation (Vertex* v1, Vertex* v2, int &n1, int& n2);
  58     int   accoupler (Quad* other, StrOrient* orient);
  59     int   coupler (Quad* other, StrOrient* orient, Elements* table);
  60
  61     Edge* getOpposEdge (Edge* arete, int &sens);
  62
  63     virtual void majReferences();            // M.A.J relation "utilise par"
  64     virtual void dump ();
  65     virtual void dumpPlus ();
  66     virtual void saveXml (XmlWriter& xml);
  67     void setScalar (double valeur);
  68
  69     virtual void replaceEdge   (Edge*   old, Edge*   nouveau);
  70     virtual void replaceVertex (Vertex* old, Vertex* nouveau);
  71
  72     int   addAssociation (Shape* forme);
  73     const std::vector <Shape*> & getAssociations () { return tab_assoc ; }
  74
  75 private:
  76     friend class Cloner;
  77     Quad* getBrother (StrOrient* orient);
  78
  79 private:
  80     Edge*   q_edge   [QUAD4];
  81     Vertex* q_vertex [QUAD4];
  82
  83     std::vector <Shape*> tab_assoc;
  84 };
  85 // ----------------------------------------------- Inlining
  86 // ========================================================== addAssociation
  87 inline int Quad::addAssociation (Shape* forme)
  88 {
  89    tab_assoc.push_back (forme);
  90    return HOK;
  91 }
  92 // ============================================================  getEdge
  93 inline Edge* Quad::getEdge (int nro)
  94 {
  95    Edge* elt = NULL;
  96    if (nro >=0 && nro < QUAD4 && el_status == HOK && q_edge [nro]->isValid())
  97       elt = q_edge [nro];
  98
  99    return elt;
 100 }
 101 // ============================================================  getVertex
 102 inline Vertex* Quad::getVertex (int nro)
 103 {
 104    Vertex* elt = NULL;
 105    if (nro >=0 && nro < QUAD4 && el_status == HOK && q_vertex [nro]->isValid())
 106       elt = q_vertex [nro];
 107
 108    return elt;
 109 }
 110 // ======================================================== commonEdge
 111 inline Edge* Quad::commonEdge (Quad* other)
 112 {
 113    for (int ne1=0 ; ne1<QUAD4 ; ne1++)
 114        for (int ne2=0 ; ne2<QUAD4 ; ne2++)
 115            if (q_edge [ne1] == other->q_edge [ne2])
 116               return q_edge [ne1];
 117
 118    return NULL;
 119 }
 120
 121 // ======================================================== Inter
 122 inline int Quad::inter (Quad* other, int& nro)
 123 {
 124    for (int ne1=0 ; ne1<QUAD4 ; ne1++)
 125        for (int ne2=0 ; ne2<QUAD4 ; ne2++)
 126            if (q_edge [ne1] == other->q_edge [ne2])
 127               {
 128               nro  = ne2;
 129               return ne1;
 130               }
 131
 132    nro  = NOTHING;
 133    return NOTHING;
 134 }
 135 // ============================================================ definedBy (v)
 136 inline bool Quad::definedBy  (Vertex* v1, Vertex* v2)
 137 {
 138    for (int n1=0 ; n1< QUAD4 ; n1++)
 139        if (v1 == q_vertex[n1] && v2 == q_vertex[(n1+2) MODULO QUAD4])
 140           return true;
 141
 142    return false;
 143 }
 144 // ============================================================ definedBy (e)
 145 inline bool Quad::definedBy  (Edge* e1, Edge* e2)
 146 {
 147    for (int n1=0 ; n1< QUAD4 ; n1++)
 148        if (e1 == q_edge[n1] && e2 == q_edge[(n1+2) MODULO QUAD4])
 149           return true;
 150
 151    return false;
 152 }
 153 // =============================================================== findEdge
 154 inline Edge* Quad::findEdge (Vertex* v1, Vertex* v2)
 155 {
 156    for (int nro=0 ; nro< QUAD4 ; nro++)
 157        {
 158        Vertex* va = q_edge[nro]->getVertex(V_AMONT) ;
 159        Vertex* vb = q_edge[nro]->getVertex(V_AVAL) ;
 160        if ((v1==va && v2==vb) || (v1==vb && v2==va))
 161            return q_edge [nro];
 162        }
 163
 164    return NULL;
 165 }
 166 // =============================================================== indexVertex
 167 inline int Quad::indexVertex  (Vertex* elt)
 168 {
 169    for (int n1=0 ; n1< QUAD4 ; n1++)
 170        if (elt == q_vertex[n1])
 171           return n1;
 172
 173    return NOTHING;
 174 }
 175 // =============================================================== indexEdge
 176 inline int Quad::indexEdge  (Edge* elt)
 177 {
 178    for (int n1=0 ; n1< QUAD4 ; n1++)
 179        if (elt == q_edge[n1])
 180           return n1;
 181
 182    return NOTHING;
 183 }
 184 // =============================================================== setScalar
 185 inline void Quad::setScalar  (double val)
 186 {
 187    for (int n1=0 ; n1< QUAD4 ; n1++)
 188        q_vertex[n1] -> setScalar (val);
 189 }
 190
 191 END_NAMESPACE_HEXA
 192 #endif