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  clearAssociation  ()      { tab_assoc.clear() ; }
  93     int   addAssociation (Shape* forme);
  94     const Shapes& getAssociations ()        { return tab_assoc ; }
  95
  96     virtual void duplicate ();
  97     Quad* getClone ()               {  return q_clone ; }
  98
  99     Edge* getOpposEdge     (Edge* arete);   // Version simplifiee
 100     Edge* getPerpendicular (Edge* arete, Vertex* node);
 101     int   getOrientation ()            { return q_orientation; }
 102     int   setOrientation ();
 103     void  setOrientation (int ori);
 104
 105 private:
 106     friend class Cloner;
 107     Quad* getBrother (StrOrient* orient);
 108
 109 private:
 110     Edge*   q_edge   [QUAD4];
 111     Vertex* q_vertex [QUAD4];
 112     Quad*   q_clone;
 113     int     q_orientation;
 114
 115     Shapes tab_assoc;
 116 };
 117 // ----------------------------------------------- Inlining
 118 // ========================================================== addAssociation
 119 inline int Quad::addAssociation (Shape* forme)
 120 {
 121    if (forme != NULL)
 122        tab_assoc.push_back (forme);
 123    return HOK;
 124 }
 125 // ============================================================  getEdge
 126 inline Edge* Quad::getEdge (int nro)
 127 {
 128    Edge* elt = NULL;
 129    if (nro >=0 && nro < QUAD4 && el_status == HOK && q_edge [nro]->isValid())
 130       elt = q_edge [nro];
 131
 132    return elt;
 133 }
 134 // ============================================================  getVertex
 135 inline Vertex* Quad::getVertex (int nro)
 136 {
 137    Vertex* elt = NULL;
 138    if (nro >=0 && nro < QUAD4 && el_status == HOK && q_vertex [nro]->isValid())
 139       elt = q_vertex [nro];
 140
 141    return elt;
 142 }
 143 // ======================================================== commonEdge
 144 inline Edge* Quad::commonEdge (Quad* other)
 145 {
 146    for (int ne1=0 ; ne1<QUAD4 ; ne1++)
 147        for (int ne2=0 ; ne2<QUAD4 ; ne2++)
 148            if (q_edge [ne1] == other->q_edge [ne2])
 149               return q_edge [ne1];
 150
 151    return NULL;
 152 }
 153
 154 // ======================================================== Inter
 155 inline int Quad::inter (Quad* other, int& nother)
 156 {
 157    for (int ne1=0 ; ne1<QUAD4 ; ne1++)
 158        for (int ne2=0 ; ne2<QUAD4 ; ne2++)
 159            if (q_edge [ne1] == other->q_edge [ne2])
 160               {
 161               nother = ne2;
 162               return  ne1;
 163               }
 164
 165    nother = NOTHING;
 166    return NOTHING;
 167 }
 168 // ============================================================ definedBy (v)
 169 inline bool Quad::definedBy  (Vertex* v1, Vertex* v2)
 170 {
 171    for (int n1=0 ; n1< QUAD4 ; n1++)
 172        if (v1 == q_vertex[n1] && v2 == q_vertex[(n1+2) MODULO QUAD4])
 173           return true;
 174
 175    return false;
 176 }
 177 // ============================================================ definedBy (e)
 178 inline bool Quad::definedBy  (Edge* e1, Edge* e2)
 179 {
 180    for (int n1=0 ; n1< QUAD4 ; n1++)
 181        if (e1 == q_edge[n1] && e2 == q_edge[(n1+2) MODULO QUAD4])
 182           return true;
 183
 184    return false;
 185 }
 186 // =============================================================== findEdge
 187 inline Edge* Quad::findEdge (Vertex* v1, Vertex* v2)
 188 {
 189    for (int nro=0 ; nro< QUAD4 ; nro++)
 190        {
 191        Vertex* va = q_edge[nro]->getVertex(V_AMONT) ;
 192        Vertex* vb = q_edge[nro]->getVertex(V_AVAL) ;
 193        if ((v1==va && v2==vb) || (v1==vb && v2==va))
 194            return q_edge [nro];
 195        }
 196
 197    return NULL;
 198 }
 199 // =============================================================== indexVertex
 200 inline int Quad::indexVertex  (Vertex* elt)
 201 {
 202    for (int n1=0 ; n1< QUAD4 ; n1++)
 203        if (elt == q_vertex[n1])
 204           return n1;
 205
 206    return NOTHING;
 207 }
 208 // =============================================================== indexEdge
 209 inline int Quad::indexEdge  (Edge* elt)
 210 {
 211    for (int n1=0 ; n1< QUAD4 ; n1++)
 212        if (elt == q_edge[n1])
 213           return n1;
 214
 215    return NOTHING;
 216 }
 217 // =============================================================== setScalar
 218 inline void Quad::setScalar  (double val)
 219 {
 220    for (int n1=0 ; n1< QUAD4 ; n1++)
 221        q_vertex[n1] -> setScalar (val);
 222 }
 223 // =============================================================== duplicate
 224 inline void Quad::duplicate  ()
 225 {
 226    q_orientation  = Q_UNDEFINED;
 227    q_clone = new Quad (GetClone (q_edge [E_A]),
 228                        GetClone (q_edge [E_B]),
 229                        GetClone (q_edge [E_C]),
 230                        GetClone (q_edge [E_D]));
 231    q_clone->tab_assoc = tab_assoc;
 232 }
 233 END_NAMESPACE_HEXA
 234 #endif
 235