CompositeTensorBase< T, U > Class Template Reference

CompositeTensorBase computes a simple T type MaterialProperty \( \bar T\) that is summed up from a list of other T objects (tensors) \( T_i \) with associated weights \( w_i \). More...

#include <CompositeTensorBase.h>

Inheritance diagram for CompositeTensorBase< T, U >:

Public Types
typedef DerivativeMaterialPropertyNameInterface::SymbolName	SymbolName

Public Member Functions
	CompositeTensorBase (const InputParameters &parameters)
const GenericMaterialProperty< U, is_ad > &	getDefaultMaterialProperty (const std::string &name)
	Fetch a material property if it exists, otherwise return getZeroMaterialProperty.
const GenericMaterialProperty< U, is_ad > &	getDefaultMaterialPropertyByName (const std::string &name)
	Fetch a material property by name if it exists, otherwise return getZeroMaterialProperty.
Moose::Kokkos::MaterialProperty< U, dimension >	declareKokkosPropertyDerivative (const std::string &base, const std::vector< SymbolName > &c)
	Declare a derivative Kokkos material property.
void	validateDerivativeMaterialPropertyBase (const std::string &base)
	Check if the material property base exists.
const MaterialPropertyName	derivativePropertyName (const MaterialPropertyName &base, const std::vector< SymbolName > &c) const
	Helper functions to generate the material property names for the arbitrary derivatives.
const MaterialPropertyName	derivativePropertyNameFirst (const MaterialPropertyName &base, const SymbolName &c1) const
	Helper functions to generate the material property names for the first derivatives.
const MaterialPropertyName	derivativePropertyNameSecond (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2) const
	Helper functions to generate the material property names for the second derivatives.
const MaterialPropertyName	derivativePropertyNameThird (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2, const SymbolName &c3) const
	Helper functions to generate the material property names for the third derivatives.
GenericMaterialProperty< U, is_ad > &	declarePropertyDerivative (const std::string &base, const std::vector< VariableName > &c)
	Methods for declaring derivative material properties.
GenericMaterialProperty< U, is_ad > &	declarePropertyDerivative (const std::string &base, const std::vector< SymbolName > &c)
GenericMaterialProperty< U, is_ad > &	declarePropertyDerivative (const std::string &base, const SymbolName &c1, const SymbolName &c2="", const SymbolName &c3="")
const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const std::vector< VariableName > &c)
	Methods for retrieving derivative material properties.
const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const std::vector< SymbolName > &c)
const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const SymbolName &c1, const SymbolName &c2="", const SymbolName &c3="")
const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const SymbolName &c1, unsigned int v2, unsigned int v3=libMesh::invalid_uint)
	Convenience methods for retrieving derivative material properties based on a mix of variable names c and indices v into the _coupled_standard_moose_vars vector.
const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, unsigned int v1, unsigned int v2=libMesh::invalid_uint, unsigned int v3=libMesh::invalid_uint)
const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivativeByName (const MaterialPropertyName &base, const std::vector< VariableName > &c)
	Methods for retrieving derivative material properties.
const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivativeByName (const MaterialPropertyName &base, const std::vector< SymbolName > &c)
const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivativeByName (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2="", const SymbolName &c3="")
Moose::Kokkos::MaterialProperty< U, dimension >	getKokkosMaterialPropertyDerivative (const std::string &base, const std::vector< SymbolName > &c)
	Methods for retrieving derivative Kokkos material properties.
Moose::Kokkos::MaterialProperty< U, dimension >	getKokkosMaterialPropertyDerivative (const std::string &base, const SymbolName &c1)
Moose::Kokkos::MaterialProperty< U, dimension >	getKokkosMaterialPropertyDerivativeByName (const MaterialPropertyName &base, const std::vector< SymbolName > &c)
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
void	validateCoupling (const MaterialPropertyName &base, const VariableName &c1="", const VariableName &c2="", const VariableName &c3="")
void	validateNonlinearCoupling (const MaterialPropertyName &base, const VariableName &c1="", const VariableName &c2="", const VariableName &c3="")
const MaterialPropertyName	propertyName (const MaterialPropertyName &base, const std::vector< SymbolName > &c) const
	aliases for the deprecated old function names
