FunctionMaterialPropertyDescriptor< is_ad > Class Template Reference

Material properties get fully described using this structure, including their dependent variables and derivation state. More...

#include <FunctionMaterialPropertyDescriptor.h>

Inheritance diagram for FunctionMaterialPropertyDescriptor< is_ad >:

Public Types
typedef std::string	SymbolName

Public Member Functions
	FunctionMaterialPropertyDescriptor (const std::string &, MooseObject *, bool required=false)
	FunctionMaterialPropertyDescriptor ()=delete
	no default constructor
	FunctionMaterialPropertyDescriptor (const FunctionMaterialPropertyDescriptor &)
	copy constructor
	FunctionMaterialPropertyDescriptor (const FunctionMaterialPropertyDescriptor &, MooseObject *)
	copy constructor assigning new parent
FunctionMaterialPropertyDescriptor &	operator= (const FunctionMaterialPropertyDescriptor &)=default
const std::string &	getSymbolName () const
	get the fparser symbol name
void	setSymbolName (const std::string &n)
	set the fparser symbol name
const std::string &	getPropertyName () const
	get the property name
GenericReal< is_ad >	value (unsigned int qp=libMesh::invalid_uint) const
	get the property value at the given quadrature point
void	addDerivative (const SymbolName &symbol)
	take another derivative
bool	dependsOn (const SymbolName &symbol) const
	Check if a material property depends on a given FParser symbol.
std::vector< SymbolName >	getDependentSymbols ()
	builds a list of dependent symbols (exactly all symbols for which depends on returns true)
void	printDebug ()
	output the internal state of this descriptor for debugging purposes
void	updatePropertyName ()
	update the cached _property_name member
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.
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 std::vector< FunctionMaterialPropertyDescriptor >	parseVector (const std::vector< std::string > &, MooseObject *)
	construct a vector of FunctionMaterialPropertyDescriptors from a vector of strings

Private Types
enum class	PropertyState { CURRENT , OLD , OLDER }
	property state More...

Private Member Functions
void	parseDerivative (const std::string &)
void	parseDependentSymbols (const std::string &)

Private Attributes
enum FunctionMaterialPropertyDescriptor::PropertyState	_state
std::string	_fparser_name
	name used in function expression
std::string	_base_name
	function material property base name
std::vector< SymbolName >	_dependent_symbols
std::vector< SymbolName >	_derivative_symbols
const GenericMaterialProperty< Real, is_ad > *	_value
	material property value (this is lazily updated and cached when read through value())
const MaterialProperty< Real > *	_old_older_value
	old/older material property value (this is lazily updated and cached when read through value())
MooseObject *	_parent
	material object that owns this descriptor
std::string	_property_name
	cache the final property name of the derivative
bool	_required
	is this a property that was directly specified by the user? Then it must exist.

Detailed Description

template<bool is_ad>
class FunctionMaterialPropertyDescriptor< is_ad >

Material properties get fully described using this structure, including their dependent variables and derivation state.

Definition at line 25 of file FunctionMaterialPropertyDescriptor.h.

Member Typedef Documentation

SymbolName

typedef std::string DerivativeMaterialPropertyNameInterface::SymbolName

inherited

Definition at line 25 of file DerivativeMaterialPropertyNameInterface.h.

Member Enumeration Documentation

PropertyState

template<bool is_ad>

enum class FunctionMaterialPropertyDescriptor::PropertyState

strongprivate

property state

Enumerator
CURRENT
OLD
OLDER

Definition at line 97 of file FunctionMaterialPropertyDescriptor.h.

  {
    CURRENT,
    OLD,
    OLDER
  } _state;

Constructor & Destructor Documentation

FunctionMaterialPropertyDescriptor() [1/4]

template<bool is_ad>

FunctionMaterialPropertyDescriptor< is_ad >::FunctionMaterialPropertyDescriptor	(	const std::string &	expression,
		MooseObject *	parent,
		bool	required = false
	)

