vtkStructuredAMRGridConnectivity.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkStructuredAMRGridConnectivity_h
#define vtkStructuredAMRGridConnectivity_h
 
#include "vtkAbstractGridConnectivity.h"
#include "vtkFiltersGeometryModule.h" // For export macro
 
#include "vtkStructuredAMRNeighbor.h" // For vtkStructuredAMRNeighbor def.
 
// C++ includes
#include <map>     // For STL map
#include <ostream> // For STL stream
#include <set>     // For STL set
#include <vector>  // For STL vector
 
VTK_ABI_NAMESPACE_BEGIN
class VTKFILTERSGEOMETRY_EXPORT vtkStructuredAMRGridConnectivity
  : public vtkAbstractGridConnectivity
{
public:
  static vtkStructuredAMRGridConnectivity* New();
  vtkTypeMacro(vtkStructuredAMRGridConnectivity, vtkAbstractGridConnectivity);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  void Initialize(unsigned int NumberOfLevels, unsigned int N, int RefinementRatio = -1);
 
  void ComputeNeighbors() override;
 
  void CreateGhostLayers(int N = 1) override;
 
  virtual void RegisterGrid(int gridIdx, int level, int refinementRatio, int extents[6],
    vtkUnsignedCharArray* nodesGhostArray, vtkUnsignedCharArray* cellGhostArray,
    vtkPointData* pointData, vtkCellData* cellData, vtkPoints* gridNodes);
 
  virtual void RegisterGrid(int gridIdx, int level, int extents[6],
    vtkUnsignedCharArray* nodesGhostArray, vtkUnsignedCharArray* cellGhostArray,
    vtkPointData* pointData, vtkCellData* cellData, vtkPoints* gridNodes);
 
 
  vtkSetMacro(BalancedRefinement, bool);
  vtkGetMacro(BalancedRefinement, bool);
 
 
  vtkSetMacro(NodeCentered, bool);
  vtkGetMacro(NodeCentered, bool);
 
 
  vtkSetMacro(CellCentered, bool);
  vtkGetMacro(CellCentered, bool);
 
  int GetNumberOfNeighbors(int gridID);
 
  void GetGhostedExtent(int gridID, int ext[6]);
 
  vtkStructuredAMRNeighbor GetNeighbor(int gridID, int nei);
 
protected:
  vtkStructuredAMRGridConnectivity();
  ~vtkStructuredAMRGridConnectivity() override;
 
  void SetNumberOfGrids(unsigned int N) override;
 
  void CreateGhostedMaskArrays(int gridID);
 
  void CreateGhostedExtent(int gridID, int N);
 
  void SetGhostedExtent(int gridID, int ext[6]);
 
  void GetCoarsenedExtent(int gridIdx, int fromLevel, int toLevel, int ext[6]);
 
  void GetRefinedExtent(int gridIdx, int fromLevel, int toLevel, int ext[6]);
 
  void RefineExtent(int orient[3], int ndim, int fromLevel, int toLevel, int ext[6]);
 
  void GetCellRefinedExtent(
    int orient[3], int ndim, int i, int j, int k, int fromLevel, int toLevel, int ext[6]);
 
  void CoarsenExtent(int orient[3], int ndim, int fromLevel, int toLevel, int ext[6]);
 
  void GetGridExtent(int gridIdx, int ext[6]);
 
  int GetGridLevel(int gridIdx);
 
  bool LevelExists(int level);
 
  bool IsNodeInterior(int i, int j, int k, int GridExtent[6]);
 
  bool IsNodeWithinExtent(int i, int j, int k, int GridExtent[6]);
 
  bool IsNodeOnSharedBoundary(int i, int j, int k, int gridId, int gridExt[6]);
 
  bool IsNodeOnBoundaryOfExtent(int i, int j, int k, int ext[6]);
 
  void InsertGridAtLevel(int level, int gridID);
 
  void ComputeNeighborSendAndRcvExtent(int gridID, int N);
 
  void ComputeWholeExtent();
 
  void GetWholeExtentAtLevel(int level, int ext[6]);
 
  void EstablishNeighbors(int i, int j);
 
  void GetNodeOrientation(int i, int j, int k, int gridExt[6], int nodeOrientation[3]);
 
  void GetOrientationVector(int dataDescription, int orient[3], int& ndim);
 
  bool HasConstantRefinementRatio();
 
  void SetRefinementRatioAtLevel(int level, int r);
 
  int GetRefinementRatioAtLevel(int level);
 
  bool AreExtentsEqual(int ext1[6], int ext2[6]);
 
  void SetBlockTopology(int gridID);
 
  int GetNumberOfConnectingBlockFaces(int gridID);
 
 
  bool HasBlockConnection(int gridID, int blockDirection)
  {
    // Sanity check
    assert("pre: gridID is out-of-bounds" && (gridID >= 0) &&
      (gridID < static_cast<int>(this->NumberOfGrids)));
    assert("pre: BlockTopology has not been properly allocated" &&
      (this->NumberOfGrids == this->BlockTopology.size()));
    assert("pre: blockDirection is out-of-bounds" && (blockDirection >= 0) && (blockDirection < 6));
    bool status = false;
    if (this->BlockTopology[gridID] & (1 << blockDirection))
    {
      status = true;
    }
    return (status);
  }
 
  void RemoveBlockConnection(int gridID, int blockDirection);
 
  void AddBlockConnection(int gridID, int blockDirection);
 
  void ClearBlockConnections(int gridID);
 
  virtual void MarkNodeProperty(
    int gridId, int i, int j, int k, int gridExt[6], int wholeExt[6], unsigned char& p);
 
  virtual void FillNodesGhostArray(int gridId, vtkUnsignedCharArray* nodesArray);
 
  virtual void FillCellsGhostArray(int gridId, vtkUnsignedCharArray* cellsArray);
 
  void FillGhostArrays(
    int gridId, vtkUnsignedCharArray* nodesArray, vtkUnsignedCharArray* cellsArray) override;
 
  vtkStructuredAMRNeighbor GetAMRNeighbor(int i, int iLevel, int next1[6], int j, int jLevel,
    int next2[6], int normalizedLevel, int levelDiff, vtkStructuredNeighbor& nei);
 
  void ComputeAMRNeighborOverlapExtents(int iLevel, int jLevel, int normalizedLevel,
    const vtkStructuredNeighbor& nei, int orient[3], int ndim, int gridOverlapExtent[6],
    int neiOverlapExtent[6]);
 
  int Get1DOrientation(int idx, int ExtentLo, int ExtentHi, int OnLo, int OnHi, int NotOnBoundary);
 
  void PrintExtent(std::ostream& os, int ext[6]);
 
  void InitializeGhostData(int gridID);
 
  void TransferRegisteredDataToGhostedData(int gridID);
 
  void TransferLocalNodeCenteredNeighborData(int gridID, vtkStructuredAMRNeighbor& nei);
 
  void GetLocalCellCentersFromCoarserLevel(int gridID, vtkStructuredAMRNeighbor& nei);
 
  void GetLocalCellCentersFromFinerLevel(int gridID, vtkStructuredAMRNeighbor& nei);
 
  void GetLocalCellCentersAtSameLevel(int gridID, vtkStructuredAMRNeighbor& nei);
 
  void TransferLocalCellCenteredNeighborData(int gridID, vtkStructuredAMRNeighbor& nei);
 
  void TransferLocalNeighborData(int gridID, vtkStructuredAMRNeighbor& nei);
 
  virtual void TransferGhostDataFromNeighbors(int gridID);
 
  void AverageFieldData(
    vtkFieldData* source, vtkIdType* sourceIds, int N, vtkFieldData* target, vtkIdType targetIdx);
 
  void CopyFieldData(
    vtkFieldData* source, vtkIdType sourceIdx, vtkFieldData* target, vtkIdType targetIdx);
 
  unsigned int NumberOfLevels; // The total number of levels;
  int DataDimension;           // The dimension of the data, i.e. 2 or 3
  int DataDescription;         // The data description, i.e., VTK_XY_PLANE, etc.
  int WholeExtent[6];          // The whole extent w.r.t. to the root level, level 0.
  int MaxLevel;                // The max level of the AMR hierarchy
  int RefinementRatio;         // The refinement ratio, set in the initialization,iff,
                               // a constant refinement ratio is used. A value of -1
                               // indicates that the refinement ratio is not constant
                               // and the RefinementRatios vector is used instead.
 
  bool NodeCentered; // Indicates if the data is node-centered
  bool CellCentered; // Indicates if the data is cell-centered
 
  bool BalancedRefinement; // If Balanced refinement is true, then adjacent
                           // grids in the hierarchy can only differ by one
                           // level.
 
  // AMRHierarchy stores the set of grid Ids in [0,N] for each level
  std::map<int, std::set<int>> AMRHierarchy;
 
  // For each grid, [0,N] store the grid extents,level, and list of neighbors
  std::vector<int> GridExtents;             // size of this vector is 6*N
  std::vector<int> GhostedExtents;          // size of this vector is 6*N
  std::vector<unsigned char> BlockTopology; // size of this vector is N
  std::vector<int> GridLevels;              // size of this vector is N
  std::vector<std::vector<vtkStructuredAMRNeighbor>> Neighbors;
 
  // For each grid, [0,N], store the donor level,grid and cell information, a
  // DonorLevel of -1 indicates that the cell is not receiving any information
  // from a donor.
  std::vector<std::vector<int>> CellCenteredDonorLevel;
 
  // RefinementRatios stores the refinement ratio at each level, this vector
  // is used only when the refinement ratio varies across levels
  std::vector<int> RefinementRatios;
 
private:
  vtkStructuredAMRGridConnectivity(const vtkStructuredAMRGridConnectivity&) = delete;
  void operator=(const vtkStructuredAMRGridConnectivity&) = delete;
};
 
