libMesh::ParsedFunction< Output, OutputGradient > 模板类 参考

通过解析数学表达式生成（通过 FParser）的函数。所有重写的虚拟函数在 function_base.h 中都有文档说明。 更多...

#include <parsed_function.h>

类 libMesh::ParsedFunction< Output, OutputGradient > 继承关系图:

Public 成员函数
	ParsedFunction (std::string expression, const std::vector< std::string > *additional_vars=nullptr, const std::vector< Output > *initial_vals=nullptr)
	构造函数。使用给定的数学表达式创建一个 ParsedFunction。 更多...
	ParsedFunction (const ParsedFunction &)
ParsedFunction &	operator= (const ParsedFunction &)
	ParsedFunction (ParsedFunction &&)=default
ParsedFunction &	operator= (ParsedFunction &&)=default
virtual	~ParsedFunction ()=default
void	reparse (std::string expression)
	重新解析 ParsedFunction 的数学表达式。 更多...
virtual Output	operator() (const Point &p, const Real time=0) override
	计算 ParsedFunction 在给定点上的值。 更多...
virtual bool	has_derivatives ()
	查询是否成功生成了自动导数。 更多...
virtual Output	dot (const Point &p, const Real time=0)
	计算 ParsedFunction 在给定点上的点乘结果。 更多...
virtual OutputGradient	gradient (const Point &p, const Real time=0)
	计算 ParsedFunction 在给定点上的梯度。 更多...
virtual void	operator() (const Point &p, const Real time, DenseVector< Output > &output) override
	计算 ParsedFunction 在给定点上的输出并存储在输出向量中。 更多...
virtual Output	component (unsigned int i, const Point &p, Real time) override
	计算 ParsedFunction 的特定分量在给定点上的值。 更多...
const std::string &	expression ()
	获取 ParsedFunction 的数学表达式。 更多...
virtual Output &	getVarAddress (std::string_view variable_name)
	获取一个解析变量的地址，以便提供参数化的值。 更多...
virtual std::unique_ptr < FunctionBase< Output > >	clone () const override
	克隆 ParsedFunction 对象。 更多...
Output	get_inline_value (std::string_view inline_var_name) const
	获取内联变量的值。 更多...
void	set_inline_value (std::string_view inline_var_name, Output newval)
	Changes the value of an inline variable. 更多...
	ParsedFunction (std::string, const std::vector< std::string > *=nullptr, const std::vector< Output > *=nullptr)
	ParsedFunction (ParsedFunction &&)=delete
	LIBMESH_HAVE_FPARSER时，这个类没有实现， 所以让通过删除特殊函数来显式地实现它。 更多...
	ParsedFunction (const ParsedFunction &)=delete
ParsedFunction &	operator= (const ParsedFunction &)=delete
ParsedFunction &	operator= (ParsedFunction &&)=delete
virtual	~ParsedFunction ()=default
virtual Output	operator() (const Point &, const Real=0)
virtual void	operator() (const Point &, const Real, DenseVector< Output > &)
	用于时间无关的矢量值函数的评估函数。 将输出值设置在传入的 output DenseVector 中。 更多...
virtual void	init ()
	实际的初始化过程。 更多...
virtual void	clear ()
	清除函数。 更多...
virtual Output &	getVarAddress (std::string_view)
virtual std::unique_ptr < FunctionBase< Output > >	clone () const
void	operator() (const Point &p, DenseVector< Output > &output)
	Evaluation function for time-independent vector-valued functions. 更多...
bool	initialized () const
void	set_is_time_dependent (bool is_time_dependent)
	设置函数是否依赖时间的函数。 这仅应该由无法本地确定时间依赖性的子类使用。 在这种情况下，应在构造之后立即使用这个函数。 更多...
bool	is_time_dependent () const

Protected 成员函数
void	partial_reparse (std::string expression)
	重新解析数学表达式，仅对表达式进行轻微更改。 更多...
std::size_t	find_name (std::string_view varname, std::string_view expr) const
	解析出变量名的辅助函数。 更多...
bool	expression_is_time_dependent (std::string_view expression) const
	检查表达式是否与时间有关。 更多...

Protected 属性
const FunctionBase *	_master
	指向我们的主函数对象的const指针，初始化为 nullptr。 可能存在需要多个函数的情况，但为了节省内存，一个主函数对象可以处理一些集中的数据。 更多...
bool	_initialized
	当 init() 被调用以确保一切都准备好后，可以调用 operator() (...) 时为 true。 更多...
bool	_is_time_dependent
	成员变量用于缓存函数是否真正依赖于时间。 更多...

Private 成员函数
void	set_spacetime (const Point &p, const Real time=0)
	设置 _spacetime 参数向量。 更多...
Output	eval (FunctionParserADBase< Output > &parser, std::string_view libmesh_dbg_var(function_name), unsigned int libmesh_dbg_var(component_idx)) const
	评估第 i 个 FunctionParser 并检查结果。 更多...

Private 属性
std::string	_expression
	存储数学表达式的字符串表示。 更多...
std::vector< std::string >	_subexpressions
	存储在数学表达式中找到的子表达式的字符串表示。 更多...
std::vector< std::unique_ptr < FunctionParserADBase< Output > > >	parsers
	存储用于计算数学表达式的解析器的集合。 更多...
std::vector< Output >	_spacetime
	存储空间-时间参数向量的值。 更多...
std::vector< std::unique_ptr < FunctionParserADBase< Output > > >	dx_parsers
	存储用于计算导数的解析器的集合。 更多...
std::vector< std::unique_ptr < FunctionParserADBase< Output > > >	dy_parsers
	存储用于计算二维场景中 y 方向导数的解析器的集合。 更多...
std::vector< std::unique_ptr < FunctionParserADBase< Output > > >	dz_parsers
	存储用于计算三维场景中 z 方向导数的解析器的集合。 更多...
std::vector< std::unique_ptr < FunctionParserADBase< Output > > >	dt_parsers
	存储用于计算时间导数的解析器的集合。 更多...
bool	_valid_derivatives
	用于跟踪导数是否有效的标志。 更多...
std::string	variables
	存储函数中可以解析和处理的变量名称和值。 更多...
std::vector< std::string >	_additional_vars
	存储附加变量的名称，这些变量可以在函数中进行解析和处理。 更多...
std::vector< Output >	_initial_vals
	存储函数中变量的初始值。 更多...
Output	_dummy

详细描述

template<typename Output = Number, typename OutputGradient = Gradient>
class libMesh::ParsedFunction< Output, OutputGradient >

通过解析数学表达式生成（通过 FParser）的函数。所有重写的虚拟函数在 function_base.h 中都有文档说明。

作者

Roy Stogner

日期

2012 由 std::string 定义的函数。

在文件 parsed_function.h 第 58 行定义.

构造及析构函数说明

template<typename Output, typename OutputGradient >

libMesh::ParsedFunction< Output, OutputGradient >::ParsedFunction ( std::string  expression, const std::vector< std::string > *  additional_vars = nullptr, const std::vector< Output > *  initial_vals = nullptr  )

inlineexplicit

构造函数。使用给定的数学表达式创建一个 ParsedFunction。

参数

expression	数学表达式的字符串表示。
additional_vars	可选参数，附加的变量名（字符串向量），默认为空。
initial_vals	可选参数，初始值（输出向量），默认为空。

在文件 parsed_function.h 第 317 行定义.

参考 libMesh::FunctionBase< Output >::_initialized , 以及 libMesh::ParsedFunction< Output, OutputGradient >::reparse().

                                                                                               :
  _expression (), // overridden by parse()
  // 调整时空向量的大小，以考虑空间、时间和传递的任何其他变量
  _spacetime (LIBMESH_DIM+1 + (additional_vars ? additional_vars->size() : 0)),
  _valid_derivatives (true),
  _additional_vars (additional_vars ? *additional_vars : std::vector<std::string>()),
  _initial_vals (initial_vals ? *initial_vals : std::vector<Output>())
{
  // time-dependence established in reparse function
  this->reparse(std::move(expression));
  this->_initialized = true;
}

template<typename Output, typename OutputGradient >

libMesh::ParsedFunction< Output, OutputGradient >::ParsedFunction ( const ParsedFunction< Output, OutputGradient > &  other )

inline

在文件 parsed_function.h 第 335 行定义.

参考 libMesh::ParsedFunction< Output, OutputGradient >::_expression, libMesh::FunctionBase< Output >::_initialized , 以及 libMesh::ParsedFunction< Output, OutputGradient >::reparse().

                                                                                                          :
  FunctionBase<Output>(other),
  _expression(other._expression),
  _subexpressions(other._subexpressions),
  _spacetime(other._spacetime),
  _valid_derivatives(other._valid_derivatives),
  variables(other.variables),
  _additional_vars(other._additional_vars),
  _initial_vals(other._initial_vals)
{
  // 可以通过重新解析表达式从头生成解析器
  this->reparse(this->_expression);
  this->_initialized = true;
}

template<typename Output = Number, typename OutputGradient = Gradient>

libMesh::ParsedFunction< Output, OutputGradient >::ParsedFunction ( ParsedFunction< Output, OutputGradient > &&  )

default

template<typename Output = Number, typename OutputGradient = Gradient>

virtual libMesh::ParsedFunction< Output, OutputGradient >::~ParsedFunction ( )

virtualdefault

template<typename Output = Number, typename OutputGradient = Gradient>

libMesh::ParsedFunction< Output, OutputGradient >::ParsedFunction ( std::string  , const std::vector< std::string > *  = nullptr, const std::vector< Output > *  = nullptr  )

inline

在文件 parsed_function.h 第 845 行定义.

                                                       : _dummy(0)
  {
    libmesh_not_implemented();
  }

template<typename Output = Number, typename OutputGradient = Gradient>

libMesh::ParsedFunction< Output, OutputGradient >::ParsedFunction ( ParsedFunction< Output, OutputGradient > &&  )

delete

LIBMESH_HAVE_FPARSER时，这个类没有实现， 所以让通过删除特殊函数来显式地实现它。

template<typename Output = Number, typename OutputGradient = Gradient>

libMesh::ParsedFunction< Output, OutputGradient >::ParsedFunction ( const ParsedFunction< Output, OutputGradient > &  )

delete

template<typename Output = Number, typename OutputGradient = Gradient>

virtual libMesh::ParsedFunction< Output, OutputGradient >::~ParsedFunction ( )

virtualdefault

成员函数说明

template<typename Output = Number, typename OutputGradient = Gradient>

virtual void libMesh::ParsedFunction< Output, OutputGradient >::clear ( )

inlinevirtual

清除函数。

这个函数可以用来清除函数对象的状态，以备重新使用。

重载 libMesh::FunctionBase< Output > .

在文件 parsed_function.h 第 871 行定义.

{}

template<typename Output , typename OutputGradient >

std::unique_ptr< FunctionBase< Output > > libMesh::ParsedFunction< Output, OutputGradient >::clone ( ) const

inlineoverridevirtual

克隆 ParsedFunction 对象。

返回

ParsedFunction 的克隆对象。

实现了 libMesh::FunctionBase< Output >.

在文件 parsed_function.h 第 489 行定义.

{
  return std::make_unique<ParsedFunction>(_expression,
                                          &_additional_vars,
                                          &_initial_vals);
}

template<typename Output = Number, typename OutputGradient = Gradient>

virtual std::unique_ptr<FunctionBase<Output> > libMesh::ParsedFunction< Output, OutputGradient >::clone ( ) const

inlinevirtual

返回

函数的新副本。

新副本应该足够“深”，以允许在不同线程中独立销毁和同时评估副本。

实现了 libMesh::FunctionBase< Output >.

在文件 parsed_function.h 第 873 行定义.

  {
    return std::make_unique<ParsedFunction<Output>>("");
  }

template<typename Output , typename OutputGradient >

Output libMesh::ParsedFunction< Output, OutputGradient >::component ( unsigned int  i, const Point &  p, Real  time  )

inlineoverridevirtual

计算 ParsedFunction 的特定分量在给定点上的值。

参数

i	要计算的分量的索引。
p	要计算分量值的点。
time	时间值。

返回

计算结果的分量值。

The vector component i at coordinate p and time time.

重载 libMesh::FunctionBase< Output > .

在文件 parsed_function.h 第 455 行定义.

{
  set_spacetime(p, time);
  libmesh_assert_less (i, parsers.size());

  // _spacetime中的其余位置目前在构建时是固定的，但可能会被动态化
  libmesh_assert_less(i, parsers.size());
  return eval(*parsers[i], "f", i);
}

template<typename Output , typename OutputGradient >

Output libMesh::ParsedFunction< Output, OutputGradient >::dot ( const Point &  p, const Real  time = 0  )

inlinevirtual

计算 ParsedFunction 在给定点上的点乘结果。

参数

p	要计算点乘结果的点。
time	时间值（可选，默认为0）。

返回

点乘结果的值。

在文件 parsed_function.h 第 404 行定义.

{
  set_spacetime(p, time);
  return eval(*dt_parsers[0], "df/dt", 0);
}

template<typename Output = Number, typename OutputGradient = Gradient>

Output libMesh::ParsedFunction< Output, OutputGradient >::eval ( FunctionParserADBase< Output > &  parser, std::string_view   libmesh_dbg_varfunction_name, unsigned int   libmesh_dbg_varcomponent_idx  ) const

inlineprivate

评估第 i 个 FunctionParser 并检查结果。

参数

parser	要评估的 FunctionParser。
function_name	函数的名称。
component_idx	组件的索引。

返回

评估结果的值。

在文件 parsed_function.h 第 779 行定义.

参考 libMesh::err.

{
  Output result = parser.Eval(_spacetime.data());
  int error_code = parser.EvalError();
  if (error_code)
    {
      libMesh::err << "ERROR: FunctionParser is unable to evaluate component "
                   << component_idx
                   << " for '"
                   << function_name;

      for (auto i : index_range(parsers))
        if (parsers[i].get() == &parser)
          libMesh::err << "' of expression '"
                       << _subexpressions[i];

      libMesh::err << "' with arguments:\n";
      for (const auto & item : _spacetime)
        libMesh::err << '\t' << item << '\n';
      libMesh::err << '\n';

      // 目前没有API来报告错误消息，我们将手动完成
      std::string error_message = "Reason: ";

      switch (error_code)
        {
        case 1:
          error_message += "Division by zero";
          break;
        case 2:
          error_message += "Square Root error (negative value)";
          break;
        case 3:
          error_message += "Log error (negative value)";
          break;
        case 4:
          error_message += "Trigonometric error (asin or acos of illegal value)";
          break;
        case 5:
          error_message += "Maximum recursion level reached";
          break;
        default:
          error_message += "Unknown";
          break;
        }
      libmesh_error_msg(error_message);
    }

  return result;
}

template<typename Output = Number, typename OutputGradient = Gradient>

const std::string& libMesh::ParsedFunction< Output, OutputGradient >::expression ( )

inline

获取 ParsedFunction 的数学表达式。

返回

数学表达式的字符串表示。

在文件 parsed_function.h 第 153 行定义.

{ return _expression; }

template<typename Output , typename OutputGradient >

