src/SMDS/SMDS_VolumeOfNodes.cxx

   1 //  Copyright (C) 2007-2008  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.
  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 //  SMESH SMDS : implementaion of Salome mesh data structure
  23 //
  24 #ifdef _MSC_VER
  25 #pragma warning(disable:4786)
  26 #endif
  27
  28 #include "SMDS_VolumeOfNodes.hxx"
  29 #include "SMDS_MeshNode.hxx"
  30 #include "SMDS_SetIterator.hxx"
  31 #include "SMDS_VolumeTool.hxx"
  32 #include "SMDS_Mesh.hxx"
  33 #include "utilities.h"
  34
  35 #include <vtkCell.h>
  36
  37 #include <vector>
  38
  39 using namespace std;
  40
  41 ///////////////////////////////////////////////////////////////////////////////
  42 /// Create an hexahedron. node 1,2,3,4 and 5,6,7,8 are quadrangle and
  43 /// 5,1 and 7,3 are an edges.
  44 ///////////////////////////////////////////////////////////////////////////////
  45 SMDS_VolumeOfNodes::SMDS_VolumeOfNodes(
  46                 const SMDS_MeshNode * node1,
  47                 const SMDS_MeshNode * node2,
  48                 const SMDS_MeshNode * node3,
  49                 const SMDS_MeshNode * node4,
  50                 const SMDS_MeshNode * node5,
  51                 const SMDS_MeshNode * node6,
  52                 const SMDS_MeshNode * node7,
  53                 const SMDS_MeshNode * node8)
  54 {
  55         myNbNodes = 8;
  56         myNodes = new const SMDS_MeshNode* [myNbNodes];
  57         myNodes[0]=node1;
  58         myNodes[1]=node2;
  59         myNodes[2]=node3;
  60         myNodes[3]=node4;
  61         myNodes[4]=node5;
  62         myNodes[5]=node6;
  63         myNodes[6]=node7;
  64         myNodes[7]=node8;
  65 }
  66
  67 SMDS_VolumeOfNodes::SMDS_VolumeOfNodes(
  68                 const SMDS_MeshNode * node1,
  69                 const SMDS_MeshNode * node2,
  70                 const SMDS_MeshNode * node3,
  71                 const SMDS_MeshNode * node4)
  72 {
  73         myNbNodes = 4;
  74         myNodes = new const SMDS_MeshNode* [myNbNodes];
  75         myNodes[0]=node1;
  76         myNodes[1]=node2;
  77         myNodes[2]=node3;
  78         myNodes[3]=node4;
  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 {
  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         myNbNodes = 6;
 106         myNodes = new const SMDS_MeshNode* [myNbNodes];
 107         myNodes[0]=node1;
 108         myNodes[1]=node2;
 109         myNodes[2]=node3;
 110         myNodes[3]=node4;
 111         myNodes[4]=node5;
 112         myNodes[5]=node6;
 113 }
 114
 115 bool SMDS_VolumeOfNodes::ChangeNodes(const SMDS_MeshNode* nodes[],
 116                                      const int            nbNodes)
 117 {
 118   if (nbNodes < 4 || nbNodes > 8 || nbNodes == 7)
 119     return false;
 120
 121   delete [] myNodes;
 122   myNbNodes = nbNodes;
 123   myNodes = new const SMDS_MeshNode* [myNbNodes];
 124   for ( int i = 0; i < nbNodes; i++ )
 125     myNodes[ i ] = nodes [ i ];
 126
 127   return true;
 128 }
 129
 130 SMDS_VolumeOfNodes::~SMDS_VolumeOfNodes()
 131 {
 132   if (myNodes != NULL) {
 133     delete [] myNodes;
 134     myNodes = NULL;
 135   }
 136 }
 137
 138 void SMDS_VolumeOfNodes::Print(ostream & OS) const
 139 {
 140         OS << "volume <" << GetID() << "> : ";
 141         int i;
 142         for (i = 0; i < NbNodes()-1; ++i) OS << myNodes[i] << ",";
 143         OS << myNodes[NbNodes()-1]<< ") " << endl;
 144 }
 145
 146 int SMDS_VolumeOfNodes::NbFaces() const
 147 {
 148         switch(NbNodes())
 149         {
 150         case 4: return 4;
 151         case 5: return 5;
 152         case 6: return 5;
 153         case 8: return 6;
 154         default: MESSAGE("invalid number of nodes");
 155         }
 156         return 0;
 157 }
 158
 159 int SMDS_VolumeOfNodes::NbNodes() const
 160 {
 161         return myNbNodes;
 162 }
 163
 164 int SMDS_VolumeOfNodes::NbEdges() const
 165 {
 166         switch(NbNodes())
 167         {
 168         case 4: return 6;
 169         case 5: return 8;
 170         case 6: return 9;
 171         case 8: return 12;
 172         default: MESSAGE("invalid number of nodes");
 173         }
 174         return 0;
 175 }
 176
 177 /*!
 178  * \brief Iterator on node of volume
 179  */
 180 class SMDS_VolumeOfNodes_MyIterator:public SMDS_NodeArrayElemIterator
 181 {
 182  public:
 183   SMDS_VolumeOfNodes_MyIterator(const SMDS_MeshNode* const* s, int l):
 184     SMDS_NodeArrayElemIterator( s, & s[ l ]) {}
 185 };
 186
 187 /*!
 188  * \brief Iterator on faces or edges of volume
 189  */
 190 class _MySubIterator : public SMDS_ElemIterator
 191 {
 192   vector< const SMDS_MeshElement* > myElems;
 193   int myIndex;
 194 public:
 195   _MySubIterator(const SMDS_VolumeOfNodes* vol, SMDSAbs_ElementType type):myIndex(0) {
 196     SMDS_VolumeTool vTool(vol);
 197     if (type == SMDSAbs_Face)
 198       vTool.GetAllExistingFaces( myElems );
 199     else
 200       vTool.GetAllExistingFaces( myElems );
 201   }
 202   /// Return true if and only if there are other object in this iterator
 203   virtual bool more() { return myIndex < myElems.size(); }
 204
 205   /// Return the current object and step to the next one
 206   virtual const SMDS_MeshElement* next() { return myElems[ myIndex++ ]; }
 207 };
 208
 209 SMDS_ElemIteratorPtr SMDS_VolumeOfNodes::elementsIterator(SMDSAbs_ElementType type) const
 210 {
 211   switch(type)
 212   {
 213   case SMDSAbs_Volume:
 214     return SMDS_MeshElement::elementsIterator(SMDSAbs_Volume);
 215   case SMDSAbs_Node:
 216     return SMDS_ElemIteratorPtr(new SMDS_VolumeOfNodes_MyIterator(myNodes,myNbNodes));
 217   case SMDSAbs_Face:
 218     return SMDS_ElemIteratorPtr(new _MySubIterator(this,SMDSAbs_Face));
 219   case SMDSAbs_Edge:
 220     return SMDS_ElemIteratorPtr(new _MySubIterator(this,SMDSAbs_Edge));
 221   default:
 222     MESSAGE("ERROR : Iterator not implemented");
 223     return SMDS_ElemIteratorPtr((SMDS_ElemIterator*)NULL);
 224   }
 225 }
 226
 227 SMDSAbs_ElementType SMDS_VolumeOfNodes::GetType() const
 228 {
 229         return SMDSAbs_Volume;
 230 }
 231
 232 /*!
 233  * \brief Return node by its index
 234  * \param ind - node index
 235  * \retval const SMDS_MeshNode* - the node
 236  */
 237 const SMDS_MeshNode* SMDS_VolumeOfNodes::GetNode(const int ind) const
 238 {
 239   return myNodes[ ind ];
 240 }
 241
 242 SMDSAbs_EntityType SMDS_VolumeOfNodes::GetEntityType() const
 243 {
 244   SMDSAbs_EntityType aType = SMDSEntity_Tetra;
 245   switch(myNbNodes)
 246   {
 247   case 4: aType = SMDSEntity_Tetra;   break;
 248   case 5: aType = SMDSEntity_Pyramid; break;
 249   case 6: aType = SMDSEntity_Penta;   break;
 250   case 8:
 251   default: aType = SMDSEntity_Hexa;    break;
 252   }
 253   return aType;
 254 }
 255
 256
 257 // *************************************************************************************
 258 //
 259
 260 SMDS_VolumeVtkNodes::SMDS_VolumeVtkNodes()
 261 {
 262 }
 263
 264 SMDS_VolumeVtkNodes::SMDS_VolumeVtkNodes(std::vector<vtkIdType> nodeIds, SMDS_Mesh* mesh)
 265 {
 266   init(nodeIds, mesh);
 267 }
 268
 269 void SMDS_VolumeVtkNodes::init(std::vector<vtkIdType> nodeIds, SMDS_Mesh* mesh)
 270 {
 271   vtkUnstructuredGrid* grid = mesh->getGrid();
 272   myVtkID = grid->InsertNextLinkedCell(GetType(), nodeIds.size(), &nodeIds[0]);
 273 }
 274
 275 bool SMDS_VolumeVtkNodes::ChangeNodes(const SMDS_MeshNode* nodes[],
 276                                      const int            nbNodes)
 277 {
 278   // utilise dans SMDS_Mesh
 279   return true;
 280 }
 281
 282 SMDS_VolumeVtkNodes::~SMDS_VolumeVtkNodes()
 283 {
 284 }
 285
 286 void SMDS_VolumeVtkNodes::Print(ostream & OS) const
 287 {
 288         OS << "volume <" << GetID() << "> : ";
 289 }
 290
 291 int SMDS_VolumeVtkNodes::NbFaces() const
 292 {
 293         switch(NbNodes())
 294         {
 295         case 4: return 4;
 296         case 5: return 5;
 297         case 6: return 5;
 298         case 8: return 6;
 299         default: MESSAGE("invalid number of nodes");
 300         }
 301         return 0;
 302 }
 303
 304 int SMDS_VolumeVtkNodes::NbNodes() const
 305 {
 306   vtkUnstructuredGrid* grid =SMDS_Mesh::_meshList[myMeshId]->getGrid();
 307   int nbPoints = grid->GetCell(myVtkID)->GetNumberOfPoints();
 308   return nbPoints;
 309 }
 310
 311 int SMDS_VolumeVtkNodes::NbEdges() const
 312 {
 313         switch(NbNodes())
 314         {
 315         case 4: return 6;
 316         case 5: return 8;
 317         case 6: return 9;
 318         case 8: return 12;
 319         default: MESSAGE("invalid number of nodes");
 320         }
 321         return 0;
 322 }
 323
 324 SMDS_ElemIteratorPtr SMDS_VolumeVtkNodes::elementsIterator(SMDSAbs_ElementType type) const
 325 {
 326   switch(type)
 327   {
 328 //   case SMDSAbs_Volume:
 329 //     return SMDS_MeshElement::elementsIterator(SMDSAbs_Volume);
 330 //   case SMDSAbs_Node:
 331 //     return SMDS_ElemIteratorPtr(new SMDS_VolumeVtkNodes_MyIterator(myNodes,myNbNodes));
 332 //   case SMDSAbs_Face:
 333 //     return SMDS_ElemIteratorPtr(new _MySubWNIterator(this,SMDSAbs_Face));
 334 //   case SMDSAbs_Edge:
 335 //     return SMDS_ElemIteratorPtr(new _MySubWNIterator(this,SMDSAbs_Edge));
 336   default:
 337     MESSAGE("ERROR : Iterator not implemented");
 338     return SMDS_ElemIteratorPtr((SMDS_ElemIterator*)NULL);
 339   }
 340 }
 341
 342 SMDSAbs_ElementType SMDS_VolumeVtkNodes::GetType() const
 343 {
 344         return SMDSAbs_Volume;
 345 }
 346
 347 /*!
 348  * \brief Return node by its index
 349  * \param ind - node index
 350  * \retval const SMDS_MeshNode* - the node
 351  */
 352 const SMDS_MeshNode* SMDS_VolumeVtkNodes::GetNode(const int ind) const
 353 {
 354   return 0;
 355 }
 356
 357 SMDSAbs_EntityType SMDS_VolumeVtkNodes::GetEntityType() const
 358 {
 359   SMDSAbs_EntityType aType = SMDSEntity_Tetra;
 360   switch(NbNodes())
 361   {
 362   case 4: aType = SMDSEntity_Tetra;   break;
 363   case 5: aType = SMDSEntity_Pyramid; break;
 364   case 6: aType = SMDSEntity_Penta;   break;
 365   case 8:
 366   default: aType = SMDSEntity_Hexa;    break;
 367   }
 368   return aType;
 369 }