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);
 
 
  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;
 
protected:
  vtkPVDataInformation();
  ~vtkPVDataInformation() override;
 
  void CopyFromPipelineInformation(vtkInformation* pipelineInfo);
  void CopyFromDataObject(vtkDataObject* dobj);
  friend class vtkPVDataInformationHelper;
 
  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;
 
  friend class vtkPVDataInformationAccumulator;
};
 
#endif