eonc::io Namespace Reference

Classes
struct	ConFrameMetadata
struct	ConMetadataText
struct	ConMetadataValue

Enumerations
enum class	IoStatus : std::uint8_t {   Ok = 0 , ReadError = 1 , WriteError = 2 , AppendError = 3 ,   OpenError = 4 , InvalidArgument = 5 }
	Structured I/O result for the client surface (nanobind-friendly). More...

Functions
readcon::ConFrame	matterToConFrame (Matter &m, const ConFrameMetadata *metadata=nullptr)
	Build a single stamped ConFrame from Matter (same builder as matter2con).
void	set_write_con_forces (bool enabled) noexcept
	Whether written .con frames carry "Forces of Component" sections.
bool	write_con_forces () noexcept
ConFrameMetadata	metadata_from_frame (const readcon::ConFrame &frame)
	Extract known frame-level fields from a parsed readcon frame.
std::pair< std::array< double, 3 >, std::array< double, 3 > >	cell_to_lengths_angles (const Matter &m)
void	resetConAppendState ()
	Drop the per-path bookkeeping that lets append-mode writes skip re-parsing frames this process wrote.
IoStatus	matter2con (Matter &m, std::string filename, bool append=false, const ConFrameMetadata *metadata=nullptr)
	Append a frame to a .con, or truncate and write one frame.
IoStatus	con2matter (Matter &m, std::string filename)
IoStatus	con2matter (Matter &m, const readcon::ConFrame &frame, ConFrameMetadata *out_metadata)
IoStatus	matter2convel (Matter &m, std::string filename)
IoStatus	convel2matter (Matter &m, std::string filename)
IoStatus	matter2xyz (Matter &m, std::string filename, bool append=false)
	Write one extended-XYZ frame: Lattice= cell and 17-digit coordinates.
IoStatus	writeTibble (Matter &m, std::string filename)
	Debug table (positions, optional cached forces). Not a structure format.
std::vector< readcon::ConFrame >	buildNebPathFrames (const std::vector< std::shared_ptr< Matter > > &path, const std::vector< ConFrameMetadata > &metadata_per_image)
	Build NEB band ConFrames without writing (clone builder path of writeNebPath).
IoStatus	writeConFrames (std::string filename, const std::vector< readcon::ConFrame > &frames)
	Write already-built ConFrames to a multi-frame .con (temp or durable).
IoStatus	writeNebPath (std::string filename, const std::vector< std::shared_ptr< Matter > > &path, const std::vector< ConFrameMetadata > &metadata_per_image)
	Write a full NEB path as one multi-frame .con using ConFrameBuilder::clone().
void	mirror_con_corpus (const std::string &path)
	Copy a con file into the run readcon-db corpus when libreadcon_db loads.
constexpr bool	io_ok (IoStatus s) noexcept
constexpr const char *	io_status_name (IoStatus s) noexcept
	Human-readable label for logging / bindings.

Enumeration Type Documentation

IoStatus

enum class eonc::io::IoStatus : std::uint8_t

strong

Structured I/O result for the client surface (nanobind-friendly).

Prefer comparing to IoStatus::Ok rather than treating as bool.

Enumerator
Ok
ReadError
WriteError
AppendError
OpenError
InvalidArgument

Definition at line 29 of file ConFileIO.h.

                    : std::uint8_t {
  Ok = 0,
  ReadError = 1,
  WriteError = 2,
  AppendError = 3,
  OpenError = 4,
  InvalidArgument = 5,
};

Function Documentation

buildNebPathFrames()

std::vector< readcon::ConFrame > eonc::io::buildNebPathFrames ( const std::vector< std::shared_ptr< Matter > > & path, const std::vector< ConFrameMetadata > & metadata_per_image )

nodiscard

Build NEB band ConFrames without writing (clone builder path of writeNebPath).

Empty vector on invalid input.

Parameters

path	length must equal metadata_per_image (endpoints included)