Definition at line 17 of file FunctionMaterialPropertyDescriptor.C.

  : _state(PropertyState::CURRENT),
    _dependent_symbols(),
    _derivative_symbols(),
    _value(nullptr),
    _old_older_value(nullptr),
    _parent(parent),
    _required(required)
{
  auto define = expression.find_last_of(":=");
 
  // expression contains a ':='
  if (define != std::string::npos)
  {
    // section before ':=' is the name used in the function expression
    _fparser_name = expression.substr(0, define - 1);
 
    // parse right hand side
    parseDerivative(expression.substr(define + 1));
  }
  else
  {
    // parse entire expression and use natural material property base name
    // for D(x(t),t,t) this would simply be 'x'!
    parseDerivative(expression);
    _fparser_name = _base_name;
  }
 
  updatePropertyName();
}

FunctionMaterialPropertyDescriptor() [2/4]

template<bool is_ad>

FunctionMaterialPropertyDescriptor< is_ad >::FunctionMaterialPropertyDescriptor ( )

delete

no default constructor

FunctionMaterialPropertyDescriptor() [3/4]

template<bool is_ad>

FunctionMaterialPropertyDescriptor< is_ad >::FunctionMaterialPropertyDescriptor

(

const FunctionMaterialPropertyDescriptor< is_ad > &

rhs

)

copy constructor

Definition at line 50 of file FunctionMaterialPropertyDescriptor.C.

  : _state(rhs._state),
    _fparser_name(rhs._fparser_name),
    _base_name(rhs._base_name),
    _dependent_symbols(rhs._dependent_symbols),
    _derivative_symbols(rhs._derivative_symbols),
    _value(nullptr),
    _old_older_value(nullptr),
    _parent(rhs._parent),
    _property_name(rhs._property_name),
    _required(false)
{
}

FunctionMaterialPropertyDescriptor() [4/4]

template<bool is_ad>

FunctionMaterialPropertyDescriptor< is_ad >::FunctionMaterialPropertyDescriptor	(	const FunctionMaterialPropertyDescriptor< is_ad > &	rhs,
		MooseObject *	parent
	)

copy constructor assigning new parent

Definition at line 66 of file FunctionMaterialPropertyDescriptor.C.

  : _state(rhs._state),
    _fparser_name(rhs._fparser_name),
    _base_name(rhs._base_name),
    _dependent_symbols(rhs._dependent_symbols),
    _derivative_symbols(rhs._derivative_symbols),
    _value(nullptr),
    _old_older_value(nullptr),
    _parent(parent),
    _property_name(rhs._property_name),
    _required(false)
{
}

Member Function Documentation

addDerivative()

template<bool is_ad>

void FunctionMaterialPropertyDescriptor< is_ad >::addDerivative

(

const SymbolName &

symbol

)

take another derivative

Definition at line 94 of file FunctionMaterialPropertyDescriptor.C.

{
  _derivative_symbols.push_back(var);
  _value = nullptr;
  updatePropertyName();
}

Referenced by DerivativeParsedMaterialHelperTempl< is_ad >::recurseMatProps().

dependsOn()

template<bool is_ad>

bool FunctionMaterialPropertyDescriptor< is_ad >::dependsOn

(

const SymbolName &

symbol

)

const

Check if a material property depends on a given FParser symbol.

A dependency is indicated by either directly specifying it, or by requesting a derivative w.r.t. that symbol using the D[x,a] syntax

Definition at line 103 of file FunctionMaterialPropertyDescriptor.C.

{
  return std::find(_dependent_symbols.begin(), _dependent_symbols.end(), var) !=
             _dependent_symbols.end() ||
         std::find(_derivative_symbols.begin(), _derivative_symbols.end(), var) !=
             _derivative_symbols.end();
}

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 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().

getDependentSymbols()

template<bool is_ad>

std::vector< DerivativeMaterialPropertyNameInterface::SymbolName > FunctionMaterialPropertyDescriptor< is_ad >::getDependentSymbols

(

)

builds a list of dependent symbols (exactly all symbols for which depends on returns true)

Definition at line 113 of file FunctionMaterialPropertyDescriptor.C.

{
  std::set<SymbolName> all(_dependent_symbols.begin(), _dependent_symbols.end());
  all.insert(_derivative_symbols.begin(), _derivative_symbols.end());
 
  return std::vector<SymbolName>(all.begin(), all.end());
}

getPropertyName()

template<bool is_ad>

const std::string & FunctionMaterialPropertyDescriptor< is_ad >::getPropertyName ( ) const

inline

get the property name

Definition at line 68 of file FunctionMaterialPropertyDescriptor.h.

{ return _property_name; };

getSymbolName()

template<bool is_ad>

const std::string & FunctionMaterialPropertyDescriptor< is_ad >::getSymbolName ( ) const

inline

get the fparser symbol name

Definition at line 62 of file FunctionMaterialPropertyDescriptor.h.

{ return _fparser_name; };

operator=()

template<bool is_ad>

FunctionMaterialPropertyDescriptor & FunctionMaterialPropertyDescriptor< is_ad >::operator= ( const FunctionMaterialPropertyDescriptor< is_ad > &  )

default

parseDependentSymbols()

template<bool is_ad>

void FunctionMaterialPropertyDescriptor< is_ad >::parseDependentSymbols ( const std::string &  expression )

private

Definition at line 190 of file FunctionMaterialPropertyDescriptor.C.

{
  auto open = expression.find_first_of("(");
  auto close = expression.find_last_of(")");
 
  if (open == std::string::npos && close == std::string::npos)
  {
    // material property name without arguments
    _base_name = expression;
  }
  else if (open != std::string::npos && close != std::string::npos)
  {
    // take material property name before bracket
    _base_name = expression.substr(0, open);
 
    // parse argument list
    MooseUtils::tokenize(expression.substr(open + 1, close - open - 1), _dependent_symbols, 0, ",");
 
    // remove duplicates from dependent variable list
    std::sort(_dependent_symbols.begin(), _dependent_symbols.end());
    _dependent_symbols.erase(std::unique(_dependent_symbols.begin(), _dependent_symbols.end()),
                             _dependent_symbols.end());
  }
  else
    mooseError("Malformed material_properties expression '", expression, "'");
}

parseDerivative()

template<bool is_ad>

void FunctionMaterialPropertyDescriptor< is_ad >::parseDerivative ( const std::string &  expression )

private

Definition at line 123 of file FunctionMaterialPropertyDescriptor.C.

{
  auto open = expression.find_first_of("[");
  auto close = expression.find_last_of("]");
 
  if (open == std::string::npos && close == std::string::npos)
  {
    // no derivative requested
    parseDependentSymbols(expression);
 
    return;
  }
  if (open != std::string::npos && close != std::string::npos)
  {
    if (expression.substr(0, open) == "Old")
    {
      _base_name = expression.substr(open + 1, close - open - 1);
      _dependent_symbols.clear();
      _state = PropertyState::OLD;
      return;
    }
    if (expression.substr(0, open) == "Older")
    {
      _base_name = expression.substr(open + 1, close - open - 1);
      _dependent_symbols.clear();
      _state = PropertyState::OLDER;
      return;
    }
    else if (expression.substr(0, open) == "D")
    {
      auto arguments = expression.substr(open + 1, close - open - 1);
      auto close2 = arguments.find_last_of(")");
 
      if (close2 == std::string::npos)
      {
        // rest of argument list 0 is the function and 1,.. are the variable to take the derivative
        // w.r.t.
        MooseUtils::tokenize(arguments, _derivative_symbols, 0, ",");
 
        // check for empty [] brackets
        if (_derivative_symbols.size() > 0)
        {
          // parse argument zero of D[] as the function material property
          parseDependentSymbols(_derivative_symbols[0]);
 
          // remove function from the _derivative_symbols vector
          _derivative_symbols.erase(_derivative_symbols.begin());
          updatePropertyName();
 
          return;
        }
      }
      else
      {
        parseDependentSymbols(arguments.substr(0, close2 + 1));
        MooseUtils::tokenize(arguments.substr(close2 + 2), _derivative_symbols, 0, ",");
        updatePropertyName();
        return;
      }
    }
  }
 
  mooseError("Malformed material_properties expression '", expression, "'");
}

