src/SMDS/SMDS_VtkVolume.cxx

   1
   2 #include "SMDS_VtkVolume.hxx"
   3 #include "SMDS_MeshNode.hxx"
   4 #include "SMDS_Mesh.hxx"
   5 #include "SMDS_VtkCellIterator.hxx"
   6
   7 #include "utilities.h"
   8
   9 #include <vector>
  10
  11
  12 SMDS_VtkVolume::SMDS_VtkVolume()
  13 {
  14 }
  15
  16 SMDS_VtkVolume::SMDS_VtkVolume(std::vector<vtkIdType> nodeIds, SMDS_Mesh* mesh)
  17 {
  18   init(nodeIds, mesh);
  19 }
  20 /*!
  21  * typed used are vtk types (@see vtkCellType.h)
  22  * see GetEntityType() for conversion in SMDS type (@see SMDSAbs_ElementType.hxx)
  23  */
  24 void SMDS_VtkVolume::init(std::vector<vtkIdType> nodeIds, SMDS_Mesh* mesh)
  25 {
  26   vtkUnstructuredGrid* grid = mesh->getGrid();
  27   myIdInShape = -1;
  28   myMeshId = mesh->getMeshId();
  29   vtkIdType aType = VTK_TETRA;
  30   switch(nodeIds.size())
  31     {
  32     case  4: aType = VTK_TETRA;                break;
  33     case  5: aType = VTK_PYRAMID;              break;
  34     case  6: aType = VTK_WEDGE;                break;
  35     case  8: aType = VTK_HEXAHEDRON;           break;
  36     case 10: aType = VTK_QUADRATIC_TETRA;      break;
  37     case 13: aType = VTK_QUADRATIC_PYRAMID;    break;
  38     case 15: aType = VTK_QUADRATIC_WEDGE;      break;
  39     case 20: aType = VTK_QUADRATIC_HEXAHEDRON; break;
  40     default: aType = VTK_HEXAHEDRON; break;
  41     }
  42   myVtkID = grid->InsertNextLinkedCell(aType, nodeIds.size(), &nodeIds[0]);
  43 }
  44
  45 bool SMDS_VtkVolume::ChangeNodes(const SMDS_MeshNode* nodes[],
  46                                  const int            nbNodes)
  47 {
  48   // utilise dans SMDS_Mesh
  49   return true;
  50 }
  51
  52 SMDS_VtkVolume::~SMDS_VtkVolume()
  53 {
  54 }
  55
  56 void SMDS_VtkVolume::Print(ostream & OS) const
  57 {
  58   OS << "volume <" << GetID() << "> : ";
  59 }
  60
  61 int SMDS_VtkVolume::NbFaces() const
  62 {
  63   switch(NbNodes())
  64     {
  65     case  4:
  66     case 10: return 4;
  67     case  5:
  68     case 13: return 5;
  69     case  6:
  70     case 15: return 5;
  71     case  8:
  72     case 20: return 6;
  73     default: MESSAGE("invalid number of nodes");
  74     }
  75   return 0;
  76 }
  77
  78 int SMDS_VtkVolume::NbNodes() const
  79 {
  80   vtkUnstructuredGrid* grid =SMDS_Mesh::_meshList[myMeshId]->getGrid();
  81   int nbPoints = grid->GetCell(myVtkID)->GetNumberOfPoints();
  82   return nbPoints;
  83 }
  84
  85 int SMDS_VtkVolume::NbEdges() const
  86 {
  87   switch(NbNodes())
  88     {
  89     case  4:
  90     case 10: return 6;
  91     case  5:
  92     case 13: return 8;
  93     case  6:
  94     case 15: return 9;
  95     case  8:
  96     case 20: return 12;
  97     default: MESSAGE("invalid number of nodes");
  98     }
  99   return 0;
 100 }
 101
 102 SMDS_ElemIteratorPtr SMDS_VtkVolume::elementsIterator(SMDSAbs_ElementType type) const
 103 {
 104   switch(type)
 105     {
 106     case SMDSAbs_Node:
 107       return SMDS_ElemIteratorPtr(new SMDS_VtkCellIterator(SMDS_Mesh::_meshList[myMeshId], myVtkID, GetEntityType()));
 108     default:
 109       MESSAGE("ERROR : Iterator not implemented");
 110       return SMDS_ElemIteratorPtr((SMDS_ElemIterator*)NULL);
 111     }
 112 }
 113
 114 SMDSAbs_ElementType SMDS_VtkVolume::GetType() const
 115 {
 116   return SMDSAbs_Volume;
 117 }
 118
 119 /*!
 120  * \brief Return node by its index
 121  * \param ind - node index
 122  * \retval const SMDS_MeshNode* - the node
 123  */
 124 const SMDS_MeshNode* SMDS_VtkVolume::GetNode(const int ind) const
 125 {
 126   return SMDS_MeshElement::GetNode(ind); // --- a optimiser !
 127 }
 128
 129 bool SMDS_VtkVolume::IsQuadratic() const
 130 {
 131   if (this->NbNodes() > 9)
 132         return true;
 133   else
 134         return false;
 135 }
 136
 137 SMDSAbs_EntityType SMDS_VtkVolume::GetEntityType() const
 138 {
 139   SMDSAbs_EntityType aType = SMDSEntity_Tetra;
 140   switch(NbNodes())
 141     {
 142     case  4: aType = SMDSEntity_Tetra;        break;
 143     case  5: aType = SMDSEntity_Pyramid;      break;
 144     case  6: aType = SMDSEntity_Penta;        break;
 145     case  8: aType = SMDSEntity_Hexa;         break;
 146     case 10: aType = SMDSEntity_Quad_Tetra;   break;
 147     case 13: aType = SMDSEntity_Quad_Pyramid; break;
 148     case 15: aType = SMDSEntity_Quad_Penta;   break;
 149     case 20: aType = SMDSEntity_Quad_Hexa;    break;
 150     default: aType = SMDSEntity_Hexa;         break;
 151     }
 152   return aType;
 153 }
 154
 155 vtkIdType SMDS_VtkVolume::GetVtkType() const
 156 {
 157   vtkIdType aType = VTK_TETRA;
 158   switch(NbNodes())
 159     {
 160     case  4: aType = VTK_TETRA;                break;
 161     case  5: aType = VTK_PYRAMID;              break;
 162     case  6: aType = VTK_WEDGE;                break;
 163     case  8: aType = VTK_HEXAHEDRON;           break;
 164     case 10: aType = VTK_QUADRATIC_TETRA;      break;
 165     case 13: aType = VTK_QUADRATIC_PYRAMID;    break;
 166     case 15: aType = VTK_QUADRATIC_WEDGE;      break;
 167     case 20: aType = VTK_QUADRATIC_HEXAHEDRON; break;
 168     default: aType = VTK_HEXAHEDRON;           break;
 169     }
 170  return aType;
 171 }