https://mooseframework.inl.gov
TimeIntegrator.C
Go to the documentation of this file.
1 //* This file is part of the MOOSE framework
2 //* https://mooseframework.inl.gov
3 //*
4 //* All rights reserved, see COPYRIGHT for full restrictions
5 //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
6 //*
7 //* Licensed under LGPL 2.1, please see LICENSE for details
8 //* https://www.gnu.org/licenses/lgpl-2.1.html
9 
10 #include "TimeIntegrator.h"
11 #include "FEProblem.h"
12 #include "NonlinearSystemBase.h"
13 
14 #include "libmesh/nonlinear_implicit_system.h"
15 #include "libmesh/nonlinear_solver.h"
16 #include "libmesh/dof_map.h"
17 
18 using namespace libMesh;
19 
22 {
24  params.addParam<std::vector<VariableName>>(
25  "variables", {}, "A subset of the variables that this time integrator should be applied to");
26  params.registerBase("TimeIntegrator");
27  return params;
28 }
29 
31  : MooseObject(parameters),
32  Restartable(this, "TimeIntegrators"),
33  NonlinearTimeIntegratorInterface(*getCheckedPointerParam<FEProblemBase *>("_fe_problem_base"),
34  *getCheckedPointerParam<SystemBase *>("_sys")),
35  LinearTimeIntegratorInterface(*getCheckedPointerParam<SystemBase *>("_sys")),
36  _fe_problem(*getCheckedPointerParam<FEProblemBase *>("_fe_problem_base")),
37  _sys(*getCheckedPointerParam<SystemBase *>("_sys")),
38  _du_dot_du(_sys.duDotDus()),
39  _solution(_sys.currentSolution()),
40  _solution_old(_sys.solutionState(1)),
41  _solution_sub(declareRestartableDataWithContext<std::unique_ptr<NumericVector<Number>>>(
42  "solution_sub", &const_cast<libMesh::Parallel::Communicator &>(this->comm()))),
43  _solution_old_sub(declareRestartableDataWithContext<std::unique_ptr<NumericVector<Number>>>(
44  "solution_old_sub", &const_cast<libMesh::Parallel::Communicator &>(this->comm()))),
45  _t_step(_fe_problem.timeStep()),
46  _dt(_fe_problem.dt()),
47  _dt_old(_fe_problem.dtOld()),
48  _n_nonlinear_iterations(0),
49  _n_linear_iterations(0),
50  _is_lumped(false),
51  _var_restriction(declareRestartableData<bool>(
52  "var_restriction", !getParam<std::vector<VariableName>>("variables").empty())),
53  _local_indices(declareRestartableData<std::vector<dof_id_type>>("local_indices")),
54  _vars(declareRestartableData<std::unordered_set<unsigned int>>("vars")),
55  _from_subvector(NumericVector<Number>::build(this->comm()))
56 {
58 }
59 
60 void
62 {
63  if (!_var_restriction)
64  return;
65 
66  const auto & var_names = getParam<std::vector<VariableName>>("variables");
67  std::vector<unsigned int> var_num_vec;
68  auto & lm_sys = _sys.system();
69  lm_sys.get_all_variable_numbers(var_num_vec);
70  std::unordered_set<unsigned int> var_nums(var_num_vec.begin(), var_num_vec.end());
71  for (const auto & var_name : var_names)
72  if (lm_sys.has_variable(var_name))
73  {
74  const auto var_num = lm_sys.variable_number(var_name);
75  _vars.insert(var_num);
76  var_nums.erase(var_num);
77  }
78 
79  // If var_nums is empty then that means the user has specified all the variables in this system
80  if (var_nums.empty())
81  {
82  _var_restriction = false;
83  return;
84  }
85 
86  std::vector<dof_id_type> var_dof_indices, work_vec;
87  for (const auto var_num : _vars)
88  {
89  work_vec = _local_indices;
90  _local_indices.clear();
91  lm_sys.get_dof_map().local_variable_indices(var_dof_indices, lm_sys.get_mesh(), var_num);
92  std::merge(work_vec.begin(),
93  work_vec.end(),
94  var_dof_indices.begin(),
95  var_dof_indices.end(),
96  std::back_inserter(_local_indices));
97  }
98 
101 }
102 
103 void
105 {
106  mooseError("Calling TimeIntegrator::solve() is no longer supported");
107 }
108 
109 void
111 {
114 }
115 
116 unsigned int
118 {
120 }
121 
122 unsigned int
124 {
125  auto & nonlinear_solver = _nonlinear_implicit_system->nonlinear_solver;
126  libmesh_assert(nonlinear_solver);
127 
128  return nonlinear_solver->get_total_linear_iterations();
129 }
130 
131 void
133 {
134  if (!_var_restriction)
135  to = from;
136  else
137  {
138  auto to_sub = to.get_subvector(_local_indices);
140  *to_sub = *_from_subvector;
141  to.restore_subvector(std::move(to_sub), _local_indices);
142  }
143 }
144 
145 bool
146 TimeIntegrator::integratesVar(const unsigned int var_num) const
147 {
148  if (!_var_restriction)
149  return true;
150 
151  return _vars.count(var_num);
152 }
153 
154 void
156 {
157  const auto coeff = duDotDuCoeff();
158  for (const auto i : index_range(_du_dot_du))
159  if (integratesVar(i))
160  _du_dot_du[i] = coeff / _dt;
161 }
virtual void solve()
Solves the time step and sets the number of nonlinear and linear iterations.
virtual Real duDotDuCoeff() const
A class for creating restricted objects.
Definition: Restartable.h:28
std::unique_ptr< NonlinearSolver< Number > > nonlinear_solver
bool & _var_restriction
Whether the user has requested that the time integrator be applied to a subset of variables...
void setNumIterationsLastSolve()
Record the linear and nonlinear iterations from a just finished solve.
std::unordered_set< unsigned int > & _vars
The variables that this time integrator integrates.
FEProblemBase & _fe_problem
Reference to the problem.
Interface class for routines and member variables for time integrators relying on Newton&#39;s method...
SystemBase & _sys
Reference to the system this time integrator operates on.
virtual libMesh::System & system()=0
Get the reference to the libMesh system.
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
const Parallel::Communicator & comm() const
void get_all_variable_numbers(std::vector< unsigned int > &all_variable_numbers) const
unsigned int n_nonlinear_iterations() const
The following methods are specializations for using the libMesh::Parallel::packed_range_* routines fo...
Base class for a system (of equations)
Definition: SystemBase.h:84
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
Real & _dt
The current time step size.
virtual void init()
Called only before the very first timestep (t_step = 0) Never called again (not even during recover/r...
libMesh::NonlinearImplicitSystem * _nonlinear_implicit_system
libMesh nonlinear implicit system, if applicable; otherwise, nullptr
virtual void create_subvector(NumericVector< T > &, const std::vector< numeric_index_type > &, bool=true) const
void registerBase(const std::string &value)
This method must be called from every base "Moose System" to create linkage with the Action System...
Every object that can be built by the factory should be derived from this class.
Definition: MooseObject.h:28
virtual void setUDotRequested(const bool u_dot_requested)
Set boolean flag to true to store solution time derivative.
constexpr auto merge(std::index_sequence< first... >, std::index_sequence< second... >)
Merge two index sequences into one.
unsigned int _n_linear_iterations
Total number of linear iterations over all stages of the time step.
libmesh_assert(ctx)
std::vector< dof_id_type > & _local_indices
The local degree of freedom indices this time integrator is being applied to.
virtual std::unique_ptr< NumericVector< T > > get_subvector(const std::vector< numeric_index_type > &)
std::unique_ptr< NumericVector< Number > > & _solution_old_sub
std::vector< Real > & _du_dot_du
Derivative of time derivative with respect to current solution: for the different variables...
Interface class for routines and member variables for time integrators relying on linear system assem...
const NumericVector< Number > *const & _solution
unsigned int getNumLinearIterationsLastSolve() const
Gets the number of linear iterations in the most recent solve.
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type.
void addParam(const std::string &name, const S &value, const std::string &doc_string)
These methods add an optional parameter and a documentation string to the InputParameters object...
const NumericVector< Number > & _solution_old
bool integratesVar(const unsigned int var_num) const
unsigned int _n_nonlinear_iterations
Total number of nonlinear iterations over all stages of the time step.
unsigned int getNumNonlinearIterationsLastSolve() const
Gets the number of nonlinear iterations in the most recent solve.
TimeIntegrator(const InputParameters &parameters)
static InputParameters validParams()
Definition: MooseObject.C:25
Real Number
std::unique_ptr< NumericVector< Number > > _from_subvector
A vector that is used for creating &#39;from&#39; subvectors in the copyVector() method.
static InputParameters validParams()
void ErrorVector unsigned int
auto index_range(const T &sizable)
std::unique_ptr< NumericVector< Number > > & _solution_sub
uint8_t dof_id_type
void computeDuDotDu()
Compute _du_dot_du.
void copyVector(const NumericVector< Number > &from, NumericVector< Number > &to)
Copy from one vector into another.
virtual void restore_subvector(std::unique_ptr< NumericVector< T >>, const std::vector< numeric_index_type > &)