DerivativeSumMaterial.C

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

#include "DerivativeSumMaterial.h"

#include "libmesh/quadrature.h"

registerMooseObject("MooseApp", DerivativeSumMaterial);
registerMooseObject("MooseApp", ADDerivativeSumMaterial);

template <bool is_ad>
InputParameters
DerivativeSumMaterialTempl<is_ad>::validParams()
{
  InputParameters params = DerivativeFunctionMaterialBaseTempl<is_ad>::validParams();
  params.addClassDescription("Meta-material to sum up multiple derivative materials");
  params.addParam<std::vector<std::string>>("sum_materials",
                                            "Base name of the parsed sum material property");

  // All arguments of the parsed expression (free energy) being summed
  params.addRequiredCoupledVar("coupled_variables", "Vector of names of variables being summed");

  params.addCoupledVar("displacement_gradients",
                       "Vector of displacement gradient variables (see "
                       "Modules/PhaseField/DisplacementGradients "
                       "action)");

  // Advanced arguments to construct a sum of the form \f$ c+\gamma\sum_iF_i \f$
  params.addParam<std::vector<Real>>("prefactor", {}, "Prefactor to multiply the sum term with.");
  params.addParam<Real>("constant", 0.0, "Constant to be added to the prefactor multiplied sum.");

  params.addParam<bool>("validate_coupling",
                        true,
                        "Check if all variables the specified materials depend on are listed in "
                        "the `coupled_variables` parameter.");
  params.addParamNamesToGroup("prefactor constant", "Advanced");

  return params;
}

template <bool is_ad>
DerivativeSumMaterialTempl<is_ad>::DerivativeSumMaterialTempl(const InputParameters & parameters)
  : DerivativeFunctionMaterialBaseTempl<is_ad>(parameters),
    _sum_materials(this->template getParam<std::vector<std::string>>("sum_materials")),
    _num_materials(_sum_materials.size()),
    _prefactor(_num_materials, 1.0),
    _constant(this->template getParam<Real>("constant")),
    _validate_coupling(this->template getParam<bool>("validate_coupling"))
{
  // we need at least one material in the sum
  if (_num_materials == 0)
    mooseError("Please supply at least one material to sum in DerivativeSumMaterial ", name());

  // get prefactor values if not 1.0
  std::vector<Real> p = this->template getParam<std::vector<Real>>("prefactor");

  // if prefactor is used we need the same number of prefactors as sum materials
  if (_num_materials == p.size())
    _prefactor = p;
  else if (p.size() != 0)
    mooseError("Supply the same number of sum materials and prefactors.");

  // reserve space for summand material properties
  _summand_F.resize(_num_materials);
  _summand_dF.resize(_num_materials);
  _summand_d2F.resize(_num_materials);
  _summand_d3F.resize(_num_materials);

  for (unsigned int n = 0; n < _num_materials; ++n)
  {
    _summand_F[n] = &this->template getGenericMaterialProperty<Real, is_ad>(_sum_materials[n]);
    _summand_dF[n].resize(_nargs);
    _summand_d2F[n].resize(_nargs);
    _summand_d3F[n].resize(_nargs);

    for (unsigned int i = 0; i < _nargs; ++i)
    {
      _summand_dF[n][i] = &this->template getMaterialPropertyDerivative<Real, is_ad>(
          _sum_materials[n], _arg_names[i]);
      _summand_d2F[n][i].resize(_nargs);

      if (_third_derivatives)
        _summand_d3F[n][i].resize(_nargs);

      for (unsigned int j = 0; j < _nargs; ++j)
      {
        _summand_d2F[n][i][j] = &this->template getMaterialPropertyDerivative<Real, is_ad>(
            _sum_materials[n], _arg_names[i], _arg_names[j]);

        if (_third_derivatives)
        {
          _summand_d3F[n][i][j].resize(_nargs);

          for (unsigned int k = 0; k < _nargs; ++k)
            _summand_d3F[n][i][j][k] = &this->template getMaterialPropertyDerivative<Real, is_ad>(
                _sum_materials[n], _arg_names[i], _arg_names[j], _arg_names[k]);
        }
      }
    }
  }
}

template <bool is_ad>
void
DerivativeSumMaterialTempl<is_ad>::initialSetup()
{
  if (_validate_coupling)
    for (unsigned int n = 0; n < _num_materials; ++n)
      this->template validateCoupling<Real>(_sum_materials[n]);
}

template <bool is_ad>
void
DerivativeSumMaterialTempl<is_ad>::computeProperties()
{
  unsigned int i, j, k;

  for (_qp = 0; _qp < _qrule->n_points(); _qp++)
  {
    // set function value
    if (_prop_F)
    {
      (*_prop_F)[_qp] = (*_summand_F[0])[_qp] * _prefactor[0];
      for (unsigned int n = 1; n < _num_materials; ++n)
        (*_prop_F)[_qp] += (*_summand_F[n])[_qp] * _prefactor[n];
    }

    for (i = 0; i < _nargs; ++i)
    {
      // set first derivatives
      if (_prop_dF[i])
      {
        (*_prop_dF[i])[_qp] = (*_summand_dF[0][i])[_qp] * _prefactor[0];
        for (unsigned int n = 1; n < _num_materials; ++n)
          (*_prop_dF[i])[_qp] += (*_summand_dF[n][i])[_qp] * _prefactor[n];
      }

      // second derivatives
      for (j = i; j < _nargs; ++j)
      {
        if (_prop_d2F[i][j])
        {
          (*_prop_d2F[i][j])[_qp] = (*_summand_d2F[0][i][j])[_qp] * _prefactor[0];
          for (unsigned int n = 1; n < _num_materials; ++n)
            (*_prop_d2F[i][j])[_qp] += (*_summand_d2F[n][i][j])[_qp] * _prefactor[n];
        }

        // third derivatives
        if (_third_derivatives)
        {
          for (k = j; k < _nargs; ++k)
            if (_prop_d3F[i][j][k])
            {
              (*_prop_d3F[i][j][k])[_qp] = (*_summand_d3F[0][i][j][k])[_qp] * _prefactor[0];
              for (unsigned int n = 1; n < _num_materials; ++n)
                (*_prop_d3F[i][j][k])[_qp] += (*_summand_d3F[n][i][j][k])[_qp] * _prefactor[n];
            }
        }
      }
    }
  }
}