bool libMesh::ParsedFunction< Output, OutputGradient >::expression_is_time_dependent ( std::string_view  expression ) const

inlineprotected

检查表达式是否与时间有关。

参数

expression

要检查的数学表达式的字符串表示。

返回

如果表达式与时间有关则返回 true，否则返回 false。

在文件 parsed_function.h 第 745 行定义.

{
  bool is_time_dependent = false;

  // 根据定义，对于基于functionbase的对象，时间是“t”，所以只需要看看这个表达式中是否有变量“t”。
  if (this->find_name(std::string("t"), expression) != std::string::npos)
    is_time_dependent = true;

  return is_time_dependent;
}

template<typename Output , typename OutputGradient >

std::size_t libMesh::ParsedFunction< Output, OutputGradient >::find_name ( std::string_view  varname, std::string_view  expr  ) const

inlineprotected

解析出变量名的辅助函数。

参数

varname	要解析的变量名。
expr	要解析的表达式。

返回

变量名在表达式中的位置。

在文件 parsed_function.h 第 723 行定义.

{
  const std::size_t namesize = varname.size();
  std::size_t varname_i = expr.find(varname);

  while ((varname_i != std::string::npos) &&
         (((varname_i > 0) &&
           (std::isalnum(expr[varname_i-1]) ||
            (expr[varname_i-1] == '_'))) ||
          ((varname_i+namesize < expr.size()) &&
           (std::isalnum(expr[varname_i+namesize]) ||
            (expr[varname_i+namesize] == '_')))))
    {
      varname_i = expr.find(varname, varname_i+1);
    }

  return varname_i;
}

template<typename Output , typename OutputGradient >

Output libMesh::ParsedFunction< Output, OutputGradient >::get_inline_value ( std::string_view  inline_var_name ) const

inline

获取内联变量的值。

参数

inline_var_name

内联变量的名称。

返回

内联变量的值。

注解

只有当内联变量的值独立于输入变量， 内联变量没有在任何子表达式中被重新定义， 以及内联变量在它出现的任何子表达式中取相同的值时才正确。

在文件 parsed_function.h 第 499 行定义.

参考 libMesh::Real.

参考自 libMesh::ParsedFunctionParameter< T >::get().

{
  libmesh_assert_greater (_subexpressions.size(), 0);

#ifndef NDEBUG
  bool found_var_name = false;
#endif
  Output old_var_value(0.);

  for (const auto & subexpression : _subexpressions)
    {
      const std::size_t varname_i =
        find_name(inline_var_name, subexpression);
      if (varname_i == std::string::npos)
        continue;

      const std::size_t assignment_i =
        subexpression.find(":", varname_i+1);

      libmesh_assert_not_equal_to(assignment_i, std::string::npos);

      libmesh_assert_equal_to(subexpression[assignment_i+1], '=');
      for (std::size_t i = varname_i+1; i != assignment_i; ++i)
        libmesh_assert_equal_to(subexpression[i], ' ');

      std::size_t end_assignment_i =
        subexpression.find(";", assignment_i+1);

      libmesh_assert_not_equal_to(end_assignment_i, std::string::npos);

      std::string new_subexpression =
        subexpression.substr(0, end_assignment_i+1).append(inline_var_name);

#ifdef LIBMESH_HAVE_FPARSER
      // Parse and evaluate the new subexpression.
      // Add the same constants as we used originally.
      FunctionParserADBase<Output> fp;
      fp.AddConstant("NaN", std::numeric_limits<Real>::quiet_NaN());
      fp.AddConstant("pi", std::acos(Real(-1)));
      fp.AddConstant("e", std::exp(Real(1)));
      libmesh_error_msg_if
        (fp.Parse(new_subexpression, variables) != -1, // -1 for success
         "ERROR: FunctionParser is unable to parse modified expression: "
         << new_subexpression << '\n' << fp.ErrorMsg());

      Output new_var_value = this->eval(fp, new_subexpression, 0);
#ifdef NDEBUG
      return new_var_value;
#else
      if (found_var_name)
        {
          libmesh_assert_equal_to(old_var_value, new_var_value);
        }
      else
        {
          old_var_value = new_var_value;
          found_var_name = true;
        }
#endif

#else
      libmesh_error_msg("ERROR: This functionality requires fparser!");
#endif
    }

  libmesh_assert(found_var_name);
  return old_var_value;
}

template<typename Output , typename OutputGradient >

Output & libMesh::ParsedFunction< Output, OutputGradient >::getVarAddress ( std::string_view  variable_name )

inlinevirtual

获取一个解析变量的地址，以便提供参数化的值。

参数

variable_name

要获取地址的变量名。

返回

变量的地址。

已解析变量的地址，以便可以提供参数化值

在文件 parsed_function.h 第 473 行定义.

{
  const std::vector<std::string>::iterator it =
    std::find(_additional_vars.begin(), _additional_vars.end(), variable_name);

  libmesh_error_msg_if(it == _additional_vars.end(),
                       "ERROR: Requested variable not found in parsed function");

  // 迭代器算术(我们的目标地址离数组末尾有多远?)
  return _spacetime[_spacetime.size() - (_additional_vars.end() - it)];
}

template<typename Output = Number, typename OutputGradient = Gradient>

virtual Output& libMesh::ParsedFunction< Output, OutputGradient >::getVarAddress ( std::string_view  )

inlinevirtual

在文件 parsed_function.h 第 872 行定义.

{ return _dummy; }

template<typename Output , typename OutputGradient >

OutputGradient libMesh::ParsedFunction< Output, OutputGradient >::gradient ( const Point &  p, const Real  time = 0  )

inlinevirtual

计算 ParsedFunction 在给定点上的梯度。

参数

p	要计算梯度的点。
time	时间值（可选，默认为0）。

返回

计算结果的梯度。

在文件 parsed_function.h 第 413 行定义.

{
  OutputGradient grad;
  set_spacetime(p, time);

  grad(0) = eval(*dx_parsers[0], "df/dx", 0);
#if LIBMESH_DIM > 1
  grad(1) = eval(*dy_parsers[0], "df/dy", 0);
#endif
#if LIBMESH_DIM > 2
  grad(2) = eval(*dz_parsers[0], "df/dz", 0);
#endif

  return grad;
}

template<typename Output = Number, typename OutputGradient = Gradient>

virtual bool libMesh::ParsedFunction< Output, OutputGradient >::has_derivatives ( )

inlinevirtual

查询是否成功生成了自动导数。

返回

如果成功生成了自动导数，返回 true；否则返回 false。

在文件 parsed_function.h 第 103 行定义.

{ return _valid_derivatives; }

template<typename Output = Number, typename OutputGradient = Gradient>

virtual void libMesh::ParsedFunction< Output, OutputGradient >::init ( )

inlinevirtual

实际的初始化过程。

这个函数可以用来进行函数对象的初始化工作。

重载 libMesh::FunctionBase< Output > .

在文件 parsed_function.h 第 870 行定义.

{}

template<typename Output >

bool libMesh::FunctionBase< Output >::initialized ( ) const

inlineinherited

返回

在坐标 p 和时间 time 处的向量的分量 i。

子类可以选择重写这个函数以提高效率，因为默认实现基于向量评估，通常是不必要的低效率。

参数

i	分量的索引。
p	坐标点。
time	时间。

注解

默认实现调用带有大小为 i+1 的DenseVector的operator()，如果operator() 在该限制之外进行访问，将导致意外行为。

在文件 function_base.h 第 216 行定义.

{
  return (this->_initialized);
}

template<typename Output >

bool libMesh::FunctionBase< Output >::is_time_dependent ( ) const

inlineinherited

返回

当前对象表示的函数是否实际上是时间相关的，是返回 true ，否则返回 false。

这个函数用于查询函数对象是否依赖于时间。有些函数对象的时间依赖性是从外部确定的，因此可以使用这个函数设置。

在文件 function_base.h 第 232 行定义.

参考自 libMesh::CompositeFunction< Output >::attach_subfunction().

{
  return (this->_is_time_dependent);
}

template<typename Output , typename OutputGradient >

Output libMesh::ParsedFunction< Output, OutputGradient >::operator() ( const Point &  p, const Real  time = 0  )

inlineoverridevirtual

计算 ParsedFunction 在给定点上的值。

参数

p	要计算值的点。
time	时间值（可选，默认为0）。

返回

计算结果的值。

实现了 libMesh::FunctionBase< Output >.

在文件 parsed_function.h 第 395 行定义.

{
  set_spacetime(p, time);
  return eval(*parsers[0], "f", 0);
}

template<typename Output>

void libMesh::FunctionBase< Output >::operator() ( const Point &  p, DenseVector< Output > &  output  )

inlineinherited

Evaluation function for time-independent vector-valued functions.

Sets output values in the passed-in output DenseVector.

在文件 function_base.h 第 252 行定义.

{
  // 调用时间相关的函数，时间设为0。
  this->operator()(p, 0., output);
}

template<typename Output, typename OutputGradient >

void libMesh::ParsedFunction< Output, OutputGradient >::operator() ( const Point &  p, const Real  time, DenseVector< Output > &  output  )

inlineoverridevirtual

计算 ParsedFunction 在给定点上的输出并存储在输出向量中。

参数

p	要计算输出的点。
time	时间值。
output	存储计算结果的输出向量。

实现了 libMesh::FunctionBase< Output >.

在文件 parsed_function.h 第 433 行定义.

{
  set_spacetime(p, time);

  unsigned int size = output.size();

  libmesh_assert_equal_to (size, parsers.size());

  // 剩余的时空位置目前是固定的，但有可能是动态的
  for (unsigned int i=0; i != size; ++i)
    output(i) = eval(*parsers[i], "f", i);
}

template<typename Output = Number, typename OutputGradient = Gradient>

virtual Output libMesh::ParsedFunction< Output, OutputGradient >::operator() ( const Point &  p, const Real  time = 0  )

inlinevirtual

返回

坐标 p 和时间 time （默认为0）处的标量函数值。

这是一个纯虚函数，因此必须重写它。

实现了 libMesh::FunctionBase< Output >.

在文件 parsed_function.h 第 862 行定义.

  { return 0.; }

template<typename Output = Number, typename OutputGradient = Gradient>