Definition at line 907 of file ConFileIO.cpp.

                                                                          {
  std::vector<readcon::ConFrame> frames;
  if (path.empty() || path.size() != metadata_per_image.size()) {
    EONC_LOG_ERROR(
        "buildNebPathFrames: path/metadata size mismatch (path={}, meta={})",
        path.size(), metadata_per_image.size());
    return frames;
  }
  for (const auto &img : path) {
    if (!img) {
      EONC_LOG_ERROR("buildNebPathFrames: null Matter in path");
      return {};
    }
  }
 
  Matter &template_m = *path.front();
  template_m.applyPeriodicBoundaryIfEnabled();
 
  std::vector<uint64_t> atom_ids;
  std::array<std::string, 2> prebox;
  std::array<std::string, 2> postbox;
  collect_ids_headers(template_m, atom_ids, prebox, postbox);
 
  frames.reserve(path.size());
  try {
    auto seed = seed_builder(template_m, prebox, postbox, atom_ids);
    for (size_t i = 0; i < path.size(); ++i) {
      Matter &img = *path[i];
      img.applyPeriodicBoundaryIfEnabled();
      if (img.numberOfAtoms() != template_m.numberOfAtoms()) {
        EONC_LOG_ERROR(
            "buildNebPathFrames: image {} atom count {} != template {}", i,
            img.numberOfAtoms(), template_m.numberOfAtoms());
        return {};
      }
      auto builder = seed.clone();
      apply_frame_metadata(builder, &metadata_per_image[i]);
      apply_geometry(builder, img, /*with_velocities=*/false,
                     &metadata_per_image[i]);
      frames.push_back(builder.build());
    }
  } catch (const std::exception &e) {
    EONC_LOG_ERROR("buildNebPathFrames failed: {}", e.what());
    return {};
  }
  return frames;
}

cell_to_lengths_angles()

std::pair< std::array< double, 3 >, std::array< double, 3 > > eonc::io::cell_to_lengths_angles

(

const Matter &

m

)

Definition at line 530 of file ConFileIO.cpp.

                                        {
  const Matrix3d cell = m.getCell();
  std::array<double, 3> lengths;
  lengths[0] = cell.row(0).norm();
  lengths[1] = cell.row(1).norm();
  lengths[2] = cell.row(2).norm();
  // CON header line 4 is alpha beta gamma:
  // alpha = angle(b,c), beta = angle(a,c), gamma = angle(a,b).
  std::array<double, 3> angles;
  angles[0] = eonc::safemath::safe_acos(eonc::safemath::safe_div(
                  cell.row(1).dot(cell.row(2)), lengths[1] * lengths[2])) *
              180.0 / eonc::helpers::pi;
  angles[1] = eonc::safemath::safe_acos(eonc::safemath::safe_div(
                  cell.row(0).dot(cell.row(2)), lengths[0] * lengths[2])) *
              180.0 / eonc::helpers::pi;
  angles[2] = eonc::safemath::safe_acos(eonc::safemath::safe_div(
                  cell.row(0).dot(cell.row(1)), lengths[0] * lengths[1])) *
              180.0 / eonc::helpers::pi;
  return {lengths, angles};
}

con2matter() [1/2]

IoStatus eonc::io::con2matter ( Matter & m, const readcon::ConFrame & frame, ConFrameMetadata * out_metadata )

nodiscard

