vtkIntersectFragments.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 vtkIntersectFragments_h
#define vtkIntersectFragments_h

#include "vtkMultiBlockDataSetAlgorithm.h"
#include "vtkPVVTKExtensionsFiltersMaterialInterfaceModule.h" //needed for exports
#include <string>                                             //
#include <vector>                                             //

class vtkPolyData;
// class vtkMultiBlockDataSet;
class vtkPoints;
class vtkDoubleArray;
class vtkIntArray;
class vtkImplicitFunction;
class vtkMultiProcessController;
class vtkMaterialInterfaceCommBuffer;
class vtkCutter;

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


  virtual void SetCutFunction(vtkImplicitFunction*);
  vtkGetObjectMacro(CutFunction, vtkImplicitFunction);

  void SetGeometryInputConnection(vtkAlgorithmOutput* algOutput);
  void SetStatisticsInputConnection(vtkAlgorithmOutput* algOutput);
  vtkMTimeType GetMTime() override;

protected:
  vtkIntersectFragments();
  ~vtkIntersectFragments() override;

  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  int FillInputPortInformation(int port, vtkInformation* info) override;
  int FillOutputPortInformation(int port, vtkInformation* info) override;
  // Make list of what we own
  int IdentifyLocalFragments();
  // Copy structure from multi block of polydata.
  int CopyInputStructureStats(vtkMultiBlockDataSet* dest, vtkMultiBlockDataSet* src);
  // Copy structure from multi block of multi piece
  int CopyInputStructureGeom(vtkMultiBlockDataSet* dest, vtkMultiBlockDataSet* src);
  //
  int PrepareToProcessRequest();
  //
  int Intersect();
  // Build arrays that describe which fragment
  // intersections are not empty.
  void BuildLoadingArray(std::vector<vtkIdType>& loadingArray, int blockId);
  int PackLoadingArray(vtkIdType*& buffer, int blockId);
  int UnPackLoadingArray(
    vtkIdType* buffer, int bufSize, std::vector<vtkIdType>& loadingArray, int blockId);
  //
  void ComputeGeometricAttributes();
  // Send my geometric attribuites to a single process.
  int SendGeometricAttributes(int recipientProcId);
  // size buffers & new containers
  int PrepareToCollectGeometricAttributes(std::vector<vtkMaterialInterfaceCommBuffer>& buffers,
    std::vector<std::vector<vtkDoubleArray*>>& centers, std::vector<std::vector<int*>>& ids);
  // Free resources.
  int CleanUpAfterCollectGeometricAttributes(std::vector<vtkMaterialInterfaceCommBuffer>& buffers,
    std::vector<std::vector<vtkDoubleArray*>>& centers, std::vector<std::vector<int*>>& ids);
  // Receive all geometric attributes from all other
  // processes.
  int CollectGeometricAttributes(std::vector<vtkMaterialInterfaceCommBuffer>& buffers,
    std::vector<std::vector<vtkDoubleArray*>>& centers, std::vector<std::vector<int*>>& ids);
  // size local copy to hold all.
  int PrepareToMergeGeometricAttributes(std::vector<std::vector<int>>& unique);
  // Gather geometric attributes on a single process.
  int GatherGeometricAttributes(int recipientProcId);
  // Copy attributes from input to output
  int CopyAttributesToStatsOutput(int controllingProcId);
  //
  int CleanUpAfterRequest();

  //
  vtkMultiProcessController* Controller;
  // Global ids of what we own before the intersection.
  std::vector<std::vector<int>> FragmentIds;
  // Centers, and global fragment ids.
  // an array for each block.
  std::vector<vtkDoubleArray*> IntersectionCenters;
  std::vector<std::vector<int>> IntersectionIds;
  //
  vtkCutter* Cutter;
  // data in/out
  vtkMultiBlockDataSet* GeomIn;
  vtkMultiBlockDataSet* GeomOut;
  vtkMultiBlockDataSet* StatsIn;
  vtkMultiBlockDataSet* StatsOut;
  int NBlocks;
  // only used on controller.
  std::vector<int> NFragmentsIntersected;

  vtkImplicitFunction* CutFunction;
  double Progress;
  double ProgressIncrement;

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

#endif