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