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 "FVScalarLagrangeMultiplierInterface.h"
      11             : #include "MooseVariableScalar.h"
      12             : #include "Assembly.h"
      13             : 
      14             : InputParameters
      15       14340 : FVScalarLagrangeMultiplierInterface::validParams()
      16             : {
      17       14340 :   InputParameters params = FVInterfaceKernel::validParams();
      18       14340 :   params.addClassDescription(
      19             :       "This class should be inherited to create interface penalties in finite volume.");
      20       14340 :   params.addRequiredCoupledVar("lambda", "The name of the scalar lagrange multiplier");
      21             : 
      22       14340 :   return params;
      23           0 : }
      24             : 
      25          39 : FVScalarLagrangeMultiplierInterface::FVScalarLagrangeMultiplierInterface(
      26          39 :     const InputParameters & params)
      27             :   : FVInterfaceKernel(params),
      28          39 :     _lambda_var(*getScalarVar("lambda", 0)),
      29          78 :     _lambda(adCoupledScalarValue("lambda"))
      30             : {
      31          39 :   if (var1().sys().number() != var2().sys().number())
      32           0 :     mooseError(this->type(), " does not support multiple nonlinear systems!");
      33          39 : }
      34             : 
      35             : void
      36          32 : FVScalarLagrangeMultiplierInterface::computeResidual(const FaceInfo & fi)
      37             : {
      38          32 :   setupData(fi);
      39             : 
      40          32 :   const auto var_elem_num = _elem_is_one ? var1().number() : var2().number();
      41          32 :   const auto var_neigh_num = _elem_is_one ? var2().number() : var1().number();
      42             : 
      43             :   const auto r =
      44          32 :       MetaPhysicL::raw_value(_lambda[0]) * fi.faceArea() * fi.faceCoord() * (2 * _elem_is_one - 1);
      45             : 
      46             :   // Primal residual
      47          32 :   addResidual(r, var_elem_num, false);
      48          32 :   addResidual(-r, var_neigh_num, true);
      49             : 
      50             :   // LM residual. We may not have any actual ScalarKernels in our simulation so we need to manually
      51             :   // make sure the scalar residuals get cached for later addition
      52          32 :   const auto lm_r = MetaPhysicL::raw_value(computeQpResidual()) * fi.faceArea() * fi.faceCoord();
      53          96 :   addResiduals(_assembly,
      54          32 :                std::array<Real, 1>{{lm_r}},
      55          32 :                _lambda_var.dofIndices(),
      56          32 :                _lambda_var.scalingFactor());
      57          32 : }
      58             : 
      59             : void
      60          32 : FVScalarLagrangeMultiplierInterface::computeJacobian(const FaceInfo & fi)
      61             : {
      62          32 :   setupData(fi);
      63             : 
      64          32 :   const auto & elem_dof_indices = _elem_is_one ? var1().dofIndices() : var2().dofIndices();
      65             :   const auto & neigh_dof_indices =
      66          32 :       _elem_is_one ? var2().dofIndicesNeighbor() : var1().dofIndicesNeighbor();
      67             :   mooseAssert((elem_dof_indices.size() == 1) && (neigh_dof_indices.size() == 1),
      68             :               "We're currently built to use CONSTANT MONOMIALS");
      69          32 :   const auto elem_scaling_factor = _elem_is_one ? var1().scalingFactor() : var2().scalingFactor();
      70          32 :   const auto neigh_scaling_factor = _elem_is_one ? var2().scalingFactor() : var1().scalingFactor();
      71             : 
      72             :   // Primal
      73          32 :   const auto primal_r = _lambda[0] * fi.faceArea() * fi.faceCoord() * (2 * _elem_is_one - 1);
      74          64 :   addResidualsAndJacobian(
      75          32 :       _assembly, std::array<ADReal, 1>{{primal_r}}, elem_dof_indices, elem_scaling_factor);
      76          64 :   addResidualsAndJacobian(
      77          32 :       _assembly, std::array<ADReal, 1>{{-primal_r}}, neigh_dof_indices, neigh_scaling_factor);
      78             : 
      79             :   // LM
      80          32 :   const auto lm_r = computeQpResidual() * fi.faceArea() * fi.faceCoord();
      81             :   mooseAssert(_lambda_var.dofIndices().size() == 1, "We should only have one dof");
      82         128 :   addResidualsAndJacobian(_assembly,
      83          32 :                           std::array<ADReal, 1>{{lm_r}},
      84          32 :                           _lambda_var.dofIndices(),
      85          32 :                           _lambda_var.scalingFactor());
      86         128 : }