main.cpp

Go to the documentation of this file.

#include <filesystem>
 
#include <CLI/CLI.hpp>
 
#include <polyfem/State.hpp>
#include <polyfem/legacy/State.hpp>
#ifdef POLYFEM_WITH_OPTIMIZATION
#include <polyfem/optimization/OptState.hpp>
#endif
 
#include <polyfem/utils/JSONUtils.hpp>
#include <polyfem/utils/Logger.hpp>
#include <polyfem/varforms/VarForm.hpp>
#include <polyfem/io/ResourceIO.hpp>
#include <polyfem/io/InputLoader.hpp>
#include <polyfem/io/Checkpoint.hpp>
#include <polyfem/varforms/VarFormFactory.hpp>
 
using namespace polyfem;
using namespace solver;
 
bool has_arg(const CLI::App &command_line, const std::string &value)
{
    const auto *opt = command_line.get_option_no_throw(value.size() == 1 ? ("-" + value) : ("--" + value));
    if (!opt)
        return false;
 
    return opt->count() > 0;
}
 
int forward_simulation(const CLI::App &command_line,
                       const io::ResourceIO &resources,
                       const std::string &output_dir,
                       const unsigned max_threads,
                       const bool is_strict,
                       const bool fallback_solver,
                       const spdlog::level::level_enum &log_level,
                       json &in_args);
 
int forward_simulation(const CLI::App &command_line,
                       const io::CheckpointReader &checkpoint,
                       const std::string &output_dir,
                       unsigned max_threads,
                       bool is_strict,
                       bool fallback_solver,
                       const spdlog::level::level_enum &log_level,
                       json &in_args);
 
#ifdef POLYFEM_WITH_OPTIMIZATION
int optimization_simulation(const CLI::App &command_line,
                            const io::ResourceIO &resources,
                            const unsigned max_threads,
                            const bool is_strict,
                            const spdlog::level::level_enum &log_level,
                            json &opt_args);
#endif
 
int run_forward_simulation(State &state);
 
int forward_simulation_with_varform_state(const io::ResourceIO &resources,
                                          json &in_args,
                                          const bool is_strict)
{
    State state;
    state.init(in_args, resources, is_strict);
    return run_forward_simulation(state);
}
 
int forward_simulation_with_varform_state(const io::CheckpointReader &checkpoint,
                                          const json &in_args,
                                          const bool is_strict)
{
    State state;
    state.init(in_args, checkpoint, is_strict);
    return run_forward_simulation(state);
}
 
int run_forward_simulation(State &state)
{
    state.load_mesh();
 
    Eigen::MatrixXd sol;
    state.solve(sol);
 
    state.variational_formulation->compute_errors(sol);
 
    io::OutRuntimeData timings = state.variational_formulation->output_timings();
    logger().info("total time: {}s", timings.total_time());
 
    state.variational_formulation->save_json(sol);
    state.variational_formulation->export_data(sol);
 
    return EXIT_SUCCESS;
}
 
int forward_simulation_with_legacy_state(const std::vector<std::string> &names,
                                         const std::vector<Eigen::MatrixXi> &cells,
                                         const std::vector<Eigen::MatrixXd> &vertices,
                                         json &in_args,
                                         const bool is_strict)
{
    legacy::State state;
    state.init(in_args, is_strict);
 
    logger().warn("Running forward simulation with legacy state.");
    state.load_mesh(/*non_conforming=*/false, names, cells, vertices);
 
    // Mesh was not loaded successfully; load_mesh() logged the error.
    if (state.mesh == nullptr)
    {
        // Cannot proceed without a mesh.
        return EXIT_FAILURE;
    }
 
    state.stats.compute_mesh_stats(*state.mesh);
 
    state.build_basis();
 
    state.assemble_rhs();
    state.assemble_mass_mat();
 
    Eigen::MatrixXd sol;
    Eigen::MatrixXd pressure;
 
    state.solve_problem(sol, pressure);
 
    state.compute_errors(sol);
 
    logger().info("total time: {}s", state.timings.total_time());
 
    state.save_json(sol);
    state.export_data(sol, pressure);
 
    return EXIT_SUCCESS;
}
 
