src/SMDS/SMDS_MeshHexahedron.cxx

   1 //  SMESH SMDS : implementaion of Salome mesh data structure
   2 //
   3 //  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
  21 //
  22 //
  23 //
  24 //  File   : SMDS_MeshHexahedron.cxx
  25 //  Author : Jean-Michel BOULCOURT
  26 //  Module : SMESH
  27
  28 using namespace std;
  29 #include "SMDS_MeshHexahedron.ixx"
  30 #include <Standard_ConstructionError.hxx>
  31
  32
  33 //=======================================================================
  34 //function : SMDS_MeshHexahedron
  35 //purpose  : Hexaedra
  36 //=======================================================================
  37
  38 SMDS_MeshHexahedron::SMDS_MeshHexahedron(const Standard_Integer ID,
  39                                          const Standard_Integer idnode1,
  40                                          const Standard_Integer idnode2,
  41                                          const Standard_Integer idnode3,
  42                                          const Standard_Integer idnode4,
  43                                          const Standard_Integer idnode5,
  44                                          const Standard_Integer idnode6,
  45                                          const Standard_Integer idnode7,
  46                                          const Standard_Integer idnode8):SMDS_MeshVolume(ID,8)
  47 {
  48   SetConnections(idnode1,idnode2,idnode3,idnode4,idnode5,idnode6,idnode7,idnode8);
  49   ComputeKey();
  50 }
  51
  52
  53 //=======================================================================
  54 //function : SetConnections
  55 //purpose  : Heaxahedron
  56 //=======================================================================
  57 void SMDS_MeshHexahedron::SetConnections(const Standard_Integer idnode1,
  58                                          const Standard_Integer idnode2,
  59                                          const Standard_Integer idnode3,
  60                                          const Standard_Integer idnode4,
  61                                          const Standard_Integer idnode5,
  62                                          const Standard_Integer idnode6,
  63                                          const Standard_Integer idnode7,
  64                                          const Standard_Integer idnode8)
  65 {
  66   Standard_Integer idmin = (idnode1 < idnode2 ? idnode1 : idnode2);
  67   idmin = (idmin < idnode3 ? idmin : idnode3);
  68   idmin = (idmin < idnode4 ? idmin : idnode4);
  69   idmin = (idmin < idnode5 ? idmin : idnode5);
  70   idmin = (idmin < idnode6 ? idmin : idnode6);
  71   idmin = (idmin < idnode7 ? idmin : idnode7);
  72   idmin = (idmin < idnode8 ? idmin : idnode8);
  73
  74   myNodes[0] = idmin;
  75   if (idmin == idnode1) { // 1 2 3 4 5 6 7 8
  76     myNodes[1] = idnode2;
  77     myNodes[2] = idnode3;
  78     myNodes[3] = idnode4;
  79     myNodes[4] = idnode5;
  80     myNodes[5] = idnode6;
  81     myNodes[6] = idnode7;
  82     myNodes[7] = idnode8;
  83   } else if (idmin == idnode2) { // 2 3 4 1 6 7 8 5
  84     myNodes[1] = idnode3;
  85     myNodes[2] = idnode4;
  86     myNodes[3] = idnode1;
  87     myNodes[4] = idnode6;
  88     myNodes[5] = idnode7;
  89     myNodes[6] = idnode8;
  90     myNodes[7] = idnode5;
  91   } else if (idmin == idnode3) { // 3 4 1 2 7 8 5 6
  92     myNodes[1] = idnode4;
  93     myNodes[2] = idnode1;
  94     myNodes[3] = idnode2;
  95     myNodes[4] = idnode7;
  96     myNodes[5] = idnode8;
  97     myNodes[6] = idnode5;
  98     myNodes[7] = idnode6;
  99   } else if (idmin == idnode4) { // 4 1 2 3 8 5 6 7
 100     myNodes[1] = idnode1;
 101     myNodes[2] = idnode2;
 102     myNodes[3] = idnode3;
 103     myNodes[4] = idnode8;
 104     myNodes[5] = idnode5;
 105     myNodes[6] = idnode6;
 106     myNodes[7] = idnode7;
 107   } else if (idmin == idnode5) { // 5 6 7 8 1 2 3 4
 108     myNodes[1] = idnode6;
 109     myNodes[2] = idnode7;
 110     myNodes[3] = idnode8;
 111     myNodes[4] = idnode1;
 112     myNodes[5] = idnode2;
 113     myNodes[6] = idnode3;
 114     myNodes[7] = idnode4;
 115   } else if (idmin == idnode6){  // 6 7 8 5 2 3 4 1
 116     myNodes[1] = idnode7;
 117     myNodes[2] = idnode8;
 118     myNodes[3] = idnode5;
 119     myNodes[4] = idnode2;
 120     myNodes[5] = idnode3;
 121     myNodes[6] = idnode4;
 122     myNodes[7] = idnode1;
 123   } else if (idmin == idnode7) {  // 7 8 5 6 3 4 1 2
 124     myNodes[1] = idnode8;
 125     myNodes[2] = idnode5;
 126     myNodes[3] = idnode6;
 127     myNodes[4] = idnode3;
 128     myNodes[5] = idnode4;
 129     myNodes[6] = idnode1;
 130     myNodes[7] = idnode2;
 131   } else {                        // 8 5 6 7 4 1 2 3
 132     myNodes[1] = idnode5;
 133     myNodes[2] = idnode6;
 134     myNodes[3] = idnode7;
 135     myNodes[4] = idnode4;
 136     myNodes[5] = idnode1;
 137     myNodes[6] = idnode2;
 138     myNodes[7] = idnode3;
 139   }
 140
 141 }
 142
 143 //=======================================================================
 144 //function : NodesOfFace
 145 //purpose  : returns the rank node in mynodes. Useful to extract faces from volume
 146 //=======================================================================
 147 Standard_Integer SMDS_MeshHexahedron::NodesOfFace(const Standard_Integer rankface,
 148                                                const Standard_Integer ranknode)
 149 {
 150   static Standard_Integer facenode[6][4] = {
 151     {0,1,2,3},
 152     {4,7,6,5},
 153     {0,4,5,1},
 154     {1,5,6,2},
 155     {2,6,7,3},
 156     {0,3,7,4}
 157   };
 158
 159   return facenode[rankface-1][ranknode-1];
 160 }
 161
 162 //=======================================================================
 163 //function : NodesOfEdge
 164 //purpose  : returns the rank node in mynodes. Useful to extract edges from volume
 165 //=======================================================================
 166 Standard_Integer SMDS_MeshHexahedron::NodesOfEdge(const Standard_Integer rankedge,
 167                                                   const Standard_Integer ranknode) const
 168 {
 169   static Standard_Integer faceedge[12][2] = {
 170     {0,1},
 171     {1,2},
 172     {2,3},
 173     {0,3},
 174     {4,7},
 175     {6,7},
 176     {5,6},
 177     {4,5},
 178     {0,4},
 179     {1,5},
 180     {2,6},
 181     {3,7}
 182
 183   };
 184
 185   return faceedge[rankedge-1][ranknode-1];
 186 }
 187
 188 //=======================================================================
 189 //function : GetFaceDefinedByNodes
 190 //purpose  :
 191 //=======================================================================
 192 void SMDS_MeshHexahedron::GetFaceDefinedByNodes(const Standard_Integer rank,
 193                                                 const Standard_Address idnode,
 194                                                 Standard_Integer& nb) const
 195 {
 196   Standard_Integer *ptr;
 197   nb = 4;
 198   ptr = (Standard_Integer *)idnode;
 199   ptr[0] = myNodes[NodesOfFace(rank,1)];
 200   ptr[1] = myNodes[NodesOfFace(rank,2)];
 201   ptr[2] = myNodes[NodesOfFace(rank,3)];
 202   ptr[3] = myNodes[NodesOfFace(rank,4)];
 203
 204 }
 205
 206 //=======================================================================
 207 //function : GetEdgeDefinedByNodes
 208 //purpose  :
 209 //=======================================================================
 210 void SMDS_MeshHexahedron::GetEdgeDefinedByNodes(const Standard_Integer rank,
 211                                             Standard_Integer& idnode1,
 212                                             Standard_Integer& idnode2) const
 213 {
 214   idnode1 = myNodes[NodesOfEdge(rank,1)];
 215   idnode2 = myNodes[NodesOfEdge(rank,2)];
 216 }
 217