const MaterialPropertyName	propertyNameFirst (const MaterialPropertyName &base, const SymbolName &c1) const
const MaterialPropertyName	propertyNameSecond (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2) const
const MaterialPropertyName	propertyNameThird (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2, const SymbolName &c3) const

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
void	initializeDerivativeProperties (const std::string name)
	Output material properties are initialized here so that derived classes can modify the name.
virtual void	computeQpTensorProperties (MaterialProperty< T > &M, Real derivative_prefactor=1.0)
	Fill in the.

Protected Attributes
std::vector< MaterialPropertyName >	_tensor_names
	component tensor names
std::vector< MaterialPropertyName >	_weight_names
	component weight names
unsigned int	_num_args
	number of dependent variables
unsigned int	_num_comp
	number of compomemt tensors and weights
std::vector< MaterialProperty< T > * >	_dM
	Composed tensor and its derivatives.
std::vector< std::vector< MaterialProperty< T > * > >	_d2M
std::vector< const MaterialProperty< T > * >	_tensors
	component tensors and their derivatives w.r.t. the args
std::vector< std::vector< const MaterialProperty< T > * > >	_dtensors
std::vector< std::vector< std::vector< const MaterialProperty< T > * > > >	_d2tensors
std::vector< const MaterialProperty< Real > * >	_weights
	component weights and their derivatives w.r.t. the args
std::vector< std::vector< const MaterialProperty< Real > * > >	_dweights
std::vector< std::vector< std::vector< const MaterialProperty< Real > * > > >	_d2weights

Private Member Functions
bool	haveMaterialProperty (const std::string &prop_name)
	Check if a material property is present with the applicable restrictions.
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 != "")
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
bool	isNotObjectVariable (const VariableName &name)

Private Attributes
FEProblemBase &	_dmi_fe_problem
	Reference to FEProblemBase.

Detailed Description

template<class T, class U>
class CompositeTensorBase< T, U >

CompositeTensorBase computes a simple T type MaterialProperty \( \bar T\) that is summed up from a list of other T objects (tensors) \( T_i \) with associated weights \( w_i \).

\( \bar T = \sum_i T_i\cdot w_i \) Derivatives w.r.t. variables are computed accordingly. This base class is used by the CompositeMobilityTensor and CompositeElasticityTensor classes.

Template Parameters

T	The type of the objects to sum together

Definition at line 27 of file CompositeTensorBase.h.

Member Typedef Documentation

SymbolName

typedef DerivativeMaterialPropertyNameInterface::SymbolName DerivativeMaterialInterface< U >::SymbolName

inherited

Definition at line 35 of file DerivativeMaterialInterface.h.

Constructor & Destructor Documentation

CompositeTensorBase()

template<class T , class U >

CompositeTensorBase< T, U >::CompositeTensorBase

(

const InputParameters &

parameters

)

Definition at line 81 of file CompositeTensorBase.h.

  : DerivativeMaterialInterface<U>(parameters),
    _tensor_names(this->template getParam<std::vector<MaterialPropertyName>>("tensors")),
    _weight_names(this->template getParam<std::vector<MaterialPropertyName>>("weights")),
    _num_args(this->DerivativeMaterialInterface<U>::coupledComponents("coupled_variables")),
    _num_comp(_tensor_names.size()),
    _dM(_num_args),
    _d2M(_num_args),
    _tensors(_num_comp),
    _dtensors(_num_comp),
    _d2tensors(_num_comp),
    _weights(_num_comp),
    _dweights(_num_comp),
    _d2weights(_num_comp)
{
  if (_num_comp != _weight_names.size())
    mooseError("The number of supplied 'tensors' and 'weights' must match.");
}

Member Function Documentation

buildVariableVector()

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

privateinherited

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

Definition at line 226 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;
}

computeQpTensorProperties()

