src/SMDS/SMDS_VolumeOfNodes.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 #include "SMDS_VolumeOfNodes.hxx"
  23 #include "SMDS_MeshNode.hxx"
  24 #include "utilities.h"
  25
  26 using namespace std;
  27
  28 ///////////////////////////////////////////////////////////////////////////////
  29 /// Create an hexahedron. node 1,2,3,4 and 5,6,7,8 are quadrangle and
  30 /// 5,1 and 7,3 are an edges.
  31 ///////////////////////////////////////////////////////////////////////////////
  32 SMDS_VolumeOfNodes::SMDS_VolumeOfNodes(
  33                 const SMDS_MeshNode * node1,
  34                 const SMDS_MeshNode * node2,
  35                 const SMDS_MeshNode * node3,
  36                 const SMDS_MeshNode * node4,
  37                 const SMDS_MeshNode * node5,
  38                 const SMDS_MeshNode * node6,
  39                 const SMDS_MeshNode * node7,
  40                 const SMDS_MeshNode * node8)
  41 {
  42         myNodes.resize(8);
  43         myNodes[0]=node1;
  44         myNodes[1]=node2;
  45         myNodes[2]=node3;
  46         myNodes[3]=node4;
  47         myNodes[4]=node5;
  48         myNodes[5]=node6;
  49         myNodes[6]=node7;
  50         myNodes[7]=node8;
  51 }
  52
  53 SMDS_VolumeOfNodes::SMDS_VolumeOfNodes(
  54                 const SMDS_MeshNode * node1,
  55                 const SMDS_MeshNode * node2,
  56                 const SMDS_MeshNode * node3,
  57                 const SMDS_MeshNode * node4)
  58 {
  59         myNodes.resize(4);
  60         myNodes[0]=node1;
  61         myNodes[1]=node2;
  62         myNodes[2]=node3;
  63         myNodes[3]=node4;
  64 }
  65
  66 SMDS_VolumeOfNodes::SMDS_VolumeOfNodes(
  67                 const SMDS_MeshNode * node1,
  68                 const SMDS_MeshNode * node2,
  69                 const SMDS_MeshNode * node3,
  70                 const SMDS_MeshNode * node4,
  71                 const SMDS_MeshNode * node5)
  72 {
  73         myNodes.resize(5);
  74         myNodes[0]=node1;
  75         myNodes[1]=node2;
  76         myNodes[2]=node3;
  77         myNodes[3]=node4;
  78         myNodes[4]=node5;
  79 }
  80
  81 SMDS_VolumeOfNodes::SMDS_VolumeOfNodes(
  82                 const SMDS_MeshNode * node1,
  83                 const SMDS_MeshNode * node2,
  84                 const SMDS_MeshNode * node3,
  85                 const SMDS_MeshNode * node4,
  86                 const SMDS_MeshNode * node5,
  87                 const SMDS_MeshNode * node6)
  88 {
  89         myNodes.resize(6);
  90         myNodes[0]=node1;
  91         myNodes[1]=node2;
  92         myNodes[2]=node3;
  93         myNodes[3]=node4;
  94         myNodes[4]=node5;
  95         myNodes[5]=node6;
  96 }
  97 bool SMDS_VolumeOfNodes::ChangeNodes(const SMDS_MeshNode* nodes[],
  98                                      const int            nbNodes)
  99 {
 100   if (nbNodes < 4 || nbNodes > 8 || nbNodes == 7)
 101     return false;
 102
 103   myNodes.resize( nbNodes );
 104   for ( int i = 0; i < nbNodes; i++ )
 105     myNodes[ i ] = nodes [ i ];
 106
 107   return true;
 108 }
 109 //=======================================================================
 110 //function : Print
 111 //purpose  :
 112 //=======================================================================
 113
 114 void SMDS_VolumeOfNodes::Print(ostream & OS) const
 115 {
 116         OS << "volume <" << GetID() << "> : ";
 117         int i;
 118         for (i = 0; i < NbNodes(); ++i) OS << myNodes[i] << ",";
 119         OS << myNodes[NbNodes()-1]<< ") " << endl;
 120 }
 121
 122 int SMDS_VolumeOfNodes::NbFaces() const
 123 {
 124         switch(NbNodes())
 125         {
 126         case 4: return 4;
 127         case 5: return 5;
 128         case 6: return 5;
 129         case 8: return 6;
 130         default: MESSAGE("invalid number of nodes");
 131         }
 132         return 0;
 133 }
 134
 135 int SMDS_VolumeOfNodes::NbNodes() const
 136 {
 137         return myNodes.size();
 138 }
 139
 140 int SMDS_VolumeOfNodes::NbEdges() const
 141 {
 142         switch(NbNodes())
 143         {
 144         case 4: return 6;
 145         case 5: return 8;
 146         case 6: return 9;
 147         case 8: return 12;
 148         default: MESSAGE("invalid number of nodes");
 149         }
 150         return 0;
 151 }
 152
 153 class SMDS_VolumeOfNodes_MyIterator:public SMDS_ElemIterator
 154 {
 155   const vector<const SMDS_MeshNode*>& mySet;
 156   int index;
 157  public:
 158   SMDS_VolumeOfNodes_MyIterator(const vector<const SMDS_MeshNode*>& s):
 159     mySet(s),index(0) {}
 160
 161   bool more()
 162   {
 163     return index<mySet.size();
 164   }
 165
 166   const SMDS_MeshElement* next()
 167   {
 168     index++;
 169     return mySet[index-1];
 170   }
 171 };
 172
 173 SMDS_ElemIteratorPtr SMDS_VolumeOfNodes::
 174         elementsIterator(SMDSAbs_ElementType type) const
 175 {
 176   switch(type)
 177   {
 178   case SMDSAbs_Volume:
 179     return SMDS_MeshElement::elementsIterator(SMDSAbs_Volume);
 180   case SMDSAbs_Node:
 181     return SMDS_ElemIteratorPtr(new SMDS_VolumeOfNodes_MyIterator(myNodes));
 182   default:
 183     MESSAGE("ERROR : Iterator not implemented");
 184     return SMDS_ElemIteratorPtr((SMDS_ElemIterator*)NULL);
 185   }
 186 }
 187
 188 SMDSAbs_ElementType SMDS_VolumeOfNodes::GetType() const
 189 {
 190         return SMDSAbs_Volume;
 191 }