Referenced by FunctionMaterialPropertyDescriptor< is_ad >::FunctionMaterialPropertyDescriptor().

parseVector()

template<bool is_ad>

std::vector< FunctionMaterialPropertyDescriptor< is_ad > > FunctionMaterialPropertyDescriptor< is_ad >::parseVector ( const std::vector< std::string > &  expression_list, MooseObject *  parent  )

static

construct a vector of FunctionMaterialPropertyDescriptors from a vector of strings

Definition at line 83 of file FunctionMaterialPropertyDescriptor.C.

{
  std::vector<FunctionMaterialPropertyDescriptor> fmpds;
  for (auto & ex : expression_list)
    fmpds.push_back(FunctionMaterialPropertyDescriptor(ex, parent));
  return fmpds;
}

printDebug()

template<bool is_ad>

void FunctionMaterialPropertyDescriptor< is_ad >::printDebug

(

)

output the internal state of this descriptor for debugging purposes

Definition at line 219 of file FunctionMaterialPropertyDescriptor.C.

{
  Moose::out << "MPD: " << _fparser_name << ' ' << _base_name << " deriv = [";
  for (auto & dv : _derivative_symbols)
    Moose::out << dv << ' ';
  Moose::out << "] dep = [";
  for (auto & dv : _dependent_symbols)
    Moose::out << dv << ' ';
  Moose::out << "] " << getPropertyName() << '\n';
}

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 59 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 65 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 71 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 78 of file DerivativeMaterialPropertyNameInterface.h.

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

setSymbolName()

template<bool is_ad>

void FunctionMaterialPropertyDescriptor< is_ad >::setSymbolName ( const std::string &  n )

inline

set the fparser symbol name

Definition at line 65 of file FunctionMaterialPropertyDescriptor.h.

{ _fparser_name = n; };

Referenced by DerivativeParsedMaterialHelperTempl< is_ad >::recurseMatProps().

updatePropertyName()

template<bool is_ad>

void FunctionMaterialPropertyDescriptor< is_ad >::updatePropertyName

(

)

update the cached _property_name member

Definition at line 291 of file FunctionMaterialPropertyDescriptor.C.

{
  _property_name = derivativePropertyName(_base_name, _derivative_symbols);
}

Referenced by FunctionMaterialPropertyDescriptor< is_ad >::FunctionMaterialPropertyDescriptor().

value()

template<bool is_ad>

GenericReal< is_ad > FunctionMaterialPropertyDescriptor< is_ad >::value

(

unsigned int

qp = libMesh::invalid_uint

)

const

get the property value at the given quadrature point

Definition at line 232 of file FunctionMaterialPropertyDescriptor.C.

{
  // current property
  if (_state == PropertyState::CURRENT)
  {
    if (_value == nullptr)
    {
      DerivativeMaterialInterface<Material> * _material_parent =
          dynamic_cast<DerivativeMaterialInterface<Material> *>(_parent);
      DerivativeMaterialInterface<Kernel> * _kernel_parent =
          dynamic_cast<DerivativeMaterialInterface<Kernel> *>(_parent);
 
      // property name
      auto name = derivativePropertyName(_base_name, _derivative_symbols);
 
      // get the material property reference
      if (_material_parent)
        _value = _required ? &(_material_parent->getGenericMaterialProperty<Real, is_ad>(name))
                           : &(_material_parent->getGenericZeroMaterialProperty<Real, is_ad>(name));
      else if (_kernel_parent)
        _value = _required ? &(_kernel_parent->getGenericMaterialProperty<Real, is_ad>(name))
                           : &(_kernel_parent->getGenericZeroMaterialProperty<Real, is_ad>(name));
      else
        mooseError("A FunctionMaterialPropertyDescriptor must be owned by either a Material or a "
                   "Kernel object.");
    }
 
    return qp != libMesh::invalid_uint ? (*_value)[qp] : 0.0;
  }
 
  // old or older property
  if (_old_older_value == nullptr)
  {
    mooseAssert(_derivative_symbols.empty(), "Don't take derivatives of old/older properties.");
 
    DerivativeMaterialInterface<Material> * _material_parent =
        dynamic_cast<DerivativeMaterialInterface<Material> *>(_parent);
    DerivativeMaterialInterface<Kernel> * _kernel_parent =
        dynamic_cast<DerivativeMaterialInterface<Kernel> *>(_parent);
 
    // get the material property reference
    if (_material_parent)
      _old_older_value = (_state == PropertyState::OLD)
                             ? &(_material_parent->getMaterialPropertyOld<Real>(_base_name))
                             : &(_material_parent->getMaterialPropertyOlder<Real>(_base_name));
    else if (_kernel_parent)
      _old_older_value = (_state == PropertyState::OLD)
                             ? &(_kernel_parent->getMaterialPropertyOld<Real>(_base_name))
                             : &(_kernel_parent->getMaterialPropertyOlder<Real>(_base_name));
    else
      mooseError("A FunctionMaterialPropertyDescriptor must be owned by either a Material or a "
                 "Kernel object.");
  }
 
  return qp != libMesh::invalid_uint ? (*_old_older_value)[qp] : 0.0;
}

