FunctionMaterialPropertyDescriptor.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://www.mooseframework.org
//*
//* 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;

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.
   */
  FunctionMaterialPropertyDescriptor(const std::string &, MooseObject *);

  FunctionMaterialPropertyDescriptor();

  FunctionMaterialPropertyDescriptor(const FunctionMaterialPropertyDescriptor &);

  FunctionMaterialPropertyDescriptor(const FunctionMaterialPropertyDescriptor &, MooseObject *);

  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 derivativePropertyName(_base_name, _derivative_vars);
  };

  const MaterialProperty<Real> & value() const;

  void addDerivative(const VariableName & var);

  bool dependsOn(const std::string & var) const;

  std::vector<VariableName> getDependentVariables();

  // output the internal state of this descriptor for debugging purposes
  void printDebug();

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

  std::string _fparser_name;

  std::string _base_name;

  std::vector<VariableName> _dependent_vars;
  std::vector<VariableName> _derivative_vars;

  mutable const MaterialProperty<Real> * _value;

  MooseObject * _parent;
};