Definition at line 637 of file ConFileIO.cpp.

                                                    {
  try {
    const auto &atoms = frame.atoms();
    const auto &lengths = frame.cell();
    const auto &angles_deg = frame.angles();
    const auto &prebox = frame.prebox_header();
    const auto &postbox = frame.postbox_header();
 
    m.headerCon[0] = prebox[0] + "\n";
    m.headerCon[1] = prebox[1] + "\n";
    m.headerCon[3] = postbox[0] + "\n";
    m.headerCon[4] = postbox[1] + "\n";
 
    double angles[3] = {angles_deg[0], angles_deg[1], angles_deg[2]};
    if (angles[0] == 90.0 && angles[1] == 90.0 && angles[2] == 90.0) {
      Matrix3d cell = Matrix3d::Zero();
      cell(0, 0) = lengths[0];
      cell(1, 1) = lengths[1];
      cell(2, 2) = lengths[2];
      m.setCell(cell);
    } else {
      angles[0] *= eonc::helpers::pi / 180.0;
      angles[1] *= eonc::helpers::pi / 180.0;
      angles[2] *= eonc::helpers::pi / 180.0;
      const double alpha = angles[0];
      const double beta = angles[1];
      const double gamma = angles[2];
 
      Matrix3d cell = Matrix3d::Zero();
      cell(0, 0) = 1.0;
      cell(1, 0) = cos(gamma);
      cell(1, 1) = sin(gamma);
      cell(2, 0) = cos(beta);
      cell(2, 1) = (cos(alpha) - cell(1, 0) * cell(2, 0)) / cell(1, 1);
      cell(2, 2) = eonc::safemath::safe_sqrt(1.0 - pow(cell(2, 0), 2) -
                                             pow(cell(2, 1), 2));
 
      cell(0, 0) *= lengths[0];
      cell(1, 0) *= lengths[1];
      cell(1, 1) *= lengths[1];
      cell(2, 0) *= lengths[2];
      cell(2, 1) *= lengths[2];
      cell(2, 2) *= lengths[2];
      m.setCell(cell);
    }
    m.headerCon[2] =
        std::format("{} {} {}\n", angles_deg[0], angles_deg[1], angles_deg[2]);
 
    const auto n = static_cast<Eigen::Index>(atoms.size());
    m.resize(static_cast<long>(atoms.size()));
 
    // Undo the species grouping the .con format imposes, so an index into
    // Matter addresses the same atom as the matching row of mode.dat.
    const std::vector<size_t> order = matter_order(atoms);
    std::vector<long> file_to_matter(static_cast<size_t>(n));
    for (Eigen::Index i = 0; i < n; ++i) {
      file_to_matter[order[static_cast<size_t>(i)]] = static_cast<long>(i);
    }
    m.setFileToMatter(std::move(file_to_matter));
 
    AtomMatrix positions = AtomMatrix::Zero(n, 3);
    AtomMatrix forces = AtomMatrix::Zero(n, 3);
    AtomMatrix velocities = AtomMatrix::Zero(n, 3);
    VectorXd masses = VectorXd::Zero(n);
    VectorXi atomic_nrs = VectorXi::Zero(n);
    bool any_force = false;
    bool any_velocity = false;
 
    for (Eigen::Index i = 0; i < n; ++i) {
      const auto &atom = atoms[order[static_cast<size_t>(i)]];
      positions(i, 0) = atom.x;
      positions(i, 1) = atom.y;
      positions(i, 2) = atom.z;
      masses(i) = atom.mass;
      atomic_nrs(i) = static_cast<int>(atom.atomic_number);
      const auto fixed = atom.fixed_mask();
      m.setFixedMask(static_cast<long>(i), {fixed[0], fixed[1], fixed[2]});
      m.setAtomIndex(static_cast<long>(i),
                     static_cast<std::int64_t>(atom.atom_id));
 
      if (auto vel = atom.velocity()) {
        any_velocity = true;
        velocities(i, 0) = (*vel)[0];
        velocities(i, 1) = (*vel)[1];
        velocities(i, 2) = (*vel)[2];
      }
      if (auto force = atom.force()) {
        any_force = true;
        forces(i, 0) = (*force)[0];
        forces(i, 1) = (*force)[1];
        forces(i, 2) = (*force)[2];
      }
    }
 
    m.setMasses(masses);
    m.setAtomicNrs(atomic_nrs);
    m.setPositions(positions);
 
    if (any_velocity || frame.has_velocities()) {
      m.setVelocities(velocities);
    }
 
    const auto meta = metadata_from_frame(frame);
    if (out_metadata != nullptr) {
      *out_metadata = meta;
    }
 
    // Trust file energy+forces only when both are present. Energy-only must not
    // mark the pot clean with a zero force matrix (optimizer footgun). Prefer
    // writing raw forces (friend) so fixed-atom components survive RT; then
    // mark clean without setComputedPotential's net-force adjustment on zeros.
    const bool has_force_section = any_force || frame.has_forces();
    if (meta.energy && has_force_section) {
      m.restoreFileForces(forces, true, *meta.energy);
    } else if (has_force_section) {
      m.restoreFileForces(forces, false, 0.0);
    } else {
      // Classic geometry-only files: always recompute pot (main-era behavior).
      m.recomputePotential = true;
    }
 
    // setPositions already applied PBC when enabled; no second wrap here.
    return IoStatus::Ok;
  } catch (const std::exception &e) {
    EONC_LOG_ERROR("Failed to convert frame to matter: {}", e.what());
    return IoStatus::ReadError;
  }
}

