vtkAMRInformation.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkAMRInformation.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 vtkAMRInformation_h
#define vtkAMRInformation_h
 
#include "vtkAMRBox.h"                //for storing AMR Boxes
#include "vtkCommonDataModelModule.h" // For export macro
#include "vtkObject.h"
#include "vtkSmartPointer.h" //for ivars
#include <vector>            //for storing AMR Boxes
 
typedef std::vector<vtkAMRBox> vtkAMRBoxList;
 
class vtkUnsignedIntArray;
class vtkIntArray;
class vtkDoubleArray;
class vtkAMRIndexIterator;
 
class VTKCOMMONDATAMODEL_EXPORT vtkAMRInformation : public vtkObject
{
public:
  static vtkAMRInformation* New();
  vtkTypeMacro(vtkAMRInformation, vtkObject);
 
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  bool operator==(const vtkAMRInformation& other);
 
  void Initialize(int numLevels, const int* blocksPerLevel);
 
 
  vtkGetMacro(GridDescription, int);
  void SetGridDescription(int description);
 
 
  void GetOrigin(double origin[3]);
  double* GetOrigin();
  void SetOrigin(const double* origin);
 
  unsigned int GetNumberOfLevels() const
  {
    return static_cast<unsigned int>(this->NumBlocks.size() - 1);
  }
 
  unsigned int GetNumberOfDataSets(unsigned int level) const;
 
  unsigned int GetTotalNumberOfBlocks() { return this->NumBlocks.back(); }
 
  int GetIndex(unsigned int level, unsigned int id) const { return this->NumBlocks[level] + id; }
 
  void ComputeIndexPair(unsigned int index, unsigned int& level, unsigned int& id);
 
  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]);
 
  bool HasSpacing(unsigned int level);
 
 
  void SetAMRBox(unsigned int level, unsigned int id, const vtkAMRBox& box);
  const vtkAMRBox& GetAMRBox(unsigned int level, unsigned int id) const;
 
  bool GetCoarsenedAMRBox(unsigned int level, unsigned int id, vtkAMRBox& box) const;
 
 
  int GetAMRBlockSourceIndex(int index);
  void SetAMRBlockSourceIndex(int index, int sourceId);
 
  void GenerateRefinementRatio();
 
  bool HasRefinementRatio();
 
  void SetRefinementRatio(unsigned int level, int ratio);
 
  int GetRefinementRatio(unsigned int level) const;
 
  void SetSpacing(unsigned int level, const double* h);
 
  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();
 
  bool Audit();
 
  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);
 
  const std::vector<int>& GetNumBlocks() const { return this->NumBlocks; }
 
  std::vector<std::vector<unsigned int>>& GetChildrenAtLevel(unsigned int i)
  {
    return this->AllChildren[i];
  }
 
  void DeepCopy(vtkAMRInformation* other);
 
private:
  vtkAMRInformation();
  ~vtkAMRInformation() override;
  vtkAMRInformation(const vtkAMRInformation&) = delete;
  void operator=(const vtkAMRInformation&) = delete;
 
  bool HasValidOrigin();
  bool HasValidBounds();
  void UpdateBounds(const int level, const int id);
  void AllocateBoxes(unsigned int n);
  void GenerateBlockLevel();
  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
  //-------------------------------------------------------------------------
  int GridDescription; // example: VTK_XYZ_GRID
  double Origin[3];    // the origin of the whole data set
  vtkAMRBoxList Boxes; // vtkAMRBoxes, one per data set
  std::vector<int>
    NumBlocks; // NumBlocks[i] stores the total number of blocks from level 0 to level i-1
 
  vtkSmartPointer<vtkIntArray>
    SourceIndex; // Typically, this maps to a file block index used by the reader
  vtkSmartPointer<vtkDoubleArray> Spacing; // The grid spacing for all levels
  double Bounds[6];                        // the bounds of the entire domain
 
  //-------------------------------------------------------------------------
  // Auxiliary information that be computed
  //-------------------------------------------------------------------------
  vtkSmartPointer<vtkIntArray> Refinement;         // refinement ratio between two adjacent levels
  vtkSmartPointer<vtkUnsignedIntArray> BlockLevel; // only necessary if need to call
                                                   // ComputeIndexPair
 
  // parent child information
  std::vector<std::vector<std::vector<unsigned int>>> AllChildren;
  std::vector<std::vector<std::vector<unsigned int>>> AllParents;
};
 
#endif