ADRayKernel.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 "ADRayKernel.h"
 
// Local includes
#include "RayTracingStudy.h"
 
// MOOSE includes
#include "Assembly.h"
#include "NonlinearSystemBase.h"
#include "ADUtils.h"
 
template <typename T>
InputParameters
ADRayKernelTempl<T>::validParams()
{
  auto params = IntegralRayKernelBase::validParams();
  params += TaggingInterface::validParams();
 
  params.template addRequiredParam<NonlinearVariableName>(
      "variable", "The name of the variable that this ADRayKernel operates on");
 
  return params;
}
 
template <typename T>
ADRayKernelTempl<T>::ADRayKernelTempl(const InputParameters & params)
  : IntegralRayKernelBase(params),
    MooseVariableInterface<T>(this,
                              false,
                              "variable",
                              Moose::VarKindType::VAR_SOLVER,
                              std::is_same<T, Real>::value ? Moose::VarFieldType::VAR_FIELD_STANDARD
                                                           : Moose::VarFieldType::VAR_FIELD_VECTOR),
    TaggingInterface(this),
    _var(this->mooseVariableField()),
    _test(_var.phi()),
    _u(_var.adSln()),
    _grad_u(_var.adGradSln()),
    _phi(_assembly.phi(_var))
{
  // We do not allow RZ/RSPHERICAL because in the context of these coord
  // systems there is no way to represent a line source - we would end up
  // with a plane/surface source or a volumetric source, respectively.
  // This is also why we do not multiply by _coord[_qp] in any of the
  // integrations that follow.
  for (const auto & subdomain_id : _mesh.meshSubdomains())
    if (_fe_problem.getCoordSystem(subdomain_id) != Moose::COORD_XYZ)
      mooseError("Not valid on coordinate systems other than XYZ");
 
  _subproblem.haveADObjects(true);
 
  addMooseVariableDependency(&variable());
 
  if (!isImplicit())
    mooseError("ADRayKernels do not currently support explicit solves.");
}
 
template <typename T>
void
ADRayKernelTempl<T>::onSegment()
{
  mooseAssert(_current_subdomain_id == _assembly.currentSubdomainID(), "Subdomain IDs not in sync");
  mooseAssert(_fe_problem.currentlyComputingJacobian() || _fe_problem.currentlyComputingResidual(),
              "Not computing residual or Jacobian");
 
  if (_fe_problem.currentlyComputingJacobian())
    computeJacobian();
  else if (_fe_problem.currentlyComputingResidual())
    computeResidual();
}
 
template <typename T>
void
ADRayKernelTempl<T>::computeResidual()
{
  prepareVectorTag(_assembly, _var.number());
 
  precalculateResidual();
  for (_qp = 0; _qp < _JxW.size(); _qp++)
    for (_i = 0; _i < _test.size(); _i++)
      _local_re(_i) += raw_value(_JxW[_qp] * computeQpResidual());
 
  accumulateTaggedLocalResidual();
}
 
template <typename T>
void
ADRayKernelTempl<T>::computeJacobian()
{
  _subproblem.prepareShapes(_var.number(), _tid);
 
  for (auto & r : _residuals)
    r = 0;
  _residuals.resize(_test.size(), 0);
 
  precalculateResidual();
  for (_qp = 0; _qp < _JxW.size(); _qp++)
    for (_i = 0; _i < _test.size(); _i++)
      _residuals[_i] += _JxW[_qp] * computeQpResidual();
 
  addJacobian(_assembly, _residuals, _var.dofIndices(), _var.scalingFactor());
}
 
template class ADRayKernelTempl<Real>;
 
// Not implementing this until there is a use case and tests for it!
// template class ADRayKernelTempl<RealVectorValue>;