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);
  }
}