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