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 "ADIntegratedBC.h"
      11             : 
      12             : // MOOSE includes
      13             : #include "Assembly.h"
      14             : #include "SubProblem.h"
      15             : #include "SystemBase.h"
      16             : #include "MooseVariableFE.h"
      17             : #include "MooseVariableScalar.h"
      18             : #include "ADUtils.h"
      19             : 
      20             : #include "libmesh/quadrature.h"
      21             : 
      22             : template <typename T>
      23             : InputParameters
      24      245990 : ADIntegratedBCTempl<T>::validParams()
      25             : {
      26      245990 :   InputParameters params = IntegratedBCBase::validParams();
      27      245990 :   params += ADFunctorInterface::validParams();
      28      245990 :   return params;
      29           0 : }
      30             : 
      31             : template <typename T>
      32        1735 : ADIntegratedBCTempl<T>::ADIntegratedBCTempl(const InputParameters & parameters)
      33             :   : IntegratedBCBase(parameters),
      34             :     MooseVariableInterface<T>(this,
      35             :                               false,
      36             :                               "variable",
      37             :                               Moose::VarKindType::VAR_SOLVER,
      38             :                               std::is_same<T, Real>::value ? Moose::VarFieldType::VAR_FIELD_STANDARD
      39             :                                                            : Moose::VarFieldType::VAR_FIELD_VECTOR),
      40             :     ADFunctorInterface(this),
      41        3470 :     _var(*this->mooseVariable()),
      42        1735 :     _normals(_assembly.adNormals()),
      43        1735 :     _ad_q_points(_assembly.adQPointsFace()),
      44        1735 :     _test(_var.phiFace()),
      45        1735 :     _grad_test(_var.adGradPhiFace()),
      46        1735 :     _u(_var.adSln()),
      47        1735 :     _grad_u(_var.adGradSln()),
      48        1735 :     _ad_JxW(_assembly.adJxWFace()),
      49        1735 :     _ad_coord(_assembly.adCoordTransformation()),
      50        1735 :     _phi(_assembly.phi(_var)),
      51        3470 :     _use_displaced_mesh(getParam<bool>("use_displaced_mesh"))
      52             : {
      53        1735 :   _subproblem.haveADObjects(true);
      54             : 
      55        1735 :   addMooseVariableDependency(this->mooseVariable());
      56             : 
      57        1735 :   _save_in.resize(_save_in_strings.size());
      58        1735 :   _diag_save_in.resize(_diag_save_in_strings.size());
      59             : 
      60        1735 :   for (unsigned int i = 0; i < _save_in_strings.size(); i++)
      61             :   {
      62           0 :     MooseVariable * var = &_subproblem.getStandardVariable(_tid, _save_in_strings[i]);
      63             : 
      64           0 :     if (var->feType() != _var.feType())
      65           0 :       paramError(
      66             :           "save_in",
      67             :           "saved-in auxiliary variable is incompatible with the object's nonlinear variable: ",
      68           0 :           moose::internal::incompatVarMsg(*var, _var));
      69           0 :     _save_in[i] = var;
      70           0 :     var->sys().addVariableToZeroOnResidual(_save_in_strings[i]);
      71           0 :     addMooseVariableDependency(var);
      72             :   }
      73             : 
      74        1735 :   _has_save_in = _save_in.size() > 0;
      75             : 
      76        1735 :   for (unsigned int i = 0; i < _diag_save_in_strings.size(); i++)
      77             :   {
      78           0 :     MooseVariable * var = &_subproblem.getStandardVariable(_tid, _diag_save_in_strings[i]);
      79             : 
      80           0 :     if (var->feType() != _var.feType())
      81           0 :       paramError(
      82             :           "diag_save_in",
      83             :           "saved-in auxiliary variable is incompatible with the object's nonlinear variable: ",
      84           0 :           moose::internal::incompatVarMsg(*var, _var));
      85             : 
      86           0 :     _diag_save_in[i] = var;
      87           0 :     var->sys().addVariableToZeroOnJacobian(_diag_save_in_strings[i]);
      88           0 :     addMooseVariableDependency(var);
      89             :   }
      90             : 
      91        1735 :   _has_diag_save_in = _diag_save_in.size() > 0;
      92        1735 : }
      93             : 
      94             : template <typename T>
      95             : void
      96      340856 : ADIntegratedBCTempl<T>::computeResidual()
      97             : {
      98      340856 :   _residuals.resize(_test.size(), 0);
      99     3080014 :   for (auto & r : _residuals)
     100     2739158 :     r = 0;
     101             : 
     102     1282064 :   for (_qp = 0; _qp < _qrule->n_points(); _qp++)
     103             :   {
     104      941208 :     const auto jxw_c = _JxW[_qp] * _coord[_qp];
     105     8771846 :     for (_i = 0; _i < _test.size(); _i++)
     106     7830638 :       _residuals[_i] += jxw_c * raw_value(computeQpResidual());
     107             :   }
     108             : 
     109      340856 :   addResiduals(_assembly, _residuals, _var.dofIndices(), _var.scalingFactor());
     110             : 
     111      340856 :   if (_has_save_in)
     112           0 :     for (unsigned int i = 0; i < _save_in.size(); i++)
     113           0 :       _save_in[i]->sys().solution().add_vector(_residuals.data(), _save_in[i]->dofIndices());
     114      340856 : }
     115             : 
     116             : template <typename T>
     117             : void
     118       25944 : ADIntegratedBCTempl<T>::computeResidualsForJacobian()
     119             : {
     120       25944 :   if (_residuals_and_jacobians.size() != _test.size())
     121         739 :     _residuals_and_jacobians.resize(_test.size(), 0);
     122      159506 :   for (auto & r : _residuals_and_jacobians)
     123      133562 :     r = 0;
     124             : 
     125       25944 :   if (_use_displaced_mesh)
     126         112 :     for (_qp = 0; _qp < _qrule->n_points(); _qp++)
     127             :     {
     128          56 :       _r = _ad_JxW[_qp];
     129          56 :       _r *= _ad_coord[_qp];
     130         168 :       for (_i = 0; _i < _test.size(); _i++)
     131         112 :         _residuals_and_jacobians[_i] += _r * computeQpResidual();
     132             :     }
     133             :   else
     134       84675 :     for (_qp = 0; _qp < _qrule->n_points(); _qp++)
     135             :     {
     136       58787 :       const auto jxw_c = _JxW[_qp] * _coord[_qp];
     137      387289 :       for (_i = 0; _i < _test.size(); _i++)
     138      328502 :         _residuals_and_jacobians[_i] += jxw_c * computeQpResidual();
     139             :     }
     140       25944 : }
     141             : 
     142             : template <typename T>
     143             : void
     144        2528 : ADIntegratedBCTempl<T>::computeResidualAndJacobian()
     145             : {
     146        2528 :   computeResidualsForJacobian();
     147        7584 :   addResidualsAndJacobian(
     148        2528 :       _assembly, _residuals_and_jacobians, _var.dofIndices(), _var.scalingFactor());
     149        2528 : }
     150             : 
     151             : template <typename T>
     152             : void
     153           0 : ADIntegratedBCTempl<T>::computeJacobian()
     154             : {
     155           0 :   computeADJacobian();
     156             : 
     157           0 :   if (_has_diag_save_in && !_sys.computingScalingJacobian())
     158           0 :     mooseError("_local_ke not computed for global AD indexing. Save-in is deprecated anyway. Use "
     159             :                "the tagging system instead.");
     160           0 : }
     161             : 
     162             : template <typename T>
     163             : void
     164       23416 : ADIntegratedBCTempl<T>::computeADJacobian()
     165             : {
     166       23416 :   computeResidualsForJacobian();
     167       23416 :   addJacobian(_assembly, _residuals_and_jacobians, _var.dofIndices(), _var.scalingFactor());
     168       23416 : }
     169             : 
     170             : template <typename T>
     171             : void
     172       25358 : ADIntegratedBCTempl<T>::computeOffDiagJacobian(const unsigned int jvar)
     173             : {
     174             :   // Only need to do this once because AD does all the derivatives at once
     175       25358 :   if (jvar == _var.number())
     176       23416 :     computeADJacobian();
     177       25358 : }
     178             : 
     179             : template <typename T>
     180             : void
     181           0 : ADIntegratedBCTempl<T>::computeOffDiagJacobianScalar(unsigned int /*jvar*/)
     182             : {
     183           0 : }
     184             : 
     185             : template class ADIntegratedBCTempl<Real>;
     186             : template class ADIntegratedBCTempl<RealVectorValue>;