vtkParallelSerialWriter.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Kitware Inc.
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkParallelSerialWriter_h
#define vtkParallelSerialWriter_h
 
#include "vtkDataObjectAlgorithm.h"
#include "vtkPVVTKExtensionsIOCoreModule.h" //needed for exports
#include "vtkSmartPointer.h"                // needed for vtkSmartPointer
#include <string>                           // for std::string
 
class vtkClientServerInterpreter;
class vtkMultiProcessController;
class vtkPartitionedDataSet;
 
class VTKPVVTKEXTENSIONSIOCORE_EXPORT vtkParallelSerialWriter : public vtkDataObjectAlgorithm
{
public:
  static vtkParallelSerialWriter* New();
  vtkTypeMacro(vtkParallelSerialWriter, vtkDataObjectAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
 
  void SetWriter(vtkAlgorithm*);
  vtkGetObjectMacro(Writer, vtkAlgorithm);
 
  vtkMTimeType GetMTime() override;
 
 
  vtkSetStringMacro(FileNameMethod);
  vtkGetStringMacro(FileNameMethod);
 
 
  vtkSetStringMacro(FileName);
  vtkGetStringMacro(FileName);
 
  int Write();
 
 
  vtkGetMacro(Piece, int);
  vtkSetMacro(Piece, int);
 
 
  vtkGetMacro(NumberOfPieces, int);
  vtkSetMacro(NumberOfPieces, int);
 
 
  vtkGetMacro(GhostLevel, int);
  vtkSetMacro(GhostLevel, int);
 
 
  void SetPreGatherHelper(vtkAlgorithm*);
  vtkGetObjectMacro(PreGatherHelper, vtkAlgorithm);
 
 
  void SetPostGatherHelper(vtkAlgorithm*);
  vtkGetObjectMacro(PostGatherHelper, vtkAlgorithm);
 
 
  vtkGetMacro(WriteAllTimeSteps, int);
  vtkSetMacro(WriteAllTimeSteps, int);
  vtkBooleanMacro(WriteAllTimeSteps, int);
 
  void SetInterpreter(vtkClientServerInterpreter* interp) { this->Interpreter = interp; }
 
 
  vtkGetStringMacro(FileNameSuffix);
  vtkSetStringMacro(FileNameSuffix);
 
 
  vtkSetClampMacro(NumberOfIORanks, int, 0, VTK_INT_MAX);
  vtkGetMacro(NumberOfIORanks, int);
 
  enum
  {
    ASSIGNMENT_MODE_CONTIGUOUS,
    ASSIGNMENT_MODE_ROUND_ROBIN
  };
 
 
  vtkSetClampMacro(
    RankAssignmentMode, int, ASSIGNMENT_MODE_CONTIGUOUS, ASSIGNMENT_MODE_ROUND_ROBIN);
  vtkGetMacro(RankAssignmentMode, int);
 
 
  void SetController(vtkMultiProcessController* controller);
  vtkGetObjectMacro(Controller, vtkMultiProcessController);
 
protected:
  vtkParallelSerialWriter();
  ~vtkParallelSerialWriter() override;
 
  int RequestInformation(vtkInformation* request, vtkInformationVector** inputVector,
    vtkInformationVector* outputVector) override;
  int RequestUpdateExtent(vtkInformation* request, vtkInformationVector** inputVector,
    vtkInformationVector* outputVector) override;
  int RequestData(vtkInformation* request, vtkInformationVector** inputVector,
    vtkInformationVector* outputVector) override;
 
private:
  vtkParallelSerialWriter(const vtkParallelSerialWriter&) = delete;
  void operator=(const vtkParallelSerialWriter&) = delete;
 
  void WriteATimestep(const std::string& fname, vtkPartitionedDataSet* input);
  void WriteAFile(const std::string& fname, vtkDataObject* input);
 
  void SetWriterFileName(const char* fname);
  void WriteInternal();
 
  std::string GetPartitionFileName(const std::string& fname);
 
  vtkAlgorithm* PreGatherHelper;
  vtkAlgorithm* PostGatherHelper;
 
  vtkAlgorithm* Writer;
  char* FileNameMethod;
  int Piece;
  int NumberOfPieces;
  int GhostLevel;
 
  int WriteAllTimeSteps;
  int NumberOfTimeSteps;
  int CurrentTimeIndex;
 
  // The name of the output file.
  char* FileName;
  char* FileNameSuffix;
 
  vtkClientServerInterpreter* Interpreter;
 
  int NumberOfIORanks;
  int RankAssignmentMode;
 
  vtkMultiProcessController* Controller;
  vtkSmartPointer<vtkMultiProcessController> SubController;
  int SubControllerColor;
};
 
#endif