con2matter() [2/2]

IoStatus eonc::io::con2matter ( Matter & m, std::string filename )

nodiscard

Definition at line 622 of file ConFileIO.cpp.

                                                   {
  filename = ensure_extension(std::move(filename), ".con");
  try {
    auto frame = readcon::read_first_frame(filename);
    const IoStatus status = con2matter(m, frame, nullptr);
    if (io_ok(status)) {
      mirror_con_corpus(filename);
    }
    return status;
  } catch (const std::exception &e) {
    EONC_LOG_ERROR("Failed to read {}: {}", filename, e.what());
    return IoStatus::ReadError;
  }
}

convel2matter()

IoStatus eonc::io::convel2matter ( Matter & m, std::string filename )

nodiscard

Definition at line 787 of file ConFileIO.cpp.

                                                      {
  filename = ensure_extension(std::move(filename), ".convel");
  try {
    auto frame = readcon::read_first_frame(filename);
    const IoStatus status = con2matter(m, frame, nullptr);
    if (io_ok(status)) {
      mirror_con_corpus(filename);
    }
    return status;
  } catch (const std::exception &e) {
    EONC_LOG_ERROR("Failed to read convel {}: {}", filename, e.what());
    return IoStatus::ReadError;
  }
}

io_ok()

bool eonc::io::io_ok ( IoStatus s )

nodiscardconstexprnoexcept

Definition at line 38 of file ConFileIO.h.

                                                        {
  return s == IoStatus::Ok;
}

io_status_name()

const char * eonc::io::io_status_name ( IoStatus s )

nodiscardconstexprnoexcept

Human-readable label for logging / bindings.

Definition at line 43 of file ConFileIO.h.

                                                                        {
  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";
}

matter2con()

IoStatus eonc::io::matter2con ( Matter & m, std::string filename, bool append = false, const ConFrameMetadata * metadata = nullptr )

nodiscard

Append a frame to a .con, or truncate and write one frame.

With append, an uncompressed target is extended in place: the new frame is serialized on its own and concatenated, so N appends cost N frame writes rather than N(N+1)/2. Earlier frames are never re-serialized, and the file is flushed before the call returns, so every intermediate state on disk is a complete multi-frame .con.

A target that eOn did not write, or that changed size or mtime since eOn last wrote it, is parsed once before anything is added; an unparseable target yields IoStatus::AppendError with its bytes untouched. Gzip and zstd targets keep the read-all-and-rewrite path because a compressed member cannot be extended in place.

Definition at line 556 of file ConFileIO.cpp.

                                                      {
  filename = ensure_extension(std::move(filename), ".con");
 
  m.applyPeriodicBoundaryIfEnabled();
 
  const fs::path path(filename);
  const auto compression =
      readcon::ConFrameWriter::compression_from_extension(path);
  const bool streamable =
      compression == readcon::ConFrameWriter::Compression::None;
 
  // The lock covers the stamp table and the read-then-extend window on one
  // path. Nothing under it evaluates a potential: frame_from_matter reads
  // cached energy and forces only while the pot is clean.
  const std::lock_guard<std::mutex> guard(append_mutex());
  const auto key = append_key(path);
  const bool exists = fs::exists(path);
  const bool concatenate = append && exists && streamable;
 
  // ConFrame is move-only (no default ctor), so frames carries the new frame
  // either way. A gzip or zstd target cannot be concatenated: readcon-core
  // reads a single gzip member, so appended members would be invisible
  // on read-back, and the streaming writers cannot be flushed frame by frame.
  // Those targets keep the whole-file rewrite, which stays O(N) per append.
  std::vector<readcon::ConFrame> frames;
  if (append && exists && !streamable) {
    try {
      // Prefer read_all_frames (single ownership hand-off) over the iterator
      // path for append rewrite; simpler lifetime for ASAN/CI envs.
      frames = readcon::read_all_frames(path);
    } catch (const std::exception &e) {
      EONC_LOG_ERROR("Failed to append to {}: {}", filename, e.what());
      return IoStatus::AppendError;
    }
  } else if (concatenate && !tail_is_ours(key, path)) {
    // Refuse to extend a file eOn cannot parse, matching the rewrite path:
    // the target keeps its bytes and the caller sees AppendError. Frames this
    // process wrote and nobody touched since need no such check.
    try {
      [[maybe_unused]] const auto existing = readcon::read_all_frames(path);
    } catch (const std::exception &e) {
      EONC_LOG_ERROR("Failed to append to {}: {}", filename, e.what());
      return IoStatus::AppendError;
    }
  }
  try {
    frames.push_back(frame_from_matter(m, metadata, /*with_velocities=*/false));
  } catch (const std::exception &e) {
    EONC_LOG_ERROR("Failed to build frame for {}: {}", filename, e.what());
    return IoStatus::InvalidArgument;
  }
 
  const auto status = concatenate ? append_frames(path, frames, kConPrecision)
                                  : write_frames(path, frames, kConPrecision);
  if (io_ok(status)) {
    remember_stamp(key, path);
    if (!concatenate) {
      mirror_con_corpus(path.string());
    }
  } else {
    append_stamps().erase(key);
  }
  return status;
}