//=============================================================================
//  INLINE METHODS
//=============================================================================
 
//------------------------------------------------------------------------------
inline int vtkStructuredAMRGridConnectivity::GetNumberOfNeighbors(int gridID)
{
  assert("pre: grid ID is out-of-bounds" && (gridID >= 0) &&
    (gridID < static_cast<int>(this->NumberOfGrids)));
  assert("pre: neighbors vector has not been properly allocated" &&
    (this->Neighbors.size() == this->NumberOfGrids));
  return (static_cast<int>(this->Neighbors[gridID].size()));
}
 
//------------------------------------------------------------------------------
inline vtkStructuredAMRNeighbor vtkStructuredAMRGridConnectivity::GetNeighbor(int gridID, int nei)
{
  assert("pre: grid ID is out-of-bounds" && (gridID >= 0) &&
    (gridID < static_cast<int>(this->NumberOfGrids)));
  assert("pre: neighbors vector has not been properly allocated" &&
    (this->Neighbors.size() == this->NumberOfGrids));
  assert("pre: nei index is out-of-bounds" && (nei >= 0) &&
    (nei < static_cast<int>(this->Neighbors[gridID].size())));
  return (this->Neighbors[gridID][nei]);
}
 
//------------------------------------------------------------------------------
inline int vtkStructuredAMRGridConnectivity::Get1DOrientation(
  int idx, int ExtentLo, int ExtentHi, int OnLo, int OnHi, int NotOnBoundary)
{
  if (idx == ExtentLo)
  {
    return OnLo;
  }
  else if (idx == ExtentHi)
  {
    return OnHi;
  }
  return NotOnBoundary;
}
 
