Transient::Transient(const InputParameters & parameters) : Executioner(parameters), _problem(_fe_problem), _time_scheme(getParam<MooseEnum>("scheme")), _t_step(_problem.timeStep()), _time(_problem.time()), _time_old(_problem.timeOld()), _dt(_problem.dt()), _dt_old(_problem.dtOld()), _unconstrained_dt(declareRecoverableData<Real>("unconstrained_dt", -1)), _at_sync_point(declareRecoverableData<bool>("at_sync_point", false)), _first(declareRecoverableData<bool>("first", true)), _multiapps_converged(declareRecoverableData<bool>("multiapps_converged", true)), _last_solve_converged(declareRecoverableData<bool>("last_solve_converged", true)), _end_time(getParam<Real>("end_time")), _dtmin(getParam<Real>("dtmin")), _dtmax(getParam<Real>("dtmax")), _num_steps(getParam<unsigned int>("num_steps")), _n_startup_steps(getParam<int>("n_startup_steps")), _steps_taken(0), _trans_ss_check(getParam<bool>("trans_ss_check")), _ss_check_tol(getParam<Real>("ss_check_tol")), _ss_tmin(getParam<Real>("ss_tmin")), _old_time_solution_norm(declareRecoverableData<Real>("old_time_solution_norm", 0.0)), _sync_times(_app.getOutputWarehouse().getSyncTimes()), _abort(getParam<bool>("abort_on_solve_fail")), _time_interval(declareRecoverableData<bool>("time_interval", false)), _start_time(getParam<Real>("start_time")), _timestep_tolerance(getParam<Real>("timestep_tolerance")), _target_time(declareRecoverableData<Real>("target_time", -1)), _use_multiapp_dt(getParam<bool>("use_multiapp_dt")), _picard_it(declareRecoverableData<int>("picard_it", 0)), _picard_max_its(getParam<unsigned int>("picard_max_its")), _picard_converged(declareRecoverableData<bool>("picard_converged", false)), _picard_initial_norm(declareRecoverableData<Real>("picard_initial_norm", 0.0)), _picard_timestep_begin_norm(declareRecoverableData<Real>("picard_timestep_begin_norm", 0.0)), _picard_timestep_end_norm(declareRecoverableData<Real>("picard_timestep_end_norm", 0.0)), _picard_rel_tol(getParam<Real>("picard_rel_tol")), _picard_abs_tol(getParam<Real>("picard_abs_tol")), _verbose(getParam<bool>("verbose")) { _problem.getNonlinearSystem().setDecomposition(_splitting); _t_step = 0; _dt = 0; _next_interval_output_time = 0.0; // Either a start_time has been forced on us, or we want to tell the App about what our start time is (in case anyone else is interested. if (_app.hasStartTime()) _start_time = _app.getStartTime(); else if (parameters.paramSetByUser("start_time")) _app.setStartTime(_start_time); _time = _time_old = _start_time; _problem.transient(true); if (!_restart_file_base.empty()) _problem.setRestartFile(_restart_file_base); setupTimeIntegrator(); if (_app.halfTransient()) // Cut timesteps and end_time in half... { _end_time /= 2.0; _num_steps /= 2.0; if (_num_steps == 0) // Always do one step in the first half _num_steps = 1; } }
Console::Console(const InputParameters & parameters) : TableOutput(parameters), _max_rows(getParam<unsigned int>("max_rows")), _fit_mode(getParam<MooseEnum>("fit_mode")), _scientific_time(getParam<bool>("scientific_time")), _write_file(getParam<bool>("output_file")), _write_screen(getParam<bool>("output_screen")), _verbose(getParam<bool>("verbose")), _perf_log(getParam<bool>("perf_log")), _solve_log(isParamValid("solve_log") ? getParam<bool>("solve_log") : _perf_log), _setup_log(isParamValid("setup_log") ? getParam<bool>("setup_log") : _perf_log), #ifdef LIBMESH_ENABLE_PERFORMANCE_LOGGING _libmesh_log(getParam<bool>("libmesh_log")), #endif _setup_log_early(getParam<bool>("setup_log_early")), _perf_header(isParamValid("perf_header") ? getParam<bool>("perf_header") : _perf_log), _all_variable_norms(getParam<bool>("all_variable_norms")), _outlier_variable_norms(getParam<bool>("outlier_variable_norms")), _outlier_multiplier(getParam<std::vector<Real> >("outlier_multiplier")), _precision(isParamValid("time_precision") ? getParam<unsigned int>("time_precision") : 0), _timing(_app.getParam<bool>("timing")), _console_buffer(_app.getOutputWarehouse().consoleBuffer()), _old_linear_norm(std::numeric_limits<Real>::max()), _old_nonlinear_norm(std::numeric_limits<Real>::max()), _print_mesh_changed_info(getParam<bool>("print_mesh_changed_info")), _system_info_flags(getParam<MultiMooseEnum>("system_info")) { // Apply the special common console flags (print_...) ActionWarehouse & awh = _app.actionWarehouse(); Action * common_action = awh.getActionsByName("common_output")[0]; // Honor the 'print_linear_residuals' option, only if 'execute_on' has not been set by the user if (!parameters.paramSetByUser("execute_on")) { if (common_action->getParam<bool>("print_linear_residuals")) _execute_on.push_back("linear"); else _execute_on.erase("linear"); } if (!_pars.paramSetByUser("perf_log") && common_action->getParam<bool>("print_perf_log")) { _perf_log = true; _solve_log = true; _setup_log = true; } // Append the common 'execute_on' to the setting for this object // This is unique to the Console object, all other objects inherit from the common options const MultiMooseEnum & common_execute_on = common_action->getParam<MultiMooseEnum>("execute_on"); for (MooseEnumIterator it = common_execute_on.begin(); it != common_execute_on.end(); ++it) _execute_on.push_back(*it); // If --timing was used from the command-line, do nothing, all logs are enabled if (!_timing) { // Disable performance logging (all log input options must be false) if (!_perf_log && !_setup_log && !_solve_log && !_perf_header && !_setup_log_early) { Moose::perf_log.disable_logging(); Moose::setup_perf_log.disable_logging(); } // Disable libMesh log #ifdef LIBMESH_ENABLE_PERFORMANCE_LOGGING if (!_libmesh_log) libMesh::perflog.disable_logging(); #endif } // If --show-outputs is used, enable it if (_app.getParam<bool>("show_outputs")) _system_info_flags.push_back("output"); // Set output coloring if (Moose::_color_console) { char * term_env = getenv("TERM"); if (term_env) { std::string term(term_env); if (term != "xterm-256color" && term != "xterm") Moose::_color_console = false; } } }