ConFileIO.h

Go to the documentation of this file.

/*
** This file is part of eOn.
**
** SPDX-License-Identifier: BSD-3-Clause
**
** Copyright (c) 2010--present, eOn Development Team
** All rights reserved.
**
** Repo:
** https://github.com/TheochemUI/eOn
*/
#pragma once
#include <array>
#include <cstdint>
#include <memory>
#include <optional>
#include <readcon-core.hpp>
#include <string>
#include <utility>
#include <vector>
 
namespace eonc {
class Matter;
 
namespace io {

enum class IoStatus : std::uint8_t {
  Ok = 0,
  ReadError = 1,
  WriteError = 2,
  AppendError = 3,
  OpenError = 4,
  InvalidArgument = 5,
};
 
[[nodiscard]] constexpr bool io_ok(IoStatus s) noexcept {
  return s == IoStatus::Ok;
}

[[nodiscard]] constexpr const char *io_status_name(IoStatus s) noexcept {
  switch (s) {
  case IoStatus::Ok:
    return "ok";
  case IoStatus::ReadError:
    return "read_error";
  case IoStatus::WriteError:
    return "write_error";
  case IoStatus::AppendError:
    return "append_error";
  case IoStatus::OpenError:
    return "open_error";
  case IoStatus::InvalidArgument:
    return "invalid_argument";
  }
  return "unknown";
}
 
struct ConMetadataValue {
  std::string key;
  double value;
};
 
struct ConMetadataText {
  std::string key;
  std::string value;
};
 
struct ConFrameMetadata {
  std::optional<uint64_t> frame_index;
  std::optional<double> energy;
  std::optional<double> time;
  std::optional<double> timestep;
  std::optional<uint64_t> neb_bead;
  std::optional<uint64_t> neb_band;
  std::optional<std::string> potential_type;
  std::vector<ConMetadataValue> scalars;
  std::vector<ConMetadataText> strings;
  std::optional<std::string> raw_json;
  std::vector<double> displacements;
  std::vector<double> spreads;
  std::optional<bool> write_con_forces;
};

ConFrameMetadata metadata_from_frame(const readcon::ConFrame &frame);

void set_write_con_forces(bool enabled) noexcept;
[[nodiscard]] bool write_con_forces() noexcept;
 
// Reading
[[nodiscard]] IoStatus con2matter(Matter &m, std::string filename);
[[nodiscard]] IoStatus con2matter(Matter &m, const readcon::ConFrame &frame,
                                  ConFrameMetadata *out_metadata = nullptr);
[[nodiscard]] IoStatus convel2matter(Matter &m, std::string filename);
 
// Writing

[[nodiscard]] IoStatus matter2con(Matter &m, std::string filename,
                                  bool append = false,
                                  const ConFrameMetadata *metadata = nullptr);

void resetConAppendState();
[[nodiscard]] IoStatus matter2convel(Matter &m, std::string filename);

[[nodiscard]] IoStatus matter2xyz(Matter &m, std::string filename,
                                  bool append = false);

[[nodiscard]] IoStatus writeTibble(Matter &m, std::string filename);

[[nodiscard]] readcon::ConFrame
matterToConFrame(Matter &m, const ConFrameMetadata *metadata = nullptr);

[[nodiscard]] std::vector<readcon::ConFrame>
buildNebPathFrames(const std::vector<std::shared_ptr<Matter>> &path,
                   const std::vector<ConFrameMetadata> &metadata_per_image);

[[nodiscard]] IoStatus
writeConFrames(std::string filename,
               const std::vector<readcon::ConFrame> &frames);

[[nodiscard]] IoStatus
writeNebPath(std::string filename,
             const std::vector<std::shared_ptr<Matter>> &path,
             const std::vector<ConFrameMetadata> &metadata_per_image);
 
// Cell lengths and CON header-line-4 angles (alpha, beta, gamma) in degrees.
std::pair<std::array<double, 3>, std::array<double, 3>>
cell_to_lengths_angles(const Matter &m);
 
} // namespace io
} // namespace eonc