vtkExtentRCBPartitioner.h

Go to the documentation of this file.

/*=========================================================================
 
 Program:   Visualization Toolkit
 Module:    vtkExtentRCBPartitioner.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 vtkExtentRCBPartitioner_h
#define vtkExtentRCBPartitioner_h
 
#include "vtkCommonExecutionModelModule.h" // For export macro
#include "vtkObject.h"
#include <cassert> // For assert
#include <string>  // For std::string
#include <vector>  // For STL vector
 
class VTKCOMMONEXECUTIONMODEL_EXPORT vtkExtentRCBPartitioner : public vtkObject
{
public:
  static vtkExtentRCBPartitioner* New();
  vtkTypeMacro(vtkExtentRCBPartitioner, vtkObject);
  void PrintSelf(ostream& oss, vtkIndent indent) override;
 
 
  void SetNumberOfPartitions(const int N)
  {
    assert("pre: Number of partitions requested must be > 0" && (N >= 0));
    this->Reset();
    this->NumberOfPartitions = N;
  }
 
 
  void SetGlobalExtent(int imin, int imax, int jmin, int jmax, int kmin, int kmax)
  {
    this->Reset();
    this->GlobalExtent[0] = imin;
    this->GlobalExtent[1] = imax;
    this->GlobalExtent[2] = jmin;
    this->GlobalExtent[3] = jmax;
    this->GlobalExtent[4] = kmin;
    this->GlobalExtent[5] = kmax;
  }
  void SetGlobalExtent(int ext[6])
  {
    this->SetGlobalExtent(ext[0], ext[1], ext[2], ext[3], ext[4], ext[5]);
  }
 
 
  vtkSetMacro(DuplicateNodes, vtkTypeBool);
  vtkGetMacro(DuplicateNodes, vtkTypeBool);
  vtkBooleanMacro(DuplicateNodes, vtkTypeBool);
 
 
  vtkSetMacro(NumberOfGhostLayers, int);
  vtkGetMacro(NumberOfGhostLayers, int);
 
 
  vtkGetMacro(NumExtents, int);
 
  void Partition();
 
  void GetPartitionExtent(const int idx, int ext[6]);
 
protected:
  vtkExtentRCBPartitioner();
  ~vtkExtentRCBPartitioner() override;
 
 
  void Reset()
  {
    this->PartitionExtents.clear();
    this->NumExtents = 0;
    this->ExtentIsPartitioned = false;
  }
 
  void ExtendGhostLayers(int ext[6]);
 
 
  void GetGhostedExtent(int ext[6], const int minIdx, const int maxIdx)
  {
    ext[minIdx] -= this->NumberOfGhostLayers;
    ext[maxIdx] += this->NumberOfGhostLayers;
    ext[minIdx] =
      (ext[minIdx] < this->GlobalExtent[minIdx]) ? this->GlobalExtent[minIdx] : ext[minIdx];
    ext[maxIdx] =
      (ext[maxIdx] > this->GlobalExtent[maxIdx]) ? this->GlobalExtent[maxIdx] : ext[maxIdx];
  }
 
  void AcquireDataDescription();
 
  void GetExtent(const int idx, int ext[6]);
 
  void AddExtent(int ext[6]);
 
  void ReplaceExtent(const int idx, int ext[6]);
 
  void SplitExtent(int parent[6], int s1[6], int s2[6], int splitDimension);
 
  int GetNumberOfTotalExtents();
 
  int GetNumberOfNodes(int ext[6]);
 
  int GetNumberOfCells(int ext[6]);
 
  int GetLongestDimensionLength(int ext[6]);
 
  int GetLongestDimension(int ext[6]);
 
  void PrintExtent(const std::string& name, int ext[6]);
 
  int NumberOfGhostLayers;
  int DataDescription;
  int GlobalExtent[6];
  int NumberOfPartitions;
  int NumExtents;
 
  vtkTypeBool DuplicateNodes; // indicates whether nodes are duplicated between
                              // partitions, so that they are abutting. This is
                              // set to true by default. If disabled, the resulting
                              // partitions will have gaps.
 
  bool ExtentIsPartitioned;
 
  std::vector<int> PartitionExtents;
 
private:
  vtkExtentRCBPartitioner(const vtkExtentRCBPartitioner&) = delete;
  void operator=(const vtkExtentRCBPartitioner&) = delete;
};
 
#endif /* VTKEXTENTRCBPARTITIONER_H_ */