template<class T , class U >

void CompositeTensorBase< T, U >::computeQpTensorProperties ( MaterialProperty< T > &  M, Real  derivative_prefactor = 1.0  )

protectedvirtual

Fill in the.

• main tensor property given by M
• derivatives, set up by initializeDerivativeProperties

The root_property is kept separate from the derivatives to allow the application of this template to the Eigenstrain calculation, which contributes derivatives to a different material property (and uses a derivative_prefactor of -1).

Definition at line 172 of file CompositeTensorBase.h.

{
  const unsigned int qp = this->DerivativeMaterialInterface<U>::_qp;
 
  M[qp].zero();
  for (unsigned int i = 0; i < _num_comp; ++i)
  {
    M[qp] += (*_tensors[i])[qp] * (*_weights[i])[qp];
 
    for (unsigned int j = 0; j < _num_args; ++j)
    {
      if (i == 0)
        (*_dM[j])[qp].zero();
 
      (*_dM[j])[qp] += derivative_prefactor * ((*_tensors[i])[qp] * (*_dweights[i][j])[qp] +
                                               (*_dtensors[i][j])[qp] * (*_weights[i])[qp]);
 
      for (unsigned int k = 0; k <= j; ++k)
      {
        if (i == 0)
          (*_d2M[j][k])[qp].zero();
 
        (*_d2M[j][k])[qp] +=
            derivative_prefactor * (2.0 * (*_dtensors[i][j])[qp] * (*_dweights[i][j])[qp] +
                                    (*_tensors[i])[qp] * (*_d2weights[i][j][k])[qp] +
                                    (*_d2tensors[i][j][k])[qp] * (*_weights[i])[qp]);
      }
    }
  }
}

declareKokkosPropertyDerivative()

Moose::Kokkos::MaterialProperty< U, dimension > DerivativeMaterialInterface< U >::declareKokkosPropertyDerivative ( const std::string &  base, const std::vector< SymbolName > &  c  )

inlineinherited

Declare a derivative Kokkos material property.

Template Parameters

U	The material property type
dimension	The material property dimension

Parameters

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

Returns

The declared Kokkos material property

Definition at line 180 of file DerivativeMaterialInterface.h.

  {
    return this->template declareKokkosPropertyByName<U, dimension>(
        derivativePropertyName(base, c));
  }

declarePropertyDerivative() [1/3]

GenericMaterialProperty< U, is_ad > & DerivativeMaterialInterface< U >::declarePropertyDerivative ( const std::string &  base, const std::vector< SymbolName > &  c  )

inherited

Definition at line 63 of file DerivativeMaterialInterface.h.

{
  return this->template declareGenericProperty<U, is_ad>(derivativePropertyName(base, c));
}

declarePropertyDerivative() [2/3]

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

inherited

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 60 of file DerivativeMaterialInterface.h.

{
  std::vector<SymbolName> symbol_vector(c.begin(), c.end());
  return declarePropertyDerivative<U, is_ad>(base, symbol_vector);
}

declarePropertyDerivative() [3/3]

GenericMaterialProperty< U, is_ad > & DerivativeMaterialInterface< U >::declarePropertyDerivative ( const std::string &  base, const SymbolName &  c1, const SymbolName &  c2 = "", const SymbolName &  c3 = ""  )

inherited

Definition at line 67 of file DerivativeMaterialInterface.h.

{
  if (c3 != "")
    return this->template declareGenericProperty<U, is_ad>(
        derivativePropertyNameThird(base, c1, c2, c3));
  if (c2 != "")
    return this->template declareGenericProperty<U, is_ad>(
        derivativePropertyNameSecond(base, c1, c2));
  return this->template declareGenericProperty<U, is_ad>(derivativePropertyNameFirst(base, c1));
}

derivativePropertyName()

const MaterialPropertyName DerivativeMaterialPropertyNameInterface::derivativePropertyName ( const MaterialPropertyName &  base, const std::vector< SymbolName > &  c  ) const

inherited

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

Definition at line 16 of file DerivativeMaterialPropertyNameInterface.C.

{
  // to obtain well defined names we sort alphabetically
  std::vector<SymbolName> 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();
}

Referenced by DerivativeMaterialInterface< T >::declareKokkosPropertyDerivative(), DerivativeMaterialPropertyNameInterface::derivativePropertyNameSecond(), DerivativeMaterialPropertyNameInterface::derivativePropertyNameThird(), and DerivativeMaterialPropertyNameInterface::propertyName().

derivativePropertyNameFirst()

const MaterialPropertyName DerivativeMaterialPropertyNameInterface::derivativePropertyNameFirst ( const MaterialPropertyName &  base, const SymbolName &  c1  ) const

inherited

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

Definition at line 56 of file DerivativeMaterialPropertyNameInterface.C.

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

Referenced by DerivativeMaterialPropertyNameInterface::propertyNameFirst(), NEML2Action::setupDerivativeMappings(), and NEML2Action::setupParameterDerivativeMappings().

derivativePropertyNameSecond()

const MaterialPropertyName DerivativeMaterialPropertyNameInterface::derivativePropertyNameSecond ( const MaterialPropertyName &  base, const SymbolName &  c1, const SymbolName &  c2  ) const

inherited

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

Definition at line 63 of file DerivativeMaterialPropertyNameInterface.C.

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

Referenced by DerivativeMaterialPropertyNameInterface::propertyNameSecond().

derivativePropertyNameThird()

const MaterialPropertyName DerivativeMaterialPropertyNameInterface::derivativePropertyNameThird ( const MaterialPropertyName &  base, const SymbolName &  c1, const SymbolName &  c2, const SymbolName &  c3  ) const

inherited

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

Definition at line 70 of file DerivativeMaterialPropertyNameInterface.C.

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

Referenced by DerivativeMaterialPropertyNameInterface::propertyNameThird().

getDefaultMaterialProperty()

const GenericMaterialProperty< U, is_ad > & DerivativeMaterialInterface< U >::getDefaultMaterialProperty ( const std::string &  name )

inherited

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

Parameters

name	The input parameter key of type MaterialPropertyName

Definition at line 44 of file DerivativeMaterialInterface.h.

{
  // get the base property name
  std::string prop_name = this->getMaterialPropertyName(name);
 
  // Check if it's just a constant
  const auto * default_property =
      this->template defaultGenericMaterialProperty<U, is_ad>(prop_name);
  if (default_property)
    return *default_property;
 
  // if found return the requested property
  return this->template getGenericZeroMaterialPropertyByName<U, is_ad>(prop_name);
}

getDefaultMaterialPropertyByName()

const GenericMaterialProperty< U, is_ad > & DerivativeMaterialInterface< U >::getDefaultMaterialPropertyByName ( const std::string &  name )

inherited

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

Definition at line 49 of file DerivativeMaterialInterface.h.

{
  // TODO: deprecate this
  return this->template getGenericZeroMaterialPropertyByName<U, is_ad>(prop_name);
}

getKokkosMaterialPropertyDerivative() [1/2]

Moose::Kokkos::MaterialProperty< U, dimension > DerivativeMaterialInterface< U >::getKokkosMaterialPropertyDerivative ( const std::string &  base, const std::vector< SymbolName > &  c  )

inherited

Methods for retrieving derivative Kokkos material properties.

A constant zero property is returned if the base property is a default (constant) property or if the derivative property is not declared.

Template Parameters

U	The material property type
dimension	The material property dimension

Parameters

base	The name of the property to take the derivative of, or the parameter name containing it
c	The variable(s) to take the derivatives with respect to

Definition at line 155 of file DerivativeMaterialInterface.h.

{
  const auto prop_name = this->getMaterialPropertyName(base);
 
  // Derivatives of constants are zero
  if (MooseUtils::parsesToReal(prop_name))
    return Moose::Kokkos::MaterialProperty<U, dimension>(U(0));
 
  return getKokkosMaterialPropertyDerivativeByName<U, dimension>(prop_name, c);
}