int main(int argc, char **argv)
{
    using namespace polyfem;
 
    CLI::App command_line{"polyfem"};
 
    command_line.ignore_case();
    command_line.ignore_underscore();
 
    // Eigen::setNbThreads(1);
    unsigned max_threads = std::numeric_limits<unsigned>::max();
    command_line.add_option("--max_threads", max_threads, "Maximum number of threads");
 
    auto input = command_line.add_option_group("input");
 
    std::string json_file = "";
    input->add_option("-j,--json", json_file, "Simulation JSON file")->check(CLI::ExistingFile);
 
    std::string yaml_file = "";
    input->add_option("-y,--yaml", yaml_file, "Simulation YAML file")->check(CLI::ExistingFile);
 
    std::string hdf5_file = "";
    input->add_option("--hdf5", hdf5_file, "Simulation HDF5 file")->check(CLI::ExistingFile);
 
    std::string checkpoint_file = "";
    auto *checkpoint_option = input->add_option("--checkpoint", checkpoint_file, "Versioned PolyFEM checkpoint")->check(CLI::ExistingFile);
    bool checkpoint_reorder = false;
    command_line.add_flag(
                    "--checkpoint-reorder", checkpoint_reorder,
                    "Reorder checkpoint state from its saved input-node ordering")
        ->needs(checkpoint_option);
 
    input->require_option(1);
 
    std::string output_dir = "";
    command_line.add_option("-o,--output_dir", output_dir, "Directory for output files")->check(CLI::ExistingDirectory | CLI::NonexistentPath);
 
    bool is_strict = true;
    command_line.add_flag("-s,--strict_validation,!--ns,!--no_strict_validation", is_strict, "Disables strict validation of input JSON");
 
    bool fallback_solver = false;
    command_line.add_flag("--enable_overwrite_solver", fallback_solver, "If solver in input is not present, falls back to default.");
 
    const std::vector<std::pair<std::string, spdlog::level::level_enum>>
        SPDLOG_LEVEL_NAMES_TO_LEVELS = {
            {"trace", spdlog::level::trace},
            {"debug", spdlog::level::debug},
            {"info", spdlog::level::info},
            {"warning", spdlog::level::warn},
            {"error", spdlog::level::err},
            {"critical", spdlog::level::critical},
            {"off", spdlog::level::off}};
    spdlog::level::level_enum log_level = spdlog::level::debug;
    command_line.add_option("--log_level", log_level, "Log level")
        ->transform(CLI::CheckedTransformer(SPDLOG_LEVEL_NAMES_TO_LEVELS, CLI::ignore_case));
 
    CLI11_PARSE(command_line, argc, argv);
 
    json in_args = json({});
    if (!json_file.empty() || !yaml_file.empty())
    {
        const io::LoadedInput loaded = !json_file.empty()
                                           ? io::load_json_input(json_file)
                                           : io::load_yaml_input(yaml_file);
        in_args = loaded.config;
 
        if (in_args.contains("states"))
        {
#ifndef POLYFEM_WITH_OPTIMIZATION
            log_and_throw_error("PolyFEM was built without optimization support.");
#else
            return optimization_simulation(command_line, *loaded.resources, max_threads, is_strict, log_level, in_args);
#endif
        }
        else
            return forward_simulation(command_line, *loaded.resources, output_dir, max_threads,
                                      is_strict, fallback_solver, log_level, in_args);
    }
    else if (!hdf5_file.empty())
    {
        const io::LoadedInput loaded = io::load_hdf5_input(hdf5_file);
        in_args = loaded.config;
        return forward_simulation(command_line, *loaded.resources, output_dir, max_threads,
                                  is_strict, fallback_solver, log_level, in_args);
    }
    else
    {
        io::CheckpointReader checkpoint(checkpoint_file);
        in_args = checkpoint.config();
        return forward_simulation(command_line, checkpoint, output_dir, max_threads,
                                  is_strict, fallback_solver, log_level, in_args);
    }
}
 
