Line data    Source code

       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 "ImplicitEuler.h"
      11             : #include "NonlinearSystem.h"
      12             : 
      13             : registerMooseObject("MooseApp", ImplicitEuler);
      14             : 
      15             : InputParameters
      16      103720 : ImplicitEuler::validParams()
      17             : {
      18      103720 :   InputParameters params = TimeIntegrator::validParams();
      19      103720 :   params.addClassDescription("Time integration using the implicit Euler method.");
      20      103720 :   return params;
      21           0 : }
      22             : 
      23       59648 : ImplicitEuler::ImplicitEuler(const InputParameters & parameters) : TimeIntegrator(parameters) {}
      24             : 
      25      110792 : ImplicitEuler::~ImplicitEuler() {}
      26             : 
      27             : void
      28     4482481 : ImplicitEuler::computeTimeDerivatives()
      29             : {
      30     4482481 :   if (!_sys.solutionUDot())
      31           0 :     mooseError("ImplicitEuler: Time derivative of solution (`u_dot`) is not stored. Please set "
      32             :                "uDotRequested() to true in FEProblemBase befor requesting `u_dot`.");
      33             : 
      34     4482481 :   NumericVector<Number> & u_dot = *_sys.solutionUDot();
      35     4482481 :   if (!_var_restriction)
      36             :   {
      37     4465687 :     u_dot = *_solution;
      38     4465687 :     computeTimeDerivativeHelper(u_dot, _solution_old);
      39             :   }
      40             :   else
      41             :   {
      42       16794 :     auto u_dot_sub = u_dot.get_subvector(_local_indices);
      43       16794 :     _solution->create_subvector(*_solution_sub, _local_indices, false);
      44       16794 :     _solution_old.create_subvector(*_solution_old_sub, _local_indices, false);
      45       16794 :     *u_dot_sub = *_solution_sub;
      46       16794 :     computeTimeDerivativeHelper(*u_dot_sub, *_solution_old_sub);
      47       16794 :     u_dot.restore_subvector(std::move(u_dot_sub), _local_indices);
      48             :     // Scatter info needed for ghosts
      49       16794 :     u_dot.close();
      50       16794 :   }
      51             : 
      52     4482481 :   computeDuDotDu();
      53     4482481 : }
      54             : 
      55             : void
      56    27614368 : ImplicitEuler::computeADTimeDerivatives(ADReal & ad_u_dot,
      57             :                                         const dof_id_type & dof,
      58             :                                         ADReal & /*ad_u_dotdot*/) const
      59             : {
      60    27614368 :   computeTimeDerivativeHelper(ad_u_dot, _solution_old(dof));
      61    27614368 : }
      62             : 
      63             : void
      64     2528099 : ImplicitEuler::postResidual(NumericVector<Number> & residual)
      65             : {
      66     2528099 :   if (!_var_restriction)
      67             :   {
      68     2511248 :     residual += *_Re_time;
      69     2511248 :     residual += *_Re_non_time;
      70     2511248 :     residual.close();
      71             :   }
      72             :   else
      73             :   {
      74       16851 :     auto residual_sub = residual.get_subvector(_local_indices);
      75       16851 :     auto re_time_sub = _Re_time->get_subvector(_local_indices);
      76       16851 :     auto re_non_time_sub = _Re_non_time->get_subvector(_local_indices);
      77       16851 :     *residual_sub += *re_time_sub;
      78       16851 :     *residual_sub += *re_non_time_sub;
      79       16851 :     residual.restore_subvector(std::move(residual_sub), _local_indices);
      80       16851 :     _Re_time->restore_subvector(std::move(re_time_sub), _local_indices);
      81       16851 :     _Re_non_time->restore_subvector(std::move(re_non_time_sub), _local_indices);
      82       16851 :   }
      83     2528099 : }
      84             : 
      85             : Real
      86       11900 : ImplicitEuler::timeDerivativeRHSContribution(dof_id_type dof_id,
      87             :                                              const std::vector<Real> & factors) const
      88             : {
      89             :   mooseAssert(factors.size() == numStatesRequired(),
      90             :               "Either too many or too few states are given!");
      91       11900 :   return factors[0] * _solution_old(dof_id) / _dt;
      92             : }
      93             : 
      94             : Real
      95       11900 : ImplicitEuler::timeDerivativeMatrixContribution(const Real factor) const
      96             : {
      97       11900 :   return factor / _dt;
      98             : }