vtkPVDataInformation.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Kitware Inc.
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkPVDataInformation_h
#define vtkPVDataInformation_h

#include "vtkDataObject.h" // for vtkDataObject::NUMBER_OF_ATTRIBUTE_TYPES
#include "vtkNew.h"        // for vtkNew
#include "vtkPVInformation.h"
#include "vtkRemotingCoreModule.h" //needed for exports
#include "vtkSmartPointer.h"       // for vtkSmartPointer

#include <set>    // for std::set
#include <vector> // for std::vector

class vtkCellGrid;
class vtkCollection;
class vtkCompositeDataSet;
class vtkDataAssembly;
class vtkDataObject;
class vtkDataSet;
class vtkGenericDataSet;
class vtkGraph;
class vtkHyperTreeGrid;
class vtkInformation;
class vtkPVArrayInformation;
class vtkPVDataInformationHelper;
class vtkPVDataSetAttributesInformation;
class vtkSelection;
class vtkTable;

class VTKREMOTINGCORE_EXPORT vtkPVDataInformation : public vtkPVInformation
{
public:
  static vtkPVDataInformation* New();
  vtkTypeMacro(vtkPVDataInformation, vtkPVInformation);
  void PrintSelf(ostream& os, vtkIndent indent) override;


  vtkSetMacro(PortNumber, int);
  vtkGetMacro(PortNumber, int);

  vtkSetMacro(InspectCells, bool);


  vtkSetClampMacro(Rank, int, -1, VTK_INT_MAX);
  vtkGetMacro(Rank, int);


  vtkGetStringMacro(SubsetSelector);
  vtkSetStringMacro(SubsetSelector);


  vtkSetStringMacro(SubsetAssemblyName);
  vtkGetStringMacro(SubsetAssemblyName);
  void SetSubsetAssemblyNameToHierarchy();

  void CopyFromObject(vtkObject* object) override;


  void AddInformation(vtkPVInformation* info) override;
  void CopyToStream(vtkClientServerStream*) override;
  void CopyFromStream(const vtkClientServerStream*) override;
  void CopyParametersToStream(vtkMultiProcessStream&) override;
  void CopyParametersFromStream(vtkMultiProcessStream&) override;

  void Initialize();

  void DeepCopy(vtkPVDataInformation* info);

  vtkPVArrayInformation* GetArrayInformation(const char* arrayname, int fieldAssociation) const;

  vtkGetMacro(DataSetType, int);

  vtkGetMacro(CompositeDataSetType, int);

  bool IsCompositeDataSet() const { return (this->CompositeDataSetType != -1); }

  bool IsNull() const { return this->DataSetType == -1 && this->CompositeDataSetType == -1; }


  const std::vector<int>& GetUniqueBlockTypes() const { return this->UniqueBlockTypes; }
  unsigned int GetNumberOfUniqueBlockTypes() const
  {
    return static_cast<unsigned int>(this->UniqueBlockTypes.size());
  }
  int GetUniqueBlockType(unsigned int index) const;


  static const char* GetDataSetTypeAsString(int type);
  const char* GetDataSetTypeAsString() const
  {
    return vtkPVDataInformation::GetDataSetTypeAsString(this->DataSetType);
  }
  const char* GetDataClassName() const
  {
    return this->DataSetType != -1 ? this->GetDataSetTypeAsString() : nullptr;
  }
  const char* GetCompositeDataClassName() const
  {
    return this->CompositeDataSetType != -1
      ? vtkPVDataInformation::GetDataSetTypeAsString(this->CompositeDataSetType)
      : nullptr;
  }


  const char* GetPrettyDataTypeString() const;
  static const char* GetPrettyDataTypeString(int dtype);


  bool DataSetTypeIsA(const char* classname) const;
  bool DataSetTypeIsA(int typeId) const;


  bool HasDataSetType(const char* classname) const;
  bool HasDataSetType(int typeId) const;

  vtkTypeInt64 GetNumberOfElements(int elementType) const;


  vtkTypeInt64 GetNumberOfPoints() const { return this->GetNumberOfElements(vtkDataObject::POINT); }
  vtkTypeInt64 GetNumberOfCells() const { return this->GetNumberOfElements(vtkDataObject::CELL); }
  vtkTypeInt64 GetNumberOfVertices() const
  {
    return this->GetNumberOfElements(vtkDataObject::VERTEX);
  }
  vtkTypeInt64 GetNumberOfEdges() const { return this->GetNumberOfElements(vtkDataObject::EDGE); }
  vtkTypeInt64 GetNumberOfRows() const { return this->GetNumberOfElements(vtkDataObject::ROW); }


  vtkGetMacro(NumberOfTrees, vtkTypeInt64);
  vtkGetMacro(NumberOfLeaves, vtkTypeInt64);

  vtkGetMacro(NumberOfAMRLevels, vtkTypeInt64);

  vtkTypeInt64 GetNumberOfAMRDataSets(vtkTypeInt64 level) const;

  vtkGetMacro(NumberOfDataSets, vtkTypeInt64);

  vtkGetMacro(MemorySize, vtkTypeInt64);

  vtkGetVector6Macro(Bounds, double);


  vtkGetVector6Macro(Extent, int);


