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 "BDF2.h"
      11             : #include "NonlinearSystem.h"
      12             : 
      13             : registerMooseObject("MooseApp", BDF2);
      14             : 
      15             : InputParameters
      16        3790 : BDF2::validParams()
      17             : {
      18        3790 :   InputParameters params = TimeIntegrator::validParams();
      19        3790 :   params.addClassDescription(
      20             :       "Second order backward differentiation formula time integration scheme.");
      21        3790 :   return params;
      22           0 : }
      23             : 
      24         486 : BDF2::BDF2(const InputParameters & parameters)
      25             :   : TimeIntegrator(parameters),
      26         486 :     _weight(declareRestartableData<std::vector<Real>>("weight")),
      27         972 :     _solution_older(_sys.solutionState(2))
      28             : {
      29         486 :   _weight.resize(3);
      30         486 : }
      31             : 
      32             : void
      33       54623 : BDF2::preStep()
      34             : {
      35       54623 :   if (_t_step > 1)
      36             :   {
      37       46202 :     Real sum = _dt + _dt_old;
      38       46202 :     _weight[0] = 1. + _dt / sum;
      39       46202 :     _weight[1] = -sum / _dt_old;
      40       46202 :     _weight[2] = _dt * _dt / _dt_old / sum;
      41             :   }
      42       54623 : }
      43             : 
      44             : void
      45       23423 : BDF2::computeTimeDerivatives()
      46             : {
      47       23423 :   if (!_sys.solutionUDot())
      48           0 :     mooseError("BDF2: Time derivative of solution (`u_dot`) is not stored. Please set "
      49             :                "uDotRequested() to true in FEProblemBase befor requesting `u_dot`.");
      50             : 
      51       23423 :   NumericVector<Number> & u_dot = *_sys.solutionUDot();
      52       23423 :   if (_t_step == 1)
      53        3337 :     u_dot = *_solution;
      54             :   else
      55       20086 :     u_dot.zero();
      56       23423 :   computeTimeDerivativeHelper(u_dot, *_solution, _solution_old, _solution_older);
      57       23423 :   u_dot.close();
      58       23423 :   computeDuDotDu();
      59       23423 : }
      60             : 
      61             : void
      62     1012486 : BDF2::computeADTimeDerivatives(ADReal & ad_u_dot,
      63             :                                const dof_id_type & dof,
      64             :                                ADReal & /*ad_u_dotdot*/) const
      65             : {
      66     1012486 :   auto ad_sln = ad_u_dot;
      67     1012486 :   if (_t_step != 1)
      68      885912 :     ad_u_dot = 0;
      69     1012486 :   computeTimeDerivativeHelper(ad_u_dot, ad_sln, _solution_old(dof), _solution_older(dof));
      70     1012486 : }
      71             : 
      72             : void
      73       16936 : BDF2::postResidual(NumericVector<Number> & residual)
      74             : {
      75       16936 :   residual += *_Re_time;
      76       16936 :   residual += *_Re_non_time;
      77       16936 :   residual.close();
      78       16936 : }
      79             : 
      80             : Real
      81       23423 : BDF2::duDotDuCoeff() const
      82             : {
      83       23423 :   if (_t_step == 1)
      84        3337 :     return 1;
      85             :   else
      86       20086 :     return _weight[0];
      87             : }
      88             : 
      89             : Real
      90        1008 : BDF2::timeDerivativeRHSContribution(dof_id_type dof_id, const std::vector<Real> & factors) const
      91             : {
      92             :   mooseAssert(factors.size() == numStatesRequired(),
      93             :               "Either too many or too few states are given!");
      94             : 
      95        1008 :   if (_t_step == 1)
      96         144 :     return factors[0] * _solution_old(dof_id) / _dt;
      97             :   else
      98         864 :     return -(_weight[1] * factors[0] * _solution_old(dof_id) +
      99         864 :              _weight[2] * factors[1] * _solution_older(dof_id)) /
     100         864 :            _dt;
     101             : }
     102             : 
     103             : Real
     104        1008 : BDF2::timeDerivativeMatrixContribution(const Real factor) const
     105             : {
     106        1008 :   if (_t_step == 1)
     107         144 :     return factor / _dt;
     108             :   else
     109         864 :     return factor * _weight[0] / _dt;
     110             : }