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;
};