main.cpp File Reference

#include "geom/geomObjectsUtil.h"
#include "inp/deckIncludes.h"
#include "util/io.h"
#include "util/function.h"
#include "material/materialUtil.h"
#include "periDEMModel.h"
#include <cmath>
#include <filesystem>
#include <format>
#include <fstream>
#include <stdexcept>
#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)
bool	anonymous_namespace{main.cpp}::is3DGeometry (const std::string &g)
bool	anonymous_namespace{main.cpp}::isAcceptableGeometryName (const std::string &g)
json	anonymous_namespace{main.cpp}::buildInputJson (const std::string &geomName, const std::string &output_path_for_deck, const std::filesystem::path &mesh_file_1, const std::filesystem::path &mesh_file_2)
int	main (int argc, char *argv[])

Function Documentation

main()

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

Definition at line 276 of file main.cpp.

                                 {
 
  util::parallel::initMpi(argc, argv);
  int mpiSize = util::parallel::mpiSize(), mpiRank = util::parallel::mpiRank();
  util::io::print(std::format("Initialized MPI. MPI size = {}, MPI rank = {}\n", mpiSize, mpiRank));
  util::io::print(util::parallel::getMpiStatus()->printStr());
 
  util::io::InputParser input(argc, argv);
 
  unsigned int nThreads;
  if (input.cmdOptionExists("-nThreads"))
    nThreads = std::stoi(input.getCmdOption("-nThreads"));
  else {
    nThreads = std::thread::hardware_concurrency();
    util::io::print(std::format("Running test with default number of threads = {}\n", nThreads));
  }
  util::parallel::initNThreads(nThreads);
  util::io::print(std::format("Number of threads = {}\n", util::parallel::getNThreads()));
 
  namespace fs = std::filesystem;
  const fs::path cwd = fs::current_path();
 
  fs::path run_base = cwd;
  if (input.cmdOptionExists("-outputDir")) {
    fs::path p = input.getCmdOption("-outputDir");
    run_base = p.is_absolute() ? std::move(p) : cwd / p;
  }
 
  fs::path inp_base = run_base;
  if (input.cmdOptionExists("-inputDir")) {
    fs::path p = input.getCmdOption("-inputDir");
    inp_base = p.is_absolute() ? std::move(p) : cwd / p;
  }
 
  std::vector<std::string> geometriesToRun;
  if (input.cmdOptionExists("-allGeometries")) {
    geometriesToRun = geom::getAcceptableGeometries();
    util::io::print("twop_general_inbuilt: -allGeometries — running full geometry list.\n");
  } else if (input.cmdOptionExists("-geometry")) {
    const std::string g = input.getCmdOption("-geometry");
    if (!isAcceptableGeometryName(g))
      throw std::runtime_error(
          "twop_general_inbuilt: -geometry \"" + g +
          "\" is not in geom::acceptable_geometries.");
    geometriesToRun = {g};
    util::io::print(std::format("twop_general_inbuilt: single geometry = {}.\n", g));
  } else {
    geometriesToRun = {"circle"};
    util::io::print("twop_general_inbuilt: default geometry = circle (use -geometry <name> or -allGeometries).\n");
  }
 
  for (const std::string &geomName : geometriesToRun) {
    util::io::print(std::format("--- twop_general_inbuilt: geometry = {} ---\n", geomName));
 
    const fs::path out_dir = run_base / geomName / "out";
    const fs::path inp_dir = inp_base / geomName / "inp";
    fs::create_directories(out_dir);
    fs::create_directories(inp_dir);
 
    const std::string output_path_for_deck = directoryPathWithTrailingSep(out_dir);
 
    const fs::path mesh1 = inp_dir / (std::string("mesh_gen_1_") + geomName + ".msh");
    const fs::path mesh2 = inp_dir / (std::string("mesh_gen_2_") + geomName + ".msh");
 
    auto inputJson = buildInputJson(geomName, output_path_for_deck, mesh1, mesh2);
 
    const fs::path input_json_path = inp_dir / (std::string("input_") + geomName + ".json");
    {
      std::ofstream os(input_json_path);
      if (!os)
        throw std::runtime_error("Failed to open " + input_json_path.string() + " for writing.");
      os << inputJson.dump(2);
    }
    util::io::print(std::format("Output directory (VTU, log.txt): {}\n", fs::absolute(out_dir).string()));
    util::io::print(std::format("Input directory (input.json, meshes): {}\n", fs::absolute(inp_dir).string()));
    util::io::print(std::format("Wrote deck to {}\n", fs::absolute(input_json_path).string()));
 
    // -deckOnly stops after the deck is written. The deck comparison reads the
    // deck and does not need this driver to run the simulation. Each geometry
    // writes its own deck, so this continues rather than returns.
    if (input.cmdOptionExists("-deckOnly"))
      continue;
 
    auto deck = std::make_shared<inp::Input>(inputJson);
 
    PeriDEMModel dem(deck);
    dem.run(deck);
  }
 
  return EXIT_SUCCESS;
}

References anonymous_namespace{main.cpp}::buildInputJson(), util::io::InputParser::cmdOptionExists(), geom::getAcceptableGeometries(), util::io::InputParser::getCmdOption(), util::parallel::getMpiStatus(), util::parallel::getNThreads(), util::parallel::initMpi(), util::parallel::initNThreads(), anonymous_namespace{main.cpp}::isAcceptableGeometryName(), main(), util::parallel::mpiRank(), util::parallel::mpiSize(), util::io::print(), and PeriDEMModel::run().

Here is the call graph for this function: