CommandLine.cpp

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
*/
#include "eon/CommandLine.h"
#include "eon/Matter.h"
#include "eon/Parameters.h"
#include "eon/Potential.h"
#include "version.h"
 
#ifdef WITH_SERVE_MODE
#include "eon/ServeMode.h"
#endif
 
#include <argum.h>
 
#include <cstdlib>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <memory>
#include <optional>
#include <sstream>
#include <string>
 
namespace {
constexpr auto colorScheme = Argum::basicDefaultColorScheme<char>;
Argum::BasicColorizer<char> colorizer(colorScheme);
} // namespace
 
void singlePoint(std::unique_ptr<eonc::Matter> matter) {
  std::cout << "Energy:         " << std::fixed << std::setprecision(15)
            << matter->getPotentialEnergy() << std::endl;
  std::cout << "(free) Forces:         \n" << matter->getForcesFree() << "\n";
  std::cout << "Max atom force: " << std::scientific << matter->maxForce()
            << std::endl;
}
 
void minimize(std::unique_ptr<eonc::Matter> matter,
              const std::string &confileout) {
  matter->relax(false, false);
  if (confileout.empty()) {
    std::cout << "No output file specified, not saving" << std::endl;
    return;
  }
  std::cout << "Saving relaxed structure to " << confileout << std::endl;
  if (!eonc::io::io_ok(matter->matter2con(confileout))) {
    std::cerr << "Failed to write " << confileout << std::endl;
  }
}
 
void printFeatures() {
  std::cout << colorizer.heading("Compile-time features:") << std::endl;
  // Parse FEATURES_STRING and colorize enabled/disabled
  std::istringstream stream(FEATURES_STRING);
  std::string line;
  while (std::getline(stream, line)) {
    if (line.find(": enabled") != std::string::npos) {
      // Extract feature name and colorize "enabled" with warning (yellow)
      size_t colonPos = line.find(": ");
      if (colonPos != std::string::npos) {
        std::string featureName = line.substr(0, colonPos + 2);
        std::string status = line.substr(colonPos + 2);
        std::cout << featureName << colorizer.warning(status) << std::endl;
      } else {
        std::cout << line << std::endl;
      }
    } else if (line.find(": disabled") != std::string::npos) {
      // Extract feature name and colorize "disabled" with error (red)
      size_t colonPos = line.find(": ");
      if (colonPos != std::string::npos) {
        std::string featureName = line.substr(0, colonPos + 2);
        std::string status = line.substr(colonPos + 2);
        std::cout << featureName << colorizer.error(status) << std::endl;
      } else {
        std::cout << line << std::endl;
      }
    } else {
      std::cout << line << std::endl;
    }
  }
}
 
namespace eonc {
 
void commandLine(int argc, char **argv) {
  bool sflag = false, mflag = false, pflag = false, cflag = false;
  double optConvergedForce = 0.001;
  std::string potential;
  std::string confile;
  std::string confileout;
  std::string optimizer("cg");
 
#ifdef WITH_SERVE_MODE
  std::optional<std::string> config_path;
  std::optional<std::string> serve_spec;
  // Empty until the matching flag is passed. A value here makes has_value()
  // true, so -p alone takes the serve path and never reads a structure file.
  std::optional<std::string> serve_host;
  std::optional<uint16_t> serve_port;
  std::optional<size_t> replicas;
  std::optional<bool> gateway;
#endif
 
  auto params = Parameters{};
 
  const char *progname = (argc ? argv[0] : "eonclient");
 
  Argum::Parser parser;
 
  parser.add(Argum::Option("--help", "-h")
                 .help("show this help message and exit")
                 .handler([&]() {
                   // Format help with color
                   auto helpText = parser.formatHelp(progname);
                   std::cout << colorizer.heading("eOn Client - Help")
                             << "\n\n";
                   std::cout << helpText;
                   std::exit(EXIT_SUCCESS);
                 }));
 
  parser.add(Argum::Option("--version", "-v")
                 .help("Print version information")
                 .handler([&]() {
                   std::cout << VERSION_STRING << std::endl;
                   std::exit(EXIT_SUCCESS);
                 }));
 
  parser.add(Argum::Option("--features")
                 .help("Print compile-time features")
                 .handler([&]() {
                   printFeatures();
                   std::exit(EXIT_SUCCESS);
                 }));
 
  parser.add(Argum::Option("--minimize", "-m")
                 .help("Minimization of inputConfile saves to outputConfile")
                 .handler([&]() { mflag = true; }));
 
  parser.add(Argum::Option("--single", "-s")
                 .help("Single point energy of inputConfile")
                 .handler([&]() { sflag = true; }));
 
  parser.add(Argum::Option("--compare", "-c")
                 .help("Compare structures of inputConfile to outputConfile")
                 .handler([&]() { cflag = true; }));
 
  parser.add(
      Argum::Option("--optimizer", "-o")
          .argName("METHOD")
          .help("Optimization method")
          .handler([&](const std::string_view &value) { optimizer = value; }));
 
  parser.add(Argum::Option("--force", "-f")
                 .argName("VALUE")
                 .help("Convergence force")
                 .handler([&](const std::string_view &value) {
                   optConvergedForce = Argum::parseFloatingPoint<double>(value);
                 }));
 
  parser.add(
      Argum::Option("--tolerance", "-t")
          .argName("VALUE")
          .help("Distance tolerance")
          .handler([&](const std::string_view &value) {
            eonc::ParametersLoadAccess::structure_comparison_options(params)
                .distance_difference = Argum::parseFloatingPoint<double>(value);
          }));
 
  parser.add(Argum::Option("--potential", "-p")
                 .argName("POTENTIAL")
                 .help("The potential (e.g. qsc, lj, eam_al)")
                 .handler([&](const std::string_view &value) {
                   pflag = true;
                   potential = value;
                 }));
 
#ifdef WITH_SERVE_MODE
  parser.add(
      Argum::Option("--serve")
          .argName("SPEC")
          .help("Serve potential(s) over rgpot Cap'n Proto RPC. "
                "Spec: 'potential:port' or 'pot1:port1,pot2:port2'")
          .handler([&](const std::string_view &value) { serve_spec = value; }));
 
  parser.add(
      Argum::Option("--serve-host")
          .argName("HOST")
          .help("Host to bind RPC server(s) to")
          .handler([&](const std::string_view &value) { serve_host = value; }));
 
  parser.add(Argum::Option("--serve-port")
                 .argName("PORT")
                 .help("Port for single-potential serve mode (used with -p)")
                 .handler([&](const std::string_view &value) {
                   serve_port = Argum::parseIntegral<uint16_t>(value);
                 }));
 
  parser.add(Argum::Option("--replicas")
                 .argName("N")
                 .help("Number of replicated server instances (used with -p)")
                 .handler([&](const std::string_view &value) {
                   replicas = Argum::parseIntegral<size_t>(value);
                 }));
 
  parser.add(Argum::Option("--gateway")
                 .help("Run a single gateway port backed by N pool instances "
                       "(use with -p and --replicas)")
                 .handler([&]() { gateway = true; }));
 
  parser.add(Argum::Option("--config")
                 .argName("FILE")
                 .help("Config file for potential parameters (INI format, "
                       "e.g. [Metatomic] model_path=model.pt)")
                 .handler([&](const std::string_view &value) {
                   config_path = value;
                 }));
#endif
 
  // One value each: the partitioner hands a greedy zeroOrMoreTimes positional
  // every remaining argument, which leaves confileout empty and overwrites
  // confile with the last one.
  parser.add(
      Argum::Positional("confile")
          .help("Input structure file")
          .occurs(Argum::zeroOrOneTime)
          .handler([&](const std::string_view &value) { confile = value; }));
 
  parser.add(
      Argum::Positional("confileout")
          .help("Output structure file (optional)")
          .occurs(Argum::zeroOrOneTime)
          .handler([&](const std::string_view &value) { confileout = value; }));
 
  try {
    parser.parse(argc, argv);
  } catch (const Argum::ParsingException &ex) {
    std::cerr << colorizer.error(ex.message()) << '\n';
    std::cerr << colorizer.warning(parser.formatUsage(progname)) << '\n';
    std::exit(EXIT_FAILURE);
  }
 
  if (sflag && mflag) {
    std::cerr << colorizer.error(
        "Cannot specify both minimization and single point\n");
    std::exit(EXIT_FAILURE);
  }
 
  if (!pflag && (sflag || mflag)) {
    std::cerr << colorizer.error("Must specify a potential\n");
    std::exit(EXIT_FAILURE);
  }
 
  if (cflag && confileout.empty()) {
    std::cerr << colorizer.error(
        "Comparison needs two structure files: the input con file and the "
        "one to compare it against\n");
    std::cerr << colorizer.warning(parser.formatUsage(progname)) << '\n';
    std::exit(EXIT_FAILURE);
  }
 
#ifdef WITH_SERVE_MODE
  // Load config file if provided (for potential-specific parameters
  // like model_path, device, length_unit, etc.)
  if (config_path.has_value()) {
    std::ifstream config_file(config_path.value());
    if (!config_file.is_open()) {
      std::cerr << colorizer.error("Cannot open config file: ")
                << config_path.value() << '\n';
      std::exit(EXIT_FAILURE);
    }
    params.load(config_path.value());
  }
 
  // Handle --serve mode (does not require a con file)
  if (serve_spec.has_value()) {
    auto endpoints = parseServeSpec(serve_spec.value());
    if (endpoints.empty()) {
      std::cerr << colorizer.error("No valid serve endpoints in spec: ")
                << serve_spec.value() << '\n';
      std::exit(EXIT_FAILURE);
    }
    serveMultiple(endpoints, params);
    std::exit(EXIT_SUCCESS);
  }
 
  // Handle -p with serve flags (single potential serve mode).
  // Defaults are applied below with value_or; has_value() is the flag.
  if (pflag && !sflag && !mflag && !cflag &&
      (serve_host.has_value() || serve_port.has_value() ||
       replicas.has_value() || gateway.has_value())) {
    for (auto &ch : potential) {
      ch = std::tolower(static_cast<unsigned char>(ch));
    }
    eonc::ParametersLoadAccess::potential_options(params).potential =
        magic_enum::enum_cast<PotType>(potential, magic_enum::case_insensitive)
            .value_or(PotType::UNKNOWN);
    auto host = serve_host.value_or("localhost");
    auto port = serve_port.value_or(12345);
    auto reps = replicas.value_or(1);
    bool gw = gateway.value_or(false);
 
    if (gw) {
      serveGateway(params, host, port, reps);
    } else if (reps > 1) {
      serveReplicated(params, host, port, reps);
    } else {
      serveMode(params, host, port);
    }
    std::exit(EXIT_SUCCESS);
  }
 
  // Config-driven serve (no -p or --serve, just --config with [Serve])
  if (!pflag && !sflag && !mflag && !cflag && config_path.has_value() &&
      !serve_spec.has_value() &&
      (!eonc::ParametersLoadAccess::serve_options(params).endpoints.empty() ||
       eonc::ParametersLoadAccess::serve_options(params).gateway_port > 0 ||
       eonc::ParametersLoadAccess::serve_options(params).replicas > 1)) {
    serveFromConfig(params);
    std::exit(EXIT_SUCCESS);
  }
#endif
 
  // Serve modes take no structure file and have already exited above.
  if (confile.empty()) {
    std::cerr << colorizer.error(
        "At least one non-option argument is required: the con file\n");
    std::cerr << colorizer.warning(parser.formatUsage(progname)) << '\n';
    std::exit(EXIT_FAILURE);
  }
 
  if (!cflag) {
    for (auto &ch : potential) {
      ch = std::tolower(static_cast<unsigned char>(ch));
    }
  }
 
  if (!cflag) {
    eonc::ParametersLoadAccess::potential_options(params).potential =
        magic_enum::enum_cast<PotType>(potential, magic_enum::case_insensitive)
            .value_or(PotType::UNKNOWN);
  }
 
  if (!sflag) {
    eonc::ParametersLoadAccess::optimizer_options(params).method =
        magic_enum::enum_cast<OptType>(optimizer, magic_enum::case_insensitive)
            .value_or(OptType::CG);
    eonc::ParametersLoadAccess::optimizer_options(params).converged_force =
        optConvergedForce;
  }
 
  if (cflag) {
    // Matter copies structure_comparison_options into its own structComp in
    // the constructor, so the flag has to be set before the two below.
    eonc::ParametersLoadAccess::structure_comparison_options(params)
        .check_rotation = true;
  }
 
  auto pot = eonc::helpers::makePotential(params);
  auto matter = std::make_unique<Matter>(pot, params);
  auto matter2 = std::make_unique<Matter>(pot, params);
  if (!eonc::io::io_ok(matter->con2matter(confile))) {
    std::cerr << "Failed to load " << confile << std::endl;
    std::exit(EXIT_FAILURE);
  }
 
  if (sflag) {
    singlePoint(std::move(matter));
  } else if (mflag) {
    minimize(std::move(matter), confileout);
  } else if (cflag) {
    if (!eonc::io::io_ok(matter2->con2matter(confileout))) {
      std::cerr << "Failed to load " << confileout << std::endl;
      std::exit(EXIT_FAILURE);
    }
    Matter probe(*matter);
    if (probe.compare(*matter2, true)) {
      std::cout << "Structures match\n";
    } else {
      std::cout << colorizer.error("Structures do not match\n");
    }
  }
}
 
} // namespace eonc