Member Data Documentation

_base_name

template<bool is_ad>

std::string FunctionMaterialPropertyDescriptor< is_ad >::_base_name

private

function material property base name

Definition at line 108 of file FunctionMaterialPropertyDescriptor.h.

Referenced by FunctionMaterialPropertyDescriptor< is_ad >::FunctionMaterialPropertyDescriptor().

_dependent_symbols

template<bool is_ad>

std::vector<SymbolName> FunctionMaterialPropertyDescriptor< is_ad >::_dependent_symbols

private

Definition at line 110 of file FunctionMaterialPropertyDescriptor.h.

_derivative_symbols

template<bool is_ad>

std::vector<SymbolName> FunctionMaterialPropertyDescriptor< is_ad >::_derivative_symbols

private

Definition at line 111 of file FunctionMaterialPropertyDescriptor.h.

_fparser_name

template<bool is_ad>

std::string FunctionMaterialPropertyDescriptor< is_ad >::_fparser_name

private

name used in function expression

Definition at line 105 of file FunctionMaterialPropertyDescriptor.h.

Referenced by FunctionMaterialPropertyDescriptor< is_ad >::FunctionMaterialPropertyDescriptor(), FunctionMaterialPropertyDescriptor< is_ad >::getSymbolName(), and FunctionMaterialPropertyDescriptor< is_ad >::setSymbolName().

_old_older_value

template<bool is_ad>

const MaterialProperty<Real>* FunctionMaterialPropertyDescriptor< is_ad >::_old_older_value

mutableprivate

old/older material property value (this is lazily updated and cached when read through value())

Definition at line 117 of file FunctionMaterialPropertyDescriptor.h.

_parent

template<bool is_ad>

MooseObject* FunctionMaterialPropertyDescriptor< is_ad >::_parent

private

material object that owns this descriptor

Definition at line 120 of file FunctionMaterialPropertyDescriptor.h.

_property_name

template<bool is_ad>

std::string FunctionMaterialPropertyDescriptor< is_ad >::_property_name

private

cache the final property name of the derivative

Definition at line 123 of file FunctionMaterialPropertyDescriptor.h.

Referenced by FunctionMaterialPropertyDescriptor< is_ad >::getPropertyName().

_required

template<bool is_ad>

bool FunctionMaterialPropertyDescriptor< is_ad >::_required

private

is this a property that was directly specified by the user? Then it must exist.

Definition at line 126 of file FunctionMaterialPropertyDescriptor.h.

_state

template<bool is_ad>

enum FunctionMaterialPropertyDescriptor::PropertyState FunctionMaterialPropertyDescriptor< is_ad >::_state

private

_value

template<bool is_ad>

const GenericMaterialProperty<Real, is_ad>* FunctionMaterialPropertyDescriptor< is_ad >::_value

mutableprivate

material property value (this is lazily updated and cached when read through value())

Definition at line 114 of file FunctionMaterialPropertyDescriptor.h.

---

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

• include/utils/FunctionMaterialPropertyDescriptor.h
• src/utils/FunctionMaterialPropertyDescriptor.C