main.cpp File Reference

#include "geom/geomObjectsUtil.h"
#include "inp/deckIncludes.h"
#include "material/materialUtil.h"
#include "periDEMModel.h"
#include "util/function.h"
#include "util/io.h"
#include <algorithm>
#include <cmath>
#include <filesystem>
#include <format>
#include <fstream>
#include <limits>
#include <random>
#include <stdexcept>
#include <string>
#include <thread>
#include <vector>

Include dependency graph for main.cpp:

Go to the source code of this file.

Data Structures
struct	anonymous_namespace{main.cpp}::PackedParticle
struct	anonymous_namespace{main.cpp}::PackedBounds

Namespaces
namespace	anonymous_namespace{main.cpp}

Functions
std::string	anonymous_namespace{main.cpp}::directoryPathWithTrailingSep (const std::filesystem::path &dir)
double	anonymous_namespace{main.cpp}::maxElem (const std::vector< double > &v)
bool	anonymous_namespace{main.cpp}::doesParticleIntersect (const PackedParticle &p, const std::vector< PackedParticle > &existing, const std::vector< double > &rect, double padding)
std::vector< PackedParticle >	anonymous_namespace{main.cpp}::generateParticleLocations (const std::vector< double > &in_rect, double max_y, double mesh_size, double R, int N_target, double padding, std::mt19937 &gen)
PackedBounds	anonymous_namespace{main.cpp}::packedAxisBounds (const std::vector< PackedParticle > &packed)
json	anonymous_namespace{main.cpp}::contactPairJson (double R_contact_factor, bool damping_on, bool friction_on, double Kn, double beta_n_eps, double friction_coeff, double Kn_factor, double beta_n_factor)
double	anonymous_namespace{main.cpp}::KnFromBulk (double Ka, double Kb, double horizon)
json	anonymous_namespace{main.cpp}::buildInputJson (const std::string &output_path_for_deck, const std::filesystem::path &inp_dir, int argc, char *argv[])
int	main (int argc, char *argv[])

Function Documentation

main()

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

Definition at line 491 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 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_for_deck = directoryPathWithTrailingSep(out_dir);
 
  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()));
 
  auto inputJson = buildInputJson(output_path_for_deck, inp_dir, argc, argv);
 
  const fs::path input_json_path = inp_dir / "input.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("Wrote deck to {}\n", fs::absolute(input_json_path).string()));
 
  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(), util::io::InputParser::getCmdOption(), util::parallel::getMpiStatus(), util::parallel::getNThreads(), util::parallel::initMpi(), util::parallel::initNThreads(), util::parallel::mpiRank(), util::parallel::mpiSize(), util::io::print(), and PeriDEMModel::run().

Here is the call graph for this function: