vtkRectilinearGridConnectivity.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Kitware Inc.
// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkRectilinearGridConnectivity_h
#define vtkRectilinearGridConnectivity_h

#include "vtkMultiBlockDataSetAlgorithm.h"
#include "vtkPVVTKExtensionsFiltersGeneralModule.h" //needed for exports

class vtkPolyData;
class vtkDoubleArray;
class vtkInformation;
class vtkEquivalenceSet;
class vtkRectilinearGrid;
class vtkInformationVector;
class vtkMultiProcessController;
class vtkIncrementalOctreePointLocator;
class vtkRectilinearGridConnectivityFaceHash;
class vtkRectilinearGridConnectivityInternal;

class VTKPVVTKEXTENSIONSFILTERSGENERAL_EXPORT vtkRectilinearGridConnectivity
  : public vtkMultiBlockDataSetAlgorithm
{
public:
  vtkTypeMacro(vtkRectilinearGridConnectivity, vtkMultiBlockDataSetAlgorithm);
  static vtkRectilinearGridConnectivity* New();
  void PrintSelf(ostream& os, vtkIndent indent) override;


  vtkSetClampMacro(VolumeFractionSurfaceValue, double, 0.0, 1.0);
  vtkGetMacro(VolumeFractionSurfaceValue, double);

  void RemoveAllVolumeArrayNames();

  void RemoveDoubleVolumeArrayNames();

  void RemoveFloatVolumeArrayNames();

  void RemoveUnsignedCharVolumeArrayNames();

  void AddDoubleVolumeArrayName(char* arayName);

  void AddFloatVolumeArrayName(char* arayName);

  void AddUnsignedCharVolumeArrayName(char* arayName);

  void AddVolumeArrayName(char* arayName);

protected:
  vtkRectilinearGridConnectivity();
  ~vtkRectilinearGridConnectivity() override;

  int DualGridsReady;
  int NumberOfBlocks;
  double DataBlocksTime;
  double DualGridBounds[6];
  double VolumeFractionSurfaceValue;
  vtkDoubleArray* FragmentValues;
  vtkEquivalenceSet* EquivalenceSet;
  vtkRectilinearGrid** DualGridBlocks;
  vtkMultiProcessController* Controller;
  vtkRectilinearGridConnectivityFaceHash* FaceHash;
  vtkRectilinearGridConnectivityInternal* Internal;

  vtkExecutive* CreateDefaultExecutive() override;
  int FillInputPortInformation(int, vtkInformation*) override;
  int RequestData(vtkInformation* request, vtkInformationVector** inputVector,
    vtkInformationVector* outputVector) override;

  // ---------------------------------------------------------------------- //
  // --------------------------- Volume  arrays --------------------------- //
  // ---------------------------------------------------------------------- //

  int GetNumberOfVolumeFractionArrays();

  int GetNumberOfVolumeArrays();

  const char* GetVolumeFractionArrayName(int arrayIdx);

  bool IsVolumeFractionArray(const char* arayName);

  bool IsVolumeArray(const char* arayName);

  int CheckVolumeDataArrays(vtkRectilinearGrid** recGrids, int numGrids);

  // ---------------------------------------------------------------------- //
  // ----------- Dual grids generation and fragments extraction ----------- //
  // ---------------------------------------------------------------------- //

  void CreateDualRectilinearGrid(vtkRectilinearGrid* rectGrid, vtkRectilinearGrid* dualGrid);

  void ExtractFragments(vtkRectilinearGrid** dualGrds, int numBlcks, double boundBox[6],
    unsigned char partIndx, vtkPolyData* polyData);

  // ---------------------------------------------------------------------- //
  // ------------- Common functions  for fragments extraction ------------- //
  // ---------------------------------------------------------------------- //

  void IntegrateFragmentAttributes(int fragIndx, int numComps, double* attrVals);

  void ResolveEquivalentFragments();

  void ResolveFaceFragmentIds();

  void ResolveIntegratedFragmentAttributes();

  // ---------------------------------------------------------------------- //
  // ----------- Intra-process intra-block fragments extraction ----------- //
  // ---------------------------------------------------------------------- //

  // Descrption:
  // Give a vtkRectilinearGrid data block (rectGrid, the dual version of an
  // original input block) with point data attributes (including some volume
  // fraction arrays and others like pressure, density, or velocity vector),
  // the name of a selected volume fraction array (fracName, through which to
  // extract fragments), and a specified volume fraction iso-value (isoValue),
  // this function performs the marching-cubes algorithm based on the volume
  // fraction array and the iso-value to produce greater-than-isovalue sub-
  // volumes (or polyhedra) by employing an extended 256-entry lookup table.
  // These resulting polyhedra are stored in the output vtkPolyData (plyHedra).
  // All point data attributes except for non-selected volume fraction arrays
  // are integrated when marching cubes. The integrated attribute arrays are
  // attached to the polyhedra's faces as the cell data.
  void ExtractFragmentPolyhedra(
    vtkRectilinearGrid* rectGrid, const char* fracName, double isoValue, vtkPolyData* plyHedra);

  void InitializeFaceHash(vtkPolyData* plyHedra);

  void AddPolygonsToFaceHash(int blockIdx, vtkPolyData* plyHedra);

  void ExtractFragmentPolygons(int blockIdx, int& maxFsize, vtkPolyData* plyHedra,
    vtkPolyData* polygons, vtkIncrementalOctreePointLocator* gPtIdGen);

  // ---------------------------------------------------------------------- //
  // ----------- Intra-process inter-block fragments extraction ----------- //
  // ---------------------------------------------------------------------- //

  void InitializeFaceHash(vtkPolyData** plyDatas, int numPolys);

  void AddPolygonsToFaceHash(vtkPolyData** plyDatas, int* maxFsize, int numPolys);

  void GenerateOutputFromSingleProcess(
    vtkPolyData** surfaces, int numSurfs, unsigned char partIndx, vtkPolyData* polyData);

  // ---------------------------------------------------------------------- //
  // ----------------- Inter-process fragments extraction ----------------- //
  // ---------------------------------------------------------------------- //

  void CreateInterProcessPolygons(vtkPolyData* fragPoly, vtkPolyData* procPoly,
    vtkIncrementalOctreePointLocator* gPtIdGen, int& maxFsize);

  void AddInterProcessPolygonsToFaceHash(vtkPolyData** procPlys, int* maxFsize, int numProcs);

  void GenerateOutputFromMultiProcesses(
    vtkPolyData** procPlys, int numProcs, unsigned char partIndx, vtkPolyData* polyData);

private:
  vtkRectilinearGridConnectivity(const vtkRectilinearGridConnectivity&) = delete;
  void operator=(const vtkRectilinearGridConnectivity&) = delete;
};

#endif