int forward_simulation(const CLI::App &command_line,
                       const io::ResourceIO &resources,
                       const std::string &output_dir,
                       const unsigned max_threads,
                       const bool is_strict,
                       const bool fallback_solver,
                       const spdlog::level::level_enum &log_level,
                       json &in_args)
{
    if (in_args.empty())
    {
        logger().error("No input file specified!");
        return command_line.exit(CLI::RequiredError("--json or --hdf5"));
    }
 
    json tmp = json::object();
    if (has_arg(command_line, "log_level"))
        tmp["/output/log/level"_json_pointer] = int(log_level);
    if (has_arg(command_line, "max_threads"))
        tmp["/solver/max_threads"_json_pointer] = max_threads;
    if (has_arg(command_line, "output_dir"))
        tmp["/output/directory"_json_pointer] = std::filesystem::absolute(output_dir);
    if (has_arg(command_line, "enable_overwrite_solver"))
        tmp["/solver/linear/enable_overwrite_solver"_json_pointer] = fallback_solver;
    assert(tmp.is_object());
    in_args.merge_patch(tmp);
 
    const std::string checkpoint_path =
        in_args.contains("/input/checkpoint/path"_json_pointer)
            ? in_args["/input/checkpoint/path"_json_pointer].get<std::string>()
            : std::string();
    if (!checkpoint_path.empty())
    {
        const std::filesystem::path path = std::filesystem::path(checkpoint_path).is_absolute()
                                               ? std::filesystem::path(checkpoint_path)
                                               : resources.host_directory() / checkpoint_path;
        io::CheckpointReader checkpoint(path.lexically_normal());
        json continuation = checkpoint.config();
        continuation["input"]["checkpoint"]["path"] = "";
        continuation["input"]["checkpoint"]["reorder"] =
            in_args.contains("/input/checkpoint/reorder"_json_pointer)
                ? in_args["/input/checkpoint/reorder"_json_pointer].get<bool>()
                : false;
        return forward_simulation(
            command_line, checkpoint, output_dir, max_threads,
            is_strict, fallback_solver, log_level, continuation);
    }
 
    if (varform::uses_varform_state(in_args, resources))
        return forward_simulation_with_varform_state(resources, in_args, is_strict);
 
    if (dynamic_cast<const io::HDF5IO *>(&resources) != nullptr)
        log_and_throw_error("HDF5 resources are supported only by the non-legacy State.");
    in_args["root_path"] = resources.describe("");
 
    return forward_simulation_with_legacy_state({}, {}, {}, in_args, is_strict);
}
 
int forward_simulation(const CLI::App &command_line,
                       const io::CheckpointReader &checkpoint,
                       const std::string &output_dir,
                       const unsigned max_threads,
                       const bool is_strict,
                       const bool fallback_solver,
                       const spdlog::level::level_enum &log_level,
                       json &in_args)
{
    if (!varform::uses_varform_state(in_args, checkpoint.resources()))
        log_and_throw_error("Checkpoints are supported only by the non-legacy State.");
 
    json tmp = json::object();
    if (has_arg(command_line, "log_level"))
        tmp["/output/log/level"_json_pointer] = int(log_level);
    if (has_arg(command_line, "max_threads"))
        tmp["/solver/max_threads"_json_pointer] = max_threads;
    if (has_arg(command_line, "output_dir"))
        tmp["/output/directory"_json_pointer] = std::filesystem::absolute(output_dir);
    if (has_arg(command_line, "enable_overwrite_solver"))
        tmp["/solver/linear/enable_overwrite_solver"_json_pointer] = fallback_solver;
    if (has_arg(command_line, "checkpoint-reorder"))
        tmp["/input/checkpoint/reorder"_json_pointer] = true;
    in_args.merge_patch(tmp);
 
    return forward_simulation_with_varform_state(checkpoint, in_args, is_strict);
}
 
#ifdef POLYFEM_WITH_OPTIMIZATION
int optimization_simulation(const CLI::App &command_line,
                            const io::ResourceIO &resources,
                            const unsigned max_threads,
                            const bool is_strict,
                            const spdlog::level::level_enum &log_level,
                            json &opt_args)
{
    json tmp = json::object();
    if (has_arg(command_line, "log_level"))
        tmp["/output/log/level"_json_pointer] = int(log_level);
    if (has_arg(command_line, "max_threads"))
        tmp["/solver/max_threads"_json_pointer] = max_threads;
    opt_args.merge_patch(tmp);
 
    OptState opt_state;
    return opt_state.run(opt_args, resources, is_strict);
}
#endif