ADUtils.h

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
 
#pragma once
 
#include "MooseError.h"
#include "MooseTypes.h"
 
class SubProblem;
class SystemBase;
namespace libMesh
{
class Elem;
}
 
namespace Moose
{
inline bool
globalADIndexing()
{
  return true;
}
 
inline std::size_t
adOffset(unsigned int var_num,
         std::size_t max_dofs_per_elem,
         ElementType element_type = ElementType::Element,
         unsigned int num_vars_in_system = 0)
{
  // If our element type is anything other than ElementType::Element, then the user must
  // supply num_vars_in_system in order to calculate the offset
  mooseAssert(element_type == ElementType::Element || num_vars_in_system,
              "If our element type is anything other than ElementType::Element, then you "
              "must supply num_vars_in_system in order to calculate the offset");
 
  switch (element_type)
  {
    case ElementType::Element:
      return var_num * max_dofs_per_elem;
 
    case ElementType::Neighbor:
      return num_vars_in_system * max_dofs_per_elem + var_num * max_dofs_per_elem;
 
    case ElementType::Lower:
      return 2 * num_vars_in_system * max_dofs_per_elem + var_num * max_dofs_per_elem;
 
    default:
      mooseError(
          "Unsupported element type ",
          static_cast<typename std::underlying_type<decltype(element_type)>::type>(element_type));
  }
}
 
inline std::size_t
adOffset(unsigned int var_num,
         std::size_t max_dofs_per_elem,
         DGJacobianType dg_jacobian_type,
         unsigned int num_vars_in_system = 0)
{
  if (dg_jacobian_type == DGJacobianType::ElementElement ||
      dg_jacobian_type == DGJacobianType::NeighborElement)
    return adOffset(var_num, max_dofs_per_elem, ElementType::Element);
  else
    return adOffset(var_num, max_dofs_per_elem, ElementType::Neighbor, num_vars_in_system);
}
 
std::unordered_map<dof_id_type, Real>
globalDofIndexToDerivative(const ADReal & ad_real,
                           const SystemBase & sys,
                           ElementType elem_type = ElementType::Element,
                           THREAD_ID tid = 0);
 
template <typename T>
auto
globalDofIndexToDerivative(const T & ad_real_container,
                           const SystemBase & sys,
                           ElementType elem_type = ElementType::Element,
                           THREAD_ID tid = 0)
    -> std::vector<std::unordered_map<
        dof_id_type,
        typename std::enable_if<std::is_same<ADReal, typename T::value_type>::value, Real>::type>>
{
  std::vector<std::unordered_map<dof_id_type, Real>> ret_val(ad_real_container.size());
 
  for (MooseIndex(ad_real_container) i = 0; i < ad_real_container.size(); ++i)
    ret_val[i] = globalDofIndexToDerivative(ad_real_container[i], sys, elem_type, tid);
 
  return ret_val;
}
 
bool doDerivatives(const SubProblem & subproblem, const SystemBase & sys);
 
template <bool is_ad>
GenericReal<is_ad>
ADRealToGenericReal(const ADReal & u_ad)
{
  if constexpr (is_ad)
    return u_ad;
  else
    return u_ad.value();
}
}