getKokkosMaterialPropertyDerivative() [2/2]

Moose::Kokkos::MaterialProperty< U, dimension > DerivativeMaterialInterface< U >::getKokkosMaterialPropertyDerivative ( const std::string &  base, const SymbolName &  c1  )

inlineinherited

Definition at line 159 of file DerivativeMaterialInterface.h.

  {
    return getKokkosMaterialPropertyDerivative<U, dimension>(base, std::vector<SymbolName>{c1});
  }

getKokkosMaterialPropertyDerivativeByName()

Moose::Kokkos::MaterialProperty< U, dimension > DerivativeMaterialInterface< U >::getKokkosMaterialPropertyDerivativeByName ( const MaterialPropertyName &  base, const std::vector< SymbolName > &  c  )

inherited

Definition at line 166 of file DerivativeMaterialInterface.h.

{
  const auto prop_name = derivativePropertyName(base, c);
 
  if (!this->template hasKokkosMaterialPropertyByName<U, dimension>(prop_name))
    return Moose::Kokkos::MaterialProperty<U, dimension>(U(0));
 
  return this->template getKokkosMaterialPropertyByName<U, dimension>(prop_name);
}

getMaterialPropertyDerivative() [1/5]

const GenericMaterialProperty< U, is_ad > & DerivativeMaterialInterface< U >::getMaterialPropertyDerivative ( const std::string &  base, const std::vector< SymbolName > &  c  )

inherited

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

Definition at line 86 of file DerivativeMaterialInterface.h.

{
  // get the base property name
  std::string prop_name = this->getMaterialPropertyName(base);
 
  if (this->template defaultGenericMaterialProperty<U, is_ad>(prop_name))
    return this->template getGenericZeroMaterialProperty<U, is_ad>();
 
  return this->template getGenericZeroMaterialPropertyByName<U, is_ad>(
      derivativePropertyName(prop_name, c));
}

getMaterialPropertyDerivative() [2/5]

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

inherited

Methods for retrieving 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 82 of file DerivativeMaterialInterface.h.

{
  std::vector<SymbolName> symbol_vector(c.begin(), c.end());
  return getMaterialPropertyDerivative(base, symbol_vector);
}

getMaterialPropertyDerivative() [3/5]

const GenericMaterialProperty< U, is_ad > & DerivativeMaterialInterface< U >::getMaterialPropertyDerivative ( const std::string &  base, const SymbolName &  c1, const SymbolName &  c2 = "", const SymbolName &  c3 = ""  )

inherited

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

Definition at line 90 of file DerivativeMaterialInterface.h.

{
  // get the base property name
  std::string prop_name = this->getMaterialPropertyName(base);
 
  if (this->template defaultGenericMaterialProperty<Real, is_ad>(prop_name))
    return this->template getGenericZeroMaterialProperty<U, is_ad>();
 
  if (c3 != "")
    return this->template getGenericZeroMaterialPropertyByName<U, is_ad>(
        derivativePropertyNameThird(prop_name, c1, c2, c3));
  if (c2 != "")
    return this->template getGenericZeroMaterialPropertyByName<U, is_ad>(
        derivativePropertyNameSecond(prop_name, c1, c2));
  return this->template getGenericZeroMaterialPropertyByName<U, is_ad>(
      derivativePropertyNameFirst(prop_name, c1));
}

getMaterialPropertyDerivative() [4/5]

const GenericMaterialProperty< U, is_ad > & DerivativeMaterialInterface< U >::getMaterialPropertyDerivative ( const std::string &  base, const SymbolName &  c1, unsigned int  v2, unsigned int  v3 = libMesh::invalid_uint  )

inherited

Convenience methods for retrieving derivative material properties based on a mix of variable names c and indices v into the _coupled_standard_moose_vars vector.

Definition at line 103 of file DerivativeMaterialInterface.h.

