vtkGhostCellsGenerator.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 vtkGhostCellsGenerator_h
#define vtkGhostCellsGenerator_h
 
#include "vtkPassInputTypeAlgorithm.h"
 
#include "vtkFiltersParallelDIY2Module.h" // for export macros
#include "vtkWeakPointer.h"               // for vtkWeakPointer
 
VTK_ABI_NAMESPACE_BEGIN
class vtkDataObject;
class vtkMultiProcessController;
class vtkDataObjectMeshCache;
 
class VTKFILTERSPARALLELDIY2_EXPORT vtkGhostCellsGenerator : public vtkPassInputTypeAlgorithm
{
public:
  static vtkGhostCellsGenerator* New();
  vtkTypeMacro(vtkGhostCellsGenerator, vtkPassInputTypeAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
 
  virtual void SetController(vtkMultiProcessController*);
  vtkMultiProcessController* GetController();
 
 
  virtual void Initialize();
 
 
  vtkSetMacro(BuildIfRequired, bool);
  vtkGetMacro(BuildIfRequired, bool);
  vtkBooleanMacro(BuildIfRequired, bool);
 
 
  vtkGetMacro(NumberOfGhostLayers, int);
  vtkSetClampMacro(NumberOfGhostLayers, int, 0, VTK_INT_MAX);
 
 
  vtkSetMacro(GenerateGlobalIds, bool);
  vtkGetMacro(GenerateGlobalIds, bool);
  vtkBooleanMacro(GenerateGlobalIds, bool);
 
 
  vtkSetMacro(GenerateProcessIds, bool);
  vtkGetMacro(GenerateProcessIds, bool);
  vtkBooleanMacro(GenerateProcessIds, bool);
 
 
  vtkSetMacro(SynchronizeOnly, bool);
  vtkGetMacro(SynchronizeOnly, bool);
  vtkBooleanMacro(SynchronizeOnly, bool);
 
 
  vtkSetMacro(UseStaticMeshCache, bool);
  vtkGetMacro(UseStaticMeshCache, bool);
  vtkBooleanMacro(UseStaticMeshCache, bool);
 
protected:
  vtkGhostCellsGenerator();
  ~vtkGhostCellsGenerator() override;
 
  int FillInputPortInformation(int port, vtkInformation* info) override;
 
  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  int RequestUpdateExtent(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
 
  virtual int Execute(vtkDataObject* inputDO, vtkInformationVector* outputVector);
 
  vtkWeakPointer<vtkMultiProcessController> Controller;
 
  int NumberOfGhostLayers = 1;
  bool BuildIfRequired = true;
 
private:
  vtkGhostCellsGenerator(const vtkGhostCellsGenerator&) = delete;
  void operator=(const vtkGhostCellsGenerator&) = delete;
 
  bool CanSynchronize(vtkDataObject* input, bool& canSyncCell, bool& canSyncPoint);
 
  int GenerateGhostCells(
    vtkDataObject* input, vtkDataObject* output, int reqGhostLayers, bool syncOnly);
 
  void UpdateCache(vtkDataObject* updatedOutput);
  bool UseCacheIfPossible(vtkDataObject* input, vtkDataObject* output);
 
  bool GenerateGlobalIds = false;
  bool GenerateProcessIds = false;
  bool SynchronizeOnly = false;
 
  bool UseStaticMeshCache = true;
  vtkNew<vtkDataObjectMeshCache> MeshCache;
};
 
VTK_ABI_NAMESPACE_END
#endif