  vtkPVDataSetAttributesInformation* GetAttributeInformation(int fieldAssociation) const;


  vtkPVDataSetAttributesInformation* GetPointDataInformation() const
  {
    return this->GetAttributeInformation(vtkDataObject::POINT);
  }
  vtkPVDataSetAttributesInformation* GetCellDataInformation() const
  {
    return this->GetAttributeInformation(vtkDataObject::CELL);
  }
  vtkPVDataSetAttributesInformation* GetVertexDataInformation() const
  {
    return this->GetAttributeInformation(vtkDataObject::VERTEX);
  }
  vtkPVDataSetAttributesInformation* GetEdgeDataInformation() const
  {
    return this->GetAttributeInformation(vtkDataObject::EDGE);
  }
  vtkPVDataSetAttributesInformation* GetRowDataInformation() const
  {
    return this->GetAttributeInformation(vtkDataObject::ROW);
  }
  vtkPVDataSetAttributesInformation* GetFieldDataInformation() const
  {
    return this->GetAttributeInformation(vtkDataObject::FIELD);
  }

  vtkGetObjectMacro(PointArrayInformation, vtkPVArrayInformation);


  vtkGetMacro(HasTime, bool);
  vtkGetMacro(Time, double);


  vtkGetVector2Macro(TimeRange, double);
  vtkGetMacro(TimeLabel, std::string);
  const std::set<double>& GetTimeSteps() const { return this->TimeSteps; }
  vtkTypeInt64 GetNumberOfTimeSteps() const
  {
    return static_cast<unsigned int>(this->TimeSteps.size());
  }

  bool IsDataStructured() const;

  bool HasStructuredData() const;

  bool HasUnstructuredData() const;

  bool IsAttributeValid(int fieldAssociation) const;

  static int GetExtentType(int dataType);


  vtkDataAssembly* GetHierarchy() const;
  vtkDataAssembly* GetDataAssembly() const;
  vtkDataAssembly* GetDataAssembly(const char* assemblyName) const;

  vtkGetMacro(FirstLeafCompositeIndex, vtkTypeUInt64);

  std::string GetBlockName(vtkTypeUInt64 cid) const;

  std::vector<std::string> GetBlockNames(
    const std::vector<std::string>& selectors, const char* assemblyName) const;

  unsigned int ComputeCompositeIndexForAMR(unsigned int level, unsigned int index) const;

  const std::vector<unsigned char>& GetUniqueCellTypes() const { return this->UniqueCellTypes; }

protected:
  vtkPVDataInformation();
  ~vtkPVDataInformation() override;

  void CopyFromPipelineInformation(vtkInformation* pipelineInfo);
  void CopyFromDataObject(vtkDataObject* dobj);
  friend class vtkPVDataInformationHelper;

  virtual vtkSmartPointer<vtkCompositeDataSet> SimplifyCompositeDataSet(vtkCompositeDataSet* cd);

  vtkSmartPointer<vtkDataObject> GetSubset(vtkDataObject* dobj) const;

private:
  vtkPVDataInformation(const vtkPVDataInformation&) = delete;
  void operator=(const vtkPVDataInformation&) = delete;

  int PortNumber = -1;
  int Rank = -1;
  char* SubsetSelector = nullptr;
  char* SubsetAssemblyName = nullptr;

  int DataSetType = -1;
  int CompositeDataSetType = -1;
  vtkTypeUInt64 FirstLeafCompositeIndex = 0;
  vtkTypeInt64 NumberOfTrees = 0;
  vtkTypeInt64 NumberOfLeaves = 0;
  vtkTypeInt64 NumberOfAMRLevels = 0;
  vtkTypeInt64 NumberOfDataSets = 0;
  vtkTypeInt64 MemorySize = 0;
  double Bounds[6] = { VTK_DOUBLE_MAX, -VTK_DOUBLE_MAX, VTK_DOUBLE_MAX, -VTK_DOUBLE_MAX,
    VTK_DOUBLE_MAX, -VTK_DOUBLE_MAX };
  int Extent[6] = { VTK_INT_MAX, -VTK_INT_MAX, VTK_INT_MAX, -VTK_INT_MAX, VTK_INT_MAX,
    -VTK_INT_MAX };
  bool HasTime = false;
  double Time = 0.0;
  double TimeRange[2] = { VTK_DOUBLE_MAX, -VTK_DOUBLE_MAX };
  std::set<double> TimeSteps;
  std::string TimeLabel;
  std::vector<vtkTypeInt64> AMRNumberOfDataSets;

  std::vector<int> UniqueBlockTypes;
  vtkTypeInt64 NumberOfElements[vtkDataObject::NUMBER_OF_ATTRIBUTE_TYPES] = { 0, 0, 0, 0, 0, 0, 0 };
  vtkNew<vtkPVDataSetAttributesInformation>
    AttributeInformations[vtkDataObject::NUMBER_OF_ATTRIBUTE_TYPES];
  vtkNew<vtkPVArrayInformation> PointArrayInformation;

  vtkNew<vtkDataAssembly> Hierarchy;
  vtkNew<vtkDataAssembly> DataAssembly;

  bool InspectCells = false;
  std::vector<unsigned char> UniqueCellTypes;

  friend class vtkPVDataInformationAccumulator;
};

#endif