vtkAMRResampleFilter.h

Go to the documentation of this file.

/*=========================================================================
 
 Program:   Visualization Toolkit
 Module:    vtkAMRResampleFilter.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 vtkAMRResampleFilter_h
#define vtkAMRResampleFilter_h
 
#include "vtkFiltersAMRModule.h" // For export macro
#include "vtkMultiBlockDataSetAlgorithm.h"
#include <vector> // For STL vector
 
class vtkInformation;
class vtkInformationVector;
class vtkUniformGrid;
class vtkOverlappingAMR;
class vtkMultiBlockDataSet;
class vtkMultiProcessController;
class vtkFieldData;
class vtkCellData;
class vtkPointData;
class vtkIndent;
 
class vtkAMRBox;
class VTKFILTERSAMR_EXPORT vtkAMRResampleFilter : public vtkMultiBlockDataSetAlgorithm
{
public:
  static vtkAMRResampleFilter* New();
  vtkTypeMacro(vtkAMRResampleFilter, vtkMultiBlockDataSetAlgorithm);
  void PrintSelf(ostream& oss, vtkIndent indent) override;
 
 
  vtkSetVector3Macro(NumberOfSamples, int);
  vtkGetVector3Macro(NumberOfSamples, int);
 
 
  vtkSetMacro(TransferToNodes, int);
  vtkGetMacro(TransferToNodes, int);
 
 
  vtkSetMacro(DemandDrivenMode, int);
  vtkGetMacro(DemandDrivenMode, int);
 
 
  vtkSetMacro(NumberOfPartitions, int);
  vtkGetMacro(NumberOfPartitions, int);
 
 
  vtkSetVector3Macro(Min, double);
  vtkGetVector3Macro(Min, double);
 
 
  vtkSetVector3Macro(Max, double);
  vtkGetVector3Macro(Max, double);
 
 
  vtkSetMacro(UseBiasVector, bool);
  vtkGetMacro(UseBiasVector, bool);
 
 
  vtkSetVector3Macro(BiasVector, double);
  vtkGetVector3Macro(BiasVector, double);
 
 
  vtkSetMacro(Controller, vtkMultiProcessController*);
  vtkGetMacro(Controller, vtkMultiProcessController*);
 
  // Standard pipeline routines
 
  int RequestInformation(vtkInformation* rqst, vtkInformationVector** inputVector,
    vtkInformationVector* outputVector) override;
 
  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  int FillInputPortInformation(int port, vtkInformation* info) override;
  int FillOutputPortInformation(int port, vtkInformation* info) override;
 
  int RequestUpdateExtent(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
 
protected:
  vtkAMRResampleFilter();
  ~vtkAMRResampleFilter() override;
 
  vtkOverlappingAMR* AMRMetaData;
  vtkMultiBlockDataSet* ROI; // Pointer to the region of interest.
  int NumberOfSamples[3];
  int GridNumberOfSamples[3];
  double Min[3];
  double Max[3];
  double GridMin[3];
  double GridMax[3];
  int LevelOfResolution;
  int NumberOfPartitions;
  int TransferToNodes;
  int DemandDrivenMode;
  vtkMultiProcessController* Controller;
  bool UseBiasVector;
  double BiasVector[3];
 
  // Debugging Stuff
  int NumberOfBlocksTestedForLevel;
  int NumberOfBlocksTested;
  int NumberOfBlocksVisSkipped;
  int NumberOfTimesFoundOnDonorLevel;
  int NumberOfTimesLevelUp;
  int NumberOfTimesLevelDown;
  int NumberOfFailedPoints;
  double AverageLevel;
 
  std::vector<int> BlocksToLoad; // Holds the ids of the blocks to load.
 
  bool IsParallel();
 
  bool IsRegionMine(const int regionIdx);
 
  int GetRegionProcessId(const int regionIdx);
 
  void ComputeCellCentroid(vtkUniformGrid* g, const vtkIdType cellIdx, double c[3]);
 
  void InitializeFields(vtkFieldData* f, vtkIdType size, vtkCellData* src);
 
  void CopyData(vtkFieldData* target, vtkIdType targetIdx, vtkCellData* src, vtkIdType srcIdx);
 
  bool FoundDonor(double q[3], vtkUniformGrid*& donorGrid, int& cellIdx);
 
  bool SearchForDonorGridAtLevel(double q[3], vtkOverlappingAMR* amrds, unsigned int level,
    unsigned int& gridId, int& donorCellIdx);
 
  int ProbeGridPointInAMR(double q[3], unsigned int& donorLevel, unsigned int& donorGridId,
    vtkOverlappingAMR* amrds, unsigned int maxLevel, bool hadDonorGrid);
 
  int ProbeGridPointInAMRGraph(double q[3], unsigned int& donorLevel, unsigned int& donorGridId,
    vtkOverlappingAMR* amrds, unsigned int maxLevel, bool useCached);
 
  void TransferToCellCenters(vtkUniformGrid* g, vtkOverlappingAMR* amrds);
 
  void TransferToGridNodes(vtkUniformGrid* g, vtkOverlappingAMR* amrds);
 
  void TransferSolution(vtkUniformGrid* g, vtkOverlappingAMR* amrds);
 
  void ExtractRegion(
    vtkOverlappingAMR* amrds, vtkMultiBlockDataSet* mbds, vtkOverlappingAMR* metadata);
 
  bool IsBlockWithinBounds(double* grd);
 
  void ComputeAMRBlocksToLoad(vtkOverlappingAMR* metadata);
 
  void ComputeRegionParameters(
    vtkOverlappingAMR* amrds, int N[3], double min[3], double max[3], double h[3]);
 
  void GetDomainParameters(vtkOverlappingAMR* amr, double domainMin[3], double domainMax[3],
    double h[3], int dims[3], double& rf);
 
  bool RegionIntersectsWithAMR(
    double domainMin[3], double domainMax[3], double regionMin[3], double regionMax[3]);
 
  void AdjustNumberOfSamplesInRegion(const double Rh[3], const bool outside[6], int N[3]);
 
  void ComputeLevelOfResolution(
    const int N[3], const double h0[3], const double L[3], const double rf);
 
  void SnapBounds(const double h0[3], const double domainMin[3], const double domainMax[3],
    const int dims[3], bool outside[6]);
 
  void ComputeAndAdjustRegionParameters(vtkOverlappingAMR* amrds, double h[3]);
 
  void GetRegion(double h[3]);
 
  bool GridsIntersect(double* g1, double* g2);
 
  vtkUniformGrid* GetReferenceGrid(vtkOverlappingAMR* amrds);
 
  void SearchGridDecendants(double q[3], vtkOverlappingAMR* amrds, unsigned int maxLevel,
    unsigned int& level, unsigned int& gridId, int& id);
 
  bool SearchGridAncestors(
    double q[3], vtkOverlappingAMR* amrds, unsigned int& level, unsigned int& gridId, int& id);
 
private:
  vtkAMRResampleFilter(const vtkAMRResampleFilter&) = delete;
  void operator=(const vtkAMRResampleFilter&) = delete;
};
 
#endif /* vtkAMRResampleFilter_h */