smash.cc File Reference

#include <getopt.h>
#include <set>
#include <sstream>
#include <vector>
#include <boost/filesystem/fstream.hpp>
#include "smash/cxx14compat.h"
#include "smash/decaymodes.h"
#include "smash/experiment.h"
#include "smash/filelock.h"
#include "smash/inputfunctions.h"
#include "smash/random.h"
#include "smash/scatteractionsfinder.h"
#include "smash/stringfunctions.h"
#include "smash/config.h"

Go to the source code of this file.

Classes
struct	smash::anonymous_namespace{smash.cc}::OutputDirectoryExists
	Exception class that is thrown, if the requested output directory already exists and -f was not specified on the command line. More...
struct	smash::anonymous_namespace{smash.cc}::OutputDirectoryOutOfIds
	Exception class that is thrown, if no new output path can be generated (there is a directory name for each positive integer value) More...

Namespaces
	smash
	smash::anonymous_namespace{smash.cc}

Functions
void	smash::anonymous_namespace{smash.cc}::print_disclaimer ()
	Print the disclaimer. More...
bf::path	smash::anonymous_namespace{smash.cc}::default_output_path ()
void	smash::anonymous_namespace{smash.cc}::ensure_path_is_valid (const bf::path &path)
	Ensures the output path is valid. More...
ScatterActionsFinder	smash::anonymous_namespace{smash.cc}::actions_finder_for_dump (Configuration configuration)
	Prepares ActionsFinder for cross-section and reaction dumps. More...
void	smash::anonymous_namespace{smash.cc}::check_config_version_is_compatible (Configuration configuration)
	Checks if the SMASH version is compatible with the version of the configuration file. More...
int	main (int argc, char *argv[])
	Main program Smashes Many Accelerated Strongly-Interacting Hadrons :-) More...

Function Documentation

main()

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

Main program Smashes Many Accelerated Strongly-Interacting Hadrons :-)

Do command line parsing and hence decides modus

Parameters

[in]	argc	Number of arguments on command-line
[in]	argv	List of arguments on command-line

Returns

Either 0 or EXIT_FAILURE.

