v5.12.0/cxx/vtkSpyPlotUniReader_8h_source.html

// 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