virtual void libMesh::ParsedFunction< Output, OutputGradient >::operator() ( const Point &  p, const Real  time, DenseVector< Output > &  output  )

inlinevirtual

用于时间无关的矢量值函数的评估函数。 将输出值设置在传入的 output DenseVector 中。

参数

p	坐标点。
output	输出的向量。

实现了 libMesh::FunctionBase< Output >.

在文件 parsed_function.h 第 866 行定义.

                                                    {}

template<typename Output , typename OutputGradient >

ParsedFunction< Output, OutputGradient > & libMesh::ParsedFunction< Output, OutputGradient >::operator= ( const ParsedFunction< Output, OutputGradient > &  other )

inline

在文件 parsed_function.h 第 355 行定义.

{
  // Use copy-and-swap idiom
  ParsedFunction<Output,OutputGradient> tmp(other);
  std::swap(tmp, *this);
  return *this;
}

template<typename Output = Number, typename OutputGradient = Gradient>

ParsedFunction& libMesh::ParsedFunction< Output, OutputGradient >::operator= ( ParsedFunction< Output, OutputGradient > &&  )

default

template<typename Output = Number, typename OutputGradient = Gradient>

ParsedFunction& libMesh::ParsedFunction< Output, OutputGradient >::operator= ( const ParsedFunction< Output, OutputGradient > &  )

delete

template<typename Output = Number, typename OutputGradient = Gradient>

ParsedFunction& libMesh::ParsedFunction< Output, OutputGradient >::operator= ( ParsedFunction< Output, OutputGradient > &&  )

delete

template<typename Output , typename OutputGradient >

void libMesh::ParsedFunction< Output, OutputGradient >::partial_reparse ( std::string  expression )

inlineprotected

重新解析数学表达式，仅对表达式进行轻微更改。

参数

expression

新的数学表达式的字符串表示。

在文件 parsed_function.h 第 636 行定义.

参考 libMesh::Real.

{
  _expression = std::move(expression);
  _subexpressions.clear();
  parsers.clear();

  size_t nextstart = 0, end = 0;

  while (end != std::string::npos)
    {
      // 如果超出了字符串的末尾，就不能再创建子解析器了
      if (nextstart >= _expression.size())
        break;

      // 如果在一个用大括号分隔的section的开头，那么只解析该section:
      if (_expression[nextstart] == '{')
        {
          nextstart++;
          end = _expression.find('}', nextstart);
        }
      // 否则解析整个东西
      else
        end = std::string::npos;

      // 我们要么需要整个字符串的末尾(end == npos)，要么需要中间的子字符串。
      _subexpressions.push_back
        (_expression.substr(nextstart, (end == std::string::npos) ?
                           std::string::npos : end - nextstart));

      // Fparser可能会在空表达式上崩溃
      libmesh_error_msg_if(_subexpressions.back().empty(),
                           "ERROR: FunctionParser is unable to parse empty expression.\n");

      // 解析(并尽可能优化)子表达式。添加一些基本常量，以达到真正的精度。
      auto fp = std::make_unique<FunctionParserADBase<Output>>();
      fp->AddConstant("NaN", std::numeric_limits<Real>::quiet_NaN());
      fp->AddConstant("pi", std::acos(Real(-1)));
      fp->AddConstant("e", std::exp(Real(1)));
      libmesh_error_msg_if
        (fp->Parse(_subexpressions.back(), variables) != -1, // -1 for success
         "ERROR: FunctionParser is unable to parse expression: "
         << _subexpressions.back() << '\n' << fp->ErrorMsg());

      // use of derivatives is optional. suppress error output on the console
      // use the has_derivatives() method to check if AutoDiff was successful.
      // also enable immediate optimization
      fp->SetADFlags(FunctionParserADBase<Output>::ADSilenceErrors |
                    FunctionParserADBase<Output>::ADAutoOptimize);

      // 优化原始函数
      fp->Optimize();

      // 通过自动微分生成导数
      auto dx_fp = std::make_unique<FunctionParserADBase<Output>>(*fp);
      if (dx_fp->AutoDiff("x") != -1) // -1 for success
        _valid_derivatives = false;
      dx_parsers.push_back(std::move(dx_fp));
#if LIBMESH_DIM > 1
      auto dy_fp = std::make_unique<FunctionParserADBase<Output>>(*fp);
      if (dy_fp->AutoDiff("y") != -1) // -1 for success
        _valid_derivatives = false;
      dy_parsers.push_back(std::move(dy_fp));
#endif
#if LIBMESH_DIM > 2
      auto dz_fp = std::make_unique<FunctionParserADBase<Output>>(*fp);
      if (dz_fp->AutoDiff("z") != -1) // -1 for success
        _valid_derivatives = false;
      dz_parsers.push_back(std::move(dz_fp));
#endif
      auto dt_fp = std::make_unique<FunctionParserADBase<Output>>(*fp);
      if (dt_fp->AutoDiff("t") != -1) // -1 for success
        _valid_derivatives = false;
      dt_parsers.push_back(std::move(dt_fp));

      // 如果在末尾，使用nextstart=maxSize。否则从下一个字符开始。
      nextstart = (end == std::string::npos) ?
        std::string::npos : end + 1;

      // Store fp for later use
      parsers.push_back(std::move(fp));
    }
}

