vtkOverlappingAMRMetaData.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 vtkOverlappingAMRMetaData_h
#define vtkOverlappingAMRMetaData_h
 
#include "vtkAMRBox.h" //for storing AMR Boxes
#include "vtkAMRMetaData.h"
#include "vtkCommonDataModelModule.h" // For export macro
#include "vtkSmartPointer.h"          //for ivars
 
VTK_ABI_NAMESPACE_BEGIN
class vtkIntArray;
class vtkDoubleArray;
class VTKCOMMONDATAMODEL_EXPORT vtkOverlappingAMRMetaData : public vtkAMRMetaData
{
public:
  static vtkOverlappingAMRMetaData* New();
  vtkTypeMacro(vtkOverlappingAMRMetaData, vtkAMRMetaData);
 
  void PrintSelf(ostream& os, vtkIndent indent) override;
  bool operator==(const vtkOverlappingAMRMetaData& other) const;
  bool operator!=(const vtkOverlappingAMRMetaData& other) const { return !(*this == other); }
 
  // VTK_DEPRECATED_IN_9_6_0
  // Remove once the deprecated Initialize method in parent class is removed
  using vtkAMRMetaData::Initialize;
 
  void Initialize(const std::vector<unsigned int>& blocksPerLevel) override;
 
 
  void GetOrigin(double origin[3]);
  [[nodiscard]] double* GetOrigin();
  void SetOrigin(const double* origin);
 
  [[nodiscard]] const double* GetBounds();
 
  void GetBounds(unsigned int level, unsigned int id, double* bb);
 
  bool GetOrigin(unsigned int level, unsigned int id, double* origin);
 
  void GetSpacing(unsigned int level, double spacing[3]);
 
  [[nodiscard]] bool HasSpacing(unsigned int level);
 
 
  void SetAMRBox(unsigned int level, unsigned int id, const vtkAMRBox& box);
  [[nodiscard]] const vtkAMRBox& GetAMRBox(unsigned int level, unsigned int id) const;
 
  bool GetCoarsenedAMRBox(unsigned int level, unsigned int id, vtkAMRBox& box) const;
 
 
  [[nodiscard]] int GetAMRBlockSourceIndex(int index);
  void SetAMRBlockSourceIndex(int index, int sourceId);
 
  void GenerateRefinementRatio();
 
  [[nodiscard]] bool HasRefinementRatio();
 
  void SetRefinementRatio(unsigned int level, int ratio);
 
  [[nodiscard]] int GetRefinementRatio(unsigned int level) const;
 
  void SetSpacing(unsigned int level, const double* h);
 
  [[nodiscard]] bool HasChildrenInformation();
 
  unsigned int* GetParents(unsigned int level, unsigned int index, unsigned int& numParents);
 
  unsigned int* GetChildren(unsigned int level, unsigned int index, unsigned int& numChildren);
 
  void PrintParentChildInfo(unsigned int level, unsigned int index);
 
  void GenerateParentChildInformation();
 
  [[nodiscard]] bool CheckValidity();
 
  bool FindCell(double q[3], unsigned int level, unsigned int index, int& cellIdx);
 
  bool FindGrid(double q[3], int level, unsigned int& gridId);
 
  bool FindGrid(double q[3], unsigned int& level, unsigned int& gridId);
 
  [[nodiscard]] std::vector<std::vector<unsigned int>>& GetChildrenAtLevel(unsigned int i)
  {
    return this->AllChildren[i];
  }
 
  void DeepCopy(vtkAMRMetaData* other) override;
 
protected:
  vtkOverlappingAMRMetaData();
  ~vtkOverlappingAMRMetaData() override;
 
private:
  vtkOverlappingAMRMetaData(const vtkOverlappingAMRMetaData&) = delete;
  void operator=(const vtkOverlappingAMRMetaData&) = delete;
 
  bool HasValidOrigin();
  bool HasValidBounds();
  void UpdateBounds(int level, int id);
  void AllocateBoxes(unsigned int n);
  void CalculateParentChildRelationShip(unsigned int level,
    std::vector<std::vector<unsigned int>>& children,
    std::vector<std::vector<unsigned int>>& parents);
 
  //-------------------------------------------------------------------------
  // Essential information that determines an AMR structure. Must be copied
  //-------------------------------------------------------------------------
 
  // the origin of the whole data set
  double Origin[3] = { VTK_DOUBLE_MAX, VTK_DOUBLE_MAX, VTK_DOUBLE_MAX };
 
  // vtkAMRBoxes, one per data set
  std::vector<vtkAMRBox> Boxes;
 
  // Typically, this maps to a file block index used by the reader
  vtkSmartPointer<vtkIntArray> SourceIndex;
 
  // The grid spacing for all levels
  vtkNew<vtkDoubleArray> Spacing;
 
  // the bounds of the entire domain
  double Bounds[6] = { VTK_DOUBLE_MAX, VTK_DOUBLE_MIN, VTK_DOUBLE_MAX, VTK_DOUBLE_MIN,
    VTK_DOUBLE_MAX, VTK_DOUBLE_MIN };
 
  //-------------------------------------------------------------------------
  // Auxiliary information that be computed
  //-------------------------------------------------------------------------
 
  // refinement ratio between two adjacent levels
  vtkNew<vtkIntArray> Refinement;
 
  // parent child information
  std::vector<std::vector<std::vector<unsigned int>>> AllChildren;
  std::vector<std::vector<std::vector<unsigned int>>> AllParents;
};
 
VTK_ABI_NAMESPACE_END
#endif