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 "DiffusionLHDGAssemblyHelper.h"
      11             : #include "DiffusionLHDGPrescribedGradientBC.h"
      12             : 
      13             : registerMooseObject("MooseApp", DiffusionLHDGPrescribedGradientBC);
      14             : 
      15             : InputParameters
      16        3174 : DiffusionLHDGPrescribedGradientBC::validParams()
      17             : {
      18        3174 :   auto params = IntegratedBC::validParams();
      19        3174 :   params += DiffusionLHDGAssemblyHelper::validParams();
      20       19044 :   params.renameParam("variable", "u", "The diffusing specie concentration");
      21        6348 :   params.addClassDescription("Implements a flux boundary condition for use with a hybridized "
      22             :                              "discretization of the diffusion equation");
      23        6348 :   params.addParam<MooseFunctorName>(
      24        6348 :       "normal_gradient", 0, "The prescribed value of the gradient dotted with the normal");
      25        3174 :   return params;
      26           0 : }
      27             : 
      28          57 : DiffusionLHDGPrescribedGradientBC::DiffusionLHDGPrescribedGradientBC(
      29          57 :     const InputParameters & parameters)
      30             :   : IntegratedBC(parameters),
      31          57 :     DiffusionLHDGAssemblyHelper(this, this, this, this, _fe_problem, _sys, _tid),
      32          57 :     _normal_gradient(getFunctor<Real>("normal_gradient")),
      33          57 :     _cached_side(libMesh::invalid_uint)
      34             : {
      35          57 : }
      36             : 
      37             : void
      38          57 : DiffusionLHDGPrescribedGradientBC::initialSetup()
      39             : {
      40          57 :   checkCoupling();
      41          57 : }
      42             : 
      43             : void
      44        1625 : DiffusionLHDGPrescribedGradientBC::computeResidual()
      45             : {
      46        1625 :   _vector_re.resize(_qu_dof_indices.size());
      47        1625 :   _scalar_re.resize(_u_dof_indices.size());
      48        1625 :   _lm_re.resize(_lm_u_dof_indices.size());
      49             : 
      50             :   // For notation, please read "A superconvergent LDG-hybridizable Galerkin method for second-order
      51             :   // elliptic problems" by Cockburn
      52             : 
      53             :   // qu, u, lm_u
      54        1625 :   vectorFaceResidual(_lm_u_sol, _JxW, *_qrule, _normals, _vector_re);
      55        1625 :   scalarFaceResidual(_qu_sol, _u_sol, _lm_u_sol, _JxW, *_qrule, _normals, _scalar_re);
      56        1625 :   lmFaceResidual(_qu_sol, _u_sol, _lm_u_sol, _JxW, *_qrule, _normals, _lm_re);
      57             : 
      58        4875 :   for (const auto qp : make_range(_qrule->n_points()))
      59       22750 :     for (const auto i : index_range(_lm_re))
      60             :       // prescribed normal gradient
      61       19500 :       _lm_re(i) += _JxW[qp] * _diff[qp] * _lm_phi_face[i][qp] *
      62       19500 :                    _normal_gradient(
      63       19500 :                        Moose::ElemSideQpArg{_current_elem, _current_side, qp, _qrule, _q_point[qp]},
      64       39000 :                        determineState());
      65             : 
      66        1625 :   addResiduals(_assembly, _vector_re, _qu_dof_indices, _grad_u_var.scalingFactor());
      67        1625 :   addResiduals(_assembly, _scalar_re, _u_dof_indices, _u_var.scalingFactor());
      68        1625 :   addResiduals(_assembly, _lm_re, _lm_u_dof_indices, _u_face_var.scalingFactor());
      69        1625 : }
      70             : 
      71             : void
      72         650 : DiffusionLHDGPrescribedGradientBC::computeJacobian()
      73             : {
      74         650 :   _vector_vector_jac.resize(_qu_dof_indices.size(), _qu_dof_indices.size());
      75         650 :   _vector_scalar_jac.resize(_qu_dof_indices.size(), _u_dof_indices.size());
      76         650 :   _scalar_vector_jac.resize(_u_dof_indices.size(), _qu_dof_indices.size());
      77         650 :   _scalar_scalar_jac.resize(_u_dof_indices.size(), _u_dof_indices.size());
      78         650 :   _scalar_lm_jac.resize(_u_dof_indices.size(), _lm_u_dof_indices.size());
      79         650 :   _lm_scalar_jac.resize(_lm_u_dof_indices.size(), _u_dof_indices.size());
      80         650 :   _lm_lm_jac.resize(_lm_u_dof_indices.size(), _lm_u_dof_indices.size());
      81         650 :   _vector_lm_jac.resize(_qu_dof_indices.size(), _lm_u_dof_indices.size());
      82         650 :   _lm_vector_jac.resize(_lm_u_dof_indices.size(), _qu_dof_indices.size());
      83             : 
      84             :   // qu, u, lm_u
      85         650 :   vectorFaceJacobian(_JxW, *_qrule, _normals, _vector_lm_jac);
      86         650 :   scalarFaceJacobian(
      87         650 :       _JxW, *_qrule, _normals, _scalar_vector_jac, _scalar_scalar_jac, _scalar_lm_jac);
      88         650 :   lmFaceJacobian(_JxW, *_qrule, _normals, _lm_vector_jac, _lm_scalar_jac, _lm_lm_jac);
      89             : 
      90        1300 :   addJacobian(
      91         650 :       _assembly, _vector_vector_jac, _qu_dof_indices, _qu_dof_indices, _grad_u_var.scalingFactor());
      92        1300 :   addJacobian(
      93         650 :       _assembly, _vector_scalar_jac, _qu_dof_indices, _u_dof_indices, _grad_u_var.scalingFactor());
      94        1300 :   addJacobian(
      95         650 :       _assembly, _scalar_vector_jac, _u_dof_indices, _qu_dof_indices, _u_var.scalingFactor());
      96        1300 :   addJacobian(
      97         650 :       _assembly, _scalar_scalar_jac, _u_dof_indices, _u_dof_indices, _u_var.scalingFactor());
      98         650 :   addJacobian(_assembly, _scalar_lm_jac, _u_dof_indices, _lm_u_dof_indices, _u_var.scalingFactor());
      99        1300 :   addJacobian(
     100         650 :       _assembly, _lm_scalar_jac, _lm_u_dof_indices, _u_dof_indices, _u_face_var.scalingFactor());
     101        1300 :   addJacobian(
     102         650 :       _assembly, _lm_lm_jac, _lm_u_dof_indices, _lm_u_dof_indices, _u_face_var.scalingFactor());
     103        1300 :   addJacobian(
     104         650 :       _assembly, _vector_lm_jac, _qu_dof_indices, _lm_u_dof_indices, _grad_u_var.scalingFactor());
     105        1300 :   addJacobian(
     106         650 :       _assembly, _lm_vector_jac, _lm_u_dof_indices, _qu_dof_indices, _u_face_var.scalingFactor());
     107         650 : }
     108             : 
     109             : void
     110         104 : DiffusionLHDGPrescribedGradientBC::jacobianSetup()
     111             : {
     112         104 :   _cached_elem = nullptr;
     113         104 :   _cached_side = libMesh::invalid_uint;
     114         104 : }
     115             : 
     116             : void
     117        1950 : DiffusionLHDGPrescribedGradientBC::computeOffDiagJacobian(const unsigned int)
     118             : {
     119        1950 :   if ((_cached_elem != _current_elem) || (_cached_side != _current_side))
     120             :   {
     121         650 :     computeJacobian();
     122         650 :     _cached_elem = _current_elem;
     123         650 :     _cached_side = _current_side;
     124             :   }
     125        1950 : }