vtkSpyPlotUniReader.h

Go to the documentation of this file.

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

#include "vtkObject.h"
#include "vtkPVVTKExtensionsIOSPCTHModule.h" //needed for exports
class vtkSpyPlotBlock;
class vtkDataArraySelection;
class vtkDataArray;
class vtkFloatArray;
class vtkIntArray;
class vtkUnsignedCharArray;
class vtkSpyPlotIStream;

class VTKPVVTKEXTENSIONSIOSPCTH_EXPORT vtkSpyPlotUniReader : public vtkObject
{
public:
  vtkTypeMacro(vtkSpyPlotUniReader, vtkObject);
  static vtkSpyPlotUniReader* New();
  void PrintSelf(ostream& os, vtkIndent indent) override;


  vtkSetStringMacro(FileName);
  vtkGetStringMacro(FileName);
  virtual void SetCellArraySelection(vtkDataArraySelection* da);

  virtual int ReadInformation();

  int MakeCurrent();

  void PrintInformation();
  void PrintMemoryUsage();


  // FIXME: This collides with `windows.h` symbols. It should be renamed.
  // https://gitlab.kitware.com/paraview/paraview/-/issues/20916
  int SetCurrentTime(double time);
  vtkGetMacro(CurrentTime, double);

  int SetCurrentTimeStep(int timeStep);
  vtkGetMacro(CurrentTimeStep, int);


  vtkGetVector2Macro(TimeStepRange, int);
  vtkGetVector2Macro(TimeRange, double);

  vtkSetMacro(NeedToCheck, int);


  int GetTimeStepFromTime(double time);
  double GetTimeFromTimeStep(int timeStep);

  vtkGetMacro(NumberOfCellFields, int);

  double* GetTimeArray();

  int IsAMR();

  int GetNumberOfDataBlocks();

  const char* GetCellFieldName(int field);

  vtkDataArray* GetCellFieldData(int block, int field, int* fixed);

  vtkDataArray* GetMaterialMassField(const int& block, const int& materialIndex);

  vtkDataArray* GetMaterialVolumeFractionField(const int& block, const int& materialIndex);

  int MarkCellFieldDataFixed(int block, int field);

  vtkFloatArray* GetTracers();

  // Return the ith block (i.e. grid) in the reader
  vtkSpyPlotBlock* GetBlock(int i);

  // Returns the number of materials
  int GetNumberOfMaterials() const { return NumberOfMaterials; }

  // Returns the number of dimensions
  int GetNumberOfDimensions() const { return NumberOfDimensions; }

  // Returns the coordinate system of the file
  int GetCoordinateSystem() const { return IGM; }

  struct CellMaterialField
  {
    char Id[30];
    char Comment[80];
    int Index;
  };
  struct Variable
  {
    char* Name;
    int Material;
    int Index;
    CellMaterialField* MaterialField;
    vtkDataArray** DataBlocks;
    int* GhostCellsFixed;
  };
  struct DataDump
  {
    int NumVars;
    int* SavedVariables;
    vtkTypeInt64* SavedVariableOffsets;
    vtkTypeInt64 SavedBlocksGeometryOffset;
    unsigned char* SavedBlockAllocatedStates;
    vtkTypeInt64 BlocksOffset;
    Variable* Variables;
    int NumberOfBlocks;
    int ActualNumberOfBlocks;
    int NumberOfTracers;
    vtkFloatArray* TracerCoord;
    vtkIntArray* TracerBlock;
  };
  struct MarkerMaterialField
  {
    char Name[30];
    char Label[256];
  };
  struct MaterialMarker
  {
    int NumMarks;
    int NumRealMarks;
    int NumVars;
    MarkerMaterialField* Variables;
  };
  struct MarkerDump
  {
    vtkFloatArray* XLoc;
    vtkFloatArray* YLoc;
    vtkFloatArray* ZLoc;
    vtkIntArray* ILoc;
    vtkIntArray* JLoc;
    vtkIntArray* KLoc;
    vtkIntArray* Block;
    vtkFloatArray** Variables;
  };
  MaterialMarker* Markers;
  MarkerDump* MarkersDumps;
  vtkSetMacro(GenerateMarkers, int);
  vtkGetMacro(GenerateMarkers, int);

  vtkGetMacro(MarkersOn, int);

  vtkSpyPlotBlock* GetDataBlock(int block);

  vtkSetMacro(DataTypeChanged, int);
  void SetDownConvertVolumeFraction(int vf);

protected:
  vtkSpyPlotUniReader();
  ~vtkSpyPlotUniReader() override;
  vtkSpyPlotBlock* Blocks;

private:
  int RunLengthDataDecode(const unsigned char* in, int inSize, float* out, int outSize);
  int RunLengthDataDecode(const unsigned char* in, int inSize, int* out, int outSize);
  int RunLengthDataDecode(const unsigned char* in, int inSize, unsigned char* out, int outSize);

  int ReadHeader(vtkSpyPlotIStream* spis);
  int ReadMarkerHeader(vtkSpyPlotIStream* spis);
  int ReadCellVariableInfo(vtkSpyPlotIStream* spis);
  int ReadMaterialInfo(vtkSpyPlotIStream* spis);
  int ReadGroupHeaderInformation(vtkSpyPlotIStream* spis);
  int ReadDataDumps(vtkSpyPlotIStream* spis);
  int ReadMarkerDumps(vtkSpyPlotIStream* spis);

  vtkDataArray* GetMaterialField(const int& block, const int& materialIndex, const char* Id);

  // Header information
  char FileDescription[128];
  int FileVersion;
  int SizeOfFilePointer;
  int FileCompressionFlag;
  int FileProcessorId;
  int NumberOfProcessors;
  int IGM;
  int NumberOfDimensions;
  int NumberOfMaterials;
  int MaximumNumberOfMaterials;
  double GlobalMin[3];
  double GlobalMax[3];
  int NumberOfBlocks;
  int MaximumNumberOfLevels;
  int MarkersOn;
  int GenerateMarkers;

  // For storing possible cell/material fields meta data
  int NumberOfPossibleCellFields;
  CellMaterialField* CellFields;
  int NumberOfPossibleMaterialFields;
  CellMaterialField* MaterialFields;

  // Individual dump information
  int NumberOfDataDumps;
  int* DumpCycle;
  double* DumpTime;
  double* DumpDT; // SPCTH 102 (What is this anyway?)
  vtkTypeInt64* DumpOffset;

  DataDump* DataDumps;

  // File name
  char* FileName;

  // Was information read
  int HaveInformation;

  // Current time and time range information
  int CurrentTimeStep;
  // Time step that the geometry represents
  int GeomTimeStep;
  double CurrentTime;
  int TimeStepRange[2];
  double TimeRange[2];

  // Indicates that the reader needs to check its data
  // (Not its geometry) - the reason is that ReadData
  // will be called a lot and there needs to be a way to
  // optimize this
  int NeedToCheck;

  int DataTypeChanged;
  int DownConvertVolumeFraction;

  int NumberOfCellFields;

  vtkDataArraySelection* CellArraySelection;

  Variable* GetCellField(int field);
  int IsVolumeFraction(Variable* var);

  vtkSpyPlotUniReader(const vtkSpyPlotUniReader&) = delete;
  void operator=(const vtkSpyPlotUniReader&) = delete;
};

inline double* vtkSpyPlotUniReader::GetTimeArray()
{
  return this->DumpTime;
}

inline int vtkSpyPlotUniReader::IsAMR()
{
  return (this->NumberOfBlocks > 1);
}

#endif