ShapeUserObject.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 "Assembly.h"
#include "Coupleable.h"
#include "InputParameters.h"
#include "MooseVariableFE.h"
#include "MooseObject.h"

enum class ShapeType
{
  Element,
  Side
};

template <typename T>
class ShapeUserObject : public T
{
public:
  static InputParameters validParams();

  ShapeUserObject(const InputParameters & parameters, ShapeType type);

  const bool & computeJacobianFlag() const { return _compute_jacobians; }

  const std::set<const MooseVariableFEBase *> & jacobianMooseVariables() const
  {
    return _jacobian_moose_variables;
  }

  virtual void executeJacobianWrapper(unsigned int jvar,
                                      const std::vector<dof_id_type> & dof_indices);

protected:
  virtual void executeJacobian(unsigned int /*jvar*/) = 0;

  virtual unsigned int coupled(const std::string & var_name, unsigned int comp = 0) const override;

  const VariablePhiValue & _phi;

  const VariablePhiGradient & _grad_phi;

  unsigned int _j;

  dof_id_type _j_global;

private:
  const bool _compute_jacobians;
  mutable std::set<const MooseVariableFEBase *> _jacobian_moose_variables;
};

template <typename T>
ShapeUserObject<T>::ShapeUserObject(const InputParameters & parameters, ShapeType type)
  : T(parameters),
    _phi(type == ShapeType::Element ? this->_assembly.phi() : this->_assembly.phiFace()),
    _grad_phi(type == ShapeType::Element ? this->_assembly.gradPhi()
                                         : this->_assembly.gradPhiFace()),
    _compute_jacobians(MooseObject::getParam<bool>("compute_jacobians"))
{
  mooseWarning("Jacobian calculation in UserObjects is an experimental capability with a "
               "potentially unstable interface.");
}

template <typename T>
InputParameters
ShapeUserObject<T>::validParams()
{
  InputParameters params = emptyInputParameters();
  params.addParam<bool>("compute_jacobians", true, "Compute Jacobians for coupled variables");
  params.addParamNamesToGroup("compute_jacobians", "Advanced");
  return params;
}

template <typename T>
unsigned int
ShapeUserObject<T>::coupled(const std::string & var_name, unsigned int comp) const
{
  const auto * var = this->template getVarHelper<MooseVariable>(var_name, comp);

  // add to the set of variables for which executeJacobian will be called
  if (_compute_jacobians && var->kind() == Moose::VAR_SOLVER)
    _jacobian_moose_variables.insert(var);

  // return the variable number
  return T::coupled(var_name, comp);
}

template <typename T>
void
ShapeUserObject<T>::executeJacobianWrapper(unsigned int jvar,
                                           const std::vector<dof_id_type> & dof_indices)
{
  for (_j = 0; _j < _phi.size(); ++_j)
  {
    _j_global = dof_indices[_j];
    executeJacobian(jvar);
  }
}