ParsedMaterialHelper.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 "FunctionMaterialBase.h"
#include "FunctionParserUtils.h"
#include "FunctionMaterialPropertyDescriptor.h"
#include "DerivativeMaterialPropertyNameInterface.h"

#include "libmesh/fparser_ad.hh"

#include <optional>

#define usingParsedMaterialHelperMembers(T)                                                        \
  usingFunctionMaterialBaseMembers(T);                                                             \
  usingFunctionParserUtilsMembers(T);                                                              \
  using typename ParsedMaterialHelper<T>::VariableNameMappingMode;                                 \
  using typename ParsedMaterialHelper<T>::MatPropDescriptorList;                                   \
  using ParsedMaterialHelper<T>::functionParse;                                                    \
  using ParsedMaterialHelper<T>::functionsPostParse;                                               \
  using ParsedMaterialHelper<T>::_func_F;                                                          \
  using ParsedMaterialHelper<T>::_symbol_names;                                                    \
  using ParsedMaterialHelper<T>::_mat_prop_descriptors;                                            \
  using ParsedMaterialHelper<T>::_tol;                                                             \
  using ParsedMaterialHelper<T>::_postprocessor_values;                                            \
  using ParsedMaterialHelper<T>::_extra_symbols;                                                   \
  using ParsedMaterialHelper<T>::_functors;                                                        \
  using ParsedMaterialHelper<T>::_map_mode

template <bool is_ad>
class ParsedMaterialHelper : public FunctionMaterialBase<is_ad>, public FunctionParserUtils<is_ad>
{
public:
  typedef DerivativeMaterialPropertyNameInterface::SymbolName SymbolName;

  enum class VariableNameMappingMode
  {
    USE_MOOSE_NAMES,
    USE_PARAM_NAMES
  };

  enum class ExtraSymbols
  {
    x,
    y,
    z,
    t,
    dt
  };

  ParsedMaterialHelper(const InputParameters & parameters,
                       const VariableNameMappingMode map_mode,
                       const std::optional<std::string> & function_param_name = {});

  static InputParameters validParams();

  void functionParse(const std::string & function_expression);

  void functionParse(const std::string & function_expression,
                     const std::vector<std::string> & constant_names,
                     const std::vector<std::string> & constant_expressions);

  void functionParse(const std::string & function_expression,
                     const std::vector<std::string> & constant_names,
                     const std::vector<std::string> & constant_expressions,
                     const std::vector<std::string> & mat_prop_names,
                     const std::vector<std::string> & tol_names,
                     const std::vector<Real> & tol_values);

  void functionParse(const std::string & function_expression,
                     const std::vector<std::string> & constant_names,
                     const std::vector<std::string> & constant_expressions,
                     const std::vector<std::string> & mat_prop_names,
                     const std::vector<PostprocessorName> & postprocessor_names,
                     const std::vector<std::string> & tol_names,
                     const std::vector<Real> & tol_values);

  void functionParse(const std::string & function_expression,
                     const std::vector<std::string> & constant_names,
                     const std::vector<std::string> & constant_expressions,
                     const std::vector<std::string> & mat_prop_names,
                     const std::vector<PostprocessorName> & postprocessor_names,
                     const std::vector<std::string> & tol_names,
                     const std::vector<Real> & tol_values,
                     const std::vector<MooseFunctorName> & functor_names,
                     const std::vector<std::string> & functor_symbols);

protected:
  usingFunctionMaterialBaseMembers(is_ad);
  usingFunctionParserUtilsMembers(is_ad);

  void initQpStatefulProperties() override;
  void computeQpProperties() override;
  virtual void initialSetup() override final;

  void insertReservedNames(std::set<std::string> & reserved_names);

  // tasks to perform after parsing the primary function
  virtual void functionsPostParse();

  SymFunctionPtr _func_F;

  std::vector<SymbolName> _symbol_names;

  const std::vector<ExtraSymbols> _extra_symbols;

  std::vector<const Moose::Functor<Real> *> _functors;

  typedef std::vector<FunctionMaterialPropertyDescriptor<is_ad>> MatPropDescriptorList;

  MatPropDescriptorList _mat_prop_descriptors;

  std::vector<Real> _tol;

  std::vector<const PostprocessorValue *> _postprocessor_values;

  const VariableNameMappingMode _map_mode;

  const std::optional<std::string> _function_param_name;

  std::vector<MaterialName> _upstream_mat_names;

  const bool _error_on_missing_material_properties;

  std::vector<MaterialBase *> _upstream_mat;

private:
  void parseError(const std::string & message) const;

  const InputParameters & _params;
};