main.cpp File Reference

#include "inp/deckIncludes.h"
#include "material/materialUtil.h"
#include "periDEMModel.h"
#include "util/function.h"
#include "util/io.h"
#include "util/parallelUtil.h"
#include <cmath>
#include <cstdlib>
#include <filesystem>
#include <format>
#include <fstream>
#include <iomanip>
#include <memory>
#include <stdexcept>
#include <string>
#include <thread>
#include <vector>

Include dependency graph for main.cpp:

Go to the source code of this file.

Namespaces
namespace	anonymous_namespace{main.cpp}

Functions
std::string	anonymous_namespace{main.cpp}::directoryPathWithTrailingSep (const std::filesystem::path &dir)
json	anonymous_namespace{main.cpp}::buildInputJson (const std::string &output_path, const std::filesystem::path &mesh_tri, const std::filesystem::path &mesh_ell, double final_time, size_t num_steps, double mesh_size, double horizon)
int	main (int argc, char *argv[])

Function Documentation

main()

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 264 of file main.cpp.

                                 {
  util::parallel::initMpi(argc, argv);
  util::io::InputParser input(argc, argv);
 
  unsigned int n_threads = std::thread::hardware_concurrency();
  if (input.cmdOptionExists("-nThreads"))
    n_threads = std::stoul(input.getCmdOption("-nThreads"));
  util::parallel::initNThreads(n_threads);
  util::io::print(std::format("Number of threads = {}\n", util::parallel::getNThreads()));
 
  double final_time = 0.0030;
  size_t num_steps = 30000;
  if (input.cmdOptionExists("-finalTime"))
    final_time = std::stod(input.getCmdOption("-finalTime"));
  if (input.cmdOptionExists("-numSteps"))
    num_steps = std::stoul(input.getCmdOption("-numSteps"));
 
  const double mesh_size = 0.00010;
  const double horizon = 3.0 * mesh_size;
 
  namespace fs = std::filesystem;
  const fs::path cwd = fs::current_path();
  fs::path out_dir = cwd / "out";
  fs::path inp_dir = cwd / "inp";
  if (input.cmdOptionExists("-outputDir")) {
    fs::path p = input.getCmdOption("-outputDir");
    out_dir = p.is_absolute() ? std::move(p) : cwd / p;
  }
  if (input.cmdOptionExists("-inputDir")) {
    fs::path p = input.getCmdOption("-inputDir");
    inp_dir = p.is_absolute() ? std::move(p) : cwd / p;
  } else if (input.cmdOptionExists("-outputDir")) {
    inp_dir = out_dir.parent_path() / "inp";
  }
  fs::create_directories(out_dir);
  fs::create_directories(inp_dir);
 
  const std::string output_path = directoryPathWithTrailingSep(out_dir);
  const fs::path mesh_tri = inp_dir / "mesh_triangle.msh";
  const fs::path mesh_ell = inp_dir / "mesh_hollow_ellipse.msh";
 
  auto j = buildInputJson(output_path, mesh_tri, mesh_ell, final_time, num_steps, mesh_size,
                          horizon);
  {
    std::ofstream ofs(inp_dir / "input.json");
    ofs << std::setw(2) << j << std::endl;
  }
 
  // -deckOnly stops after the deck is written. The Python comparison reads
  // the deck and does not need this driver to run the simulation.
  if (input.cmdOptionExists("-deckOnly")) {
    util::io::print("deck written; -deckOnly, not running\n");
    util::parallel::finalizeMpi();
    return 0;
  }
 
  // Hard check: deck must request a hollow ellipse, not a rectangle plate.
  if (j["Particle"]["Set_2"]["Type"] != "ellipse_minus_ellipse")
    throw std::runtime_error("ellipse_triangle: Particle Set_2 must be ellipse_minus_ellipse");
 
  util::io::print(std::format(
      "[ellipse_triangle] Type={}, T={}, Nt={}, mesh={:.4e}, out={}\n",
      j["Particle"]["Set_2"]["Type"].get<std::string>(), final_time, num_steps, mesh_size,
      out_dir.string()));
 
  auto deck = std::make_shared<inp::Input>(j);
  PeriDEMModel dem(deck);
  dem.run(deck);
 
  return 0;
}

References anonymous_namespace{main.cpp}::buildInputJson(), util::io::InputParser::cmdOptionExists(), anonymous_namespace{main.cpp}::directoryPathWithTrailingSep(), util::parallel::finalizeMpi(), util::io::InputParser::getCmdOption(), util::parallel::getNThreads(), util::parallel::initMpi(), util::parallel::initNThreads(), main(), util::io::print(), and PeriDEMModel::run().

Here is the call graph for this function: