Made _nonlinear_implicit_system in TimeIntegrator non-const

Changes:
* Made _nonlinear_implicit_system in TimeIntegrator non-const.
  In explicit time integrators, update() is called on these
  objects, so it cannot be const.
* Added doxygen for TimeIntegrator::computeTimeDerivatives()
* Fixed typo in doxygen for _du_dot_du for TimeIntegrator
* Had ActuallyExplicitEuler use _nonlinear_implicit_system
  from TimeIntegrator

Refs idaholab#11855

framework/include/timeintegrators/TimeIntegrator.h

@@ -97,6 +97,15 @@ class TimeIntegrator : public MooseObject, public Restartable
   virtual void postStep() {}
 
   virtual int order() = 0;
+
+  /**
+   * Computes the time derivative and the Jacobian of the time derivative
+   *
+   * This function is responsible for the following:
+   * - computing the time derivative; a reference is retrieved from _sys.solutionUDot().
+   * - computing the time derivative Jacobian, stored in _du_dot_du, which is a
+   *   reference to _sys.duDotDu().
+   */
   virtual void computeTimeDerivatives() = 0;
 
   /**
@@ -130,9 +139,10 @@ class TimeIntegrator : public MooseObject, public Restartable
   NonlinearSystemBase & _nl;
 
   /// Nonlinear implicit system, if applicable; otherwise, nullptr
-  const NonlinearImplicitSystem * _nonlinear_implicit_system;
+  // NonlinearImplicitSystem * _nonlinear_implicit_system;
+  NonlinearImplicitSystem * _nonlinear_implicit_system;
 
-  /// solution vector for \f$ {du^dot}\over{du} \f$
+  /// Derivative of time derivative with respect to current solution: \f$ {du^dot}\over{du} \f$
   Real & _du_dot_du;
   /// solution vectors
   const NumericVector<Number> * const & _solution;
@@ -154,4 +164,3 @@ class TimeIntegrator : public MooseObject, public Restartable
   /// Total number of linear iterations over all stages of the time step
   unsigned int _n_linear_iterations;
 };
-

framework/src/timeintegrators/ActuallyExplicitEuler.C

@@ -108,7 +108,7 @@ ActuallyExplicitEuler::computeTimeDerivatives()
 {
   if (!_sys.solutionUDot())
     mooseError("ActuallyExplicitEuler: Time derivative of solution (`u_dot`) is not stored. Please "
-               "set uDotRequested() to true in FEProblemBase befor requesting `u_dot`.");
+               "set uDotRequested() to true in FEProblemBase before requesting `u_dot`.");
 
   NumericVector<Number> & u_dot = *_sys.solutionUDot();
   u_dot = *_solution;
@@ -131,29 +131,26 @@ ActuallyExplicitEuler::solve()
 
   auto & nonlinear_system = _fe_problem.getNonlinearSystemBase();
 
-  auto & libmesh_system = dynamic_cast<NonlinearImplicitSystem &>(nonlinear_system.system());
-
-  auto & mass_matrix = *libmesh_system.matrix;
+  auto & mass_matrix = *_nonlinear_implicit_system->matrix;
 
   _current_time = _fe_problem.time();
 
   // Set time back so that we're evaluating the interior residual at the old time
   _fe_problem.time() = _fe_problem.timeOld();
 
-  libmesh_system.update();
+  _nonlinear_implicit_system->update();
 
   // Must compute the residual first
   _explicit_residual.zero();
-  _fe_problem.computeResidual(*libmesh_system.current_local_solution, _explicit_residual);
+  _fe_problem.computeResidual(*_nonlinear_implicit_system->current_local_solution,
+                              _explicit_residual);
 
   // The residual is on the RHS
   _explicit_residual *= -1.;
 
   // Compute the mass matrix
-  _fe_problem.computeJacobianTag(*libmesh_system.current_local_solution, mass_matrix, _Ke_time_tag);
-
-  // Still testing whether leaving the old update is a good idea or not
-  // _explicit_euler_update = 0;
+  _fe_problem.computeJacobianTag(
+      *_nonlinear_implicit_system->current_local_solution, mass_matrix, _Ke_time_tag);
 
   auto converged = false;
 
@@ -217,18 +214,19 @@ ActuallyExplicitEuler::solve()
       mooseError("Unknown solve_type in ActuallyExplicitEuler ");
   }
 
-  *libmesh_system.solution = nonlinear_system.solutionOld();
-  *libmesh_system.solution += _explicit_euler_update;
+  *_nonlinear_implicit_system->solution = nonlinear_system.solutionOld();
+  *_nonlinear_implicit_system->solution += _explicit_euler_update;
 
   // Enforce contraints on the solution
-  DofMap & dof_map = libmesh_system.get_dof_map();
-  dof_map.enforce_constraints_exactly(libmesh_system, libmesh_system.solution.get());
+  DofMap & dof_map = _nonlinear_implicit_system->get_dof_map();
+  dof_map.enforce_constraints_exactly(*_nonlinear_implicit_system,
+                                      _nonlinear_implicit_system->solution.get());
 
-  libmesh_system.update();
+  _nonlinear_implicit_system->update();
 
-  nonlinear_system.setSolution(*libmesh_system.current_local_solution);
+  nonlinear_system.setSolution(*_nonlinear_implicit_system->current_local_solution);
 
-  libmesh_system.nonlinear_solver->converged = converged;
+  _nonlinear_implicit_system->nonlinear_solver->converged = converged;
 }
 
 void

framework/src/timeintegrators/TimeIntegrator.C

@@ -30,7 +30,7 @@ TimeIntegrator::TimeIntegrator(const InputParameters & parameters)
     _fe_problem(*getCheckedPointerParam<FEProblemBase *>("_fe_problem_base")),
     _sys(*getCheckedPointerParam<SystemBase *>("_sys")),
     _nl(_fe_problem.getNonlinearSystemBase()),
-    _nonlinear_implicit_system(dynamic_cast<const NonlinearImplicitSystem *>(&_sys.system())),
+    _nonlinear_implicit_system(dynamic_cast<NonlinearImplicitSystem *>(&_sys.system())),
     _du_dot_du(_sys.duDotDu()),
     _solution(_sys.currentSolution()),
     _solution_old(_sys.solutionOld()),