template<typename Output , typename OutputGradient >

void libMesh::ParsedFunction< Output, OutputGradient >::reparse ( std::string  expression )

inline

重新解析 ParsedFunction 的数学表达式。

参数

expression

新的数学表达式的字符串表示。

在文件 parsed_function.h 第 367 行定义.

参考自 libMesh::ParsedFunction< Output, OutputGradient >::ParsedFunction().

{
  variables = "x";
#if LIBMESH_DIM > 1
  variables += ",y";
#endif
#if LIBMESH_DIM > 2
  variables += ",z";
#endif
  variables += ",t";

  // 如果传递了额外的变量，将它们附加到我们发送给函数解析器的字符串中。也把它们加到时空向量的末尾
  for (auto i : index_range(_additional_vars))
    {
      variables += "," + _additional_vars[i];
      // 将额外变量初始化为传入或zeroNote的向量:initial_vals向量可以比additional_vars向量短
      _spacetime[LIBMESH_DIM+1 + i] =
        (i < _initial_vals.size()) ? _initial_vals[i] : 0;
    }

  this->_is_time_dependent = this->expression_is_time_dependent(expression);

  this->partial_reparse(std::move(expression));
}

template<typename Output, typename OutputGradient >

void libMesh::ParsedFunction< Output, OutputGradient >::set_inline_value ( std::string_view  inline_var_name, Output  newval  )

inline

Changes the value of an inline variable.

注解

以后，变量值将采取给定的常数，独立于输入变量，在每个子表达式中，它已经定义。

当前仅在内联变量未在任何一个子表达式中重新定义时起作用。 更改内联变量的值。

参数

inline_var_name	要更改的内联变量的名称。
newval	新的内联变量值。

在文件 parsed_function.h 第 572 行定义.

参考自 libMesh::ParsedFunctionParameter< T >::set().

{
  libmesh_assert_greater (_subexpressions.size(), 0);

#ifndef NDEBUG
  bool found_var_name = false;
#endif
  for (auto & subexpression : _subexpressions)
    {
      const std::size_t varname_i =
        find_name(inline_var_name, subexpression);
      if (varname_i == std::string::npos)
        continue;

#ifndef NDEBUG
      found_var_name = true;
#endif
      const std::size_t assignment_i =
        subexpression.find(":", varname_i+1);

      libmesh_assert_not_equal_to(assignment_i, std::string::npos);

      libmesh_assert_equal_to(subexpression[assignment_i+1], '=');
      for (std::size_t i = varname_i+1; i != assignment_i; ++i)
        libmesh_assert_equal_to(subexpression[i], ' ');

      std::size_t end_assignment_i =
        subexpression.find(";", assignment_i+1);

      libmesh_assert_not_equal_to(end_assignment_i, std::string::npos);

      std::ostringstream new_subexpression;
      new_subexpression << subexpression.substr(0, assignment_i+2)
                        << std::setprecision(std::numeric_limits<Output>::digits10+2)
#ifdef LIBMESH_USE_COMPLEX_NUMBERS
                        << '(' << newval.real() << '+'
                        << newval.imag() << 'i' << ')'
#else
                        << newval
#endif
                        << subexpression.substr(end_assignment_i,
                                                std::string::npos);
      subexpression = new_subexpression.str();
    }

  libmesh_assert(found_var_name);

  std::string new_expression;

  for (const auto & subexpression : _subexpressions)
    {
      new_expression += '{';
      new_expression += subexpression;
      new_expression += '}';
    }

  this->partial_reparse(new_expression);
}

template<typename Output >

void libMesh::FunctionBase< Output >::set_is_time_dependent ( bool  is_time_dependent )

inlineinherited

设置函数是否依赖时间的函数。 这仅应该由无法本地确定时间依赖性的子类使用。 在这种情况下，应在构造之后立即使用这个函数。

在文件 function_base.h 第 224 行定义.

{
  this->_is_time_dependent = is_time_dependent;
}

template<typename Output , typename OutputGradient >

void libMesh::ParsedFunction< Output, OutputGradient >::set_spacetime ( const Point &  p, const Real  time = 0  )

inlineprivate

设置 _spacetime 参数向量。

参数

p	要设置参数向量的点。
time	时间值（可选，默认为0）。

在文件 parsed_function.h 第 760 行定义.

{
  _spacetime[0] = p(0);
#if LIBMESH_DIM > 1
  _spacetime[1] = p(1);
#endif
#if LIBMESH_DIM > 2
  _spacetime[2] = p(2);
#endif
  _spacetime[LIBMESH_DIM] = time;

  // _spacetime中的其余位置目前在构建时是固定的，但可能会被动态化
}

类成员变量说明

template<typename Output = Number, typename OutputGradient = Gradient>

std::vector<std::string> libMesh::ParsedFunction< Output, OutputGradient >::_additional_vars

private

存储附加变量的名称，这些变量可以在函数中进行解析和处理。

在文件 parsed_function.h 第 304 行定义.

template<typename Output = Number, typename OutputGradient = Gradient>

