FunctionMaterialPropertyDescriptor.h

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

#pragma once

#include "DerivativeMaterialPropertyNameInterface.h"
#include "Material.h"

#include <string>
#include <vector>

class MooseObject;

template <bool is_ad>
class FunctionMaterialPropertyDescriptor : public DerivativeMaterialPropertyNameInterface
{
public:
  /*
   * The descriptor is constructed with an expression that describes the
   * material property.
   * Examples:
   *   'F'                 A material property called 'F' with no declared variable
   *                       dependencies (i.e. vanishing derivatives)
   *   'F(c,phi)'          A material property called 'F' with declared dependence
   *                       on 'c' and 'phi' (uses DerivativeFunctionMaterial rules to
   *                       look up the derivatives)
   *   'a:=D[x(t),t,t]'    The second time derivative of the t-dependent material property 'x'
   *                       which will be referred to as 'a' in the function expression.
   *   'x_old:=Old[x]'     The previous time step value of x
   *   'x_older:=Older[x]' The value of x two time steps ago
   */
  FunctionMaterialPropertyDescriptor(const std::string &, MooseObject *, bool required = false);

  FunctionMaterialPropertyDescriptor() = delete;

  FunctionMaterialPropertyDescriptor(const FunctionMaterialPropertyDescriptor &);

  FunctionMaterialPropertyDescriptor(const FunctionMaterialPropertyDescriptor &, MooseObject *);

  // copy assignment operator
  FunctionMaterialPropertyDescriptor &
  operator=(const FunctionMaterialPropertyDescriptor &) = default;

  static std::vector<FunctionMaterialPropertyDescriptor>
  parseVector(const std::vector<std::string> &, MooseObject *);

  const std::string & getSymbolName() const { return _fparser_name; };

  void setSymbolName(const std::string & n) { _fparser_name = n; };

  const std::string & getPropertyName() const { return _property_name; };

  GenericReal<is_ad> value(unsigned int qp = libMesh::invalid_uint) const;

  void addDerivative(const SymbolName & symbol);

  bool dependsOn(const SymbolName & symbol) const;

  std::vector<SymbolName> getDependentSymbols();

  void printDebug();

  void updatePropertyName();

private:
  void parseDerivative(const std::string &);
  void parseDependentSymbols(const std::string &);

  enum class PropertyState
  {
    CURRENT,
    OLD,
    OLDER
  } _state;

  std::string _fparser_name;

  std::string _base_name;

  std::vector<SymbolName> _dependent_symbols;
  std::vector<SymbolName> _derivative_symbols;

  mutable const GenericMaterialProperty<Real, is_ad> * _value;

  mutable const MaterialProperty<Real> * _old_older_value;

  MooseObject * _parent;

  std::string _property_name;

  bool _required;
};