vtkGenerateStatistics.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Kitware Inc.
// SPDX-FileCopyrightText: Copyright 2025 Sandia Corporation
// SPDX-License-Identifier: LicenseRef-BSD-3-Clause-Sandia-USGov
#ifndef vtkGenerateStatistics_h
#define vtkGenerateStatistics_h

#include "vtkFiltersParallelStatisticsModule.h" //needed for exports
#include "vtkPartitionedDataSetCollectionAlgorithm.h"

#include <memory>
#include <unordered_map>
#include <vector>

VTK_ABI_NAMESPACE_BEGIN

class vtkCompositeDataSet;
class vtkDataObjectToTable;
class vtkFieldData;
class vtkInformationIntegerKey;
class vtkUniformGridAMR;
class vtkPartitionedDataSet;
class vtkCellGrid;
class vtkDataSet;
class vtkGraph;
class vtkTable;
class vtkMultiProcessController;
class vtkStatisticalModel;
class vtkStatisticsAccumulator;
class vtkStatisticsAlgorithm;
class vtkStatisticsAlgorithmPrivate;
class vtkUnsignedCharArray;

class VTKFILTERSPARALLELSTATISTICS_EXPORT vtkGenerateStatistics
  : public vtkPartitionedDataSetCollectionAlgorithm
{
public:
  static vtkGenerateStatistics* New();
  vtkTypeMacro(vtkGenerateStatistics, vtkPartitionedDataSetCollectionAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;


  vtkGetMacro(AttributeMode, int);
  vtkSetMacro(AttributeMode, int);

  int GetNumberOfAttributeArrays();

  const char* GetAttributeArrayName(int nn);

  int GetAttributeArrayStatus(const char* arrName);


  void EnableAttributeArray(const char* arrName);
  void ClearAttributeArrays();


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


  virtual void SetController(vtkMultiProcessController*);
  vtkGetObjectMacro(Controller, vtkMultiProcessController);


  virtual void SetStatisticsAlgorithm(vtkStatisticsAlgorithm*);
  vtkGetObjectMacro(StatisticsAlgorithm, vtkStatisticsAlgorithm);

  vtkSetMacro(WeightByCellMeasure, vtkTypeBool);
  vtkGetMacro(WeightByCellMeasure, vtkTypeBool);
  vtkBooleanMacro(WeightByCellMeasure, vtkTypeBool);

  vtkSetMacro(SingleModel, vtkTypeBool);
  vtkGetMacro(SingleModel, vtkTypeBool);
  vtkBooleanMacro(SingleModel, vtkTypeBool);

protected:
  vtkGenerateStatistics();
  ~vtkGenerateStatistics() override;

  int FillInputPortInformation(int port, vtkInformation* info) override;
  // int FillOutputPortInformation(int port, vtkInformation* info) override;

  int RequestData(
    vtkInformation* request, vtkInformationVector** input, vtkInformationVector* output) override;

  void TranslateRequests(vtkDataObject* data);

  int RequestLocalDataDispatch(
    vtkDataObject* dataObject, vtkPartitionedDataSetCollection* modelTree);

  int RequestDataNonComposite(vtkDataObject* dataObject, vtkStatisticalModel* model);

  int RequestDataAMR(vtkUniformGridAMR* amr, vtkPartitionedDataSetCollection* modelTree);
  int RequestDataPDC(
    vtkPartitionedDataSetCollection* pdc, vtkPartitionedDataSetCollection* modelTree);
  int RequestDataPD(vtkPartitionedDataSet* pd, vtkStatisticalModel* model);
  int RequestDataCellGrid(vtkCellGrid* cellGrid, vtkStatisticalModel* model);
  int RequestDataPlain(vtkDataObject* dataObject, vtkStatisticalModel* model);

  void PrepareAlgorithmRequests(const std::vector<vtkSmartPointer<vtkAbstractArray>>& columns);

  virtual vtkIdType GetNumberOfObservationsForTraining(vtkIdType N);

  void ShallowCopy(vtkDataObject* out, vtkDataObject* in);

  void GenerateSubset(std::unordered_map<vtkIdType, vtkIdType>& subset, vtkIdType numberOfTuples,
    double trainingFraction, vtkUnsignedCharArray* ghostMarks, unsigned char ghostMask);

  using PointsOfCellsWeightMap =
    std::unordered_map<vtkIdType, std::unordered_map<vtkIdType, double>>;
  void ComputeCellToPointWeights(PointsOfCellsWeightMap& cellToPointsToWeights, vtkDataSet* dataSet,
    const std::unordered_map<vtkIdType, vtkIdType>& subset);

  void ComputeEdgeToVertexWeights(
    std::unordered_map<vtkIdType, std::unordered_map<vtkIdType, double>>& edgesToVertsToWeights,
    vtkGraph* graph, const std::unordered_map<vtkIdType, vtkIdType>& subset);

  vtkSmartPointer<vtkAbstractArray> SubsetArray(vtkSmartPointer<vtkAbstractArray> fullArray,
    const std::unordered_map<vtkIdType, vtkIdType>& subset);

  vtkSmartPointer<vtkAbstractArray> CellToPointSamples(vtkSmartPointer<vtkAbstractArray> fullArray,
    vtkDataSet* data, const std::unordered_map<vtkIdType, vtkIdType>& subset,
    const PointsOfCellsWeightMap& cellsToPointsToWeights);

  vtkSmartPointer<vtkAbstractArray> EdgeToVertexSamples(vtkSmartPointer<vtkAbstractArray> fullArray,
    vtkGraph* data, const std::unordered_map<vtkIdType, vtkIdType>& subset,
    const std::unordered_map<vtkIdType, std::unordered_map<vtkIdType, double>>&
      edgesToVertsToWeights);

  vtkSmartPointer<vtkAbstractArray> FieldDataToSamples(vtkSmartPointer<vtkAbstractArray> fullArray,
    vtkDataObject* data, const std::unordered_map<vtkIdType, vtkIdType>& subset,
    vtkIdType numberOfSamples);

  int MergeRemoteModels(vtkPartitionedDataSetCollection* modelTree);

  int MergeModelTrees(
    vtkPartitionedDataSetCollection* other, vtkPartitionedDataSetCollection* target);

  int ComputeDerivedData(vtkPartitionedDataSetCollection* modelTree);

  int AttributeMode;
  double TrainingFraction;
  vtkTypeBool SingleModel;
  vtkTypeBool WeightByCellMeasure;
  std::unique_ptr<vtkStatisticsAlgorithmPrivate> P;
  vtkMultiProcessController* Controller;
  vtkStatisticsAlgorithm* StatisticsAlgorithm;

private:
  // This class is internal so it can access protected data.
  class StatisticsAccumulator;

  vtkGenerateStatistics(const vtkGenerateStatistics&) = delete;
  void operator=(const vtkGenerateStatistics&) = delete;
};

VTK_ABI_NAMESPACE_END

#endif // vtkGenerateStatistics_h