{
  return getMaterialPropertyDerivative<U, is_ad>(
      base,
      c1,
      this->_coupled_standard_moose_vars[v2]->name(),
      v3 == libMesh::invalid_uint ? "" : this->_coupled_standard_moose_vars[v3]->name());
}

getMaterialPropertyDerivative() [5/5]

const GenericMaterialProperty< U, is_ad > & DerivativeMaterialInterface< U >::getMaterialPropertyDerivative ( const std::string &  base, unsigned int  v1, unsigned int  v2 = libMesh::invalid_uint, unsigned int  v3 = libMesh::invalid_uint  )

inherited

Definition at line 110 of file DerivativeMaterialInterface.h.

{
  return getMaterialPropertyDerivative<U, is_ad>(
      base,
      this->_coupled_standard_moose_vars[v1]->name(),
      v2 == libMesh::invalid_uint ? "" : this->_coupled_standard_moose_vars[v2]->name(),
      v3 == libMesh::invalid_uint ? "" : this->_coupled_standard_moose_vars[v3]->name());
}

getMaterialPropertyDerivativeByName() [1/3]

const GenericMaterialProperty< U, is_ad > & DerivativeMaterialInterface< U >::getMaterialPropertyDerivativeByName ( const MaterialPropertyName &  base, const std::vector< SymbolName > &  c  )

inherited

Definition at line 130 of file DerivativeMaterialInterface.h.

{
  return this->template getGenericZeroMaterialPropertyByName<U, is_ad>(
      derivativePropertyName(base, c));
}

getMaterialPropertyDerivativeByName() [2/3]

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

inherited

Methods for retrieving 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 125 of file DerivativeMaterialInterface.h.

{
  std::vector<SymbolName> symbol_vector(c.begin(), c.end());
  return getMaterialPropertyDerivativeByName(base, symbol_vector);
}

getMaterialPropertyDerivativeByName() [3/3]

const GenericMaterialProperty< U, is_ad > & DerivativeMaterialInterface< U >::getMaterialPropertyDerivativeByName ( const MaterialPropertyName &  base, const SymbolName &  c1, const SymbolName &  c2 = "", const SymbolName &  c3 = ""  )

inherited

Definition at line 135 of file DerivativeMaterialInterface.h.

{
  if (c3 != "")
    return this->template getGenericZeroMaterialPropertyByName<U, is_ad>(
        derivativePropertyNameThird(base, c1, c2, c3));
  if (c2 != "")
    return this->template getGenericZeroMaterialPropertyByName<U, is_ad>(
        derivativePropertyNameSecond(base, c1, c2));
  return this->template getGenericZeroMaterialPropertyByName<U, is_ad>(
      derivativePropertyNameFirst(base, c1));
}

haveMaterialProperty()

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

privateinherited

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

Definition at line 222 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, is_ad>(prop_name)) ||
          (blk && blk->template hasBlockMaterialProperty<U, is_ad>(prop_name)) ||
          (this->template hasGenericMaterialProperty<U, is_ad>(prop_name)));
}

initializeDerivativeProperties()

template<class T , class U >

void CompositeTensorBase< T, U >::initializeDerivativeProperties ( const std::string  name )

protected

Output material properties are initialized here so that derived classes can modify the name.

Definition at line 113 of file CompositeTensorBase.h.

{
  // setup output composite tensor and derivatives
  for (unsigned int j = 0; j < _num_args; ++j)
  {
    const VariableName & jname =
        this->DerivativeMaterialInterface<U>::getVar("coupled_variables", j)->name();
    _dM[j] = &this->template declarePropertyDerivative<T>(name, jname);
    _d2M[j].resize(j + 1);
 
    for (unsigned int k = 0; k <= j; ++k)
    {
      const VariableName & kname =
          this->DerivativeMaterialInterface<U>::getVar("coupled_variables", k)->name();
 
      _d2M[j][k] = &this->template declarePropertyDerivative<T>(name, jname, kname);
    }
  }
 
  // setup input components and its derivatives
  for (unsigned int i = 0; i < _num_comp; ++i)
  {
    _tensors[i] = &this->template getMaterialPropertyByName<T>(_tensor_names[i]);
    _weights[i] = &this->template getMaterialPropertyByName<Real>(_weight_names[i]);
 
    _dtensors[i].resize(_num_args);
    _dweights[i].resize(_num_args);
    _d2tensors[i].resize(_num_args);
    _d2weights[i].resize(_num_args);
 
    for (unsigned int j = 0; j < _num_args; ++j)
    {
      const VariableName & jname =
          this->DerivativeMaterialInterface<U>::getVar("coupled_variables", j)->name();
 
      _dtensors[i][j] =
          &this->template getMaterialPropertyDerivativeByName<T>(_tensor_names[i], jname);
      _dweights[i][j] =
          &this->template getMaterialPropertyDerivativeByName<Real>(_weight_names[i], jname);
 
      _d2tensors[i][j].resize(j + 1);
      _d2weights[i][j].resize(j + 1);
 
      for (unsigned int k = 0; k <= j; ++k)
      {
        const VariableName & kname =
            this->DerivativeMaterialInterface<U>::getVar("coupled_variables", k)->name();
 
        _d2tensors[i][j][k] =
            &this->template getMaterialPropertyDerivativeByName<T>(_tensor_names[i], jname, kname);
        _d2weights[i][j][k] = &this->template getMaterialPropertyDerivativeByName<Real>(
            _weight_names[i], jname, kname);
      }
    }
  }
}

isNotObjectVariable()

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

inlineprivateinherited

Definition at line 237 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< SymbolName > &  c  ) const

inlineinherited

aliases for the deprecated old function names

Definition at line 58 of file DerivativeMaterialPropertyNameInterface.h.

  {
    mooseDeprecated("This function was renamed to 'derivativePropertyName'");
    return derivativePropertyName(base, c);
  }

propertyNameFirst()

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

inlineinherited

Definition at line 64 of file DerivativeMaterialPropertyNameInterface.h.

  {
    mooseDeprecated("This function was renamed to 'derivativePropertyNameFirst'");
    return derivativePropertyNameFirst(base, c1);
  }

propertyNameSecond()

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

inlineinherited

Definition at line 70 of file DerivativeMaterialPropertyNameInterface.h.

  {
    mooseDeprecated("This function was renamed to 'derivativePropertyNameSecond'");
    return derivativePropertyNameSecond(base, c1, c2);
  }

propertyNameThird()

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

inlineinherited

Definition at line 77 of file DerivativeMaterialPropertyNameInterface.h.

  {
    mooseDeprecated("This function was renamed to 'derivativePropertyNameThird'");
    return derivativePropertyNameThird(base, c1, c2, c3);
  }

validateCoupling() [1/2]

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

inherited

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 193 of file DerivativeMaterialInterface.h.

{
  // get the base property name
  std::string prop_name = this->getMaterialPropertyName(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, is_ad>(
      prop_name, c, _dmi_fe_problem.getNonlinearSystemBase(/*nl_sys=*/0).system(), missing);
  if (validate_aux)
    validateCouplingHelper<U, is_ad>(
        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 coupled_variables parameter of ",
                 this->name(),
                 ")");
  }
}

validateCoupling() [2/2]

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

inherited

Definition at line 198 of file DerivativeMaterialInterface.h.

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

validateCouplingHelper()

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

privateinherited

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

Definition at line 230 of file DerivativeMaterialInterface.h.

{
  unsigned int ncoupled = this->_coupled_standard_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 libMesh::VariableGroup & vg = system.variable_group(i);
    for (unsigned int j = 0; j < vg.n_variables(); ++j)
    {
      std::vector<SymbolName> cj(c.begin(), c.end());
      SymbolName jname = vg.name(j);
      cj.push_back(jname);
 
      // if the derivative exists make sure the variable is coupled
      if (haveMaterialProperty<U, is_ad>(derivativePropertyName(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_standard_moose_vars[k]->name() == jname)
          {
            is_missing = false;
            break;
          }
 
        if (is_missing)
          missing.push_back(jname);
      }
    }
  }
}

validateDerivativeMaterialPropertyBase()

void DerivativeMaterialInterface< U >::validateDerivativeMaterialPropertyBase ( const std::string &  base )

inherited

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 217 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, is_ad>(prop_name) &&
      this->template defaultGenericMaterialProperty<U, is_ad>(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()

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

inherited

Definition at line 204 of file DerivativeMaterialInterface.h.

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

validParams()

template<class T , class U >

InputParameters CompositeTensorBase< T, U >::validParams ( )

static

Definition at line 102 of file CompositeTensorBase.h.

{
  InputParameters params = U::validParams();
  params.addRequiredParam<std::vector<MaterialPropertyName>>("tensors", "Component tensors");
  params.addRequiredParam<std::vector<MaterialPropertyName>>("weights", "Component weights");
  params.addRequiredCoupledVar("coupled_variables", "variable dependencies for the prefactor");
  return params;
}

Member Data Documentation

_d2M

template<class T , class U >

std::vector<std::vector<MaterialProperty<T> *> > CompositeTensorBase< T, U >::_d2M

protected

Definition at line 64 of file CompositeTensorBase.h.

_d2tensors

template<class T , class U >

std::vector<std::vector<std::vector<const MaterialProperty<T> *> > > CompositeTensorBase< T, U >::_d2tensors

protected

Definition at line 70 of file CompositeTensorBase.h.

_d2weights

template<class T , class U >

std::vector<std::vector<std::vector<const MaterialProperty<Real> *> > > CompositeTensorBase< T, U >::_d2weights

protected

Definition at line 76 of file CompositeTensorBase.h.

_dM

template<class T , class U >

std::vector<MaterialProperty<T> *> CompositeTensorBase< T, U >::_dM

protected

Composed tensor and its derivatives.

Definition at line 63 of file CompositeTensorBase.h.

_dmi_fe_problem

FEProblemBase& DerivativeMaterialInterface< U >::_dmi_fe_problem

privateinherited

Reference to FEProblemBase.

Definition at line 240 of file DerivativeMaterialInterface.h.

_dtensors

template<class T , class U >

std::vector<std::vector<const MaterialProperty<T> *> > CompositeTensorBase< T, U >::_dtensors

protected

Definition at line 69 of file CompositeTensorBase.h.

_dweights

template<class T , class U >

std::vector<std::vector<const MaterialProperty<Real> *> > CompositeTensorBase< T, U >::_dweights

protected

Definition at line 75 of file CompositeTensorBase.h.

_num_args

template<class T , class U >

unsigned int CompositeTensorBase< T, U >::_num_args

protected

number of dependent variables

Definition at line 58 of file CompositeTensorBase.h.

_num_comp

template<class T , class U >

unsigned int CompositeTensorBase< T, U >::_num_comp

protected

number of compomemt tensors and weights

Definition at line 60 of file CompositeTensorBase.h.

Referenced by CompositeTensorBase< T, U >::CompositeTensorBase().

_tensor_names

template<class T , class U >

std::vector<MaterialPropertyName> CompositeTensorBase< T, U >::_tensor_names

protected

component tensor names

Definition at line 53 of file CompositeTensorBase.h.

_tensors

template<class T , class U >

std::vector<const MaterialProperty<T> *> CompositeTensorBase< T, U >::_tensors

protected

component tensors and their derivatives w.r.t. the args

Definition at line 68 of file CompositeTensorBase.h.

_weight_names

template<class T , class U >

std::vector<MaterialPropertyName> CompositeTensorBase< T, U >::_weight_names

protected

component weight names

Definition at line 55 of file CompositeTensorBase.h.

Referenced by CompositeTensorBase< T, U >::CompositeTensorBase().

_weights

template<class T , class U >

std::vector<const MaterialProperty<Real> *> CompositeTensorBase< T, U >::_weights

protected

component weights and their derivatives w.r.t. the args

Definition at line 74 of file CompositeTensorBase.h.

---

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

• include/materials/CompositeTensorBase.h