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.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21
  22 #ifdef _MSC_VER
  23 #pragma warning(disable:4786)
  24 #endif
  25
  26 #include "SMDS_VolumeOfNodes.hxx"
  27 #include "SMDS_MeshNode.hxx"
  28 #include "SMDS_SetIterator.hxx"
  29 #include "utilities.h"
  30
  31 using namespace std;
  32
  33 ///////////////////////////////////////////////////////////////////////////////
  34 /// Create an hexahedron. node 1,2,3,4 and 5,6,7,8 are quadrangle and
  35 /// 5,1 and 7,3 are an edges.
  36 ///////////////////////////////////////////////////////////////////////////////
  37 SMDS_VolumeOfNodes::SMDS_VolumeOfNodes(
  38                 const SMDS_MeshNode * node1,
  39                 const SMDS_MeshNode * node2,
  40                 const SMDS_MeshNode * node3,
  41                 const SMDS_MeshNode * node4,
  42                 const SMDS_MeshNode * node5,
  43                 const SMDS_MeshNode * node6,
  44                 const SMDS_MeshNode * node7,
  45                 const SMDS_MeshNode * node8)
  46 {
  47         myNbNodes = 8;
  48         myNodes = new const SMDS_MeshNode* [myNbNodes];
  49         myNodes[0]=node1;
  50         myNodes[1]=node2;
  51         myNodes[2]=node3;
  52         myNodes[3]=node4;
  53         myNodes[4]=node5;
  54         myNodes[5]=node6;
  55         myNodes[6]=node7;
  56         myNodes[7]=node8;
  57 }
  58
  59 SMDS_VolumeOfNodes::SMDS_VolumeOfNodes(
  60                 const SMDS_MeshNode * node1,
  61                 const SMDS_MeshNode * node2,
  62                 const SMDS_MeshNode * node3,
  63                 const SMDS_MeshNode * node4)
  64 {
  65         myNbNodes = 4;
  66         myNodes = new const SMDS_MeshNode* [myNbNodes];
  67         myNodes[0]=node1;
  68         myNodes[1]=node2;
  69         myNodes[2]=node3;
  70         myNodes[3]=node4;
  71 }
  72
  73 SMDS_VolumeOfNodes::SMDS_VolumeOfNodes(
  74                 const SMDS_MeshNode * node1,
  75                 const SMDS_MeshNode * node2,
  76                 const SMDS_MeshNode * node3,
  77                 const SMDS_MeshNode * node4,
  78                 const SMDS_MeshNode * node5)
  79 {
  80         myNbNodes = 5;
  81         myNodes = new const SMDS_MeshNode* [myNbNodes];
  82         myNodes[0]=node1;
  83         myNodes[1]=node2;
  84         myNodes[2]=node3;
  85         myNodes[3]=node4;
  86         myNodes[4]=node5;
  87 }
  88
  89 SMDS_VolumeOfNodes::SMDS_VolumeOfNodes(
  90                 const SMDS_MeshNode * node1,
  91                 const SMDS_MeshNode * node2,
  92                 const SMDS_MeshNode * node3,
  93                 const SMDS_MeshNode * node4,
  94                 const SMDS_MeshNode * node5,
  95                 const SMDS_MeshNode * node6)
  96 {
  97         myNbNodes = 6;
  98         myNodes = new const SMDS_MeshNode* [myNbNodes];
  99         myNodes[0]=node1;
 100         myNodes[1]=node2;
 101         myNodes[2]=node3;
 102         myNodes[3]=node4;
 103         myNodes[4]=node5;
 104         myNodes[5]=node6;
 105 }
 106
 107 bool SMDS_VolumeOfNodes::ChangeNodes(const SMDS_MeshNode* nodes[],
 108                                      const int            nbNodes)
 109 {
 110   if (nbNodes < 4 || nbNodes > 8 || nbNodes == 7)
 111     return false;
 112
 113   delete [] myNodes;
 114   myNbNodes = nbNodes;
 115   myNodes = new const SMDS_MeshNode* [myNbNodes];
 116   for ( int i = 0; i < nbNodes; i++ )
 117     myNodes[ i ] = nodes [ i ];
 118
 119   return true;
 120 }
 121
 122 SMDS_VolumeOfNodes::~SMDS_VolumeOfNodes()
 123 {
 124   if (myNodes != NULL) {
 125     delete [] myNodes;
 126     myNodes = NULL;
 127   }
 128 }
 129
 130 //=======================================================================
 131 //function : Print
 132 //purpose  :
 133 //=======================================================================
 134
 135 void SMDS_VolumeOfNodes::Print(ostream & OS) const
 136 {
 137         OS << "volume <" << GetID() << "> : ";
 138         int i;
 139         for (i = 0; i < NbNodes(); ++i) OS << myNodes[i] << ",";
 140         OS << myNodes[NbNodes()-1]<< ") " << endl;
 141 }
 142
 143 int SMDS_VolumeOfNodes::NbFaces() const
 144 {
 145         switch(NbNodes())
 146         {
 147         case 4: return 4;
 148         case 5: return 5;
 149         case 6: return 5;
 150         case 8: return 6;
 151         default: MESSAGE("invalid number of nodes");
 152         }
 153         return 0;
 154 }
 155
 156 int SMDS_VolumeOfNodes::NbNodes() const
 157 {
 158         return myNbNodes;
 159 }
 160
 161 int SMDS_VolumeOfNodes::NbEdges() const
 162 {
 163         switch(NbNodes())
 164         {
 165         case 4: return 6;
 166         case 5: return 8;
 167         case 6: return 9;
 168         case 8: return 12;
 169         default: MESSAGE("invalid number of nodes");
 170         }
 171         return 0;
 172 }
 173
 174 class SMDS_VolumeOfNodes_MyIterator:public SMDS_NodeArrayElemIterator
 175 {
 176  public:
 177   SMDS_VolumeOfNodes_MyIterator(const SMDS_MeshNode* const* s, int l):
 178     SMDS_NodeArrayElemIterator( s, & s[ l ]) {}
 179 };
 180
 181 SMDS_ElemIteratorPtr SMDS_VolumeOfNodes::elementsIterator(SMDSAbs_ElementType type) const
 182 {
 183   switch(type)
 184   {
 185   case SMDSAbs_Volume:
 186     return SMDS_MeshElement::elementsIterator(SMDSAbs_Volume);
 187   case SMDSAbs_Node:
 188     return SMDS_ElemIteratorPtr(new SMDS_VolumeOfNodes_MyIterator(myNodes,myNbNodes));
 189   default:
 190     MESSAGE("ERROR : Iterator not implemented");
 191     return SMDS_ElemIteratorPtr((SMDS_ElemIterator*)NULL);
 192   }
 193 }
 194
 195 SMDSAbs_ElementType SMDS_VolumeOfNodes::GetType() const
 196 {
 197         return SMDSAbs_Volume;
 198 }
 199
 200 /*!
 201  * \brief Return node by its index
 202  * \param ind - node index
 203  * \retval const SMDS_MeshNode* - the node
 204  *
 205  * Index is wrapped if it is out of a valid range
 206  */
 207 const SMDS_MeshNode* SMDS_VolumeOfNodes::GetNode(const int ind) const
 208 {
 209   return myNodes[ WrappedIndex( ind )];
 210 }