vtkHDFWriter.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkHDFWriter_h
#define vtkHDFWriter_h

#include "vtkIOHDFModule.h" // For export macro
#include "vtkWriter.h"

#include <map>
#include <memory>

VTK_ABI_NAMESPACE_BEGIN

class vtkCellArray;
class vtkDataObjectTree;
class vtkDataSet;
class vtkHyperTreeGrid;
class vtkImageData;
class vtkPoints;
class vtkPointSet;
class vtkPolyData;
class vtkRectilinearGrid;
class vtkStructuredGrid;
class vtkTable;
class vtkUnstructuredGrid;
class vtkPartitionedDataSet;
class vtkPartitionedDataSetCollection;
class vtkMultiBlockDataSet;
class vtkMultiProcessController;
class vtkDataObjectTreeIterator;

typedef int64_t hid_t;

class VTKIOHDF_EXPORT vtkHDFWriter : public vtkWriter
{

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

public:
  static vtkHDFWriter* New();
  vtkTypeMacro(vtkHDFWriter, vtkWriter);
  void PrintSelf(ostream& os, vtkIndent indent) override;


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


  vtkSetFilePathMacro(FileName);
  vtkGetFilePathMacro(FileName);


  vtkSetMacro(Overwrite, bool);
  vtkGetMacro(Overwrite, bool);


  vtkSetMacro(WriteAllTimeSteps, bool);
  vtkGetMacro(WriteAllTimeSteps, bool);


  vtkSetMacro(ChunkSize, int);
  vtkGetMacro(ChunkSize, int);


  vtkSetClampMacro(CompressionLevel, int, 0, 9);
  vtkGetMacro(CompressionLevel, int);


  vtkSetMacro(UseExternalComposite, bool);
  vtkGetMacro(UseExternalComposite, bool);


  vtkSetMacro(UseExternalTimeSteps, bool);
  vtkGetMacro(UseExternalTimeSteps, bool);


  vtkSetMacro(UseExternalPartitions, bool);
  vtkGetMacro(UseExternalPartitions, bool);

protected:
  vtkTypeBool ProcessRequest(vtkInformation* request, vtkInformationVector** inputVector,
    vtkInformationVector* outputVector) override;

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

  int RequestInformation(vtkInformation* request, vtkInformationVector** inputVector,
    vtkInformationVector* outputVector);

  virtual int RequestUpdateExtent(vtkInformation* request, vtkInformationVector** inputVector,
    vtkInformationVector* outputVector);

  int RequestData(vtkInformation* request, vtkInformationVector** inputVector,
    vtkInformationVector* outputVector) override;

  vtkHDFWriter();
  ~vtkHDFWriter() override;

private:
  bool WriteDataAndReturn() override;

  bool DispatchDataObject(hid_t group, vtkDataObject* input, unsigned int partId = 0);

  bool WriteDistributedMetafile(vtkDataObject* input);


  bool WriteDatasetToFile(hid_t group, vtkImageData* input, unsigned int partId = 0);
  bool WriteDatasetToFile(hid_t group, vtkRectilinearGrid* input, unsigned int partId = 0);
  bool WriteDatasetToFile(hid_t group, vtkStructuredGrid* input, unsigned int partId = 0);
  bool WriteDatasetToFile(hid_t group, vtkPolyData* input, unsigned int partId = 0);
  bool WriteDatasetToFile(hid_t group, vtkUnstructuredGrid* input, unsigned int partId = 0);
  bool WriteDatasetToFile(hid_t group, vtkTable* input, unsigned int partId = 0);
  bool WriteDatasetToFile(hid_t group, vtkHyperTreeGrid* input, unsigned int partId = 0);
  bool WriteDatasetToFile(hid_t group, vtkPartitionedDataSet* input);
  bool WriteDatasetToFile(hid_t group, vtkDataObjectTree* input);


  bool UpdateStepsGroup(hid_t group, vtkRectilinearGrid* input);
  bool UpdateStepsGroup(hid_t group, vtkStructuredGrid* input);
  bool UpdateStepsGroup(hid_t group, vtkUnstructuredGrid* input, unsigned int partId);
  bool UpdateStepsGroup(hid_t group, vtkPolyData* input, unsigned int partId);
  bool UpdateStepsGroup(hid_t group, vtkHyperTreeGrid* input, unsigned int partId,
    vtkIdType numberOfCellsPerDepthSize, vtkIdType descriptorsSize, vtkIdType maskSize);


  bool InitializeTemporalRectilinearGrid(hid_t group);
  bool InitializeTemporalStructuredGrid(hid_t group);
  bool InitializeTemporalPolyData(hid_t group);
  bool InitializeTemporalUnstructuredGrid(hid_t group);
  bool InitializeTemporalPolyhedra(hid_t group);
  bool InitializeTemporalHTG(hid_t group);


