src/HEXABLOCK/HexQuad.hxx

   1
   2 // class : Les Quadrangles
   3
   4 // Copyright (C) 2009-2012  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 #ifndef __QUAD_H
  23 #define __QUAD_H
  24
  25 #include "HexEdge.hxx"
  26
  27 BEGIN_NAMESPACE_HEXA
  28
  29 struct StrOrient
  30 {
  31    Vertex* v11;     // 1er sommet 1er quad
  32    Vertex* v12;     // 2eme
  33    Vertex* v21;     // 1er sommet 2eme quad
  34    Vertex* v22;     // 2eme
  35    int dir;         // direction element suivant
  36
  37 StrOrient ( Vertex* n11, Vertex* n12, Vertex* n21, Vertex* n22, int d=0)
  38     : v11 (n11), v12 (n12), v21 (n21), v22 (n22), dir (d) {}
  39
  40 StrOrient ( StrOrient* s)
  41     : v11 (s->v11), v12(s->v12), v21(s->v21), v22(s->v22), dir(s->dir){}
  42
  43 };
  44
  45 class Quad : public EltBase
  46 {
  47 public:
  48     virtual Edge*   getEdge   (int  nro);
  49     virtual Vertex* getVertex (int  nro);
  50
  51     virtual int countEdge   () { return QUAD4; }
  52     virtual int countVertex () { return QUAD4; }
  53
  54 public:
  55     Quad (Vertex* va, Vertex* vb, Vertex* vc, Vertex* vd);
  56     Quad (Edge* ea, Edge* eb, Edge* ec, Edge* ed);
  57     Quad (Quad* other);
  58
  59     Hexa* getParent (int nro);
  60
  61     Edge* findEdge   (Vertex* v1, Vertex*v2);
  62     Edge* commonEdge (Quad* other);
  63     int   anaMerge (Vertex* v1, Vertex* v2, Vertex* tv[], Edge* te[]);
  64
  65     int   ordoVertex (Vertex* v1, Vertex* v2, Vertex* tv[]);
  66     int   prepaMerge (Vertex* tv1[], Vertex* tv2[], Edge* te1[]);
  67
  68     int   inter     (Quad* other, int& nro);
  69     bool  definedBy (Vertex* v1, Vertex* v2);
  70     bool  definedBy (Edge*   e1,  Edge*   e2);
  71
  72     int   indexVertex (Vertex* elt);
  73     int   indexEdge   (Edge*   elt);
  74
  75     int   accoupler (Quad* other, StrOrient* orient);
  76     int   coupler (Quad* other, StrOrient* orient, Elements* table);
  77
  78     Edge*   getOpposEdge   (Edge* arete, int &sens);
  79     Vertex* getOpposVertex (Vertex* sommet);
  80
  81     virtual void majReferences();            // M.A.J relation "utilise par"
  82     virtual void dump ();
  83     virtual void dumpPlus ();
  84     virtual void saveXml (XmlWriter* xml);
  85     void setScalar (double valeur);
  86     void setColor  (double valeur)          { setScalar (valeur) ; }
  87
  88     void         replace (Quad* old);
  89     virtual void replaceEdge   (Edge*   old, Edge*   nouveau);
  90     virtual void replaceVertex (Vertex* old, Vertex* nouveau);
  91
  92     virtual void  setAssociation (Shape* forme);
  93     virtual int   addAssociation (Shape* forme);
  94     virtual void  clearAssociation  ()      { tab_assoc.clear() ; }
  95     virtual bool  isAssociated ()           { return tab_assoc.size() > 0  ; }
  96
  97     const Shapes& getAssociations ()        { return tab_assoc ; }
  98
  99
 100     virtual void duplicate ();
 101     Quad* getClone ()               {  return q_clone ; }
 102
 103     Edge* getOpposEdge     (Edge* arete);   // Version simplifiee
 104     Edge* getPerpendicular (Edge* arete, Vertex* node);
 105     int   getOrientation ()            { return q_orientation; }
 106     int   setOrientation ();
 107     void  setOrientation (int ori);
 108
 109 private:
 110     friend class Cloner;
 111     Quad* getBrother (StrOrient* orient);
 112
 113 private:
 114     Edge*   q_edge   [QUAD4];
 115     Vertex* q_vertex [QUAD4];
 116     Quad*   q_clone;
 117     int     q_orientation;
 118
 119     Shapes tab_assoc;
 120 };
 121 // ----------------------------------------------- Inlining
 122 // ========================================================== addAssociation
 123 inline int Quad::addAssociation (Shape* forme)
 124 {
 125    if (forme != NULL)
 126        tab_assoc.push_back (forme);
 127    return HOK;
 128 }
 129 // ============================================================  getEdge
 130 inline Edge* Quad::getEdge (int nro)
 131 {
 132    Edge* elt = NULL;
 133    if (nro >=0 && nro < QUAD4 && el_status == HOK && q_edge [nro]->isValid())
 134       elt = q_edge [nro];
 135
 136    return elt;
 137 }
 138 // ============================================================  getVertex
 139 inline Vertex* Quad::getVertex (int nro)
 140 {
 141    Vertex* elt = NULL;
 142    if (nro >=0 && nro < QUAD4 && el_status == HOK && q_vertex [nro]->isValid())
 143       elt = q_vertex [nro];
 144
 145    return elt;
 146 }
 147 // ======================================================== commonEdge
 148 inline Edge* Quad::commonEdge (Quad* other)
 149 {
 150    for (int ne1=0 ; ne1<QUAD4 ; ne1++)
 151        for (int ne2=0 ; ne2<QUAD4 ; ne2++)
 152            if (q_edge [ne1] == other->q_edge [ne2])
 153               return q_edge [ne1];
 154
 155    return NULL;
 156 }
 157
 158 // ======================================================== Inter
 159 inline int Quad::inter (Quad* other, int& nother)
 160 {
 161    for (int ne1=0 ; ne1<QUAD4 ; ne1++)
 162        for (int ne2=0 ; ne2<QUAD4 ; ne2++)
 163            if (q_edge [ne1] == other->q_edge [ne2])
 164               {
 165               nother = ne2;
 166               return  ne1;
 167               }
 168
 169    nother = NOTHING;
 170    return NOTHING;
 171 }
 172 // ============================================================ definedBy (v)
 173 inline bool Quad::definedBy  (Vertex* v1, Vertex* v2)
 174 {
 175    for (int n1=0 ; n1< QUAD4 ; n1++)
 176        if (v1 == q_vertex[n1] && v2 == q_vertex[(n1+2) MODULO QUAD4])
 177           return true;
 178
 179    return false;
 180 }
 181 // ============================================================ definedBy (e)
 182 inline bool Quad::definedBy  (Edge* e1, Edge* e2)
 183 {
 184    for (int n1=0 ; n1< QUAD4 ; n1++)
 185        if (e1 == q_edge[n1] && e2 == q_edge[(n1+2) MODULO QUAD4])
 186           return true;
 187
 188    return false;
 189 }
 190 // =============================================================== findEdge
 191 inline Edge* Quad::findEdge (Vertex* v1, Vertex* v2)
 192 {
 193    for (int nro=0 ; nro< QUAD4 ; nro++)
 194        {
 195        Vertex* va = q_edge[nro]->getVertex(V_AMONT) ;
 196        Vertex* vb = q_edge[nro]->getVertex(V_AVAL) ;
 197        if ((v1==va && v2==vb) || (v1==vb && v2==va))
 198            return q_edge [nro];
 199        }
 200
 201    return NULL;
 202 }
 203 // =============================================================== indexVertex
 204 inline int Quad::indexVertex  (Vertex* elt)
 205 {
 206    for (int n1=0 ; n1< QUAD4 ; n1++)
 207        if (elt == q_vertex[n1])
 208           return n1;
 209
 210    return NOTHING;
 211 }
 212 // =============================================================== indexEdge
 213 inline int Quad::indexEdge  (Edge* elt)
 214 {
 215    for (int n1=0 ; n1< QUAD4 ; n1++)
 216        if (elt == q_edge[n1])
 217           return n1;
 218
 219    return NOTHING;
 220 }
 221 // =============================================================== setScalar
 222 inline void Quad::setScalar  (double val)
 223 {
 224    for (int n1=0 ; n1< QUAD4 ; n1++)
 225        q_vertex[n1] -> setScalar (val);
 226 }
 227 // =============================================================== duplicate
 228 inline void Quad::duplicate  ()
 229 {
 230    q_orientation  = Q_UNDEFINED;
 231    q_clone = new Quad (GetClone (q_edge [E_A]),
 232                        GetClone (q_edge [E_B]),
 233                        GetClone (q_edge [E_C]),
 234                        GetClone (q_edge [E_D]));
 235    q_clone->tab_assoc = tab_assoc;
 236 }
 237 END_NAMESPACE_HEXA
 238 #endif
 239