EnSightFile.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 EnSightFile_h
#define EnSightFile_h

#include "vtkByteSwap.h"

#include "vtksys/FStream.hxx"

#include <cassert>
#include <limits>
#include <memory>
#include <sstream>
#include <string>
#include <vector>

namespace ensight_gold
{
VTK_ABI_NAMESPACE_BEGIN

constexpr int MAX_LINE_LENGTH = 80;
// This is half the precision of an int.
constexpr int MAXIMUM_PART_ID = 65536;

enum class FileType
{
  Unknown,
  ASCII,
  CBinary,
  FBinary
};

enum class Endianness
{
  Unknown,
  Little,
  Big
};

struct TimeSetInfo
{
  int NumberOfSteps;
  std::vector<int> FileNameNumbers;
  std::vector<double> TimeValues;
};

using TimeSetInfoMapType = std::map<int, std::shared_ptr<TimeSetInfo>>;

struct FileSetInfo
{
  std::vector<int> NumberOfSteps;
  std::vector<int> FileNameIndex;
  std::vector<int> TimeStepIndexInFile;
};

using FileSetInfoMapType = std::map<int, std::shared_ptr<FileSetInfo>>;

struct EnSightFile
{
  FileType Format = FileType::Unknown;
  Endianness ByteOrder = Endianness::Unknown;
  int TimeSet = -1;
  int FileSet = -1;
  bool InBlockRead = false;

  EnSightFile();
  ~EnSightFile();

  bool SetFileNamePattern(const std::string& filename, bool isCaseFile = false);

  void SetTimeAndFileSetInfo(int timeSet, int fileSet);

  void SetTimeSetInfo(std::shared_ptr<TimeSetInfo> info);
  std::shared_ptr<TimeSetInfo> GetTimeSetInfo() { return this->TimeInfo; }

  void SetFileSetInfo(std::shared_ptr<FileSetInfo> info);

  bool SetTimeStepToRead(double ts);

  bool CheckForMultipleTimeSteps();

  void CheckForBeginTimeStepLine();

  bool CheckForEndTimeStepLine();

  std::pair<bool, std::string> ReadNextLine(int size = MAX_LINE_LENGTH);

  std::pair<bool, std::string> ReadLine(int size = MAX_LINE_LENGTH);

  void SkipLine(vtkTypeInt64 size = std::numeric_limits<std::streamsize>::max());

  void SkipNLines(vtkIdType n);

  template <typename T>
  void SkipNNumbers(vtkIdType n, int numsPerLine = 1);

  void GoBackOneLine();

  bool DetectByteOrder(int* result);

  template <typename T>
  bool ReadNumber(T* result, bool padBeginning = true, bool padEnd = true);

  template <typename T>
  bool ReadArray(
    T* result, vtkIdType n, bool singleLine = false, bool padBeginning = true, bool padEnd = true);

  void MoveReadPosition(vtkTypeInt64 numBytes);

  std::streampos GetCurrentPosition();

  int GetCurrentOpenTimeStep();

  bool OpenFile(const std::string& filename, bool isCaseFile = false);
  bool OpenFile(bool isCaseFile = false);

private:
  std::string FileNamePattern;
  std::string CurrentOpenFileName;
  std::shared_ptr<TimeSetInfo> TimeInfo;
  std::shared_ptr<FileSetInfo> FileInfo;

  // This map keeps track of the positions in the file
  // where time steps begin
  // file index to the vector of positions for that file
  std::map<int, std::vector<std::streampos>> TimeStepBeginPositions;
  int CurrentFileIndex = -1;

  int TimeStepIndex = -1;

  vtksys::ifstream* Stream;
  bool HasBinaryHeader = false;
  int FortranSkipBytes = 0;

  void ResetFile();

  void CloseFile();