//------------------------------------------------------------------------------
inline int vtkStructuredAMRGridConnectivity::GetNumberOfConnectingBlockFaces(int gridID)
{
  // Sanity check
  assert("pre: gridID is out-of-bounds" && (gridID >= 0) &&
    (gridID < static_cast<int>(this->NumberOfGrids)));
  assert("pre: BlockTopology has not been properly allocated" &&
    (this->NumberOfGrids == this->BlockTopology.size()));
 
  int count = 0;
  for (int i = 0; i < 6; ++i)
  {
    if (this->HasBlockConnection(gridID, i))
    {
      ++count;
    }
  }
  assert("post: count must be in [0,5]" && (count >= 0 && count <= 6));
  return (count);
}
 
//------------------------------------------------------------------------------
inline void vtkStructuredAMRGridConnectivity::RemoveBlockConnection(int gridID, int blockDirection)
{
  // Sanity check
  assert("pre: gridID is out-of-bounds" && (gridID >= 0) &&
    (gridID < static_cast<int>(this->NumberOfGrids)));
  assert("pre: BlockTopology has not been properly allocated" &&
    (this->NumberOfGrids == this->BlockTopology.size()));
  assert("pre: blockDirection is out-of-bounds" && (blockDirection >= 0) && (blockDirection < 6));
 
  this->BlockTopology[gridID] &= ~(1 << blockDirection);
}
 
//------------------------------------------------------------------------------
inline void vtkStructuredAMRGridConnectivity::AddBlockConnection(int gridID, int blockDirection)
{
  // Sanity check
  assert("pre: gridID is out-of-bounds" && (gridID >= 0) &&
    (gridID < static_cast<int>(this->NumberOfGrids)));
  assert("pre: BlockTopology has not been properly allocated" &&
    (this->NumberOfGrids == this->BlockTopology.size()));
  assert("pre: blockDirection is out-of-bounds" && (blockDirection >= 0) && (blockDirection < 6));
  this->BlockTopology[gridID] |= (1 << blockDirection);
}
 