Definition at line 333 of file smash.cc.

                                 {
  using namespace smash;  // NOLINT(build/namespaces)

  const auto &log = logger<LogArea::Main>();

  constexpr option longopts[] = {
      {"config", required_argument, 0, 'c'},
      {"decaymodes", required_argument, 0, 'd'},
      {"endtime", required_argument, 0, 'e'},
      {"force", no_argument, 0, 'f'},
      {"help", no_argument, 0, 'h'},
      {"inputfile", required_argument, 0, 'i'},
      {"modus", required_argument, 0, 'm'},
      {"particles", required_argument, 0, 'p'},
      {"output", required_argument, 0, 'o'},
      {"list-2-to-n", no_argument, 0, 'l'},
      {"resonance", required_argument, 0, 'r'},
      {"cross-sections", required_argument, 0, 's'},
      {"cross-sections-fs", required_argument, 0, 'S'},
      {"version", no_argument, 0, 'v'},
      {nullptr, 0, 0, 0}};

  // strip any path to progname
  const std::string progname = bf::path(argv[0]).filename().native();

  try {
    bool force_overwrite = false;
    bf::path output_path = default_output_path(), input_path("./config.yaml");
    std::vector<std::string> extra_config;
    char *particles = nullptr, *decaymodes = nullptr, *modus = nullptr,
         *end_time = nullptr, *pdg_string = nullptr, *cs_string = nullptr;
    bool list2n_activated = false;
    bool resonance_dump_activated = false;
    bool cross_section_dump_activated = false;
    bool final_state_cross_sections = false;

    // parse command-line arguments
    int opt;
    bool suppress_disclaimer = false;
    while ((opt = getopt_long(argc, argv, "c:d:e:fhi:m:p:o:lr:s:S:v", longopts,
                              nullptr)) != -1) {
      switch (opt) {
        case 'c':
          extra_config.emplace_back(optarg);
          break;
        case 'd':
          decaymodes = optarg;
          break;
        case 'f':
          force_overwrite = true;
          break;
        case 'i':
          input_path = optarg;
          break;
        case 'h':
          usage(EXIT_SUCCESS, progname);
          break;
        case 'm':
          modus = optarg;
          break;
        case 'p':
          particles = optarg;
          break;
        case 'e':
          end_time = optarg;
          break;
        case 'o':
          output_path = optarg;
          break;
        case 'l':
          list2n_activated = true;
          suppress_disclaimer = true;
          break;
        case 'r':
          resonance_dump_activated = true;
          pdg_string = optarg;
          suppress_disclaimer = true;
          break;
        case 'S':
          final_state_cross_sections = true;
          // fallthrough
        case 's':
          cross_section_dump_activated = true;
          cs_string = optarg;
          suppress_disclaimer = true;
          break;
        case 'v':
          std::printf(
              "%s\n"
              "Branch   : %s\nSystem   : %s\nCompiler : %s %s\n"
              "Build    : %s\nDate     : %s\n",
              VERSION_MAJOR, GIT_BRANCH, CMAKE_SYSTEM, CMAKE_CXX_COMPILER_ID,
              CMAKE_CXX_COMPILER_VERSION, CMAKE_BUILD_TYPE, BUILD_DATE);
          std::exit(EXIT_SUCCESS);
        default:
          usage(EXIT_FAILURE, progname);
      }
    }

    // Abort if there are unhandled arguments left.
    if (optind < argc) {
      std::cout << argv[0] << ": invalid argument -- '" << argv[optind]
                << "'\n";
      usage(EXIT_FAILURE, progname);
    }

    if (!suppress_disclaimer) {
      print_disclaimer();
    }

    setup_default_float_traps();

    // Read in config file
    Configuration configuration(input_path.parent_path(),
                                input_path.filename());
    for (const auto &config : extra_config) {
      configuration.merge_yaml(config);
    }

    // check if version matches before doing anything else
    check_config_version_is_compatible(configuration);

    if (particles) {
      if (!bf::exists(particles)) {
        std::stringstream err;
        err << "The particles file was expected at '" << particles
            << "', but the file does not exist.";
        throw std::runtime_error(err.str());
      }
      std::string particle_string = read_all(bf::ifstream{particles});
      if (has_crlf_line_ending(particle_string)) {
        std::stringstream err;
        err << "The particles file has CR LF line endings. Please use LF"
               " line endings.";
        throw std::runtime_error(err.str());
      }
      configuration["particles"] = particle_string;
    }
    if (decaymodes) {
      if (!bf::exists(decaymodes)) {
        std::stringstream err;
        err << "The decay modes file was expected at '" << decaymodes
            << "', but the file does not exist.";
        throw std::runtime_error(err.str());
      }
      std::string decay_string = read_all(bf::ifstream{decaymodes});
      if (has_crlf_line_ending(decay_string)) {
        std::stringstream err;
        err << "The decay mode file has CR LF line endings. Please use LF"
               " line endings.";
        throw std::runtime_error(err.str());
      }
      configuration["decaymodes"] = decay_string;
    }
    if (list2n_activated) {
      /* Print only 2->n, n > 1. Do not dump decays, which can be found in
       * decaymodes.txt anyway */
      configuration.merge_yaml("{Collision_Term: {Two_to_One: False}}");
      ParticleType::create_type_list(configuration.take({"particles"}));
      DecayModes::load_decaymodes(configuration.take({"decaymodes"}));
      ParticleType::check_consistency();
      auto scat_finder = actions_finder_for_dump(configuration);
      scat_finder.dump_reactions();
      std::exit(EXIT_SUCCESS);
    }
    if (resonance_dump_activated) {
      ParticleType::create_type_list(configuration.take({"particles"}));
      DecayModes::load_decaymodes(configuration.take({"decaymodes"}));
      ParticleType::check_consistency();
      PdgCode pdg(pdg_string);
      const ParticleType &res = ParticleType::find(pdg);
      res.dump_width_and_spectral_function();
      std::exit(EXIT_SUCCESS);
    }
    if (cross_section_dump_activated) {
      ParticleType::create_type_list(configuration.take({"particles"}));
      DecayModes::load_decaymodes(configuration.take({"decaymodes"}));
      ParticleType::check_consistency();
      std::string arg_string(cs_string);
      std::vector<std::string> args = split(arg_string, ',');
      const unsigned int n_arg = args.size();
      if (n_arg < 2 || n_arg > 4) {
        throw std::invalid_argument("-s usage: pdg1,pdg2[,m1][,m2]");
      }
      PdgCode pdg_a(args[0]), pdg_b(args[1]);
      const ParticleType &a = ParticleType::find(pdg_a);
      const ParticleType &b = ParticleType::find(pdg_b);
      for (unsigned int i = 0; i < 4 - n_arg; i++) {
        args.push_back("");
      }
      double ma = (args[2] == "") ? a.mass() : std::stod(args[2]);
      double mb = (args[3] == "") ? b.mass() : std::stod(args[3]);
      if (a.is_stable() && args[2] != "") {
        ma = a.mass();
        std::cout << "Warning: pole mass is used for stable particle "
                  << a.name() << " instead of " << args[2] << std::endl;
      }
      if (b.is_stable() && args[3] != "") {
        mb = b.mass();
        std::cout << "Warning: pole mass is used for stable particle "
                  << b.name() << " instead of " << args[3] << std::endl;
      }
      auto scat_finder = actions_finder_for_dump(configuration);
      scat_finder.dump_cross_sections(a, b, ma, mb, final_state_cross_sections);
      std::exit(EXIT_SUCCESS);
    }
    if (modus) {
      configuration["General"]["Modus"] = std::string(modus);
    }
    if (end_time) {
      configuration["General"]["End_Time"] = std::abs(std::atof(end_time));
    }

    // Set up logging
    set_default_loglevel(
        configuration.take({"Logging", "default"}, einhard::ALL));
    create_all_loggers(configuration["Logging"]);

    int64_t seed = configuration.read({"General", "Randomseed"});
    if (seed < 0) {
      // Seed with a truly random 63-bit value, if possible
      std::random_device rd;
      static_assert(std::is_same<decltype(rd()), uint32_t>::value,
                    "random_device is assumed to generate uint32_t");
      uint64_t unsigned_seed =
          (static_cast<uint64_t>(rd()) << 32) | static_cast<uint64_t>(rd());
      // Discard the highest bit to make sure it fits into a positive int64_t
      seed = static_cast<int64_t>(unsigned_seed >> 1);
      configuration["General"]["Randomseed"] = seed;
    }

    // Check output path
    ensure_path_is_valid(output_path);
    const bf::path lock_path = output_path / "smash.lock";
    FileLock lock(lock_path);
    if (!lock.acquire()) {
      throw std::runtime_error(
          "Another instance of SMASH is already writing to the specified "
          "output directory. If you are sure this is not the case, remove \"" +
          lock_path.native() + "\".");
    }
    log.debug("output path: ", output_path);
    if (!force_overwrite && bf::exists(output_path / "config.yaml")) {
      throw std::runtime_error(
          "Output directory would get overwritten. Select a different output "
          "directory, clean up, or tell SMASH to ignore existing files.");
    }

    /* Keep a copy of the configuration that was used in the output directory
     * also save information about SMASH build as a comment */
    bf::ofstream(output_path / "config.yaml")
        << "# " << VERSION_MAJOR << '\n'
        << "# Branch   : " << GIT_BRANCH << '\n'
        << "# System   : " << CMAKE_SYSTEM << '\n'
        << "# Compiler : " << CMAKE_CXX_COMPILER_ID << ' '
        << CMAKE_CXX_COMPILER_VERSION << '\n'
        << "# Build    : " << CMAKE_BUILD_TYPE << '\n'
        << "# Date     : " << BUILD_DATE << '\n'
        << configuration.to_string() << '\n';

    log.trace(source_location, " create ParticleType and DecayModes");
    ParticleType::create_type_list(configuration.take({"particles"}));
    DecayModes::load_decaymodes(configuration.take({"decaymodes"}));
    ParticleType::check_consistency();

    // Create an experiment
    log.trace(source_location, " create Experiment");
    auto experiment = ExperimentBase::create(configuration, output_path);
    //
    // version value is not used in experiment. Get rid of it to prevent
    // warning.
    configuration.take({"Version"});
    const std::string report = configuration.unused_values_report();

    if (report != "{}") {
      throw std::runtime_error(
          "The following configuration values were not used:\n" + report);
    }

    // Run the experiment
    log.trace(source_location, " run the Experiment");
    experiment->run();
  } catch (std::exception &e) {
    log.fatal() << "SMASH failed with the following error:\n" << e.what();
    return EXIT_FAILURE;
  }

  log.trace() << source_location << " about to return from main";
  return 0;
}

Here is the call graph for this function: