DerivativeMaterialInterface< T > Class Template Reference

Interface class ("Veneer") to provide generator methods for derivative material property names. More...

#include <DerivativeMaterialInterface.h>

Inheritance diagram for DerivativeMaterialInterface< T >:

Public Member Functions
	DerivativeMaterialInterface (const InputParameters &parameters)
template<typename U >
const MaterialProperty< U > &	getDefaultMaterialProperty (const std::string &name)
	Fetch a material property if it exists, otherwise return getZeroMaterialProperty. More...
template<typename U >
const MaterialProperty< U > &	getDefaultMaterialPropertyByName (const std::string &name)
	Fetch a material property by name if it exists, otherwise return getZeroMaterialProperty. More...
template<typename U >
void	validateDerivativeMaterialPropertyBase (const std::string &base)
	Check if the material property base exists. More...
const MaterialPropertyName	propertyName (const MaterialPropertyName &base, const std::vector< VariableName > &c) const
	Helper functions to generate the material property names for the arbitrary derivatives. More...
const MaterialPropertyName	propertyNameFirst (const MaterialPropertyName &base, const VariableName &c1) const
	Helper functions to generate the material property names for the first derivatives. More...
const MaterialPropertyName	propertyNameSecond (const MaterialPropertyName &base, const VariableName &c1, const VariableName &c2) const
	Helper functions to generate the material property names for the second derivatives. More...
const MaterialPropertyName	propertyNameThird (const MaterialPropertyName &base, const VariableName &c1, const VariableName &c2, const VariableName &c3) const
	Helper functions to generate the material property names for the third derivatives. More...
template<typename U >
MaterialProperty< U > &	declarePropertyDerivative (const std::string &base, const std::vector< VariableName > &c)
	Methods for declaring derivative material properties. More...
template<typename U >
MaterialProperty< U > &	declarePropertyDerivative (const std::string &base, const VariableName &c1, const VariableName &c2="", const VariableName &c3="")
template<typename U >
const MaterialProperty< U > &	getMaterialPropertyDerivative (const std::string &base, const std::vector< VariableName > &c)
	Methods for retreiving derivative material properties. More...
template<typename U >
const MaterialProperty< U > &	getMaterialPropertyDerivative (const std::string &base, const VariableName &c1, const VariableName &c2="", const VariableName &c3="")
template<typename U >
const MaterialProperty< U > &	getMaterialPropertyDerivativeByName (const MaterialPropertyName &base, const std::vector< VariableName > &c)
	Methods for retreiving derivative material properties. More...
template<typename U >
const MaterialProperty< U > &	getMaterialPropertyDerivativeByName (const MaterialPropertyName &base, const VariableName &c1, const VariableName &c2="", const VariableName &c3="")
template<typename U >
void	validateCoupling (const MaterialPropertyName &base, const std::vector< VariableName > &c, bool validate_aux=true)
	check if derivatives of the passed in material property exist w.r.t a variable that is not coupled in to the current object More...
template<typename U >
void	validateCoupling (const MaterialPropertyName &base, const VariableName &c1="", const VariableName &c2="", const VariableName &c3="")
template<typename U >
void	validateNonlinearCoupling (const MaterialPropertyName &base, const VariableName &c1="", const VariableName &c2="", const VariableName &c3="")

Private Member Functions
template<typename U >
bool	haveMaterialProperty (const std::string &prop_name)
	Check if a material property is present with the applicable restrictions. More...
std::vector< VariableName >	buildVariableVector (const VariableName &c1, const VariableName &c2, const VariableName &c3)
	helper method to combine multiple VariableNames into a vector (if they are != "") More...
template<typename U >
void	validateCouplingHelper (const MaterialPropertyName &base, const std::vector< VariableName > &c, const System &system, std::vector< VariableName > &missing)
	helper method to compile list of missing coupled variables for a given system More...
bool	isNotObjectVariable (const VariableName &name)

Private Attributes
FEProblemBase &	_dmi_fe_problem
	Reference to FEProblemBase. More...

Detailed Description

template<class T>
class DerivativeMaterialInterface< T >

Interface class ("Veneer") to provide generator methods for derivative material property names.

Definition at line 32 of file DerivativeMaterialInterface.h.

Constructor & Destructor Documentation

DerivativeMaterialInterface()

template<class T >

DerivativeMaterialInterface< T >::DerivativeMaterialInterface

(

const InputParameters &

parameters

)

Definition at line 155 of file DerivativeMaterialInterface.h.

  : T(parameters),
    _dmi_fe_problem(*parameters.getCheckedPointerParam<FEProblemBase *>("_fe_problem_base"))
{
}

Member Function Documentation

buildVariableVector()

template<class T >

std::vector< VariableName > DerivativeMaterialInterface< T >::buildVariableVector ( const VariableName &  c1, const VariableName &  c2, const VariableName &  c3  )

private

helper method to combine multiple VariableNames into a vector (if they are != "")

Definition at line 383 of file DerivativeMaterialInterface.h.

{
  std::vector<VariableName> c;
  if (c1 != "")
  {
    c.push_back(c1);
    if (c2 != "")
    {
      c.push_back(c2);
      if (c3 != "")
        c.push_back(c3);
    }
  }
  return c;
}

declarePropertyDerivative() [1/2]

template<class T >

template<typename U >

MaterialProperty< U > & DerivativeMaterialInterface< T >::declarePropertyDerivative	(	const std::string &	base,
		const std::vector< VariableName > &	c
	)

Methods for declaring derivative material properties.

Template Parameters

U	The material property type

Parameters

base	The name of the property to take the derivative of
c	The variable(s) to take the derivatives with respect to

Definition at line 218 of file DerivativeMaterialInterface.h.

{
  return this->template declareProperty<U>(propertyName(base, c));
}

declarePropertyDerivative() [2/2]

template<class T >

template<typename U >

MaterialProperty< U > & DerivativeMaterialInterface< T >::declarePropertyDerivative	(	const std::string &	base,
		const VariableName &	c1,
		const VariableName &	c2 = "",
		const VariableName &	c3 = ""
	)

Definition at line 227 of file DerivativeMaterialInterface.h.

{
  if (c3 != "")
    return this->template declareProperty<U>(propertyNameThird(base, c1, c2, c3));
  if (c2 != "")
    return this->template declareProperty<U>(propertyNameSecond(base, c1, c2));
  return this->template declareProperty<U>(propertyNameFirst(base, c1));
}

getDefaultMaterialProperty()

template<class T >

template<typename U >

const MaterialProperty< U > & DerivativeMaterialInterface< T >::getDefaultMaterialProperty

(

const std::string &

name

)

Fetch a material property if it exists, otherwise return getZeroMaterialProperty.

Parameters

name	The input parameter key of type MaterialPropertyName

Definition at line 188 of file DerivativeMaterialInterface.h.

{
  // get the base property name
  std::string prop_name = this->deducePropertyName(name);

  // Check if it's just a constant
  const MaterialProperty<U> * default_property =
      this->template defaultMaterialProperty<U>(prop_name);
  if (default_property)
    return *default_property;

  // if found return the requested property
  return getDefaultMaterialPropertyByName<U>(prop_name);
}

getDefaultMaterialPropertyByName()

template<class T >

template<typename U >

const MaterialProperty< U > & DerivativeMaterialInterface< T >::getDefaultMaterialPropertyByName

(

const std::string &

name

)

Fetch a material property by name if it exists, otherwise return getZeroMaterialProperty.

Definition at line 206 of file DerivativeMaterialInterface.h.

{
  // if found return the requested property
  if (haveMaterialProperty<U>(prop_name))
    return this->template getMaterialPropertyByName<U>(prop_name);

  return this->template getZeroMaterialProperty<U>(prop_name);
}

getMaterialPropertyDerivative() [1/2]

template<class T >

template<typename U >

const MaterialProperty< U > & DerivativeMaterialInterface< T >::getMaterialPropertyDerivative	(	const std::string &	base,
		const std::vector< VariableName > &	c
	)

Methods for retreiving derivative material properties.

Template Parameters

U	The material property type

Parameters

base	The name of the property to take the derivative of
c	The variable(s) to take the derivatives with respect to

Check if base is a default property and shortcut to returning zero, as derivatives of constants are zero.

Definition at line 242 of file DerivativeMaterialInterface.h.

Referenced by FunctionMaterialPropertyDescriptor::value().

{
  // get the base property name
  std::string prop_name = this->deducePropertyName(base);

  if (this->template defaultMaterialProperty<U>(prop_name))
    return this->template getZeroMaterialProperty<U>(prop_name + "_zeroderivative");

  return getDefaultMaterialPropertyByName<U>(propertyName(prop_name, c));
}

getMaterialPropertyDerivative() [2/2]

template<class T >

template<typename U >

const MaterialProperty< U > & DerivativeMaterialInterface< T >::getMaterialPropertyDerivative	(	const std::string &	base,
		const VariableName &	c1,
		const VariableName &	c2 = "",
		const VariableName &	c3 = ""
	)

Check if base is a default property and shortcut to returning zero, as derivatives of constants are zero.

Definition at line 261 of file DerivativeMaterialInterface.h.

{
  // get the base property name
  std::string prop_name = this->deducePropertyName(base);

  if (this->template defaultMaterialProperty<U>(prop_name))
    return this->template getZeroMaterialProperty<U>(prop_name + "_zeroderivative");

  if (c3 != "")
    return getDefaultMaterialPropertyByName<U>(propertyNameThird(prop_name, c1, c2, c3));
  if (c2 != "")
    return getDefaultMaterialPropertyByName<U>(propertyNameSecond(prop_name, c1, c2));
  return getDefaultMaterialPropertyByName<U>(propertyNameFirst(prop_name, c1));
}

getMaterialPropertyDerivativeByName() [1/2]

template<class T >

template<typename U >

const MaterialProperty< U > & DerivativeMaterialInterface< T >::getMaterialPropertyDerivativeByName	(	const MaterialPropertyName &	base,
		const std::vector< VariableName > &	c
	)

Methods for retreiving derivative material properties.

Template Parameters

U	The material property type

Parameters

base	The name of the property to take the derivative of
c	The variable(s) to take the derivatives with respect to

Definition at line 286 of file DerivativeMaterialInterface.h.

{
  return getDefaultMaterialPropertyByName<U>(propertyName(base, c));
}

getMaterialPropertyDerivativeByName() [2/2]

template<class T >

template<typename U >

const MaterialProperty< U > & DerivativeMaterialInterface< T >::getMaterialPropertyDerivativeByName	(	const MaterialPropertyName &	base,
		const VariableName &	c1,
		const VariableName &	c2 = "",
		const VariableName &	c3 = ""
	)

Definition at line 295 of file DerivativeMaterialInterface.h.

{
  if (c3 != "")
    return getDefaultMaterialPropertyByName<U>(propertyNameThird(base, c1, c2, c3));
  if (c2 != "")
    return getDefaultMaterialPropertyByName<U>(propertyNameSecond(base, c1, c2));
  return getDefaultMaterialPropertyByName<U>(propertyNameFirst(base, c1));
}

haveMaterialProperty()

template<class T >

template<typename U >

bool DerivativeMaterialInterface< T >::haveMaterialProperty ( const std::string &  prop_name )

private

Check if a material property is present with the applicable restrictions.

Definition at line 174 of file DerivativeMaterialInterface.h.

{
  // Call the correct method to test for material property declarations
  BlockRestrictable * blk = dynamic_cast<BlockRestrictable *>(this);
  BoundaryRestrictable * bnd = dynamic_cast<BoundaryRestrictable *>(this);
  return ((bnd && bnd->boundaryRestricted() &&
           bnd->template hasBoundaryMaterialProperty<U>(prop_name)) ||
          (blk && blk->template hasBlockMaterialProperty<U>(prop_name)) ||
          (this->template hasMaterialProperty<U>(prop_name)));
}

isNotObjectVariable()

template<class T >

bool DerivativeMaterialInterface< T >::isNotObjectVariable ( const VariableName &  name )

inlineprivate

Definition at line 444 of file DerivativeMaterialInterface.h.

{
  // try to cast this to a Kernel pointer
  KernelBase * kernel_ptr = dynamic_cast<KernelBase *>(this);
  if (kernel_ptr != nullptr)
    return kernel_ptr->variable().name() != name;

  // try to cast this to a BoundaryCondition pointer
  BoundaryCondition * bc_ptr = dynamic_cast<BoundaryCondition *>(this);
  if (bc_ptr != nullptr)
    return bc_ptr->variable().name() != name;

  // This interface is not templated on a class derived from either Kernel or BC
  return true;
}

propertyName()

const MaterialPropertyName DerivativeMaterialPropertyNameInterface::propertyName ( const MaterialPropertyName &  base, const std::vector< VariableName > &  c  ) const

inherited

Helper functions to generate the material property names for the arbitrary derivatives.

Definition at line 15 of file DerivativeMaterialPropertyNameInterface.C.

Referenced by FunctionMaterialPropertyDescriptor::getPropertyName(), DerivativeMaterialPropertyNameInterface::propertyNameSecond(), and DerivativeMaterialPropertyNameInterface::propertyNameThird().

{
  // to obtain well defined names we sort alphabetically
  std::vector<VariableName> a(c);
  std::sort(a.begin(), a.end());

  // derivative order
  unsigned int order = a.size();
  if (order == 0)
    return base;

  // build the property name as a stringstream
  std::stringstream name;

  // build numerator
  name << 'd';
  if (order > 1)
    name << '^' << order;
  name << base << '/';

  // build denominator with 'pretty' names using exponents rather than repeat multiplication
  unsigned int exponent = 1;
  for (unsigned i = 1; i <= order; ++i)
  {
    if (i == order || a[i - 1] != a[i])
    {
      name << 'd' << a[i - 1];
      if (exponent > 1)
        name << '^' << exponent;
      exponent = 1;
    }
    else
      exponent++;
  }

  return name.str();
}

propertyNameFirst()

const MaterialPropertyName DerivativeMaterialPropertyNameInterface::propertyNameFirst ( const MaterialPropertyName &  base, const VariableName &  c1  ) const

inherited

Helper functions to generate the material property names for the first derivatives.

Definition at line 55 of file DerivativeMaterialPropertyNameInterface.C.

Referenced by DerivativeFunctionMaterialBase::initialSetup().

{
  return "d" + base + "/d" + c1;
}

propertyNameSecond()

const MaterialPropertyName DerivativeMaterialPropertyNameInterface::propertyNameSecond ( const MaterialPropertyName &  base, const VariableName &  c1, const VariableName &  c2  ) const

inherited

Helper functions to generate the material property names for the second derivatives.

Definition at line 62 of file DerivativeMaterialPropertyNameInterface.C.

Referenced by DerivativeFunctionMaterialBase::initialSetup().

{
  return propertyName(base, {c1, c2});
}

propertyNameThird()

const MaterialPropertyName DerivativeMaterialPropertyNameInterface::propertyNameThird ( const MaterialPropertyName &  base, const VariableName &  c1, const VariableName &  c2, const VariableName &  c3  ) const

inherited

Helper functions to generate the material property names for the third derivatives.

Definition at line 70 of file DerivativeMaterialPropertyNameInterface.C.

Referenced by DerivativeFunctionMaterialBase::initialSetup().

{
  return propertyName(base, {c1, c2, c3});
}

validateCoupling() [1/2]

template<class T >

template<typename U >

void DerivativeMaterialInterface< T >::validateCoupling	(	const MaterialPropertyName &	base,
		const std::vector< VariableName > &	c,
		bool	validate_aux = true
	)

check if derivatives of the passed in material property exist w.r.t a variable that is not coupled in to the current object

Definition at line 351 of file DerivativeMaterialInterface.h.

{
  // get the base property name
  std::string prop_name = this->deducePropertyName(base);
  // list of potentially missing coupled variables
  std::vector<VariableName> missing;

  // iterate over all variables in the both the non-linear and auxiliary system (optional)
  validateCouplingHelper<U>(
      prop_name, c, _dmi_fe_problem.getNonlinearSystemBase().system(), missing);
  if (validate_aux)
    validateCouplingHelper<U>(prop_name, c, _dmi_fe_problem.getAuxiliarySystem().system(), missing);

  if (missing.size() > 0)
  {
    // join list of missing variable names
    std::string list = missing[0];
    for (unsigned int i = 1; i < missing.size(); ++i)
      list += ", " + missing[i];

    mooseWarning("Missing coupled variables {",
                 list,
                 "} (add them to args parameter of ",
                 this->name(),
                 ")");
  }
}

validateCoupling() [2/2]

template<class T >

template<typename U >

void DerivativeMaterialInterface< T >::validateCoupling	(	const MaterialPropertyName &	base,
		const VariableName &	c1 = "",
		const VariableName &	c2 = "",
		const VariableName &	c3 = ""
	)

Definition at line 404 of file DerivativeMaterialInterface.h.

{
  validateCoupling<U>(base, buildVariableVector(c1, c2, c3), true);
}

validateCouplingHelper()

template<class T >

template<typename U >

void DerivativeMaterialInterface< T >::validateCouplingHelper ( const MaterialPropertyName &  base, const std::vector< VariableName > &  c, const System &  system, std::vector< VariableName > &  missing  )

private

helper method to compile list of missing coupled variables for a given system

Definition at line 311 of file DerivativeMaterialInterface.h.

{
  unsigned int ncoupled = this->_coupled_moose_vars.size();

  // iterate over all variables in the current system (in groups)
  for (unsigned int i = 0; i < system.n_variable_groups(); ++i)
  {
    const VariableGroup & vg = system.variable_group(i);
    for (unsigned int j = 0; j < vg.n_variables(); ++j)
    {
      std::vector<VariableName> cj(c);
      VariableName jname = vg.name(j);
      cj.push_back(jname);

      // if the derivative exists make sure the variable is coupled
      if (haveMaterialProperty<U>(propertyName(base, cj)))
      {
        // kernels and BCs to not have the variable they are acting on in coupled_moose_vars
        bool is_missing = isNotObjectVariable(jname);

        for (unsigned int k = 0; k < ncoupled; ++k)
          if (this->_coupled_moose_vars[k]->name() == jname)
          {
            is_missing = false;
            break;
          }

        if (is_missing)
          missing.push_back(jname);
      }
    }
  }
}

validateDerivativeMaterialPropertyBase()

template<class T >

template<typename U >

void DerivativeMaterialInterface< T >::validateDerivativeMaterialPropertyBase

(

const std::string &

base

)

Check if the material property base exists.

Print a warning if it doesn't. This is useful in materials that pull in only derivative properties, which are optional. If the base property name has a typo all derivatives will be set to zero without the user ever knowing.

Definition at line 426 of file DerivativeMaterialInterface.h.

{
  // resolve the input parameter name base to the actual material property name
  const MaterialPropertyName prop_name = this->template getParam<MaterialPropertyName>(base);

  // check if the material property does not exist on the blocks of the current object,
  // and check if it is not a plain number in the input file
  if (!haveMaterialProperty<U>(prop_name) &&
      this->template defaultMaterialProperty<U>(prop_name) == 0)
    mooseWarning("The material property '",
                 prop_name,
                 "' does not exist. The kernel '",
                 this->name(),
                 "' only needs its derivatives, but this may indicate a typo in the input file.");
}

validateNonlinearCoupling()

template<class T >

template<typename U >

void DerivativeMaterialInterface< T >::validateNonlinearCoupling	(	const MaterialPropertyName &	base,
		const VariableName &	c1 = "",
		const VariableName &	c2 = "",
		const VariableName &	c3 = ""
	)

Definition at line 415 of file DerivativeMaterialInterface.h.

{
  validateCoupling<U>(base, buildVariableVector(c1, c2, c3), false);
}

Member Data Documentation

_dmi_fe_problem

template<class T>

FEProblemBase& DerivativeMaterialInterface< T >::_dmi_fe_problem

private

Reference to FEProblemBase.

Definition at line 151 of file DerivativeMaterialInterface.h.

---

The documentation for this class was generated from the following file:

• include/materials/DerivativeMaterialInterface.h