//------------------------------------------------------------------------------
inline void vtkStructuredAMRGridConnectivity::ClearBlockConnections(int gridID)
{
  // Sanity check
  assert("pre: gridID is out-of-bounds" && (gridID >= 0) &&
    (gridID < static_cast<int>(this->NumberOfGrids)));
  assert("pre: BlockTopology has not been properly allocated" &&
    (this->NumberOfGrids == this->BlockTopology.size()));
  for (int i = 0; i < 6; ++i)
  {
    this->RemoveBlockConnection(gridID, i);
  } // END for all block directions
}
 
//------------------------------------------------------------------------------
inline bool vtkStructuredAMRGridConnectivity::AreExtentsEqual(int ext1[6], int ext2[6])
{
  for (int i = 0; i < 6; ++i)
  {
    if (ext1[i] != ext2[i])
    {
      return false;
    }
  } // END for
  return true;
}
 
//------------------------------------------------------------------------------
inline void vtkStructuredAMRGridConnectivity::PrintExtent(std::ostream& os, int ext[6])
{
  for (int i = 0; i < 6; i += 2)
  {
    os << "[";
    os << ext[i] << " ";
    os << ext[i + 1] << "] ";
  } // END for
}
 
//------------------------------------------------------------------------------
inline int vtkStructuredAMRGridConnectivity::GetGridLevel(int gridIdx)
{
  assert("pre: grid Index is out-of-bounds!" && (gridIdx < static_cast<int>(this->NumberOfGrids)));
  assert("pre: grid levels vector has not been allocated" &&
    (this->GridLevels.size() == this->NumberOfGrids));
  return (this->GridLevels[gridIdx]);
}
 
//------------------------------------------------------------------------------
inline void vtkStructuredAMRGridConnectivity::SetRefinementRatioAtLevel(int level, int r)
{
  assert("pre: RefinementRatios vector is not properly allocated" &&
    this->RefinementRatios.size() == this->NumberOfLevels);
  assert("pre: level is out-of-bounds!" && (level >= 0) &&
    (level < static_cast<int>(this->RefinementRatios.size())));
  assert("pre: invalid refinement ratio" && (r >= 2));
 
  this->RefinementRatios[level] = r;
}
 
//------------------------------------------------------------------------------
inline int vtkStructuredAMRGridConnectivity::GetRefinementRatioAtLevel(int level)
{
  assert("pre: RefinementRatios vector is not properly allocated" &&
    this->RefinementRatios.size() == this->NumberOfLevels);
  assert("pre: level is out-of-bounds!" && (level >= 0) &&
    (level < static_cast<int>(this->RefinementRatios.size())));
  assert(
    "pre: refinement ratio for level has not been set" && (this->RefinementRatios[level] >= 2));
 
  return (this->RefinementRatios[level]);
}
 
//------------------------------------------------------------------------------
inline bool vtkStructuredAMRGridConnectivity::HasConstantRefinementRatio()
{
  if (this->RefinementRatio < 2)
  {
    return false;
  }
  return true;
}
 
//------------------------------------------------------------------------------
inline void vtkStructuredAMRGridConnectivity::GetGridExtent(int gridIdx, int ext[6])
{
  assert("pre: grid index is out-of-bounds" &&
    ((gridIdx >= 0) && (gridIdx < static_cast<int>(this->GridExtents.size()))));
 
  for (int i = 0; i < 6; ++i)
  {
    ext[i] = this->GridExtents[gridIdx * 6 + i];
  }
}
 
//------------------------------------------------------------------------------
inline bool vtkStructuredAMRGridConnectivity::LevelExists(int level)
{
  if (this->AMRHierarchy.find(level) != this->AMRHierarchy.end())
  {
    return true;
  }
  return false;
}
 
//------------------------------------------------------------------------------
inline void vtkStructuredAMRGridConnectivity::InsertGridAtLevel(int level, int gridID)
{
  if (this->LevelExists(level))
  {
    this->AMRHierarchy[level].insert(gridID);
  }
  else
  {
    std::set<int> grids;
    grids.insert(gridID);
    this->AMRHierarchy[level] = grids;
  }
}
 
VTK_ABI_NAMESPACE_END
#endif /* VTKSTRUCTUREDAMRGRIDCONNECTIVITY_H_ */