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       12485 : FVScalarLagrangeMultiplierConstraint::validParams()
      18             : {
      19       12485 :   InputParameters params = FVElementalKernel::validParams();
      20       24970 :   params.addClassDescription(
      21             :       "Base class for imposing constraints using scalar Lagrange multipliers");
      22       49940 :   params.addParam<PostprocessorName>("phi0", "0", "The value that the constraint will enforce.");
      23       37455 :   params.addRequiredCoupledVar("lambda", "Lagrange multiplier variable");
      24       12485 :   return params;
      25           0 : }
      26             : 
      27         124 : FVScalarLagrangeMultiplierConstraint::FVScalarLagrangeMultiplierConstraint(
      28         124 :     const InputParameters & parameters)
      29             :   : FVElementalKernel(parameters),
      30         124 :     _phi0(getPostprocessorValue("phi0")),
      31         248 :     _lambda_var(*getScalarVar("lambda", 0)),
      32         372 :     _lambda(adCoupledScalarValue("lambda"))
      33             : {
      34         124 : }
      35             : 
      36             : void
      37        5292 : FVScalarLagrangeMultiplierConstraint::computeResidualAndJacobian()
      38             : {
      39        5292 :   const auto volume = _assembly.elemVolume();
      40       21168 :   addResidualsAndJacobian(_assembly,
      41        5292 :                           std::array<ADReal, 1>{{_lambda[0] * volume}},
      42        5292 :                           _var.dofIndices(),
      43        5292 :                           _var.scalingFactor());
      44       21168 :   addResidualsAndJacobian(_assembly,
      45        5292 :                           std::array<ADReal, 1>{{computeQpResidual() * volume}},
      46        5292 :                           _lambda_var.dofIndices(),
      47        5292 :                           _lambda_var.scalingFactor());
      48        5292 : }
      49             : 
      50             : void
      51        8245 : FVScalarLagrangeMultiplierConstraint::computeResidual()
      52             : {
      53             :   // Primal residual
      54        8245 :   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        8245 :   _local_re(0) += MetaPhysicL::raw_value(_lambda[0]) * _assembly.elemVolume();
      59        8245 :   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        8245 :   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       24735 :   addResiduals(_assembly,
      66        8245 :                std::array<Real, 1>{{lm_r}},
      67        8245 :                _lambda_var.dofIndices(),
      68        8245 :                _lambda_var.scalingFactor());
      69        8245 : }
      70             : 
      71             : void
      72           0 : FVScalarLagrangeMultiplierConstraint::computeJacobian()
      73             : {
      74           0 : }
      75             : 
      76             : void
      77        2647 : FVScalarLagrangeMultiplierConstraint::computeOffDiagJacobian()
      78             : {
      79             :   // Primal
      80             :   mooseAssert(_lambda.size() == 1 && _lambda_var.order() == 1,
      81             :               "The lambda variable should be first order");
      82        2647 :   const auto primal_r = _lambda[0] * _assembly.elemVolume();
      83             :   mooseAssert(_var.dofIndices().size() == 1, "We should only have one dof");
      84       10588 :   addJacobian(
      85        2647 :       _assembly, std::array<ADReal, 1>{{primal_r}}, _var.dofIndices(), _var.scalingFactor());
      86             : 
      87             :   // LM
      88        2647 :   const auto lm_r = computeQpResidual() * _assembly.elemVolume();
      89             :   mooseAssert(_lambda_var.dofIndices().size() == 1, "We should only have one dof");
      90       10588 :   addJacobian(_assembly,
      91        2647 :               std::array<ADReal, 1>{{lm_r}},
      92        2647 :               _lambda_var.dofIndices(),
      93        2647 :               _lambda_var.scalingFactor());
      94        2647 : }