279 lines
10 KiB
C++
279 lines
10 KiB
C++
/*
|
|
* Copyright © 2004-2011 Ondra Kamenik
|
|
* Copyright © 2019 Dynare Team
|
|
*
|
|
* This file is part of Dynare.
|
|
*
|
|
* Dynare is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* Dynare is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with Dynare. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "dynare_params.hh"
|
|
|
|
#include "sthread.hh"
|
|
|
|
#include <getopt.h>
|
|
#include <string>
|
|
#include <iostream>
|
|
|
|
DynareParams::DynareParams(int argc, char **argv)
|
|
: num_per(100), num_burn(0), num_sim(80),
|
|
num_rtper(0), num_rtsim(0),
|
|
num_condper(0), num_condsim(0),
|
|
num_threads(sthread::default_threads_number()), num_steps(0),
|
|
prefix("dyn"), seed(934098), order(-1), ss_tol(1.e-13),
|
|
check_along_path(false), check_along_shocks(false),
|
|
check_on_ellipse(false), check_evals(1000), check_num(10), check_scale(2.0),
|
|
do_irfs_all(true), do_centralize(true), qz_criterium(1.0+1e-6),
|
|
help(false), version(false)
|
|
{
|
|
if (argc == 1 || std::string{argv[1]} == "--help")
|
|
{
|
|
help = true;
|
|
return;
|
|
}
|
|
if (argc == 1 || std::string{argv[1]} == "--version")
|
|
{
|
|
version = true;
|
|
return;
|
|
}
|
|
|
|
modname = argv[argc-1];
|
|
argc--;
|
|
|
|
struct option const opts[] =
|
|
{
|
|
{"periods", required_argument, nullptr, static_cast<int>(opt::per)},
|
|
{"per", required_argument, nullptr, static_cast<int>(opt::per)},
|
|
{"burn", required_argument, nullptr, static_cast<int>(opt::burn)},
|
|
{"simulations", required_argument, nullptr, static_cast<int>(opt::sim)},
|
|
{"sim", required_argument, nullptr, static_cast<int>(opt::sim)},
|
|
{"rtperiods", required_argument, nullptr, static_cast<int>(opt::rtper)},
|
|
{"rtper", required_argument, nullptr, static_cast<int>(opt::rtper)},
|
|
{"rtsimulations", required_argument, nullptr, static_cast<int>(opt::rtsim)},
|
|
{"rtsim", required_argument, nullptr, static_cast<int>(opt::rtsim)},
|
|
{"condperiods", required_argument, nullptr, static_cast<int>(opt::condper)},
|
|
{"condper", required_argument, nullptr, static_cast<int>(opt::condper)},
|
|
{"condsimulations", required_argument, nullptr, static_cast<int>(opt::condsim)},
|
|
{"condsim", required_argument, nullptr, static_cast<int>(opt::condsim)},
|
|
{"prefix", required_argument, nullptr, static_cast<int>(opt::prefix)},
|
|
{"threads", required_argument, nullptr, static_cast<int>(opt::threads)},
|
|
{"steps", required_argument, nullptr, static_cast<int>(opt::steps)},
|
|
{"seed", required_argument, nullptr, static_cast<int>(opt::seed)},
|
|
{"order", required_argument, nullptr, static_cast<int>(opt::order)},
|
|
{"ss-tol", required_argument, nullptr, static_cast<int>(opt::ss_tol)},
|
|
{"check", required_argument, nullptr, static_cast<int>(opt::check)},
|
|
{"check-scale", required_argument, nullptr, static_cast<int>(opt::check_scale)},
|
|
{"check-evals", required_argument, nullptr, static_cast<int>(opt::check_evals)},
|
|
{"check-num", required_argument, nullptr, static_cast<int>(opt::check_num)},
|
|
{"qz-criterium", required_argument, nullptr, static_cast<int>(opt::qz_criterium)},
|
|
{"no-irfs", no_argument, nullptr, static_cast<int>(opt::noirfs)},
|
|
{"irfs", no_argument, nullptr, static_cast<int>(opt::irfs)},
|
|
{"centralize", no_argument, nullptr, static_cast<int>(opt::centralize)},
|
|
{"no-centralize", no_argument, nullptr, static_cast<int>(opt::no_centralize)},
|
|
{"help", no_argument, nullptr, static_cast<int>(opt::help)},
|
|
{"version", no_argument, nullptr, static_cast<int>(opt::version)},
|
|
{nullptr, 0, nullptr, 0}
|
|
};
|
|
|
|
int ret;
|
|
int index;
|
|
while (-1 != (ret = getopt_long(argc, argv, "", opts, &index)))
|
|
{
|
|
if (ret == '?')
|
|
{
|
|
std::cerr << "Unknown option, ignored\n";
|
|
continue;
|
|
}
|
|
|
|
try
|
|
{
|
|
switch (static_cast<opt>(ret))
|
|
{
|
|
case opt::per:
|
|
num_per = std::stoi(optarg);
|
|
break;
|
|
case opt::burn:
|
|
num_burn = std::stoi(optarg);
|
|
break;
|
|
case opt::sim:
|
|
num_sim = std::stoi(optarg);
|
|
break;
|
|
case opt::rtper:
|
|
num_rtper = std::stoi(optarg);
|
|
break;
|
|
case opt::rtsim:
|
|
num_rtsim = std::stoi(optarg);
|
|
break;
|
|
case opt::condper:
|
|
num_condper = std::stoi(optarg);
|
|
break;
|
|
case opt::condsim:
|
|
num_condsim = std::stoi(optarg);
|
|
break;
|
|
case opt::prefix:
|
|
prefix = optarg;
|
|
break;
|
|
case opt::threads:
|
|
num_threads = std::stoi(optarg);
|
|
break;
|
|
case opt::steps:
|
|
num_steps = std::stoi(optarg);
|
|
break;
|
|
case opt::seed:
|
|
seed = std::stoi(optarg);
|
|
break;
|
|
case opt::order:
|
|
order = std::stoi(optarg);
|
|
break;
|
|
case opt::ss_tol:
|
|
ss_tol = std::stod(optarg);
|
|
break;
|
|
case opt::check:
|
|
processCheckFlags(optarg);
|
|
break;
|
|
case opt::check_scale:
|
|
check_scale = std::stod(optarg);
|
|
break;
|
|
case opt::check_evals:
|
|
check_evals = std::stoi(optarg);
|
|
break;
|
|
case opt::check_num:
|
|
check_num = std::stoi(optarg);
|
|
break;
|
|
case opt::noirfs:
|
|
irf_list.clear();
|
|
do_irfs_all = false;
|
|
break;
|
|
case opt::irfs:
|
|
processIRFList(argc, argv);
|
|
if (irf_list.empty())
|
|
do_irfs_all = true;
|
|
else
|
|
do_irfs_all = false;
|
|
break;
|
|
case opt::centralize:
|
|
do_centralize = true;
|
|
break;
|
|
case opt::no_centralize:
|
|
do_centralize = false;
|
|
break;
|
|
case opt::qz_criterium:
|
|
qz_criterium = std::stod(optarg);
|
|
break;
|
|
case opt::help:
|
|
help = true;
|
|
break;
|
|
case opt::version:
|
|
version = true;
|
|
break;
|
|
}
|
|
}
|
|
catch (std::invalid_argument &)
|
|
{
|
|
std::cerr << "Couldn't parse option " << optarg << ", ignored\n";
|
|
}
|
|
catch (std::out_of_range &)
|
|
{
|
|
std::cerr << "Out-of-range value " << optarg << ", ignored\n";
|
|
}
|
|
}
|
|
|
|
// make basename (get rid of the directory and the extension)
|
|
basename = modname;
|
|
auto pos = basename.find_last_of(R"(/\)");
|
|
if (pos != std::string::npos)
|
|
basename = basename.substr(pos+1);
|
|
pos = basename.find_last_of('.');
|
|
if (pos != std::string::npos)
|
|
basename.erase(pos);
|
|
}
|
|
|
|
void
|
|
DynareParams::printHelp() const
|
|
{
|
|
std::cout << "usage: dynare++ [--help] [--version] [options] <model file>\n"
|
|
"\n"
|
|
" --help print this message and return\n"
|
|
" --version print version and return\n"
|
|
"\n"
|
|
"options:\n"
|
|
" --per <num> number of periods simulated after burnt [100]\n"
|
|
" --burn <num> number of periods burnt [0]\n"
|
|
" --sim <num> number of simulations [80]\n"
|
|
" --rtper <num> number of RT periods simulated after burnt [0]\n"
|
|
" --rtsim <num> number of RT simulations [0]\n"
|
|
" --condper <num> number of periods in cond. simulations [0]\n"
|
|
" --condsim <num> number of conditional simulations [0]\n"
|
|
" --steps <num> steps towards stoch. SS [0=deter.]\n"
|
|
" --centralize centralize the rule [do centralize]\n"
|
|
" --no-centralize do not centralize the rule [do centralize]\n"
|
|
" --prefix <string> prefix of variables in Mat-4 file [\"dyn\"]\n"
|
|
" --seed <num> random number generator seed [934098]\n"
|
|
" --order <num> order of approximation [no default]\n"
|
|
" --threads <num> number of max parallel threads [1/2 * nb. of logical CPUs]\n"
|
|
" --ss-tol <num> steady state calcs tolerance [1.e-13]\n"
|
|
" --check pesPES check model residuals [no checks]\n"
|
|
" lower/upper case switches off/on\n"
|
|
" pP checking along simulation path\n"
|
|
" eE checking on ellipse\n"
|
|
" sS checking along shocks\n"
|
|
" --check-evals <num> max number of evals per residual [1000]\n"
|
|
" --check-num <num> number of checked points [10]\n"
|
|
" --check-scale <num> scaling of checked points [2.0]\n"
|
|
" --no-irfs shuts down IRF simulations [do IRFs]\n"
|
|
" --irfs performs IRF simulations [do IRFs]\n"
|
|
" --qz-criterium <num> threshold for stable eigenvalues [1.000001]\n"
|
|
"\n\n";
|
|
}
|
|
|
|
void
|
|
DynareParams::processCheckFlags(const std::string &flags)
|
|
{
|
|
for (char c : flags)
|
|
switch (c)
|
|
{
|
|
case 'p':
|
|
check_along_path = false;
|
|
break;
|
|
case 'P':
|
|
check_along_path = true;
|
|
break;
|
|
case 'e':
|
|
check_on_ellipse = false;
|
|
break;
|
|
case 'E':
|
|
check_on_ellipse = true;
|
|
break;
|
|
case 's':
|
|
check_along_shocks = false;
|
|
break;
|
|
case 'S':
|
|
check_along_shocks = true;
|
|
break;
|
|
default:
|
|
std::cerr << "Unknown check type selection character <" << c << ">, ignored.\n";
|
|
}
|
|
}
|
|
|
|
void
|
|
DynareParams::processIRFList(int argc, char **argv)
|
|
{
|
|
irf_list.clear();
|
|
while (optind < argc && *(argv[optind]) != '-')
|
|
{
|
|
irf_list.push_back(argv[optind]);
|
|
optind++;
|
|
}
|
|
}
|