vtkAbstractGridConnectivity.h

Go to the documentation of this file.

/*=========================================================================

 Program:   Visualization Toolkit
 Module:    vtkAbstractGridConnectivity.h

 Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
 All rights reserved.
 See Copyright.txt or http://www.kitware.com/Copyright.htm for details.

 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notice for more information.

 =========================================================================*/
#ifndef vtkAbstractGridConnectivity_h
#define vtkAbstractGridConnectivity_h

// VTK includes
#include "vtkCellData.h"              // for vtkCellData definition int STL vector
#include "vtkFiltersGeometryModule.h" // For export macro
#include "vtkObject.h"
#include "vtkPointData.h"         // for vtkPointData definition in STL vector
#include "vtkPoints.h"            // for vtkPoints definition in STL vector
#include "vtkUnsignedCharArray.h" // for vtkUnsignedCharArray definition

// Forward declarations
class vtkPointData;
class vtkCellData;
class vtkUnsignedCharArray;
class vtkPoints;

// C++ include directives
#include <cassert> // For assert
#include <vector>  // For STL vector

class VTKFILTERSGEOMETRY_EXPORT vtkAbstractGridConnectivity : public vtkObject
{
public:
  vtkTypeMacro(vtkAbstractGridConnectivity, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;


  vtkSetMacro(NumberOfGhostLayers, unsigned int);
  vtkGetMacro(NumberOfGhostLayers, unsigned int);

  virtual void SetNumberOfGrids(const unsigned int N) = 0;

  unsigned int GetNumberOfGrids() { return this->NumberOfGrids; }

  virtual void ComputeNeighbors() = 0;

  virtual void CreateGhostLayers(const int N = 1) = 0;

  vtkUnsignedCharArray* GetGhostedPointGhostArray(const int gridID);

  vtkUnsignedCharArray* GetGhostedCellGhostArray(const int gridID);

  vtkPointData* GetGhostedGridPointData(const int gridID);

  vtkCellData* GetGhostedGridCellData(const int gridID);

  vtkPoints* GetGhostedPoints(const int gridID);

protected:
  vtkAbstractGridConnectivity();
  ~vtkAbstractGridConnectivity() override;

  virtual void FillGhostArrays(
    const int gridId, vtkUnsignedCharArray* nodesArray, vtkUnsignedCharArray* cellsArray) = 0;

  void RegisterGridGhostArrays(
    const int gridID, vtkUnsignedCharArray* nodesArray, vtkUnsignedCharArray* cellsArray);

  void RegisterFieldData(const int gridID, vtkPointData* PointData, vtkCellData* CellData);

  void RegisterGridNodes(const int gridID, vtkPoints* nodes);


  void AllocateUserRegisterDataStructures();
  void DeAllocateUserRegisterDataStructures();


  void AllocateInternalDataStructures();
  void DeAllocateInternalDataStructures();

  // The total number of grids, set initially by the user.
  unsigned int NumberOfGrids;
  unsigned int NumberOfGhostLayers;

  // Arrays registered by the user for each grid
  std::vector<vtkUnsignedCharArray*> GridPointGhostArrays;
  std::vector<vtkUnsignedCharArray*> GridCellGhostArrays;
  std::vector<vtkPointData*> GridPointData;
  std::vector<vtkCellData*> GridCellData;
  std::vector<vtkPoints*> GridPoints;

  // Arrays computed internally for each grid
  bool AllocatedGhostDataStructures;
  std::vector<vtkPointData*> GhostedGridPointData;
  std::vector<vtkCellData*> GhostedGridCellData;
  std::vector<vtkUnsignedCharArray*> GhostedPointGhostArray;
  std::vector<vtkUnsignedCharArray*> GhostedCellGhostArray;
  std::vector<vtkPoints*> GhostedGridPoints;

private:
  vtkAbstractGridConnectivity(const vtkAbstractGridConnectivity&) = delete;
  void operator=(const vtkAbstractGridConnectivity&) = delete;
};

//------------------------------------------------------------------------------
inline vtkUnsignedCharArray* vtkAbstractGridConnectivity::GetGhostedPointGhostArray(
  const int gridID)
{
  if (!this->AllocatedGhostDataStructures)
  {
    return nullptr;
  }

  assert("pre: GridID is out-of-bound GridPointData" && (gridID >= 0) &&
    (gridID < static_cast<int>(this->NumberOfGrids)));
  assert("pre: Ghosted point ghost array" &&
    (this->NumberOfGrids == this->GhostedPointGhostArray.size()));

  return (this->GhostedPointGhostArray[gridID]);
}

//------------------------------------------------------------------------------
inline vtkUnsignedCharArray* vtkAbstractGridConnectivity::GetGhostedCellGhostArray(const int gridID)
{
  if (!this->AllocatedGhostDataStructures)
  {
    return nullptr;
  }

  assert("pre: GridID is out-of-bound GridPointData" && (gridID >= 0) &&
    (gridID < static_cast<int>(this->NumberOfGrids)));
  assert("pre: Ghosted point ghost array" &&
    (this->NumberOfGrids == this->GhostedCellGhostArray.size()));

  return (this->GhostedCellGhostArray[gridID]);
}

//------------------------------------------------------------------------------
inline vtkPointData* vtkAbstractGridConnectivity::GetGhostedGridPointData(const int gridID)
{
  if (!this->AllocatedGhostDataStructures)
  {
    return nullptr;
  }

  assert("pre: GridID is out-of-bound GridPointData" && (gridID >= 0) &&
    (gridID < static_cast<int>(this->NumberOfGrids)));
  assert(
    "pre: Ghosted point ghost array" && (this->NumberOfGrids == this->GhostedGridPointData.size()));

  return (this->GhostedGridPointData[gridID]);
}

//------------------------------------------------------------------------------
inline vtkCellData* vtkAbstractGridConnectivity::GetGhostedGridCellData(const int gridID)
{
  if (!this->AllocatedGhostDataStructures)
  {
    return nullptr;
  }

  assert("pre: GridID is out-of-bound GridPointData" && (gridID >= 0) &&
    (gridID < static_cast<int>(this->NumberOfGrids)));
  assert(
    "pre: Ghosted point ghost array" && (this->NumberOfGrids == this->GhostedGridCellData.size()));

  return (this->GhostedGridCellData[gridID]);
}

//------------------------------------------------------------------------------
inline vtkPoints* vtkAbstractGridConnectivity::GetGhostedPoints(const int gridID)
{
  if (!this->AllocatedGhostDataStructures)
  {
    return nullptr;
  }

  assert("pre: GridID is out-of-bound GridPointData" && (gridID >= 0) &&
    (gridID < static_cast<int>(this->NumberOfGrids)));
  assert(
    "pre: Ghosted point ghost array" && (this->NumberOfGrids == this->GhostedGridPoints.size()));

  return (this->GhostedGridPoints[gridID]);
}

//------------------------------------------------------------------------------
inline void vtkAbstractGridConnectivity::AllocateUserRegisterDataStructures()
{
  // Sanity Check
  assert("pre: Allocating UserRegister for N > 0 grids" && (this->NumberOfGrids > 0));

  this->GridPointGhostArrays.resize(this->NumberOfGrids, nullptr);
  this->GridCellGhostArrays.resize(this->NumberOfGrids, nullptr);
  this->GridPointData.resize(this->NumberOfGrids, nullptr);
  this->GridCellData.resize(this->NumberOfGrids, nullptr);
  this->GridPoints.resize(this->NumberOfGrids, nullptr);
}

//------------------------------------------------------------------------------
inline void vtkAbstractGridConnectivity::DeAllocateUserRegisterDataStructures()
{
  assert("pre: Data-structure has not been properly allocated" &&
    (this->GridPointGhostArrays.size() == this->NumberOfGrids));
  assert("pre: Data-structure has not been properly allocated" &&
    (this->GridCellGhostArrays.size() == this->NumberOfGrids));
  assert("pre: Data-structure has not been properly allocated" &&
    (this->GridPointData.size() == this->NumberOfGrids));
  assert("pre: Data-structure has not been properly allocated" &&
    (this->GridCellData.size() == this->NumberOfGrids));
  assert("pre: Data-structure has not been properly allocated" &&
    (this->GridPoints.size() == this->NumberOfGrids));

  for (unsigned int i = 0; i < this->NumberOfGrids; ++i)
  {
    // NOTE: Ghost arrays are not deleted here b/c when they are registered, they
    // are not shallow-copied.
    //    if( this->GridPointGhostArrays[i] != nullptr )
    //      {
    //      this->GridPointGhostArrays[i]->Delete();
    //      }
    //    if( this->GridCellGhostArrays[i] != nullptr )
    //      {
    //      this->GridCellGhostArrays[i]->Delete();
    //      }
    if (this->GridPointData[i] != nullptr)
    {
      this->GridPointData[i]->Delete();
    }
    if (this->GridCellData[i] != nullptr)
    {
      this->GridCellData[i]->Delete();
    }
    if (this->GridPoints[i] != nullptr)
    {
      this->GridPoints[i]->Delete();
    }
  } // END for all grids

  this->GridPointGhostArrays.clear();
  this->GridCellGhostArrays.clear();
  this->GridPointData.clear();
  this->GridCellData.clear();
  this->GridPoints.clear();
}

//------------------------------------------------------------------------------
inline void vtkAbstractGridConnectivity::AllocateInternalDataStructures()
{
  assert("pre: Allocating Internal data-structured for N > 0 grids" && (this->NumberOfGrids > 0));

  this->GhostedGridPointData.resize(this->NumberOfGrids, nullptr);
  this->GhostedGridCellData.resize(this->NumberOfGrids, nullptr);
  this->GhostedPointGhostArray.resize(this->NumberOfGrids, nullptr);
  this->GhostedCellGhostArray.resize(this->NumberOfGrids, nullptr);
  this->GhostedGridPoints.resize(this->NumberOfGrids, nullptr);
  this->AllocatedGhostDataStructures = true;
}

//------------------------------------------------------------------------------
inline void vtkAbstractGridConnectivity::DeAllocateInternalDataStructures()
{
  if (!this->AllocatedGhostDataStructures)
  {
    return;
  }

  assert("pre: Data-structure has not been properly allocated" &&
    (this->GhostedGridPointData.size() == this->NumberOfGrids));
  assert("pre: Data-structure has not been properly allocated" &&
    (this->GhostedGridCellData.size() == this->NumberOfGrids));
  assert("pre: Data-structure has not been properly allocated" &&
    (this->GhostedPointGhostArray.size() == this->NumberOfGrids));
  assert("pre: Data-structure has not been properly allocated" &&
    (this->GhostedCellGhostArray.size() == this->NumberOfGrids));
  assert("pre: Data-structure has not been properly allocated" &&
    (this->GhostedGridPoints.size() == this->NumberOfGrids));

  for (unsigned int i = 0; i < this->NumberOfGrids; ++i)
  {
    if (this->GhostedGridPointData[i] != nullptr)
    {
      this->GhostedGridPointData[i]->Delete();
    }
    if (this->GhostedGridCellData[i] != nullptr)
    {
      this->GhostedGridCellData[i]->Delete();
    }
    if (this->GhostedPointGhostArray[i] != nullptr)
    {
      this->GhostedPointGhostArray[i]->Delete();
    }
    if (this->GhostedCellGhostArray[i] != nullptr)
    {
      this->GhostedCellGhostArray[i]->Delete();
    }
    if (this->GhostedGridPoints[i] != nullptr)
    {
      this->GhostedGridPoints[i]->Delete();
    }
  } // END for all grids

  this->GhostedGridPointData.clear();
  this->GhostedGridCellData.clear();
  this->GhostedPointGhostArray.clear();
  this->GhostedCellGhostArray.clear();
  this->GhostedGridPoints.clear();

  this->AllocatedGhostDataStructures = false;
}

//------------------------------------------------------------------------------
inline void vtkAbstractGridConnectivity::RegisterGridGhostArrays(
  const int gridID, vtkUnsignedCharArray* nodesArray, vtkUnsignedCharArray* cellsArray)
{
  // Sanity check
  assert("pre: GridID is out-of-bound GridPointData" && (gridID >= 0) &&
    (gridID < static_cast<int>(this->NumberOfGrids)));
  assert("pre: GridPointGhostArrays has not been allocated" &&
    (this->GridPointGhostArrays.size() == this->NumberOfGrids));
  assert("pre: GridCellGhostArrays has not been allocated" &&
    (this->GridCellGhostArrays.size() == this->NumberOfGrids));

  // NOTE: We should really shallow copy the objects here
  this->GridPointGhostArrays[gridID] = nodesArray;
  this->GridCellGhostArrays[gridID] = cellsArray;
}

//------------------------------------------------------------------------------
inline void vtkAbstractGridConnectivity::RegisterFieldData(
  const int gridID, vtkPointData* PointData, vtkCellData* CellData)
{
  // Sanity check
  assert("pre: GridID is out-of-bound GridPointData" && (gridID >= 0) &&
    (gridID < static_cast<int>(this->NumberOfGrids)));
  assert("pre: GridPointData has not been allocated!" &&
    (this->GridPointData.size() == this->NumberOfGrids));
  assert("pre: GridCellData has not been allocated!" &&
    (this->GridCellData.size() == this->NumberOfGrids));

  // Note: The size of these vectors is allocated in SetNumberOfGrids
  if (PointData != nullptr)
  {
    assert("pre: GridPointData[gridID] must be nullptr" && this->GridPointData[gridID] == nullptr);
    this->GridPointData[gridID] = vtkPointData::New();
    this->GridPointData[gridID]->ShallowCopy(PointData);
  }
  else
  {
    this->GridPointData[gridID] = nullptr;
  }

  if (CellData != nullptr)
  {
    assert("pre: GridCellData[gridID] must be nullptr" && this->GridCellData[gridID] == nullptr);
    this->GridCellData[gridID] = vtkCellData::New();
    this->GridCellData[gridID]->ShallowCopy(CellData);
  }
  else
  {
    this->GridCellData[gridID] = nullptr;
  }
}

//------------------------------------------------------------------------------
inline void vtkAbstractGridConnectivity::RegisterGridNodes(const int gridID, vtkPoints* nodes)
{
  // Sanity check
  assert("pre: GridID is out-of-bound GridPointData" && (gridID >= 0) &&
    (gridID < static_cast<int>(this->NumberOfGrids)));
  assert(
    "pre: GridPoints has not been allocated!" && (this->GridPoints.size() == this->NumberOfGrids));

  if (nodes != nullptr)
  {
    assert("pre:GridPoints[gridID] must be nullptr" && this->GridPoints[gridID] == nullptr);
    this->GridPoints[gridID] = vtkPoints::New();
    this->GridPoints[gridID]->SetDataTypeToDouble();
    this->GridPoints[gridID]->ShallowCopy(nodes);
  }
  else
  {
    this->GridPoints[gridID] = nullptr;
  }
}

#endif /* vtkAbstractGridConnectivity_h */