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 "MooseEnum.h"
#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;
 
  CreateMooseEnumClass(VariableNameMappingMode, USE_MOOSE_NAMES, USE_PARAM_NAMES);
  CreateMooseEnumClass(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;
};