ACBulk.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://www.mooseframework.org
//*
//* 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 "KernelValue.h"
#include "JvarMapInterface.h"
#include "DerivativeMaterialInterface.h"
 
template <typename T>
class ACBulk : public DerivativeMaterialInterface<JvarMapKernelInterface<KernelValue>>
{
public:
  ACBulk(const InputParameters & parameters);
 
  static InputParameters validParams();
  virtual void initialSetup();
 
protected:
  virtual Real precomputeQpResidual();
  virtual Real precomputeQpJacobian();
  virtual Real computeQpOffDiagJacobian(unsigned int jvar);
 
  enum PFFunctionType
  {
    Jacobian,
    Residual
  };
 
  virtual Real computeDFDOP(PFFunctionType type) = 0;
 
  const MaterialProperty<T> & _L;
 
  const MaterialProperty<T> & _dLdop;
 
  std::vector<const MaterialProperty<T> *> _dLdarg;
};
 
template <typename T>
ACBulk<T>::ACBulk(const InputParameters & parameters)
  : DerivativeMaterialInterface<JvarMapKernelInterface<KernelValue>>(parameters),
    _L(getMaterialProperty<T>("mob_name")),
    _dLdop(getMaterialPropertyDerivative<T>("mob_name", _var.name()))
{
  // Get number of coupled variables
  unsigned int nvar = _coupled_moose_vars.size();
 
  // reserve space for derivatives
  _dLdarg.resize(nvar);
 
  // Iterate over all coupled variables
  for (unsigned int i = 0; i < nvar; ++i)
    _dLdarg[i] = &getMaterialPropertyDerivative<T>("mob_name", _coupled_moose_vars[i]->name());
}
 
template <typename T>
InputParameters
ACBulk<T>::validParams()
{
  InputParameters params = ::validParams<KernelValue>();
  params.addClassDescription("Allen-Cahn base Kernel");
  params.addParam<MaterialPropertyName>("mob_name", "L", "The mobility used with the kernel");
  params.addCoupledVar("args", "Vector of arguments of the mobility");
  return params;
}
 
template <typename T>
void
ACBulk<T>::initialSetup()
{
  validateNonlinearCoupling<Real>("mob_name");
}
 
template <typename T>
Real
ACBulk<T>::precomputeQpResidual()
{
  // Get free energy derivative from function
  Real dFdop = computeDFDOP(Residual);
 
  // Set residual
  return _L[_qp] * dFdop;
}
 
template <typename T>
Real
ACBulk<T>::precomputeQpJacobian()
{
  // Get free energy derivative and Jacobian
  Real dFdop = computeDFDOP(Residual);
 
  Real JdFdop = computeDFDOP(Jacobian);
 
  // Set Jacobian value using product rule
  return _L[_qp] * JdFdop + _dLdop[_qp] * _phi[_j][_qp] * dFdop;
}
 
template <typename T>
Real
ACBulk<T>::computeQpOffDiagJacobian(unsigned int jvar)
{
  // Get the coupled variable jvar is referring to
  const unsigned int cvar = mapJvarToCvar(jvar);
 
  // Set off-diagonal Jacobian term from mobility derivatives
  return (*_dLdarg[cvar])[_qp] * _phi[_j][_qp] * computeDFDOP(Residual) * _test[_i][_qp];
}