ADDGAdvection.C

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html

#include "ADDGAdvection.h"

registerMooseObject("MooseApp", ADDGAdvection);

InputParameters
ADDGAdvection::validParams()
{
  InputParameters params = ADDGKernel::validParams();
  params.addRequiredParam<MaterialPropertyName>("velocity", "Velocity vector");
  params.addClassDescription(
      "Adds internal face advection flux contributions for discontinuous Galerkin discretizations");
  params.addParam<MaterialPropertyName>("advected_quantity",
                                        "An optional material property to be advected. If not "
                                        "supplied, then the variable will be used.");
  return params;
}

ADDGAdvection::ADDGAdvection(const InputParameters & parameters)
  : ADDGKernel(parameters),
    _velocity(getADMaterialProperty<RealVectorValue>("velocity")),
    _velocity_neighbor(getNeighborADMaterialProperty<RealVectorValue>("velocity")),
    _adv_quant_elem(isParamValid("advected_quantity")
                        ? getADMaterialProperty<Real>("advected_quantity").get()
                        : _u),
    _adv_quant_neighbor(isParamValid("advected_quantity")
                            ? getNeighborADMaterialProperty<Real>("advected_quantity").get()
                            : _u_neighbor)
{
}

ADReal
ADDGAdvection::computeQpResidual(Moose::DGResidualType type)
{
  ADReal r = 0;

  auto average = [](const auto & elem_value, const auto & neighbor_value)
  { return (elem_value + neighbor_value) / 2; };

  const auto vdotn = average(_velocity[_qp], _velocity_neighbor[_qp]) * _normals[_qp];

  const auto face_u = [&]()
  {
    if (vdotn >= 0)
      return _adv_quant_elem[_qp];
    else
      return _adv_quant_neighbor[_qp];
  }();

  switch (type)
  {
    case Moose::Element:
      r += vdotn * face_u * _test[_i][_qp];
      break;

    case Moose::Neighbor:
      r -= vdotn * face_u * _test_neighbor[_i][_qp];
      break;
  }

  return r;
}