matter2convel()

IoStatus eonc::io::matter2convel ( Matter & m, std::string filename )

nodiscard

Definition at line 767 of file ConFileIO.cpp.

                                                      {
  filename = ensure_extension(std::move(filename), ".convel");
 
  m.applyPeriodicBoundaryIfEnabled();
 
  try {
    auto frame = frame_from_matter(m, nullptr, /*with_velocities=*/true);
    std::vector<readcon::ConFrame> frames;
    frames.push_back(std::move(frame));
    const IoStatus status = write_frames(filename, frames, kConvelPrecision);
    if (io_ok(status)) {
      mirror_con_corpus(filename);
    }
    return status;
  } catch (const std::exception &e) {
    EONC_LOG_ERROR("Failed to write convel {}: {}", filename, e.what());
    return IoStatus::WriteError;
  }
}

matter2xyz()

IoStatus eonc::io::matter2xyz ( Matter & m, std::string filename, bool append = false )

nodiscard

Write one extended-XYZ frame: Lattice= cell and 17-digit coordinates.

append concatenates another frame. A tail that does not end in a newline gets one before the next atom count, so the frames stay separate. A target whose last frame has a different atom count yields InvalidArgument and is left unchanged. Chemfiles in readcon is ingress (XYZ/PDB/GRO into ConFrame), not XYZ egress, so this writer emits the Lattice= comment ASE and chemfiles already read.

Definition at line 802 of file ConFileIO.cpp.

                                                                {
  filename = ensure_extension(std::move(filename), ".xyz");
 
  m.applyPeriodicBoundaryIfEnabled();
  const long n = m.numberOfAtoms();
 
  if (append && fs::exists(filename)) {
    std::error_code ec;
    const auto sz = fs::file_size(filename, ec);
    if (!ec && sz > 0) {
      const auto prev = last_xyz_natoms(filename);
      if (!prev) {
        EONC_LOG_ERROR("matter2xyz: cannot parse existing {}", filename);
        return IoStatus::AppendError;
      }
      if (*prev != n) {
        EONC_LOG_ERROR(
            "matter2xyz: append atom count {} != last frame {} in {}", n, *prev,
            filename);
        return IoStatus::InvalidArgument;
      }
    }
  }
 
  std::ofstream out;
  out.open(filename,
           append ? (std::ios::out | std::ios::app | std::ios::binary)
                  : (std::ios::out | std::ios::trunc | std::ios::binary));
  if (!out) {
    EONC_LOG_ERROR("matter2xyz: cannot open {}", filename);
    return IoStatus::OpenError;
  }
 
  // A frame header must start its own line. eOn's own frames end in a
  // newline; a hand-written or foreign tail may not.
  if (append && !ends_with_newline(filename)) {
    out.put('\n');
  }
 
  const Matrix3d cell = m.getCell();
  out << std::format(
      "{}\nLattice=\"{:.17g} {:.17g} {:.17g} {:.17g} {:.17g} {:.17g} "
      "{:.17g} {:.17g} {:.17g}\" Properties=species:S:1:pos:R:3 Generated "
      "by eOn\n",
      n, cell(0, 0), cell(0, 1), cell(0, 2), cell(1, 0), cell(1, 1), cell(1, 2),
      cell(2, 0), cell(2, 1), cell(2, 2));
  const AtomMatrix pos = m.getPositions();
  for (long i = 0; i < n; ++i) {
    out << std::format("{}\t{:.17g}\t{:.17g}\t{:.17g}\n",
                       symbol_for_z(m.getAtomicNr(i)), pos(i, 0), pos(i, 1),
                       pos(i, 2));
  }
  // Close before testing: the destructor's flush is where a full disk or a
  // short write surfaces, and by then the state is gone.
  out.close();
  if (!out) {
    EONC_LOG_ERROR("matter2xyz: failed to write {}", filename);
    return IoStatus::WriteError;
  }
  return IoStatus::Ok;
}