Output libMesh::ParsedFunction< Output, OutputGradient >::_dummy

private

在文件 parsed_function.h 第 878 行定义.

参考自 libMesh::ParsedFunction< T >::getVarAddress().

template<typename Output = Number, typename OutputGradient = Gradient>

std::string libMesh::ParsedFunction< Output, OutputGradient >::_expression

private

存储数学表达式的字符串表示。

在文件 parsed_function.h 第 250 行定义.

参考自 libMesh::ParsedFunction< T >::expression() , 以及 libMesh::ParsedFunction< Output, OutputGradient >::ParsedFunction().

template<typename Output = Number, typename OutputGradient = Gradient>

std::vector<Output> libMesh::ParsedFunction< Output, OutputGradient >::_initial_vals

private

存储函数中变量的初始值。

在文件 parsed_function.h 第 309 行定义.

template<typename Output>

bool libMesh::FunctionBase< Output >::_initialized

protectedinherited

当 init() 被调用以确保一切都准备好后，可以调用 operator() (...) 时为 true。

这个成员变量用于跟踪函数对象是否已经完成初始化，如果已经准备好进行评估，则为 true。

在文件 function_base.h 第 191 行定义.

参考自 libMesh::AnalyticFunction< Output >::AnalyticFunction(), libMesh::ConstFunction< Output >::ConstFunction(), libMesh::ParsedFunction< Output, OutputGradient >::ParsedFunction() , 以及 libMesh::WrappedFunction< Output >::WrappedFunction().

template<typename Output>

bool libMesh::FunctionBase< Output >::_is_time_dependent

protectedinherited

成员变量用于缓存函数是否真正依赖于时间。

在文件 function_base.h 第 197 行定义.

参考自 libMesh::CompositeFunction< Output >::attach_subfunction() , 以及 libMesh::ConstFunction< Output >::ConstFunction().

template<typename Output>

const FunctionBase* libMesh::FunctionBase< Output >::_master

protectedinherited

指向我们的主函数对象的const指针，初始化为 nullptr。 可能存在需要多个函数的情况，但为了节省内存，一个主函数对象可以处理一些集中的数据。

这个成员变量用于指向主函数对象的指针，有时候多个函数对象需要共享一些数据，可以通过主函数对象来管理。

在文件 function_base.h 第 184 行定义.

template<typename Output = Number, typename OutputGradient = Gradient>

std::vector<Output> libMesh::ParsedFunction< Output, OutputGradient >::_spacetime

private

存储空间-时间参数向量的值。

在文件 parsed_function.h 第 265 行定义.

template<typename Output = Number, typename OutputGradient = Gradient>

std::vector<std::string> libMesh::ParsedFunction< Output, OutputGradient >::_subexpressions

private

存储在数学表达式中找到的子表达式的字符串表示。

在文件 parsed_function.h 第 255 行定义.

template<typename Output = Number, typename OutputGradient = Gradient>

bool libMesh::ParsedFunction< Output, OutputGradient >::_valid_derivatives

private

用于跟踪导数是否有效的标志。

在文件 parsed_function.h 第 294 行定义.

参考自 libMesh::ParsedFunction< T >::has_derivatives().

template<typename Output = Number, typename OutputGradient = Gradient>

std::vector<std::unique_ptr<FunctionParserADBase<Output> > > libMesh::ParsedFunction< Output, OutputGradient >::dt_parsers

private

存储用于计算时间导数的解析器的集合。

在文件 parsed_function.h 第 289 行定义.

template<typename Output = Number, typename OutputGradient = Gradient>

std::vector<std::unique_ptr<FunctionParserADBase<Output> > > libMesh::ParsedFunction< Output, OutputGradient >::dx_parsers

private

存储用于计算导数的解析器的集合。

在文件 parsed_function.h 第 270 行定义.

template<typename Output = Number, typename OutputGradient = Gradient>

std::vector<std::unique_ptr<FunctionParserADBase<Output> > > libMesh::ParsedFunction< Output, OutputGradient >::dy_parsers

private

存储用于计算二维场景中 y 方向导数的解析器的集合。

在文件 parsed_function.h 第 276 行定义.

template<typename Output = Number, typename OutputGradient = Gradient>

std::vector<std::unique_ptr<FunctionParserADBase<Output> > > libMesh::ParsedFunction< Output, OutputGradient >::dz_parsers

private

存储用于计算三维场景中 z 方向导数的解析器的集合。

在文件 parsed_function.h 第 283 行定义.

template<typename Output = Number, typename OutputGradient = Gradient>

std::vector<std::unique_ptr<FunctionParserADBase<Output> > > libMesh::ParsedFunction< Output, OutputGradient >::parsers

private

存储用于计算数学表达式的解析器的集合。

在文件 parsed_function.h 第 260 行定义.

template<typename Output = Number, typename OutputGradient = Gradient>

std::string libMesh::ParsedFunction< Output, OutputGradient >::variables

private

存储函数中可以解析和处理的变量名称和值。

在文件 parsed_function.h 第 299 行定义.

---

该类的文档由以下文件生成:

• /home/lwz/libmesh/include/numerics/parsed_function.h