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 "DivergenceAux.h"
      11             : #include "MooseMesh.h"
      12             : 
      13             : registerMooseObject("MooseApp", DivergenceAux);
      14             : registerMooseObject("MooseApp", ADDivergenceAux);
      15             : 
      16             : template <bool is_ad>
      17             : InputParameters
      18       28601 : DivergenceAuxTempl<is_ad>::validParams()
      19             : {
      20       28601 :   InputParameters params = AuxKernel::validParams();
      21             : 
      22       28601 :   params.addClassDescription("Computes the divergence of a vector of functors.");
      23             :   // Coupled functors
      24       28601 :   params.addRequiredParam<MooseFunctorName>("u", "x-component of the vector");
      25       28601 :   params.addParam<MooseFunctorName>("v", "y-component of the vector"); // only required in 2D and 3D
      26       28601 :   params.addParam<MooseFunctorName>("w", "z-component of the vector"); // only required in 3D
      27             : 
      28       28601 :   return params;
      29           0 : }
      30             : 
      31             : template <bool is_ad>
      32          37 : DivergenceAuxTempl<is_ad>::DivergenceAuxTempl(const InputParameters & parameters)
      33             :   : AuxKernel(parameters),
      34          37 :     _u(getFunctor<GenericReal<is_ad>>("u")),
      35          37 :     _v(_mesh.dimension() >= 2 ? &getFunctor<GenericReal<is_ad>>("v") : nullptr),
      36          37 :     _w(_mesh.dimension() == 3 ? &getFunctor<GenericReal<is_ad>>("w") : nullptr),
      37          74 :     _use_qp_arg(dynamic_cast<MooseVariableFE<Real> *>(&_var))
      38             : {
      39          37 : }
      40             : 
      41             : template <bool is_ad>
      42             : Real
      43       29218 : DivergenceAuxTempl<is_ad>::computeValue()
      44             : {
      45             :   using MetaPhysicL::raw_value;
      46       29218 :   const auto state = determineState();
      47       29218 :   Real divergence = 0;
      48       29218 :   if (_use_qp_arg)
      49             :   {
      50       23786 :     const Moose::ElemQpArg qp_arg = {_current_elem, _qp, _qrule, _q_point[_qp]};
      51       23786 :     divergence += raw_value(_u.gradient(qp_arg, state)(0));
      52       23786 :     if (_v)
      53       23744 :       divergence += raw_value(_v->gradient(qp_arg, state)(1));
      54       23786 :     if (_w)
      55           0 :       divergence += raw_value(_w->gradient(qp_arg, state)(2));
      56       23786 :     return divergence;
      57             :   }
      58             :   else
      59             :   {
      60        5432 :     const auto elem_arg = makeElemArg(_current_elem);
      61        5432 :     divergence += raw_value(_u.gradient(elem_arg, state)(0));
      62        5432 :     if (_v)
      63        5432 :       divergence += raw_value(_v->gradient(elem_arg, state)(1));
      64        5432 :     if (_w)
      65           0 :       divergence += raw_value(_w->gradient(elem_arg, state)(2));
      66        5432 :     return divergence;
      67             :   }
      68             : }