matterToConFrame()

readcon::ConFrame eonc::io::matterToConFrame ( Matter & m, const ConFrameMetadata * metadata = nullptr )

nodiscard

Build a single stamped ConFrame from Matter (same builder as matter2con).

Does not write to disk.

Definition at line 500 of file ConFileIO.cpp.

                                                                     {
  return frame_from_matter(m, metadata, /*with_velocities=*/false);
}

metadata_from_frame()

ConFrameMetadata eonc::io::metadata_from_frame

(

const readcon::ConFrame &

frame

)

Extract known frame-level fields from a parsed readcon frame.

Definition at line 513 of file ConFileIO.cpp.

                                                                   {
  ConFrameMetadata meta;
  meta.energy = frame.energy_opt();
  meta.frame_index = frame.frame_index_opt();
  meta.time = frame.time_opt();
  meta.timestep = frame.timestep_opt();
  meta.neb_bead = frame.neb_bead_opt();
  meta.neb_band = frame.neb_band_opt();
  meta.potential_type = frame.potential_type();
  const auto json = frame.metadata_json();
  if (!json.empty() && json != "{}") {
    meta.raw_json = json;
  }
  return meta;
}

mirror_con_corpus()

void eonc::io::mirror_con_corpus

(

const std::string &

path

)

Copy a con file into the run readcon-db corpus when libreadcon_db loads.

Failure to load the library or to insert the blob does not change IoStatus.

Definition at line 138 of file ReadconDbMirror.cpp.

                                              {
#if !defined(_WIN32)
  namespace fs = std::filesystem;
  std::error_code ec;
  if (!fs::is_regular_file(path, ec) || ec) {
    return;
  }
  std::ifstream in(path);
  if (!in) {
    return;
  }
  std::ostringstream buf;
  buf << in.rdbuf();
  const std::string text = buf.str();
  if (text.find_first_not_of(" \t\r\n") == std::string::npos) {
    return;
  }
  fs::path canonical = fs::weakly_canonical(path, ec);
  if (ec) {
    canonical = fs::absolute(path);
  }
  const std::string resolved = canonical.string();
  const std::size_t id = corpus_handle(corpus_dir(canonical));
  if (id == static_cast<std::size_t>(-1)) {
    return;
  }
  const std::uint64_t tid = fnv1a(resolved + '\0' + text);
  std::uint32_t nframes = 0;
  api().append_str(id, tid, text.c_str(), resolved.c_str(), &nframes);
#else
  (void)path;
#endif
}

resetConAppendState()

void eonc::io::resetConAppendState

(

)

Drop the per-path bookkeeping that lets append-mode writes skip re-parsing frames this process wrote.

Appends already re-parse a target whose size or mtime moved, so this only matters when a file is replaced with different content of the same size inside one filesystem timestamp tick.

Definition at line 551 of file ConFileIO.cpp.

                           {
  const std::lock_guard<std::mutex> guard(append_mutex());
  append_stamps().clear();
}

set_write_con_forces()

void eonc::io::set_write_con_forces ( bool enabled )

noexcept

Whether written .con frames carry "Forces of Component" sections.

Force sections enable force+energy co-loading on re-read (warm NEB restarts without re-evaluating the potential) but are not part of the classic con layout: external readers such as ASE's eon parser reject frames that carry them. Off unless [Main] write_con_forces enables it. A ConFrameMetadata.write_con_forces value, then the Matter Parameters field, override this process-wide flag for a single write. Reading force-bearing frames is always supported regardless of this flag.

Definition at line 505 of file ConFileIO.cpp.

                                                 {
  g_write_con_forces.store(enabled, std::memory_order_relaxed);
}