  bool InitializeChunkedDatasets(hid_t group, vtkUnstructuredGrid* input);
  bool InitializeChunkedDatasets(hid_t group, vtkPolyData* input);
  bool InitializeChunkedDatasets(hid_t group, vtkHyperTreeGrid* input);
  bool InitializePointDatasets(hid_t group, vtkPoints* input);
  bool InitializePrimitiveDataset(hid_t group);
  bool InitializePolyhedraDatasets(hid_t group);

  bool AppendRectilinearCoordinates(hid_t group, vtkRectilinearGrid* input);

  bool AppendNumberOfPoints(hid_t group, vtkPointSet* input);

  bool AppendPoints(hid_t group, vtkPointSet* input, const int* dims = nullptr);

  bool AppendNumberOfCells(hid_t group, vtkCellArray* input);

  bool AppendNumberOfFaceConnectivityIds(hid_t group, vtkCellArray* input);

  bool AppendNumberOfFaces(hid_t group, vtkCellArray* input);

  bool AppendNumberOfConnectivityIds(hid_t group, vtkCellArray* input);

  bool AppendCellTypes(hid_t group, vtkUnstructuredGrid* input);

  bool AppendOffsets(hid_t group, vtkCellArray* input);

  bool AppendConnectivity(hid_t group, vtkCellArray* input);

  bool AppendFaceConnectivity(hid_t group, vtkCellArray* input);

  bool AppendFaceOffsets(hid_t group, vtkCellArray* input);

  bool AppendPolyhedronToFaces(hid_t group, vtkCellArray* input);

  bool AppendPolyhedronOffsets(hid_t group, vtkCellArray* input);

  bool AppendNumberOfPolyhedronToFaceIds(hid_t group, vtkCellArray* input);

  bool AppendPrimitiveCells(hid_t baseGroup, vtkPolyData* input);


  bool AppendDataArrays(hid_t group, vtkDataObject* input, unsigned int partId = 0);
  bool AppendDataSetAttributes(hid_t group, vtkDataObject* input, unsigned int partId = 0,
    vtkIdList* cellIdMap = nullptr, const int* dims = nullptr);
  bool AppendFieldDataArrays(hid_t group, vtkDataObject* input, unsigned int partId = 0);


  bool AppendBlocks(hid_t group, vtkPartitionedDataSetCollection* pdc);


  bool AppendExternalBlock(vtkDataObject* block, const std::string& blockName);

  bool AppendAssembly(hid_t group, vtkPartitionedDataSetCollection* pdc);

  bool AppendMultiblock(hid_t group, vtkMultiBlockDataSet* mb, int& leafIndex);

  bool AppendIterDataObject(vtkDataObjectTreeIterator* treeIter, const int& leafIndex,
    const std::string& uniqueSubTreeName);

  bool AppendCompositeSubfilesDataObject(const std::string& uniqueSubTreeName);


  bool AppendDataArrayOffset(hid_t baseGroup, vtkAbstractArray* array, const std::string& arrayName,
    const std::string& offsetsGroupName, unsigned int partId, bool isStructured = false);
  bool AppendDataArraySizeOffset(hid_t baseGroup, vtkAbstractArray* array,
    const std::string& arrayName, const std::string& offsetsGroupName, unsigned int partId);

  bool AppendTimeValues(hid_t group);

  bool HasGeometryChangedFromPreviousStep(vtkDataSet* input);

  void UpdatePreviousStepMeshMTime(vtkDataObject* input);

  class Implementation;
  std::unique_ptr<Implementation> Impl;

  // Configurable properties
  char* FileName = nullptr;
  bool Overwrite = true;
  bool WriteAllTimeSteps = true;
  bool UseExternalComposite = false;
  bool UseExternalTimeSteps = false;
  bool UseExternalPartitions = false;
  int ChunkSize = 25000;
  int CompressionLevel = 0;

  // Temporal-related private variables
  std::vector<double> timeSteps;
  bool IsTemporal = false;
  int CurrentTimeIndex = 0;
  int NumberOfTimeSteps = 1;
  vtkMTimeType PreviousStepMeshMTime = 0;
  std::map<vtkIdType, vtkMTimeType> CompositeMeshMTime;

  // Distributed-related variables
  vtkMultiProcessController* Controller = nullptr;
  int NbPieces = 1;
  int CurrentPiece = 0;
  bool UsesDummyController = false;
  std::vector<vtkIdType> PointOffsets;
  std::vector<vtkIdType> CellOffsets;
  std::vector<vtkIdType> ConnectivityIdOffsets;
};
VTK_ABI_NAMESPACE_END
#endif