src/SMDS/SMDS_MeshVolume.cxx

   1 // Copyright (C) 2007-2019  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 : implementation of Salome mesh data structure
  24 //  File   : SMDS_MeshVolume.cxx
  25 //  Author : Jean-Michel BOULCOURT
  26 //  Module : SMESH
  27 //
  28
  29 #include "SMDS_MeshVolume.hxx"
  30
  31 #include "SMDS_Mesh.hxx"
  32 #include "SMDS_VolumeTool.hxx"
  33 #include "SMDS_VtkCellIterator.hxx"
  34
  35 #include <boost/make_shared.hpp>
  36
  37 // init a polyherdon
  38 void SMDS_MeshVolume::init( const std::vector<const SMDS_MeshNode*>& nodes,
  39                             const std::vector<int>&                  nbNodesPerFace )
  40 {
  41   std::vector<vtkIdType> ptIds;
  42   ptIds.reserve( nodes.size() + nbNodesPerFace.size() + 1 );
  43
  44   size_t nbFaces = nbNodesPerFace.size();
  45   for ( size_t iN = 0, iF = 0; iF < nbFaces; iF++ )
  46   {
  47     int nf = nbNodesPerFace[iF];
  48     ptIds.push_back(nf);
  49     for (int n = 0; n < nf; n++)
  50       ptIds.push_back( nodes[ iN++ ]->GetVtkID() );
  51   }
  52
  53   int vtkID = getGrid()->InsertNextLinkedCell(VTK_POLYHEDRON, nbFaces, &ptIds[0]);
  54   setVtkID( vtkID );
  55 }
  56
  57 void SMDS_MeshVolume::init( const std::vector<vtkIdType>& vtkNodeIds )
  58 {
  59   SMDSAbs_EntityType aType = SMDSEntity_Tetra;
  60   switch ( vtkNodeIds.size()) // cases are in order of usage frequency
  61   {
  62   case 4:  aType = SMDSEntity_Tetra;           break;
  63   case 5:  aType = SMDSEntity_Pyramid;         break;
  64   case 8:  aType = SMDSEntity_Hexa;            break;
  65   case 6:  aType = SMDSEntity_Penta;           break;
  66   case 10: aType = SMDSEntity_Quad_Tetra;      break;
  67   case 20: aType = SMDSEntity_Quad_Hexa;       break;
  68   case 13: aType = SMDSEntity_Quad_Pyramid;    break;
  69   case 27: aType = SMDSEntity_TriQuad_Hexa;    break;
  70   case 15: aType = SMDSEntity_Quad_Penta;      break;
  71   case 18: aType = SMDSEntity_BiQuad_Penta;    break;
  72   case 12: aType = SMDSEntity_Hexagonal_Prism; break;
  73   default: throw SALOME_Exception("wrong volume nodes");
  74   }
  75   SMDS_MeshCell::init( aType, vtkNodeIds );
  76 }
  77
  78 bool SMDS_MeshVolume::ChangeNodes(const std::vector<const SMDS_MeshNode*>& nodes,
  79                                   const std::vector<int>&                  quantities) const
  80 {
  81   if ( !IsPoly() )
  82     return false;
  83
  84   vtkIdType nFaces = 0;
  85   vtkIdType *ptIds;
  86   vtkIdType const *tmp(nullptr);
  87   getGrid()->GetFaceStream( GetVtkID(), nFaces, tmp );
  88   std::copy(tmp, tmp+nFaces, ptIds);
  89
  90   // stream size and nb faces should not change
  91
  92   if ((int) quantities.size() != nFaces )
  93   {
  94     return false;
  95   }
  96   int id = 0, nbPoints = 0;
  97   for ( int i = 0; i < nFaces; i++ )
  98   {
  99     int nodesInFace = ptIds[id];
 100     nbPoints += nodesInFace;
 101     id += (nodesInFace + 1);
 102   }
 103   if ((int) nodes.size() != nbPoints )
 104   {
 105     return false;
 106   }
 107
 108   // update ptIds
 109   size_t iP = 0, iN = 0;
 110   for ( size_t i = 0; i < quantities.size(); ++i )
 111   {
 112     ptIds[ iP++ ] = quantities[ i ]; // nb face nodes
 113     for ( int j = 0; j < quantities[ i ]; ++j )
 114       ptIds[ iP++ ] = nodes[ iN++ ]->GetVtkID();
 115   }
 116   return true;
 117 }
 118
 119 const SMDS_MeshNode* SMDS_MeshVolume::GetNode(const int ind) const
 120 {
 121   if ( !IsPoly() )
 122     return SMDS_MeshCell::GetNode( ind );
 123
 124   vtkIdType nFaces = 0;
 125   vtkIdType const *ptIds(nullptr);
 126   getGrid()->GetFaceStream( GetVtkID(), nFaces, ptIds );
 127   int id = 0, nbPoints = 0;
 128   for (int i = 0; i < nFaces; i++)
 129   {
 130     int nodesInFace = ptIds[id];
 131     if ( ind < nbPoints + nodesInFace )
 132       return GetMesh()->FindNodeVtk( ptIds[ 1 + ind + i ]);
 133     nbPoints += nodesInFace;
 134     id += (nodesInFace + 1);
 135   }
 136   return 0;
 137 }
 138 int SMDS_MeshVolume::NbNodes() const
 139 {
 140   if ( !IsPoly() )
 141     return SMDS_MeshCell::NbNodes();
 142
 143   vtkIdType nFaces = 0;
 144   vtkIdType const *ptIds(nullptr);
 145   getGrid()->GetFaceStream( GetVtkID(), nFaces, ptIds );
 146   int id = 0, nbPoints = 0;
 147   for (int i = 0; i < nFaces; i++)
 148   {
 149     int nodesInFace = ptIds[id];
 150     nbPoints += nodesInFace;
 151     id += (nodesInFace + 1);
 152   }
 153   return nbPoints;
 154 }
 155
 156 int SMDS_MeshVolume::NbFaces() const
 157 {
 158   if ( !IsPoly() )
 159     return SMDS_MeshCell::NbFaces();
 160
 161   vtkIdType nFaces = 0;
 162   vtkIdType const *ptIds(nullptr);
 163   getGrid()->GetFaceStream( GetVtkID(), nFaces, ptIds );
 164   return nFaces;
 165
 166 }
 167 int SMDS_MeshVolume::NbEdges() const
 168 {
 169   if ( !IsPoly() )
 170     return SMDS_MeshCell::NbEdges();
 171
 172   vtkIdType nFaces = 0;
 173   vtkIdType const *ptIds(nullptr);
 174   getGrid()->GetFaceStream( GetVtkID(), nFaces, ptIds );
 175   int id = 0, nbEdges = 0;
 176   for (int i = 0; i < nFaces; i++)
 177   {
 178     int edgesInFace = ptIds[id];
 179     id += (edgesInFace + 1);
 180     nbEdges += edgesInFace;
 181   }
 182   nbEdges = nbEdges / 2;
 183   return nbEdges;
 184 }
 185
 186 int SMDS_MeshVolume::GetNodeIndex( const SMDS_MeshNode* node ) const
 187 {
 188   if ( !IsPoly() )
 189     return SMDS_MeshCell::GetNodeIndex( node );
 190
 191   vtkIdType nFaces = 0;
 192   vtkIdType const *ptIds(nullptr);
 193   getGrid()->GetFaceStream( GetVtkID(), nFaces, ptIds );
 194   int id = 0;
 195   for (int iF = 0; iF < nFaces; iF++)
 196   {
 197     int nodesInFace = ptIds[id];
 198     for ( vtkIdType i = 0; i < nodesInFace; ++i )
 199       if ( ptIds[id+i+1] == node->GetVtkID() )
 200         return id+i-iF;
 201     id += (nodesInFace + 1);
 202   }
 203   return -1;
 204 }
 205 bool SMDS_MeshVolume::ChangeNodes(const SMDS_MeshNode* nodes[], const int nbNodes)
 206 {
 207   return false;
 208 }
 209
 210 bool SMDS_MeshVolume::IsMediumNode(const SMDS_MeshNode* node) const
 211 {
 212   if ( !IsPoly() )
 213     return SMDS_MeshCell::IsMediumNode( node );
 214
 215   return false;
 216 }
 217
 218 int SMDS_MeshVolume::NbCornerNodes() const
 219 {
 220   if ( !IsPoly() )
 221     return SMDS_MeshCell::NbCornerNodes();
 222
 223   return NbNodes();
 224 }
 225
 226 int SMDS_MeshVolume::NbFaceNodes (const int face_ind) const
 227 {
 228   if ( !IsPoly() )
 229     return SMDS_VolumeTool( this ).NbFaceNodes( face_ind-1 );
 230
 231   vtkIdType nFaces = 0;
 232   vtkIdType const *ptIds(nullptr);
 233   getGrid()->GetFaceStream( GetVtkID(), nFaces, ptIds );
 234   int id = 0, nbNodes = 0;
 235   for (int i = 0; i < nFaces; i++)
 236   {
 237     int nodesInFace = ptIds[id];
 238     id += (nodesInFace + 1);
 239     if (i == face_ind - 1)
 240     {
 241       nbNodes = nodesInFace;
 242       break;
 243     }
 244   }
 245   return nbNodes;
 246 }
 247
 248 const SMDS_MeshNode* SMDS_MeshVolume::GetFaceNode (const int face_ind, const int node_ind) const
 249 {
 250   if ( !IsPoly() )
 251     return SMDS_VolumeTool( this ).GetFaceNodes( face_ind-1 )[ node_ind - 1 ];
 252
 253   vtkIdType nFaces = 0;
 254   vtkIdType const *ptIds(nullptr);
 255   getGrid()->GetFaceStream( GetVtkID(), nFaces, ptIds);
 256   int id = 0;
 257   for (int i = 0; i < nFaces; i++)
 258   {
 259     int nodesInFace = ptIds[id]; // nodeIds in ptIds[id+1 .. id+nodesInFace]
 260     if (i == face_ind - 1) // first face is number 1
 261     {
 262       if ((node_ind > 0) && (node_ind <= nodesInFace))
 263         return GetMesh()->FindNodeVtk(ptIds[id + node_ind]); // ptIds[id+1] : first node
 264     }
 265     id += (nodesInFace + 1);
 266   }
 267   return 0;
 268 }
 269
 270 std::vector<int> SMDS_MeshVolume::GetQuantities() const
 271 {
 272   std::vector<int> quantities;
 273   if ( IsPoly() )
 274   {
 275     vtkIdType nFaces = 0;
 276     vtkIdType const *ptIds(nullptr);
 277     getGrid()->GetFaceStream( GetVtkID(), nFaces, ptIds );
 278     int id = 0;
 279     for (int i = 0; i < nFaces; i++)
 280     {
 281       int nodesInFace = ptIds[id]; // nodeIds in ptIds[id+1 .. id+nodesInFace]
 282       quantities.push_back( nodesInFace );
 283       id += (nodesInFace + 1);
 284     }
 285   }
 286   return quantities;
 287 }
 288
 289 ///////////////////////////////////////////////////////////////////////////////
 290 /// Create an iterator which iterate on nodes owned by the element.
 291 ///////////////////////////////////////////////////////////////////////////////
 292 SMDS_ElemIteratorPtr SMDS_MeshVolume::nodesIterator() const
 293 {
 294   if ( !IsPoly() )
 295     return SMDS_MeshCell::nodesIterator();
 296
 297   return boost::make_shared< SMDS_VtkCellIteratorPolyH<> >( GetMesh(), GetVtkID(), GetEntityType());
 298 }
 299
 300 ///////////////////////////////////////////////////////////////////////////////
 301 /// Create an iterator which iterate on nodes owned by the element.
 302 ///////////////////////////////////////////////////////////////////////////////
 303 SMDS_NodeIteratorPtr SMDS_MeshVolume::nodeIterator() const
 304 {
 305   if ( !IsPoly() )
 306     return SMDS_MeshCell::nodeIterator();
 307
 308   return boost::make_shared< SMDS_VtkCellIteratorPolyH< SMDS_NodeIterator> >( GetMesh(), GetVtkID(), GetEntityType());
 309 }