main.cpp File Reference

#include "inp/deckIncludes.h"
#include "material/materialUtil.h"
#include "periDEMModel.h"
#include "util/io.h"
#include "util/parallelUtil.h"
#include "util/point.h"
#include <cmath>
#include <cstdlib>
#include <filesystem>
#include <format>
#include <fstream>
#include <memory>
#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}::CrackMetrics
struct	anonymous_namespace{main.cpp}::LawResult

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_file, double L, double mesh_size, double horizon, double final_time, size_t num_steps, const std::string &self_contact)
size_t	anonymous_namespace{main.cpp}::applyPrecrack (PeriDEMModel &dem, double x_crack)
void	anonymous_namespace{main.cpp}::applyRigidOpenClose (PeriDEMModel &dem, double x_crack, double u_right)
CrackMetrics	anonymous_namespace{main.cpp}::measure (PeriDEMModel &dem, double x_crack, double band)
LawResult	anonymous_namespace{main.cpp}::runLaw (const std::string &self_contact, const std::filesystem::path &run_dir, double L, double mesh_size, double horizon, unsigned n_threads, bool deck_only=false)
int	main (int argc, char *argv[])

Function Documentation

main()

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

Definition at line 280 of file main.cpp.

                                 {
  util::parallel::initMpi(argc, argv);
  util::io::InputParser input(argc, argv);
 
  unsigned int n_threads = 2;
  if (input.cmdOptionExists("-nThreads"))
    n_threads = static_cast<unsigned>(std::stoi(input.getCmdOption("-nThreads")));
  util::parallel::initNThreads(n_threads);
 
  namespace fs = std::filesystem;
  fs::path base = fs::current_path() / "self_contact_mode1_run";
  if (input.cmdOptionExists("-outputDir"))
    base = input.getCmdOption("-outputDir");
 
  const double L = 0.002;
  const double mesh_size = L / 6.0;
  const double horizon = 3.0 * mesh_size;
 
  LawResult bb;
  LawResult rg;
  try {
    const bool deck_only = input.cmdOptionExists("-deckOnly");
    bb = runLaw("broken_bond_kn", base / "broken_bond_kn", L, mesh_size, horizon,
                n_threads, deck_only);
    rg = runLaw("reference_gap", base / "reference_gap", L, mesh_size, horizon,
                n_threads, deck_only);
    if (deck_only)
      return EXIT_SUCCESS;
  } catch (const std::exception &e) {
    util::io::print(std::format("self-contact Mode-I failed: {}\n", e.what()));
    return 1;
  }
 
  if (!(bb.close_force_amp > 0.) || !(rg.close_force_amp > 0.)) {
    util::io::print(std::format(
        "close did not activate self-contact: F_bb={}, F_rg={}\n", bb.close_force_amp,
        rg.close_force_amp));
    return 1;
  }
 
  const double fmax = std::max(bb.close_force_amp, rg.close_force_amp);
  const double rel = std::abs(bb.close_force_amp - rg.close_force_amp) / fmax;
  if (!(rel > 0.05)) {
    util::io::print(std::format(
        "self-contact laws did not differ enough under close: F_bb={}, F_rg={}, rel={}\n",
        bb.close_force_amp, rg.close_force_amp, rel));
    return 1;
  }
 
  util::io::print(std::format(
      "self-contact Mode-I OK: open gaps bb={}/rg={}, close forces bb={}/rg={}, rel_diff={}\n", bb.open_min_gap,
      rg.open_min_gap, bb.close_force_amp, rg.close_force_amp, rel));
  return 0;
}

References util::io::InputParser::cmdOptionExists(), util::io::InputParser::getCmdOption(), util::parallel::initMpi(), util::parallel::initNThreads(), main(), util::io::print(), and anonymous_namespace{main.cpp}::runLaw().

Here is the call graph for this function: