src/SMDS/SMDS_VolumeOfNodes.cxx

   1 // Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  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, or (at your option) any later version.
  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
  23 //  SMESH SMDS : implementaion of Salome mesh data structure
  24 //
  25 #ifdef _MSC_VER
  26 #pragma warning(disable:4786)
  27 #endif
  28
  29 #include "SMDS_VolumeOfNodes.hxx"
  30 #include "SMDS_MeshNode.hxx"
  31 #include "SMDS_SetIterator.hxx"
  32 #include "SMDS_VolumeTool.hxx"
  33 #include "SMDS_Mesh.hxx"
  34 #include "utilities.h"
  35
  36 using namespace std;
  37
  38 ///////////////////////////////////////////////////////////////////////////////
  39 /// Create an hexahedron. node 1,2,3,4 and 5,6,7,8 are quadrangle and
  40 /// 5,1 and 7,3 are an edges.
  41 ///////////////////////////////////////////////////////////////////////////////
  42 SMDS_VolumeOfNodes::SMDS_VolumeOfNodes(
  43                 const SMDS_MeshNode * node1,
  44                 const SMDS_MeshNode * node2,
  45                 const SMDS_MeshNode * node3,
  46                 const SMDS_MeshNode * node4,
  47                 const SMDS_MeshNode * node5,
  48                 const SMDS_MeshNode * node6,
  49                 const SMDS_MeshNode * node7,
  50                 const SMDS_MeshNode * node8)
  51 {
  52   //MESSAGE("***************************************************** SMDS_VolumeOfNodes");
  53         myNbNodes = 8;
  54         myNodes = new const SMDS_MeshNode* [myNbNodes];
  55         myNodes[0]=node1;
  56         myNodes[1]=node2;
  57         myNodes[2]=node3;
  58         myNodes[3]=node4;
  59         myNodes[4]=node5;
  60         myNodes[5]=node6;
  61         myNodes[6]=node7;
  62         myNodes[7]=node8;
  63 }
  64
  65 SMDS_VolumeOfNodes::SMDS_VolumeOfNodes(
  66                 const SMDS_MeshNode * node1,
  67                 const SMDS_MeshNode * node2,
  68                 const SMDS_MeshNode * node3,
  69                 const SMDS_MeshNode * node4)
  70 {
  71   //MESSAGE("***************************************************** SMDS_VolumeOfNodes");
  72         myNbNodes = 4;
  73         myNodes = new const SMDS_MeshNode* [myNbNodes];
  74         myNodes[0]=node1;
  75         myNodes[1]=node2;
  76         myNodes[2]=node3;
  77         myNodes[3]=node4;
  78 }
  79
  80 SMDS_VolumeOfNodes::SMDS_VolumeOfNodes(
  81                 const SMDS_MeshNode * node1,
  82                 const SMDS_MeshNode * node2,
  83                 const SMDS_MeshNode * node3,
  84                 const SMDS_MeshNode * node4,
  85                 const SMDS_MeshNode * node5)
  86 {
  87   //MESSAGE("***************************************************** SMDS_VolumeOfNodes");
  88         myNbNodes = 5;
  89         myNodes = new const SMDS_MeshNode* [myNbNodes];
  90         myNodes[0]=node1;
  91         myNodes[1]=node2;
  92         myNodes[2]=node3;
  93         myNodes[3]=node4;
  94         myNodes[4]=node5;
  95 }
  96
  97 SMDS_VolumeOfNodes::SMDS_VolumeOfNodes(
  98                 const SMDS_MeshNode * node1,
  99                 const SMDS_MeshNode * node2,
 100                 const SMDS_MeshNode * node3,
 101                 const SMDS_MeshNode * node4,
 102                 const SMDS_MeshNode * node5,
 103                 const SMDS_MeshNode * node6)
 104 {
 105   //MESSAGE("***************************************************** SMDS_VolumeOfNodes");
 106         myNbNodes = 6;
 107         myNodes = new const SMDS_MeshNode* [myNbNodes];
 108         myNodes[0]=node1;
 109         myNodes[1]=node2;
 110         myNodes[2]=node3;
 111         myNodes[3]=node4;
 112         myNodes[4]=node5;
 113         myNodes[5]=node6;
 114 }
 115
 116 bool SMDS_VolumeOfNodes::ChangeNodes(const SMDS_MeshNode* nodes[],
 117                                      const int            nbNodes)
 118 {
 119   if (nbNodes < 4 || nbNodes > 8 || nbNodes == 7)
 120     return false;
 121
 122   delete [] myNodes;
 123   myNbNodes = nbNodes;
 124   myNodes = new const SMDS_MeshNode* [myNbNodes];
 125   for ( int i = 0; i < nbNodes; i++ )
 126     myNodes[ i ] = nodes [ i ];
 127
 128   return true;
 129 }
 130
 131 SMDS_VolumeOfNodes::~SMDS_VolumeOfNodes()
 132 {
 133   if (myNodes != NULL) {
 134     delete [] myNodes;
 135     myNodes = NULL;
 136   }
 137 }
 138
 139 void SMDS_VolumeOfNodes::Print(ostream & OS) const
 140 {
 141         OS << "volume <" << GetID() << "> : ";
 142         int i;
 143         for (i = 0; i < NbNodes()-1; ++i) OS << myNodes[i] << ",";
 144         OS << myNodes[NbNodes()-1]<< ") " << endl;
 145 }
 146
 147 int SMDS_VolumeOfNodes::NbFaces() const
 148 {
 149         switch(NbNodes())
 150         {
 151         case 4: return 4;
 152         case 5: return 5;
 153         case 6: return 5;
 154         case 8: return 6;
 155         default: MESSAGE("invalid number of nodes");
 156         }
 157         return 0;
 158 }
 159
 160 int SMDS_VolumeOfNodes::NbNodes() const
 161 {
 162         return myNbNodes;
 163 }
 164
 165 int SMDS_VolumeOfNodes::NbEdges() const
 166 {
 167         switch(NbNodes())
 168         {
 169         case 4: return 6;
 170         case 5: return 8;
 171         case 6: return 9;
 172         case 8: return 12;
 173         default: MESSAGE("invalid number of nodes");
 174         }
 175         return 0;
 176 }
 177
 178 /*!
 179  * \brief Iterator on node of volume
 180  */
 181 class SMDS_VolumeOfNodes_MyIterator:public SMDS_NodeArrayElemIterator
 182 {
 183  public:
 184   SMDS_VolumeOfNodes_MyIterator(const SMDS_MeshNode* const* s, int l):
 185     SMDS_NodeArrayElemIterator( s, & s[ l ]) {}
 186 };
 187
 188 /*!
 189  * \brief Iterator on faces or edges of volume
 190  */
 191 class _MySubIterator : public SMDS_ElemIterator
 192 {
 193   vector< const SMDS_MeshElement* > myElems;
 194   size_t myIndex;
 195 public:
 196   _MySubIterator(const SMDS_VolumeOfNodes* vol, SMDSAbs_ElementType type):myIndex(0) {
 197     SMDS_VolumeTool vTool(vol);
 198     if (type == SMDSAbs_Face)
 199       vTool.GetAllExistingFaces( myElems );
 200     else
 201       vTool.GetAllExistingFaces( myElems );
 202   }
 203   /// Return true if and only if there are other object in this iterator
 204   virtual bool more() { return myIndex < myElems.size(); }
 205
 206   /// Return the current object and step to the next one
 207   virtual const SMDS_MeshElement* next() { return myElems[ myIndex++ ]; }
 208 };
 209
 210 SMDS_ElemIteratorPtr SMDS_VolumeOfNodes::elementsIterator(SMDSAbs_ElementType type) const
 211 {
 212   switch(type)
 213   {
 214   case SMDSAbs_Volume:
 215     return SMDS_MeshElement::elementsIterator(SMDSAbs_Volume);
 216   case SMDSAbs_Node:
 217     return SMDS_ElemIteratorPtr(new SMDS_VolumeOfNodes_MyIterator(myNodes,myNbNodes));
 218   case SMDSAbs_Face:
 219     return SMDS_ElemIteratorPtr(new _MySubIterator(this,SMDSAbs_Face));
 220   case SMDSAbs_Edge:
 221     return SMDS_ElemIteratorPtr(new _MySubIterator(this,SMDSAbs_Edge));
 222   default:
 223     MESSAGE("ERROR : Iterator not implemented");
 224     return SMDS_ElemIteratorPtr((SMDS_ElemIterator*)NULL);
 225   }
 226 }
 227
 228 SMDSAbs_ElementType SMDS_VolumeOfNodes::GetType() const
 229 {
 230         return SMDSAbs_Volume;
 231 }
 232
 233 /*!
 234  * \brief Return node by its index
 235  * \param ind - node index
 236  * \retval const SMDS_MeshNode* - the node
 237  */
 238 const SMDS_MeshNode* SMDS_VolumeOfNodes::GetNode(const int ind) const
 239 {
 240   return myNodes[ ind ];
 241 }
 242
 243 SMDSAbs_EntityType SMDS_VolumeOfNodes::GetEntityType() const
 244 {
 245   SMDSAbs_EntityType aType = SMDSEntity_Tetra;
 246   switch(myNbNodes)
 247   {
 248   case 4: aType = SMDSEntity_Tetra;   break;
 249   case 5: aType = SMDSEntity_Pyramid; break;
 250   case 6: aType = SMDSEntity_Penta;   break;
 251   case 8:
 252   default: aType = SMDSEntity_Hexa;    break;
 253   }
 254   return aType;
 255 }
 256
 257 SMDSAbs_GeometryType SMDS_VolumeOfNodes::GetGeomType() const
 258 {
 259   SMDSAbs_GeometryType aType = SMDSGeom_NONE;
 260   switch(myNbNodes)
 261   {
 262   case 4: aType = SMDSGeom_TETRA;   break;
 263   case 5: aType = SMDSGeom_PYRAMID; break;
 264   case 6: aType = SMDSGeom_PENTA;   break;
 265   case 12: aType = SMDSGeom_HEXAGONAL_PRISM; break;
 266   case 8:
 267   default: aType = SMDSGeom_HEXA;    break;
 268   }
 269   return aType;
 270 }
 271