  void MoveToPosition(std::streampos pos);
};

template <typename T>
int getNumChars();

template <typename T>
bool stringTo(const std::string& input, T& output);

//------------------------------------------------------------------------------
template <typename T>
void EnSightFile::SkipNNumbers(vtkIdType n, int numsPerLine /* = 1 */)
{
  // for ascii, n is number of numeric lines to skip
  if (this->Format == FileType::ASCII)
  {
    // this->SkipNLines(n);
    //  so this format has max of 10 digits for integers
    //  for float, 12 characters total
    //  there's also white space allowed between numbers
    int size = getNumChars<T>() * numsPerLine + 10 * numsPerLine;
    vtkIdType lineIdx = 0;
    while (lineIdx < n)
    {
      auto result = this->ReadLine(size);
      lineIdx++;
      if (!result.first)
      {
        vtkGenericWarningMacro("SkipNNumbers() the full ascii line was not read");
      }
    }
  }
  else
  {
    vtkTypeInt64 numBytes = n * sizeof(T) + this->FortranSkipBytes * 2;
    this->MoveReadPosition(numBytes);
  }
}

//------------------------------------------------------------------------------
template <typename T>
bool EnSightFile::ReadNumber(T* result, bool padBeginning /* = true*/, bool padEnd /* = true*/)
{
  if (this->Format == FileType::ASCII)
  {
    auto line = this->ReadNextLine();
    stringTo(line.second, *result);
  }
  else
  {
    if (padBeginning)
    {
      assert(!this->InBlockRead);
      this->MoveReadPosition(this->FortranSkipBytes);
    }
    if (!this->Stream->read((char*)result, sizeof(T)))
    {
      vtkGenericWarningMacro("read failed");
      return false;
    }
    if (padEnd)
    {
      assert(!this->InBlockRead);
      this->MoveReadPosition(this->FortranSkipBytes);
    }
    if (this->ByteOrder == Endianness::Little)
    {
      vtkByteSwap::Swap4LE(result);
    }
    else if (this->ByteOrder == Endianness::Big)
    {
      vtkByteSwap::Swap4BE(result);
    }
  }
  return true;
}

//------------------------------------------------------------------------------
template <typename T>
bool EnSightFile::ReadArray(T* result, vtkIdType n, bool singleLine /* = false*/,
  bool padBeginning /* = true*/, bool padEnd /* = true*/)
{
  if (n <= 0)
  {
    return true;
  }

  if (this->Format == FileType::ASCII)
  {
    if (!singleLine)
    {
      for (int i = 0; i < n; i++)
      {
        this->ReadNumber(&result[i]);
      }
    }
    else
    {
      int size = getNumChars<T>() * n + 10 * n;
      auto lineResult = this->ReadLine(size);
      if (!lineResult.first)
      {
        vtkGenericWarningMacro("ReadArray() the full ascii line was not read");
      }

      std::stringstream ss(lineResult.second);
      for (int i = 0; i < n; i++)
      {
        ss >> result[i];
      }
    }
  }
  else
  {
    // In some cases we want to read everything in a single fortran
    // read into a single array, but sometimes we don't want to, so
    // we have to handle the skip bytes appropriately
    if (padBeginning && this->FortranSkipBytes > 0)
    {
      this->MoveReadPosition(this->FortranSkipBytes);
    }
    if (!this->Stream->read((char*)result, sizeof(T) * n))
    {
      vtkGenericWarningMacro("read array failed");
      return false;
    }
    if (padEnd && this->FortranSkipBytes > 0)
    {
      this->MoveReadPosition(this->FortranSkipBytes);
    }
    if (this->ByteOrder == Endianness::Little)
    {
      vtkByteSwap::Swap4LERange(result, n);
    }
    else if (this->ByteOrder == Endianness::Big)
    {
      vtkByteSwap::Swap4BERange(result, n);
    }
  }
  return true;
}

VTK_ABI_NAMESPACE_END
} // end namespace ensight_gold

#endif // end EnSightFile_h