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 "vtkBoundingBox.h"           //for storing AMR Bounding boxes
#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); }

  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);

  void SetBounds(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) const;

  [[nodiscard]] bool HasSpacing() const;

  [[nodiscard]] bool HasBlockBounds(unsigned int index) const;

  [[nodiscard]] bool HasBlockBounds() const;


  void SetAMRBox(unsigned int level, unsigned int id, const vtkAMRBox& box);
  [[nodiscard]] const vtkAMRBox& GetAMRBox(unsigned int level, unsigned int id) const;
  bool GetAMRBox(unsigned int level, unsigned int id, vtkAMRBox& box) const;

  bool GetCoarsenedAMRBox(unsigned int level, unsigned int id, vtkAMRBox& box);


  [[nodiscard]] int GetAMRBlockSourceIndex(int index);
  void SetAMRBlockSourceIndex(int index, int sourceId);

  bool GenerateRefinementRatio();

  [[nodiscard]] bool HasRefinementRatio() const;

  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() const;

  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 FindGrids(double q[3], unsigned int level, std::vector<unsigned int>& gridIds);

  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];
  }


  [[nodiscard]] vtkGetMacro(GridType, unsigned int);
  vtkSetMacro(GridType, unsigned int);

  void DeepCopy(vtkAMRMetaData* other) override;
 
protected:
  vtkOverlappingAMRMetaData();
  ~vtkOverlappingAMRMetaData() override;
 
private:
  vtkOverlappingAMRMetaData(const vtkOverlappingAMRMetaData&) = delete;
  void operator=(const vtkOverlappingAMRMetaData&) = delete;
 
  bool HasValidOrigin() const;
  bool HasValidBounds() const;
  void UpdateBounds(int level, int id);
  void AllocateBoxes(unsigned int n);
  void AllocateBlockBounds(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
  //-------------------------------------------------------------------------
  unsigned int GridType = VTK_DATA_SET;
 
  // the origin of the whole data set
  double Origin[3] = { VTK_DOUBLE_MAX, VTK_DOUBLE_MAX, VTK_DOUBLE_MAX };
 
  // vtkAMRBoxes, one per block
  std::vector<vtkAMRBox> Boxes;
 
  // BoundingBoxes, one per block if used
  std::vector<vtkBoundingBox> BlockBounds;
 
  // 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