smash.cc File Reference

#include <getopt.h>
#include <filesystem>
#include <set>
#include <sstream>
#include <vector>
#include "smash/decaymodes.h"
#include "smash/experiment.h"
#include "smash/filelock.h"
#include "smash/random.h"
#include "smash/scatteractionsfinder.h"
#include "smash/setup_particles_decaymodes.h"
#include "smash/sha256.h"
#include "smash/stringfunctions.h"
#include "smash/config.h"
#include "smash/library.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}::usage (const int rc, const std::string &progname)
	Prints usage information and exits the program. More...
void	smash::anonymous_namespace{smash.cc}::print_disclaimer ()
	Print the disclaimer. More...
std::filesystem::path	smash::anonymous_namespace{smash.cc}::default_output_path ()
void	smash::anonymous_namespace{smash.cc}::ensure_path_is_valid (const std::filesystem::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_for_unused_config_values (const Configuration &configuration)
	Checks if there are unused config values. More...
void	smash::anonymous_namespace{smash.cc}::ignore_simulation_config_values (Configuration &configuration)
	Remove all config values that are only needed for simulations. 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 438 of file smash.cc.

                                 {
  using namespace smash;  // NOLINT(build/namespaces)
 
  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'},
      {"tabulations", required_argument, 0, 't'},
      {"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'},
      {"dump-iSS", no_argument, 0, 'x'},
      {"version", no_argument, 0, 'v'},
      {"no-cache", no_argument, 0, 'n'},
      {"quiet", no_argument, 0, 'q'},
      {nullptr, 0, 0, 0}};
 
  // strip any path to progname
  const std::string progname =
      std::filesystem::path(argv[0]).filename().native();
 
  try {
    bool force_overwrite = false;
    std::filesystem::path output_path = default_output_path();
    std::string input_path("./config.yaml"), particles, decaymodes;
    std::vector<std::string> extra_config;
    char *modus = nullptr, *end_time = nullptr, *pdg_string = nullptr,
         *cs_string = nullptr;
    std::string custom_tabulations_path;
    bool list2n_activated = false;
    bool resonance_dump_activated = false;
    bool cross_section_dump_activated = false;
    bool final_state_cross_sections = false;
    bool particles_dump_iSS_format = false;
    bool cache_integrals = true;
    bool suppress_disclaimer = false;
 
    // parse command-line arguments
    int opt;
    while ((opt = getopt_long(argc, argv, "c:d:e:fhi:m:p:o:t:lr:s:S:xvnq",
                              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 't':
          custom_tabulations_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 'x':
          particles_dump_iSS_format = true;
          suppress_disclaimer = true;
          break;
        case 'v':
          std::printf(
              "%s\n"
#ifdef GIT_BRANCH
              "Branch   : %s\n"
#endif
              "System   : %s\nCompiler : %s %s\n"
              "Build    : %s\nDate     : %s\n",
              SMASH_VERSION,
#ifdef GIT_BRANCH
              GIT_BRANCH,
#endif
              CMAKE_SYSTEM, CMAKE_CXX_COMPILER_ID, CMAKE_CXX_COMPILER_VERSION,
              CMAKE_BUILD_TYPE, BUILD_DATE);
          std::exit(EXIT_SUCCESS);
        case 'n':
          cache_integrals = false;
          break;
        case 'q':
          suppress_disclaimer = true;
          break;
        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();
    }
 
    auto configuration = setup_config_and_logging(input_path, particles,
                                                  decaymodes, extra_config);
 
    setup_default_float_traps();
 
    // Check output path
    ensure_path_is_valid(output_path);
    if (!cache_integrals && !custom_tabulations_path.empty()) {
      throw std::invalid_argument(
          "--tabulations cannot be used together with --no-cache.");
    }
    std::string tabulations_path;
    if (cache_integrals) {
      if (!custom_tabulations_path.empty()) {
        tabulations_path = custom_tabulations_path;
      } else {
        tabulations_path = output_path.has_parent_path()
                               ? output_path.parent_path().string()
                               : ".";
        tabulations_path += "/tabulations";
      }
    } else {
      tabulations_path = "";
    }
    const std::string version(SMASH_VERSION);
 
    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}}");
      initialize_particles_decays_and_tabulations(configuration, version,
                                                  tabulations_path);
      auto scat_finder = actions_finder_for_dump(configuration);
 
      ignore_simulation_config_values(configuration);
      check_for_unused_config_values(configuration);
 
      scat_finder.dump_reactions();
      std::exit(EXIT_SUCCESS);
    }
    if (particles_dump_iSS_format) {
      initialize_particles_decays_and_tabulations(configuration, version,
                                                  tabulations_path);
      ParticleTypePtrList list;
      list.clear();
      for (const auto &ptype : ParticleType::list_all()) {
        list.push_back(&ptype);
      }
      std::sort(list.begin(), list.end(),
                [](ParticleTypePtr a, ParticleTypePtr b) {
                  return a->mass() < b->mass();
                });
      for (const ParticleTypePtr &ptype : list) {
        if (ptype->pdgcode().is_lepton() || ptype->baryon_number() < 0) {
          continue;
        }
        const auto &decay_modes = ptype->decay_modes();
        const auto &modelist = decay_modes.decay_mode_list();
        int ndecays = ptype->is_stable() ? 1 : modelist.size();
        std::printf("%13i %s %10.5f %10.5f %5i %5i %5i %5i %5i %5i %5i %5i\n",
                    ptype->pdgcode().get_decimal(),
                    smash::utf8::fill_left(ptype->name(), 12, ' ').c_str(),
                    ptype->mass(), ptype->width_at_pole(),
                    ptype->pdgcode().spin_degeneracy(), ptype->baryon_number(),
                    ptype->strangeness(), ptype->pdgcode().charmness(),
                    ptype->pdgcode().bottomness(), ptype->isospin() + 1,
                    ptype->charge(), ndecays);
        if (!ptype->is_stable()) {
          for (const auto &decay : modelist) {
            auto ptypes = decay->particle_types();
            std::printf("%13i %13i %20.5f %13i %13i %13i %13i %13i\n",
                        ptype->pdgcode().get_decimal(), 2, decay->weight(),
                        ptypes[0]->pdgcode().get_decimal(),
                        ptypes[1]->pdgcode().get_decimal(), 0, 0, 0);
          }
        } else {
          std::printf("%13i %13i %20.5f %13i %13i %13i %13i %13i\n",
                      ptype->pdgcode().get_decimal(), 1, 1.0,
                      ptype->pdgcode().get_decimal(), 0, 0, 0, 0);
        }
      }
      std::exit(EXIT_SUCCESS);
    }
    if (resonance_dump_activated) {
      // Ignore config values that don't make sense.
      initialize_particles_decays_and_tabulations(configuration, version,
                                                  tabulations_path);
      const auto _dummy = ExperimentBase::create(configuration, output_path);
      ignore_simulation_config_values(configuration);
      check_for_unused_config_values(configuration);
 
      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) {
      initialize_particles_decays_and_tabulations(configuration, version,
                                                  tabulations_path);
      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 && n_arg < 5) {
        throw std::invalid_argument("-s usage: pdg1,pdg2[,m1,m2[,plab1,...]]");
      }
      PdgCode pdg_a(args[0]), pdg_b(args[1]);
      const ParticleType &a = ParticleType::find(pdg_a);
      const ParticleType &b = ParticleType::find(pdg_b);
      if (n_arg < 4) {
        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] != "" && std::stod(args[2]) != a.mass()) {
        ma = a.mass();
        std::ostringstream warn_msg{"Pole mass ", std::ios::ate};
        warn_msg << a.mass() << " GeV is used for stable particle " << a.name()
                 << " instead of the provided " << args[2] << " GeV.\n";
        logg[LMain].warn(warn_msg.str());
      }
      if (b.is_stable() && args[3] != "" && std::stod(args[3]) != b.mass()) {
        mb = b.mass();
        std::ostringstream warn_msg{"Pole mass ", std::ios::ate};
        warn_msg << b.mass() << " GeV is used for stable particle " << b.name()
                 << " instead of the provided " << args[3] << " GeV.\n";
        logg[LMain].warn(warn_msg.str());
      }
      const size_t plab_size = n_arg <= 4 ? 0 : n_arg - 4;
      std::vector<double> plab;
      plab.reserve(plab_size);
      for (size_t i = 4; i < n_arg; i++) {
        plab.push_back(std::stod(args.at(i)));
      }
      auto scat_finder = actions_finder_for_dump(configuration);
 
      ignore_simulation_config_values(configuration);
      check_for_unused_config_values(configuration);
 
      scat_finder.dump_cross_sections(a, b, ma, mb, final_state_cross_sections,
                                      plab);
      std::exit(EXIT_SUCCESS);
    }
    if (modus) {
      configuration.set_value(InputKeys::gen_modus, std::string(modus));
    }
    if (end_time) {
      configuration.set_value(InputKeys::gen_endTime,
                              std::abs(std::atof(end_time)));
    }
 
    int64_t seed = configuration.read(InputKeys::gen_randomseed);
    if (seed < 0) {
      configuration.set_value(InputKeys::gen_randomseed,
                              random::generate_63bit_seed());
    }
 
    // Avoid overwriting SMASH output
    const std::filesystem::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() + "\".");
    }
    logg[LMain].debug("output path: ", output_path);
    if (!force_overwrite &&
        std::filesystem::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 */
    std::ofstream(output_path / "config.yaml")
        << "# " << SMASH_VERSION << '\n'
#ifdef GIT_BRANCH
        << "# Branch   : " << GIT_BRANCH << '\n'
#endif
        << "# 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';
 
    const auto hash =
        initialize_particles_decays_and_return_hash(configuration, version);
 
    // Create an experiment
    logg[LMain].trace(SMASH_SOURCE_LOCATION, " create Experiment");
    auto experiment = ExperimentBase::create(configuration, output_path);
    check_for_unused_config_values(configuration);
    tabulate_resonance_integrals(hash, tabulations_path);
 
    // Run the experiment
    logg[LMain].trace(SMASH_SOURCE_LOCATION, " run the Experiment");
    experiment->run();
  } catch (std::exception &e) {
    logg[LMain].fatal() << "SMASH failed with the following error:\n"
                        << e.what();
    return EXIT_FAILURE;
  }
 
  logg[LMain].trace() << SMASH_SOURCE_LOCATION << " about to return from main";
  return 0;
}

Here is the call graph for this function: