libMesh::ParsedFEMFunction< Output > 模板类 参考

ParsedFEMFunction 提供对 FEMSystem 中基于 FParser 的解析函数的支持。 更多...

#include <parsed_fem_function.h>

类 libMesh::ParsedFEMFunction< Output > 继承关系图:

Public 成员函数
	ParsedFEMFunction (const System &sys, std::string expression, const std::vector< std::string > *additional_vars=nullptr, const std::vector< Output > *initial_vals=nullptr)
	构造函数。 更多...
ParsedFEMFunction &	operator= (const ParsedFEMFunction &)
	赋值运算符。 更多...
	ParsedFEMFunction (const ParsedFEMFunction &)
	复制构造函数。 更多...
void	reparse (std::string expression)
	重新解析使用新表达式。 更多...
virtual void	init_context (const FEMContext &c) override
	初始化上下文。 更多...
virtual std::unique_ptr < FEMFunctionBase< Output > >	clone () const override
	克隆函数。 更多...
virtual Output	operator() (const FEMContext &c, const Point &p, const Real time=0.) override
	调用运算符，用于计算解析函数的值。 更多...
void	operator() (const FEMContext &c, const Point &p, const Real time, DenseVector< Output > &output) override
	调用运算符，用于计算解析函数的值。 更多...
virtual Output	component (const FEMContext &c, unsigned int i, const Point &p, Real time=0.) override
	计算解析函数的第 i 个分量的值。 更多...
const std::string &	expression ()
	获取解析表达式。 更多...
Output	get_inline_value (std::string_view inline_var_name) const
	获取内联变量的值。 更多...
void	set_inline_value (std::string_view inline_var_name, Output newval)
	更改内联变量的值。 更多...
void	operator() (const FEMContext &, const Point &p, DenseVector< Output > &output)
	计算时间无关的向量值函数的评估函数。将输出值设置在传入的output DenseVector中。 更多...

Protected 成员函数
void	partial_reparse (std::string expression)
	用于重新解析表达式的辅助函数。 更多...
std::size_t	find_name (std::string_view varname, std::string_view expr) const
	用于解析变量名称的辅助函数。 更多...
void	eval_args (const FEMContext &c, const Point &p, const Real time)
	用于计算函数参数的辅助函数。 更多...
Output	eval (FunctionParserBase< Output > &parser, std::string_view libmesh_dbg_var(function_name), unsigned int libmesh_dbg_var(component_idx)) const
	评估第 i 个 FunctionParser 并检查结果。 更多...
Output	eval (char &libmesh_dbg_var(parser), std::string_view libmesh_dbg_var(function_name), unsigned int libmesh_dbg_var(component_idx)) const
	评估字符对象。 更多...

Private 属性
const System &	_sys
std::string	_expression
std::vector< std::string >	_subexpressions
unsigned int	_n_vars
unsigned int	_n_requested_vars
unsigned int	_n_requested_grad_components
unsigned int	_n_requested_hess_components
bool	_requested_normals
std::vector< std::unique_ptr < FunctionParserBase< Output > > >	parsers
std::vector< char * >	parsers
std::vector< Output >	_spacetime
std::vector< bool >	_need_var
std::vector< bool >	_need_var_grad
std::vector< bool >	_need_var_hess
std::string	variables
std::vector< std::string >	_additional_vars
std::vector< Output >	_initial_vals

详细描述

template<typename Output = Number>
class libMesh::ParsedFEMFunction< Output >

ParsedFEMFunction 提供对 FEMSystem 中基于 FParser 的解析函数的支持。

所有覆盖的虚拟函数在 fem_function_base.h 中有文档说明。

作者

Roy Stogner

日期

2014 用于在 FEMSystem 中使用解析函数的支持。

模板参数

Output

输出类型，默认为 Number。

在文件 parsed_fem_function.h 第 59 行定义.

构造及析构函数说明

template<typename Output>

libMesh::ParsedFEMFunction< Output >::ParsedFEMFunction ( const System &  sys, std::string  expression, const std::vector< std::string > *  additional_vars = nullptr, const std::vector< Output > *  initial_vals = nullptr  )

inlineexplicit

构造函数。

参数

sys	System 对象的引用。
expression	解析表达式。
additional_vars	其他变量的字符串向量（可选，默认为 nullptr）。
initial_vals	初始值的输出向量（可选，默认为 nullptr）。

在文件 parsed_fem_function.h 第 292 行定义.

参考 libMesh::ParsedFEMFunction< Output >::reparse().

                                                                                      :
  _sys(sys),
  _expression (), // overridden by parse()
  _n_vars(sys.n_vars()),
  _n_requested_vars(0),
  _n_requested_grad_components(0),
  _n_requested_hess_components(0),
  _requested_normals(false),
  _need_var(_n_vars, false),
  _need_var_grad(_n_vars*LIBMESH_DIM, false),
#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
  _need_var_hess(_n_vars*LIBMESH_DIM*LIBMESH_DIM, false),
#endif // LIBMESH_ENABLE_SECOND_DERIVATIVES
  _additional_vars (additional_vars ? *additional_vars : std::vector<std::string>()),
  _initial_vals (initial_vals ? *initial_vals : std::vector<Output>())
{
  this->reparse(std::move(expression));
}

template<typename Output>

libMesh::ParsedFEMFunction< Output >::ParsedFEMFunction ( const ParsedFEMFunction< Output > &  other )

inline

复制构造函数。

此类包含 unique_ptrs，因此无法进行默认复制构造或赋值。

可以进行默认移动和删除。

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

参考 libMesh::ParsedFEMFunction< Output >::_expression , 以及 libMesh::ParsedFEMFunction< Output >::reparse().

                                                                                     :
  FEMFunctionBase<Output>(other),
  _sys(other._sys),
  _expression(other._expression),
  _subexpressions(other._subexpressions),
  _n_vars(other._n_vars),
  _n_requested_vars(other._n_requested_vars),
  _n_requested_grad_components(other._n_requested_grad_components),
  _n_requested_hess_components(other._n_requested_hess_components),
  _requested_normals(other._requested_normals),
  _spacetime(other._spacetime),
  _need_var(other._need_var),
  _need_var_grad(other._need_var_grad),
#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
  _need_var_hess(other._need_var_hess),
#endif // LIBMESH_ENABLE_SECOND_DERIVATIVES
  variables(other.variables),
  _additional_vars(other._additional_vars),
  _initial_vals(other._initial_vals)
{
  this->reparse(_expression);
}

成员函数说明

template<typename Output >

std::unique_ptr< FEMFunctionBase< Output > > libMesh::ParsedFEMFunction< Output >::clone ( ) const

inlineoverridevirtual

克隆函数。

返回

返回一个 FEMFunctionBase 类型的新对象的独立指针。

实现了 libMesh::FEMFunctionBase< Output >.

在文件 parsed_fem_function.h 第 520 行定义.

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

template<typename Output >

Output libMesh::ParsedFEMFunction< Output >::component ( const FEMContext &  c, unsigned int  i, const Point &  p, Real  time = 0.  )

inlineoverridevirtual

计算解析函数的第 i 个分量的值。

参数

c	FEMContext 对象的引用。
i	分量的索引。
p	点的引用。
time	时间，默认值为 0。

返回

返回解析函数的第 i 个分量的值。

重载 libMesh::FEMFunctionBase< Output > .

在文件 parsed_fem_function.h 第 562 行定义.

{
  eval_args(c, p, time);

  libmesh_assert_less (i, parsers.size());
  return eval(*parsers[i], "f", i);
}

template<typename Output>

Output libMesh::ParsedFEMFunction< Output >::eval ( FunctionParserBase< Output > &  parser, std::string_view   libmesh_dbg_varfunction_name, unsigned int   libmesh_dbg_varcomponent_idx  ) const

inlineprotected

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

参数

parser	要评估的 FunctionParserBase 对象。
function_name	函数名称。
component_idx	分量索引。

返回

返回评估结果。

在文件 parsed_fem_function.h 第 934 行定义.

参考 libMesh::err.

{
#ifndef NDEBUG
  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 & st : _spacetime)
        libMesh::err << '\t' << st << '\n';
      libMesh::err << '\n';

      // Currently no API to report error messages, we'll do it manually
      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;
#else
  return parser.Eval(_spacetime.data());
#endif
}

template<typename Output = Number>

Output libMesh::ParsedFEMFunction< Output >::eval ( char &  libmesh_dbg_varparser, std::string_view   libmesh_dbg_varfunction_name, unsigned int   libmesh_dbg_varcomponent_idx  ) const

inlineprotected

评估字符对象。

参数

parser	要评估的字符对象。
function_name	函数名称。
component_idx	分量索引。

返回

返回评估结果。

template<typename Output >

void libMesh::ParsedFEMFunction< Output >::eval_args ( const FEMContext &  c, const Point &  p, const Real  time  )

inlineprotected

用于计算函数参数的辅助函数。

参数

c	FEMContext 对象的引用。
p	点的引用。
time	时间。

在文件 parsed_fem_function.h 第 805 行定义.

{
  _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;

  unsigned int request_index = 0;
  for (unsigned int v=0; v != _n_vars; ++v)
    {
      if (!_need_var[v])
        continue;

      c.point_value(v, p, _spacetime[LIBMESH_DIM+1+request_index]);
      request_index++;
    }

  if (_n_requested_grad_components)
    for (unsigned int v=0; v != _n_vars; ++v)
      {
        if (!_need_var_grad[v*LIBMESH_DIM]
#if LIBMESH_DIM > 1
            && !_need_var_grad[v*LIBMESH_DIM+1]
#if LIBMESH_DIM > 2
            && !_need_var_grad[v*LIBMESH_DIM+2]
#endif
#endif
            )
          continue;

        Gradient g;
        c.point_gradient(v, p, g);

        for (unsigned int d=0; d != LIBMESH_DIM; ++d)
          {
            if (!_need_var_grad[v*LIBMESH_DIM+d])
              continue;

            _spacetime[LIBMESH_DIM+1+request_index] = g(d);
            request_index++;
          }
      }

#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
  if (_n_requested_hess_components)
    for (unsigned int v=0; v != _n_vars; ++v)
      {
        if (!_need_var_hess[v*LIBMESH_DIM*LIBMESH_DIM]
#if LIBMESH_DIM > 1
            && !_need_var_hess[v*LIBMESH_DIM*LIBMESH_DIM+1]
            && !_need_var_hess[v*LIBMESH_DIM*LIBMESH_DIM+2]
            && !_need_var_hess[v*LIBMESH_DIM*LIBMESH_DIM+3]
#if LIBMESH_DIM > 2
            && !_need_var_hess[v*LIBMESH_DIM*LIBMESH_DIM+4]
            && !_need_var_hess[v*LIBMESH_DIM*LIBMESH_DIM+5]
            && !_need_var_hess[v*LIBMESH_DIM*LIBMESH_DIM+6]
            && !_need_var_hess[v*LIBMESH_DIM*LIBMESH_DIM+7]
            && !_need_var_hess[v*LIBMESH_DIM*LIBMESH_DIM+8]
#endif
#endif
            )
          continue;

        Tensor h;
        c.point_hessian(v, p, h);

        for (unsigned int d1=0; d1 != LIBMESH_DIM; ++d1)
          for (unsigned int d2=0; d2 != LIBMESH_DIM; ++d2)
            {
              if (!_need_var_hess[v*LIBMESH_DIM*LIBMESH_DIM+d1*LIBMESH_DIM+d2])
                continue;

              _spacetime[LIBMESH_DIM+1+request_index] = h(d1,d2);
              request_index++;
            }
      }
#endif // LIBMESH_ENABLE_SECOND_DERIVATIVES

  if (_requested_normals)
    {
      FEBase * side_fe;
      c.get_side_fe(0, side_fe);

      const std::vector<Point> & normals = side_fe->get_normals();

      const std::vector<Point> & xyz = side_fe->get_xyz();

      libmesh_assert_equal_to(normals.size(), xyz.size());

      // We currently only support normals at quadrature points!
#ifndef NDEBUG
      bool at_quadrature_point = false;
#endif
      for (auto qp : index_range(normals))
        {
          if (p == xyz[qp])
            {
              const Point & n = normals[qp];
              for (unsigned int d=0; d != LIBMESH_DIM; ++d)
                {
                  _spacetime[LIBMESH_DIM+1+request_index] = n(d);
                  request_index++;
                }
#ifndef NDEBUG
              at_quadrature_point = true;
#endif
              break;
            }
        }

      libmesh_assert(at_quadrature_point);
    }

  // The remaining locations in _spacetime are currently set at construction
  // but could potentially be made dynamic
}

template<typename Output = Number>

const std::string& libMesh::ParsedFEMFunction< Output >::expression ( )

inline

获取解析表达式。

返回

返回解析表达式的引用。

在文件 parsed_fem_function.h 第 165 行定义.

{ return _expression; }

template<typename Output >

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

inlineprotected

用于解析变量名称的辅助函数。

参数

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

返回

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

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

{
  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 >

Output libMesh::ParsedFEMFunction< Output >::get_inline_value ( std::string_view  inline_var_name ) const

inline

获取内联变量的值。

参数

inline_var_name

内联变量的名称。

返回

返回内联变量的值。

注解

仅当内联变量值与输入变量无关时，内联变量在任何子表达式中未被重新定义， 并且在出现内联变量的任何子表达式中取相同值时，才能正确使用此函数。

在文件 parsed_fem_function.h 第 576 行定义.

参考 libMesh::Real.

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

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

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

  for (const std::string & 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.
      auto fp = std::make_unique<FunctionParserBase<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(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 >

void libMesh::ParsedFEMFunction< Output >::init_context ( const FEMContext &  c )

inlineoverridevirtual

初始化上下文。

参数

c	FEMContext 对象的引用。

重载 libMesh::FEMFunctionBase< Output > .

在文件 parsed_fem_function.h 第 488 行定义.

{
  for (unsigned int v=0; v != _n_vars; ++v)
    {
      FEBase * elem_fe;
      c.get_element_fe(v, elem_fe);
      if (_n_requested_vars)
        elem_fe->get_phi();
      if (_n_requested_grad_components)
        elem_fe->get_dphi();
#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
      if (_n_requested_hess_components)
        elem_fe->get_d2phi();
#endif // LIBMESH_ENABLE_SECOND_DERIVATIVES
    }

  if (_requested_normals)
    {
      FEBase * side_fe;
      c.get_side_fe(0, side_fe);

      side_fe->get_normals();

      // FIXME: this is a hack to support normals at quadrature
      // points; we don't support normals elsewhere.
      side_fe->get_xyz();
    }
}

template<typename Output >

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

inlineinherited

计算时间无关的向量值函数的评估函数。将输出值设置在传入的output DenseVector中。

参数

context	FEM上下文对象。
p	坐标点。
output	输出的向量。

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

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

template<typename Output >

Output libMesh::ParsedFEMFunction< Output >::operator() ( const FEMContext &  c, const Point &  p, const Real  time = 0.  )

inlineoverridevirtual

调用运算符，用于计算解析函数的值。

参数

c	FEMContext 对象的引用。
p	点的引用。
time	时间，默认值为 0。

返回

返回解析函数的值。

实现了 libMesh::FEMFunctionBase< Output >.

在文件 parsed_fem_function.h 第 529 行定义.

{
  eval_args(c, p, time);

  return eval(*parsers[0], "f", 0);
}

template<typename Output>

void libMesh::ParsedFEMFunction< Output >::operator() ( const FEMContext &  c, const Point &  p, const Real  time, DenseVector< Output > &  output  )

inlineoverridevirtual

调用运算符，用于计算解析函数的值。

参数

c	FEMContext 对象的引用。
p	点的引用。
time	时间。
output	输出向量的引用。

实现了 libMesh::FEMFunctionBase< Output >.

在文件 parsed_fem_function.h 第 543 行定义.

参考 libMesh::DenseVector< T >::size().

{
  eval_args(c, 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 >

ParsedFEMFunction< Output > & libMesh::ParsedFEMFunction< Output >::operator= ( const ParsedFEMFunction< Output > &  other )

inline

赋值运算符。

此类包含一个 const 引用，因此无法进行默认复制或移动赋值。我们手动实现了前者。

此类包含 unique_ptrs，因此无法进行默认复制构造或赋值。

可以进行默认移动和删除。

在文件 parsed_fem_function.h 第 344 行定义.

参考 libMesh::ParsedFEMFunction< Output >::_sys.

{
  // We can only be assigned another ParsedFEMFunction defined on the same System
  libmesh_assert(&_sys == &other._sys);

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

template<typename Output >

void libMesh::ParsedFEMFunction< Output >::partial_reparse ( std::string  expression )

inlineprotected

用于重新解析表达式的辅助函数。

参数

expression

新的解析表达式。

在文件 parsed_fem_function.h 第 715 行定义.

参考 libMesh::Real.

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

  size_t nextstart = 0, end = 0;

  while (end != std::string::npos)
    {
      // If we're past the end of the string, we can't make any more
      // subparsers
      if (nextstart >= _expression.size())
        break;

      // If we're at the start of a brace delimited section, then we
      // parse just that section:
      if (_expression[nextstart] == '{')
        {
          nextstart++;
          end = _expression.find('}', nextstart);
        }
      // otherwise we parse the whole thing
      else
        end = std::string::npos;

      // We either want the whole end of the string (end == npos) or
      // a substring in the middle.
      _subexpressions.push_back
        (_expression.substr(nextstart, (end == std::string::npos) ?
                           std::string::npos : end - nextstart));

      // fparser can crash on empty expressions
      libmesh_error_msg_if(_subexpressions.back().empty(),
                           "ERROR: FunctionParser is unable to parse empty expression.\n");


#ifdef LIBMESH_HAVE_FPARSER
      // Parse (and optimize if possible) the subexpression.
      // Add some basic constants, to Real precision.
      auto fp = std::make_unique<FunctionParserBase<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());
      fp->Optimize();
      parsers.push_back(std::move(fp));
#else
      libmesh_error_msg("ERROR: This functionality requires fparser!");
#endif

      // If at end, use nextstart=maxSize.  Else start at next
      // character.
      nextstart = (end == std::string::npos) ?
        std::string::npos : end + 1;
    }
}

template<typename Output >

void libMesh::ParsedFEMFunction< Output >::reparse ( std::string  expression )

inline

重新解析使用新表达式。

参数

expression

新的解析表达式。

在文件 parsed_fem_function.h 第 359 行定义.

参考自 libMesh::ParsedFEMFunction< Output >::ParsedFEMFunction().

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

  for (unsigned int v=0; v != _n_vars; ++v)
    {
      const std::string & varname = _sys.variable_name(v);
      std::size_t varname_i = find_name(varname, expression);

      // If we didn't find our variable name then let's go to the
      // next.
      if (varname_i == std::string::npos)
        continue;

      _need_var[v] = true;
      variables += ',';
      variables += varname;
      _n_requested_vars++;
    }

  for (unsigned int v=0; v != _n_vars; ++v)
    {
      const std::string & varname = _sys.variable_name(v);

      for (unsigned int d=0; d != LIBMESH_DIM; ++d)
        {
          std::string gradname = std::string("grad_") +
            "xyz"[d] + '_' + varname;
          std::size_t gradname_i = find_name(gradname, expression);

          // If we didn't find that gradient component of our
          // variable name then let's go to the next.
          if (gradname_i == std::string::npos)
            continue;

          _need_var_grad[v*LIBMESH_DIM+d] = true;
          variables += ',';
          variables += gradname;
          _n_requested_grad_components++;
        }
    }

#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
  for (unsigned int v=0; v != _n_vars; ++v)
    {
      const std::string & varname = _sys.variable_name(v);

      for (unsigned int d1=0; d1 != LIBMESH_DIM; ++d1)
        for (unsigned int d2=0; d2 != LIBMESH_DIM; ++d2)
          {
            std::string hessname = std::string("hess_") +
              "xyz"[d1] + "xyz"[d2] + '_' + varname;
            std::size_t hessname_i = find_name(hessname, expression);

            // If we didn't find that hessian component of our
            // variable name then let's go to the next.
            if (hessname_i == std::string::npos)
              continue;

            _need_var_hess[v*LIBMESH_DIM*LIBMESH_DIM+d1*LIBMESH_DIM+d2]
              = true;
            variables += ',';
            variables += hessname;
            _n_requested_hess_components++;
          }
    }
#endif // LIBMESH_ENABLE_SECOND_DERIVATIVES

  {
    std::size_t nx_i = find_name("n_x", expression);
    std::size_t ny_i = find_name("n_y", expression);
    std::size_t nz_i = find_name("n_z", expression);

    // If we found any requests for normal components then we'll
    // compute normals
    if (nx_i != std::string::npos ||
        ny_i != std::string::npos ||
        nz_i != std::string::npos)
      {
        _requested_normals = true;
        variables += ',';
        variables += "n_x";
        if (LIBMESH_DIM > 1)
          {
            variables += ',';
            variables += "n_y";
          }
        if (LIBMESH_DIM > 2)
          {
            variables += ',';
            variables += "n_z";
          }
      }
  }

  _spacetime.resize
    (LIBMESH_DIM + 1 + _n_requested_vars +
     _n_requested_grad_components + _n_requested_hess_components +
     (_requested_normals ? LIBMESH_DIM : 0) +
     _additional_vars.size());

  // If additional vars were passed, append them to the string
  // that we send to the function parser. Also add them to the
  // end of our spacetime vector
  unsigned int offset = LIBMESH_DIM + 1 + _n_requested_vars +
    _n_requested_grad_components + _n_requested_hess_components;

  for (auto i : index_range(_additional_vars))
    {
      variables += "," + _additional_vars[i];
      // Initialize extra variables to the vector passed in or zero
      // Note: The initial_vals vector can be shorter than the additional_vars vector
      _spacetime[offset + i] =
        (i < _initial_vals.size()) ? _initial_vals[i] : 0;
    }

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

template<typename Output>

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

inline

更改内联变量的值。

参数

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

注解

以后，该变量值将在已定义该变量的每个子表达式中采用给定的常量值， 与输入变量无关。

当前仅在内联变量未在任何一个子表达式中重新定义时有效。

在文件 parsed_fem_function.h 第 649 行定义.

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

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

#ifndef NDEBUG
  bool found_var_name = false;
#endif
  for (auto s : index_range(_subexpressions))
    {
      const std::string & subexpression = _subexpressions[s];
      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);
      _subexpressions[s] = 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 = Number>

std::vector<std::string> libMesh::ParsedFEMFunction< Output >::_additional_vars

private

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

template<typename Output = Number>

std::string libMesh::ParsedFEMFunction< Output >::_expression

private

在文件 parsed_fem_function.h 第 253 行定义.

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

template<typename Output = Number>

std::vector<Output> libMesh::ParsedFEMFunction< Output >::_initial_vals

private

在文件 parsed_fem_function.h 第 284 行定义.

template<typename Output = Number>

unsigned int libMesh::ParsedFEMFunction< Output >::_n_requested_grad_components

private

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

template<typename Output = Number>

unsigned int libMesh::ParsedFEMFunction< Output >::_n_requested_hess_components

private

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

template<typename Output = Number>

unsigned int libMesh::ParsedFEMFunction< Output >::_n_requested_vars

private

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

template<typename Output = Number>

unsigned int libMesh::ParsedFEMFunction< Output >::_n_vars

private

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

template<typename Output = Number>

std::vector<bool> libMesh::ParsedFEMFunction< Output >::_need_var

private

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

template<typename Output = Number>

std::vector<bool> libMesh::ParsedFEMFunction< Output >::_need_var_grad

private

在文件 parsed_fem_function.h 第 273 行定义.

template<typename Output = Number>

std::vector<bool> libMesh::ParsedFEMFunction< Output >::_need_var_hess

private

在文件 parsed_fem_function.h 第 278 行定义.

template<typename Output = Number>

bool libMesh::ParsedFEMFunction< Output >::_requested_normals

private

在文件 parsed_fem_function.h 第 259 行定义.

template<typename Output = Number>

std::vector<Output> libMesh::ParsedFEMFunction< Output >::_spacetime

private

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

template<typename Output = Number>

std::vector<std::string> libMesh::ParsedFEMFunction< Output >::_subexpressions

private

在文件 parsed_fem_function.h 第 254 行定义.

template<typename Output = Number>

const System& libMesh::ParsedFEMFunction< Output >::_sys

private

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

参考自 libMesh::ParsedFEMFunction< Output >::operator=().

template<typename Output = Number>

std::vector<std::unique_ptr<FunctionParserBase<Output> > > libMesh::ParsedFEMFunction< Output >::parsers

private

在文件 parsed_fem_function.h 第 261 行定义.

template<typename Output = Number>

std::vector<char*> libMesh::ParsedFEMFunction< Output >::parsers

private

在文件 parsed_fem_function.h 第 263 行定义.

template<typename Output = Number>

std::string libMesh::ParsedFEMFunction< Output >::variables

private

在文件 parsed_fem_function.h 第 282 行定义.

---

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

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