FunctionParserUtils.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 "Moose.h"
#include "MooseTypes.h"
#include "ADFParser.h"
 
#include "libmesh/fparser_ad.hh"
 
// C++ includes
#include <memory>
 
#define usingFunctionParserUtilsMembers(T)                                                         \
  using typename FunctionParserUtils<T>::SymFunction;                                              \
  using typename FunctionParserUtils<T>::SymFunctionPtr;                                           \
  using typename FunctionParserUtils<T>::FailureMethod;                                            \
  using FunctionParserUtils<T>::evaluate;                                                          \
  using FunctionParserUtils<T>::functionsOptimize;                                                 \
  using FunctionParserUtils<T>::setParserFeatureFlags;                                             \
  using FunctionParserUtils<T>::addFParserConstants;                                               \
  using FunctionParserUtils<T>::_enable_jit;                                                       \
  using FunctionParserUtils<T>::_enable_ad_cache;                                                  \
  using FunctionParserUtils<T>::_disable_fpoptimizer;                                              \
  using FunctionParserUtils<T>::_enable_auto_optimize;                                             \
  using FunctionParserUtils<T>::_eval_error_msg;                                                   \
  using FunctionParserUtils<T>::_func_params
 
template <bool is_ad>
struct GenericSymFunctionTempl
{
  typedef FunctionParserADBase<Real> type;
};
template <>
struct GenericSymFunctionTempl<true>
{
  typedef ADFParser type;
};
template <bool is_ad>
using GenericSymFunction = typename GenericSymFunctionTempl<is_ad>::type;
 
// Forward declartions
class InputParameters;
 
template <bool is_ad = false>
class FunctionParserUtils
{
public:
  static InputParameters validParams();
 
  FunctionParserUtils(const InputParameters & parameters);
 
  typedef GenericSymFunction<is_ad> SymFunction;
 
  typedef std::shared_ptr<SymFunction> SymFunctionPtr;
 
  void setParserFeatureFlags(SymFunctionPtr &) const;
 
protected:
  GenericReal<is_ad> evaluate(SymFunctionPtr &, const std::string & object_name = "");
  GenericReal<is_ad> evaluate(SymFunctionPtr &,
                              const std::vector<GenericReal<is_ad>> &,
                              const std::string & object_name = "");
 
  void addFParserConstants(SymFunctionPtr & parser,
                           const std::vector<std::string> & constant_names,
                           const std::vector<std::string> & constant_expressions) const;
 
  virtual void functionsOptimize(SymFunctionPtr & parsed_function);
 
  void parsedFunctionSetup(SymFunctionPtr & function,
                           const std::string & expression,
                           const std::string & variables,
                           const std::vector<std::string> & constant_names,
                           const std::vector<std::string> & constant_expressions,
                           const libMesh::Parallel::Communicator & comm) const;
 
  bool _enable_jit;
  bool _enable_ad_cache;
  bool _disable_fpoptimizer;
  bool _enable_auto_optimize;
 
  const enum class FailureMethod { nan, nan_warning, error, exception } _evalerror_behavior;
 
  const Real _quiet_nan;
 
  static const char * _eval_error_msg[];
 
  std::vector<GenericReal<is_ad>> _func_params;
 
  const Real _epsilon;
};
 
template <>
void FunctionParserUtils<false>::functionsOptimize(SymFunctionPtr & parsed_function);
 
template <>
void FunctionParserUtils<true>::functionsOptimize(SymFunctionPtr & parsed_function);