Transient::Transient(const InputParameters & parameters)
: Executioner(parameters),
_problem(_fe_problem),
_nl(_fe_problem.getNonlinearSystemBase()),
_time_scheme(getParam<MooseEnum>("scheme").getEnum<Moose::TimeIntegratorType>()),
_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)),
_xfem_repeat_step(false),
_xfem_update_count(0),
_max_xfem_update(getParam<unsigned int>("max_xfem_update")),
_update_xfem_at_timestep_begin(getParam<bool>("update_xfem_at_timestep_begin")),
_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),
_steady_state_detection(getParam<bool>("steady_state_detection")),
_steady_state_tolerance(getParam<Real>("steady_state_tolerance")),
_steady_state_start_time(getParam<Real>("steady_state_start_time")),
_sln_diff_norm(declareRecoverableData<Real>("sln_diff_norm", 0.0)),
_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")),
_sln_diff(_nl.addVector("sln_diff", false, PARALLEL)),
_relax_factor(getParam<Real>("relaxation_factor")),
_relaxed_vars(getParam<std::vector<std::string>>("relaxed_variables"))
{
// Handl deprecated parameters
if (!parameters.isParamSetByAddParam("trans_ss_check"))
_steady_state_detection = getParam<bool>("trans_ss_check");
if (!parameters.isParamSetByAddParam("ss_check_tol"))
_steady_state_tolerance = getParam<Real>("ss_check_tol");
if (!parameters.isParamSetByAddParam("ss_tmin"))
_steady_state_start_time = getParam<Real>("ss_tmin");
_nl.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.isParamSetByUser("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;
}
// Set up relaxation
if (_relax_factor != 1.0)
{
if (_relax_factor >= 2.0 || _relax_factor <= 0.0)
mooseError("The Picard iteration relaxation factor should be between 0.0 and 2.0");
// Store a copy of the previous solution here
_nl.addVector("relax_previous", false, PARALLEL);
}
// This lets us know if we are at Picard iteration > 0, works for both master- AND sub-app.
// Initialize such that _prev_time != _time for the first Picard iteration
_prev_time = _time - 1.0;
}
