CHBulk.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 "KernelGrad.h"
#include "JvarMapInterface.h"
#include "DerivativeMaterialInterface.h"
 
template <typename T>
class CHBulk : public DerivativeMaterialInterface<JvarMapKernelInterface<KernelGrad>>
{
public:
  CHBulk(const InputParameters & parameters);
 
  static InputParameters validParams();
  virtual void initialSetup();
 
protected:
  virtual RealGradient precomputeQpResidual();
  virtual RealGradient precomputeQpJacobian();
  virtual Real computeQpOffDiagJacobian(unsigned int jvar);
 
  enum PFFunctionType
  {
    Jacobian,
    Residual
  };
 
  virtual RealGradient computeGradDFDCons(PFFunctionType type) = 0;
 
  const MaterialProperty<T> & _M;
 
  const MaterialProperty<T> & _dMdc;
 
  std::vector<const MaterialProperty<T> *> _dMdarg;
};
 
template <typename T>
CHBulk<T>::CHBulk(const InputParameters & parameters)
  : DerivativeMaterialInterface<JvarMapKernelInterface<KernelGrad>>(parameters),
    _M(getMaterialProperty<T>("mob_name")),
    _dMdc(getMaterialPropertyDerivative<T>("mob_name", _var.name()))
{
  // Get number of coupled variables
  unsigned int nvar = _coupled_moose_vars.size();
 
  // reserve space for derivatives
  _dMdarg.resize(nvar);
 
  // Iterate over all coupled variables
  for (unsigned int i = 0; i < nvar; ++i)
    _dMdarg[i] = &getMaterialPropertyDerivative<T>("mob_name", _coupled_moose_vars[i]->name());
}
 
template <typename T>
InputParameters
CHBulk<T>::validParams()
{
  InputParameters params = ::validParams<KernelGrad>();
  params.addClassDescription("Cahn-Hilliard base Kernel");
  params.addParam<MaterialPropertyName>("mob_name", "M", "The mobility used with the kernel");
  params.addCoupledVar("args", "Vector of arguments of the mobility");
  return params;
}
 
template <typename T>
void
CHBulk<T>::initialSetup()
{
  validateNonlinearCoupling<Real>("mob_name");
}
 
template <typename T>
RealGradient
CHBulk<T>::precomputeQpResidual()
{
  return _M[_qp] * computeGradDFDCons(Residual);
}
 
template <typename T>
RealGradient
CHBulk<T>::precomputeQpJacobian()
{
  RealGradient grad_value = _M[_qp] * computeGradDFDCons(Jacobian) +
                            _dMdc[_qp] * _phi[_j][_qp] * computeGradDFDCons(Residual);
 
  return grad_value;
}
 
template <typename T>
Real
CHBulk<T>::computeQpOffDiagJacobian(unsigned int jvar)
{
  // get the coupled variable jvar is referring to
  const unsigned int cvar = mapJvarToCvar(jvar);
 
  return (*_dMdarg[cvar])[_qp] * _phi[_j][_qp] * computeGradDFDCons(Residual) * _grad_test[_i][_qp];
}