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 "FVScalarLagrangeMultiplierConstraint.h"
      11             : 
      12             : #include "MooseVariableScalar.h"
      13             : #include "MooseVariableFV.h"
      14             : #include "Assembly.h"
      15             : 
      16             : InputParameters
      17       57322 : FVScalarLagrangeMultiplierConstraint::validParams()
      18             : {
      19       57322 :   InputParameters params = FVElementalKernel::validParams();
      20       57322 :   params.addClassDescription(
      21             :       "Base class for imposing constraints using scalar Lagrange multipliers");
      22       57322 :   params.addParam<PostprocessorName>("phi0", "0", "The value that the constraint will enforce.");
      23       57322 :   params.addRequiredCoupledVar("lambda", "Lagrange multiplier variable");
      24       57322 :   return params;
      25           0 : }
      26             : 
      27         134 : FVScalarLagrangeMultiplierConstraint::FVScalarLagrangeMultiplierConstraint(
      28         134 :     const InputParameters & parameters)
      29             :   : FVElementalKernel(parameters),
      30         134 :     _phi0(getPostprocessorValue("phi0")),
      31         134 :     _lambda_var(*getScalarVar("lambda", 0)),
      32         268 :     _lambda(adCoupledScalarValue("lambda"))
      33             : {
      34         134 : }
      35             : 
      36             : void
      37        6426 : FVScalarLagrangeMultiplierConstraint::computeResidualAndJacobian()
      38             : {
      39        6426 :   const auto volume = _assembly.elemVolume();
      40       25704 :   addResidualsAndJacobian(_assembly,
      41        6426 :                           std::array<ADReal, 1>{{_lambda[0] * volume}},
      42        6426 :                           _var.dofIndices(),
      43        6426 :                           _var.scalingFactor());
      44       25704 :   addResidualsAndJacobian(_assembly,
      45        6426 :                           std::array<ADReal, 1>{{computeQpResidual() * volume}},
      46        6426 :                           _lambda_var.dofIndices(),
      47        6426 :                           _lambda_var.scalingFactor());
      48       19278 : }
      49             : 
      50             : void
      51        9739 : FVScalarLagrangeMultiplierConstraint::computeResidual()
      52             : {
      53             :   // Primal residual
      54        9739 :   prepareVectorTag(_assembly, _var.number());
      55             :   mooseAssert(_local_re.size() == 1, "We should only have a single dof");
      56             :   mooseAssert(_lambda.size() == 1 && _lambda_var.order() == 1,
      57             :               "The lambda variable should be first order");
      58        9739 :   _local_re(0) += MetaPhysicL::raw_value(_lambda[0]) * _assembly.elemVolume();
      59        9739 :   accumulateTaggedLocalResidual();
      60             : 
      61             :   // LM residual. We may not have any actual ScalarKernels in our simulation so we need to manually
      62             :   // make sure the scalar residuals get cached for later addition
      63        9739 :   const auto lm_r = MetaPhysicL::raw_value(computeQpResidual()) * _assembly.elemVolume();
      64             :   mooseAssert(_lambda_var.dofIndices().size() == 1, "We should only have a single dof");
      65       29217 :   addResiduals(_assembly,
      66        9739 :                std::array<Real, 1>{{lm_r}},
      67        9739 :                _lambda_var.dofIndices(),
      68        9739 :                _lambda_var.scalingFactor());
      69        9739 : }
      70             : 
      71             : void
      72           0 : FVScalarLagrangeMultiplierConstraint::computeJacobian()
      73             : {
      74           0 : }
      75             : 
      76             : void
      77        3009 : FVScalarLagrangeMultiplierConstraint::computeOffDiagJacobian()
      78             : {
      79             :   // Primal
      80             :   mooseAssert(_lambda.size() == 1 && _lambda_var.order() == 1,
      81             :               "The lambda variable should be first order");
      82        3009 :   const auto primal_r = _lambda[0] * _assembly.elemVolume();
      83             :   mooseAssert(_var.dofIndices().size() == 1, "We should only have one dof");
      84       12036 :   addJacobian(
      85        6018 :       _assembly, std::array<ADReal, 1>{{primal_r}}, _var.dofIndices(), _var.scalingFactor());
      86             : 
      87             :   // LM
      88        3009 :   const auto lm_r = computeQpResidual() * _assembly.elemVolume();
      89             :   mooseAssert(_lambda_var.dofIndices().size() == 1, "We should only have one dof");
      90       12036 :   addJacobian(_assembly,
      91        3009 :               std::array<ADReal, 1>{{lm_r}},
      92        3009 :               _lambda_var.dofIndices(),
      93        3009 :               _lambda_var.scalingFactor());
      94        9027 : }