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 vtkPoints;
class vtkPointSet;
class vtkPolyData;
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:
  void WriteData() override;
 
  void DispatchDataObject(hid_t group, vtkDataObject* input, unsigned int partId = 0);
 
  void WriteDistributedMetafile(vtkDataObject* input);
 
 
  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, vtkPartitionedDataSet* input);
  bool WriteDatasetToFile(hid_t group, vtkDataObjectTree* input);
 
 
  bool UpdateStepsGroup(hid_t group, vtkUnstructuredGrid* input);
  bool UpdateStepsGroup(hid_t group, vtkPolyData* input);
 
 
  bool InitializeTemporalPolyData(hid_t group);
  bool InitializeTemporalUnstructuredGrid(hid_t group);
 
 
  bool InitializeChunkedDatasets(hid_t group, vtkUnstructuredGrid* input);
  bool InitializeChunkedDatasets(hid_t group, vtkPolyData* input);
  bool InitializePointDatasets(hid_t group, vtkPoints* input);
  bool InitializePrimitiveDataset(hid_t group);
 
  bool AppendNumberOfPoints(hid_t group, vtkPointSet* input);
 
  bool AppendPoints(hid_t group, vtkPointSet* input);
 
  bool AppendNumberOfCells(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 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);
  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);
 
  void AppendIterDataObject(vtkDataObjectTreeIterator* treeIter, const int& leafIndex,
    const std::string& uniqueSubTreeName);
 
  void AppendCompositeSubfilesDataObject(const std::string& uniqueSubTreeName);
 
 
  bool AppendDataArrayOffset(hid_t baseGroup, vtkAbstractArray* array, const std::string& arrayName,
    const std::string& offsetsGroupName);
  bool AppendDataArraySizeOffset(hid_t baseGroup, vtkAbstractArray* array,
    const std::string& arrayName, const std::string& offsetsGroupName);
 
  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