write_con_forces()

bool eonc::io::write_con_forces ( )

nodiscardnoexcept

Definition at line 509 of file ConFileIO.cpp.

                                 {
  return g_write_con_forces.load(std::memory_order_relaxed);
}

writeConFrames()

IoStatus eonc::io::writeConFrames ( std::string filename, const std::vector< readcon::ConFrame > & frames )

nodiscard

Write already-built ConFrames to a multi-frame .con (temp or durable).

Definition at line 956 of file ConFileIO.cpp.

                                                                  {
  if (frames.empty()) {
    return IoStatus::InvalidArgument;
  }
  filename = ensure_extension(std::move(filename), ".con");
  const fs::path path(filename);
  const std::lock_guard<std::mutex> guard(append_mutex());
  const auto key = append_key(path);
  const auto status = write_frames(path, frames, kConPrecision);
  if (io_ok(status)) {
    remember_stamp(key, path);
    mirror_con_corpus(path.string());
  } else {
    append_stamps().erase(key);
  }
  return status;
}

writeNebPath()

IoStatus eonc::io::writeNebPath ( std::string filename, const std::vector< std::shared_ptr< Matter > > & path, const std::vector< ConFrameMetadata > & metadata_per_image )

nodiscard

Write a full NEB path as one multi-frame .con using ConFrameBuilder::clone().

Seeds identity (symbols/fixed/mass/id/cell headers) from path[0] only, then for each image clones that template and bulk-updates positions/forces + metadata. Images must share atom count and topology with path[0] (standard NEB band invariant); heterogeneous multi-frame movies should not use this. Avoids re-reading the output file per image (legacy append path).

Parameters

path	length must be numImages+2 (endpoints included)
metadata_per_image	length must equal path.size()

Definition at line 975 of file ConFileIO.cpp.

                                                                             {
  auto frames = buildNebPathFrames(path, metadata_per_image);
  if (frames.empty()) {
    return IoStatus::InvalidArgument;
  }
  return writeConFrames(std::move(filename), frames);
}

writeTibble()

IoStatus eonc::io::writeTibble ( Matter & m, std::string fname )

nodiscard

Debug table (positions, optional cached forces). Not a structure format.

Definition at line 864 of file ConFileIO.cpp.

                                                 {
  // Debug table, not a structure format. getForces()/getPotentialEnergy()
  // run computePotential() on a dirty pot, which would charge a dump to
  // the force-call count in results.dat. Cached values only; the header
  // drops the columns it cannot fill. atmID is the CON column-5 id.
  const bool have_forces = !m.needsForceUpdate();
  if (!have_forces) {
    EONC_LOG_WARNING(
        "writeTibble: pot is dirty, {} omits the force and energy columns",
        fname);
  }
  const AtomMatrix pos = m.getPositions();
  std::ofstream out(fname);
  if (!out) {
    EONC_LOG_ERROR("writeTibble: cannot open {}", fname);
    return IoStatus::OpenError;
  }
  out << (have_forces ? "x y z fx fy fz energy mass symbol atmID fixed\n"
                      : "x y z mass symbol atmID fixed\n");
  const AtomMatrix fSys = have_forces ? m.getForces() : AtomMatrix();
  const double eSys = have_forces ? m.getPotentialEnergy() : 0.0;
  for (long idx = 0; idx < m.numberOfAtoms(); ++idx) {
    out << std::format("{} {} {}", pos(idx, 0), pos(idx, 1), pos(idx, 2));
    if (have_forces) {
      out << std::format(" {} {} {} {}", fSys(idx, 0), fSys(idx, 1),
                         fSys(idx, 2), eSys);
    }
    const auto mask = m.getFixedMask(idx);
    const int fixed_bits =
        (mask[0] ? 1 : 0) | (mask[1] ? 2 : 0) | (mask[2] ? 4 : 0);
    out << std::format(" {} {} {} {}\n", m.getMass(idx),
                       symbol_for_z(m.getAtomicNr(idx)), m.getAtomIndex(idx),
                       fixed_bits);
  }
  out.close();
  if (!out) {
    EONC_LOG_ERROR("writeTibble: failed to write {}", fname);
    return IoStatus::WriteError;
  }
  return IoStatus::Ok;
}