libMesh::ParsedFunction< Output, OutputGradient > Class Template Reference

A Function generated (via FParser) by parsing a mathematical expression. More...

#include <parsed_function.h>

Inheritance diagram for libMesh::ParsedFunction< Output, OutputGradient >:

Public Member Functions
	ParsedFunction (std::string expression, const std::vector< std::string > *additional_vars=nullptr, const std::vector< Output > *initial_vals=nullptr)
	ParsedFunction (const ParsedFunction &)
	Constructors. More...
ParsedFunction &	operator= (const ParsedFunction &)
	ParsedFunction (ParsedFunction &&)=default
ParsedFunction &	operator= (ParsedFunction &&)=default
virtual	~ParsedFunction ()=default
void	reparse (std::string expression)
	Re-parse with new expression. More...
virtual Output	operator() (const Point &p, const Real time=0) override
virtual bool	has_derivatives ()
	Query if the automatic derivative generation was successful. More...
virtual Output	dot (const Point &p, const Real time=0)
virtual OutputGradient	gradient (const Point &p, const Real time=0)
virtual void	operator() (const Point &p, const Real time, DenseVector< Output > &output) override
	Evaluation function for time-dependent vector-valued functions. More...
virtual Output	component (unsigned int i, const Point &p, Real time) override
const std::string &	expression ()
virtual Output &	getVarAddress (std::string_view variable_name)
virtual std::unique_ptr< FunctionBase< Output > >	clone () const override
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. More...
	ParsedFunction (std::string, const std::vector< std::string > *=nullptr, const std::vector< Output > *=nullptr)
	ParsedFunction (ParsedFunction &&)=delete
	When !LIBMESH_HAVE_FPARSER, this class is not implemented, so let's make that explicit by deleting the special functions. More...
	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 > &)
	Evaluation function for time-dependent vector-valued functions. More...
virtual void	init ()
	The actual initialization process. More...
virtual void	clear ()
	Clears the function. More...
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. More...
bool	initialized () const
void	set_is_time_dependent (bool is_time_dependent)
	Function to set whether this is a time-dependent function or not. More...
bool	is_time_dependent () const

Protected Member Functions
void	partial_reparse (std::string expression)
	Re-parse with minor changes to expression. More...
std::size_t	find_name (std::string_view varname, std::string_view expr) const
	Helper function for parsing out variable names. More...
bool	expression_is_time_dependent (std::string_view expression) const

Protected Attributes
const FunctionBase *	_master
	Const pointer to our master, initialized to nullptr. More...
bool	_initialized
	When init() was called so that everything is ready for calls to operator() (...), then this bool is true. More...
bool	_is_time_dependent
	Cache whether or not this function is actually time-dependent. More...

Private Member Functions
void	set_spacetime (const Point &p, const Real time=0)
	Set the _spacetime argument vector. More...
Output	eval (FunctionParserADBase< Output > &parser, std::string_view libmesh_dbg_var(function_name), unsigned int libmesh_dbg_var(component_idx)) const
	Evaluate the ith FunctionParser and check the result. More...

Private Attributes
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
std::vector< std::unique_ptr< FunctionParserADBase< Output > > >	dz_parsers
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

Detailed Description

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

A Function generated (via FParser) by parsing a mathematical expression.

All overridden virtual functions are documented in function_base.h.

Author

Roy Stogner

Date

2012 A Function defined by a std::string.

Definition at line 60 of file parsed_function.h.

Constructor & Destructor Documentation

ParsedFunction() [1/6]

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

Definition at line 197 of file parsed_function.h.

                                                                                               :
  _expression (), // overridden by parse()
  // Size the spacetime vector to account for space, time, and any additional
  // variables passed
  _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;
}

ParsedFunction() [2/6]

template<typename Output, typename OutputGradient >

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

inline

Constructors.

• This class contains unique_ptrs so it can't be default copy constructed or assigned, only default moved and deleted.

Definition at line 216 of file parsed_function.h.

                                                                                                          :
  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)
{
  // parsers can be generated from scratch by reparsing expression
  this->reparse(this->_expression);
  this->_initialized = true;
}

ParsedFunction() [3/6]

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

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

default

~ParsedFunction() [1/2]

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

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

virtualdefault

ParsedFunction() [4/6]

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

Definition at line 738 of file parsed_function.h.

                                                       : _dummy(0)
  {
    libmesh_not_implemented();
  }

ParsedFunction() [5/6]

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

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

delete

When !LIBMESH_HAVE_FPARSER, this class is not implemented, so let's make that explicit by deleting the special functions.

ParsedFunction() [6/6]

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

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

delete

~ParsedFunction() [2/2]

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

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

virtualdefault

Member Function Documentation

clear()

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

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

inlinevirtual

Clears the function.

Reimplemented from libMesh::FunctionBase< Output >.

Definition at line 764 of file parsed_function.h.

{}

clone() [1/2]

template<typename Output , typename OutputGradient >

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

inlineoverridevirtual

Returns

A new copy of the function.

The new copy should be as "deep" as necessary to allow independent destruction and simultaneous evaluations of the copies in different threads.

Implements libMesh::FunctionBase< Output >.

Definition at line 375 of file parsed_function.h.

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

clone() [2/2]

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

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

inlinevirtual

Returns

A new copy of the function.

The new copy should be as "deep" as necessary to allow independent destruction and simultaneous evaluations of the copies in different threads.

Implements libMesh::FunctionBase< Output >.

Definition at line 766 of file parsed_function.h.

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

component()

template<typename Output , typename OutputGradient >

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

inlineoverridevirtual

Returns

The vector component i at coordinate p and time time.

Reimplemented from libMesh::FunctionBase< Output >.

Definition at line 340 of file parsed_function.h.

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

  // The remaining locations in _spacetime are currently fixed at construction
  // but could potentially be made dynamic
  libmesh_assert_less(i, parsers.size());
  return eval(*parsers[i], "f", i);
}

dot()

template<typename Output , typename OutputGradient >

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

inlinevirtual

Definition at line 288 of file parsed_function.h.

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

eval()

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

Evaluate the ith FunctionParser and check the result.

Definition at line 672 of file parsed_function.h.

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

      // 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;
}

expression()

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

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

inline

Definition at line 107 of file parsed_function.h.

{ return _expression; }

expression_is_time_dependent()

template<typename Output , typename OutputGradient >

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

inlineprotected

Returns

true if the expression is time-dependent, false otherwise.

Definition at line 636 of file parsed_function.h.

{
  bool is_time_dependent = false;

  // By definition, time is "t" for FunctionBase-based objects, so we just need to
  // see if this expression has the variable "t" in it.
  if (this->find_name(std::string("t"), expression) != std::string::npos)
    is_time_dependent = true;

  return is_time_dependent;
}

find_name()

template<typename Output , typename OutputGradient >

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

inlineprotected

Helper function for parsing out variable names.

Definition at line 614 of file parsed_function.h.

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

get_inline_value()

template<typename Output , typename OutputGradient >

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

inline

Returns

The value of an inline variable.

Note

Will only be correct if the inline variable value is independent of input variables, if the inline variable is not redefined within any subexpression, and if the inline variable takes the same value within any subexpressions where it appears.

Definition at line 385 of file parsed_function.h.

Referenced by libMesh::ParsedFunctionParameter< T >::get(), ParsedFunctionTest::testInlineGetter(), and ParsedFunctionTest::testInlineSetter().

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

getVarAddress() [1/2]

template<typename Output , typename OutputGradient >

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

inlinevirtual

Returns

The address of a parsed variable so you can supply a parameterized value.

The address of a parsed variable so you can supply a parameterized value

Definition at line 359 of file parsed_function.h.

{
  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");

  // Iterator Arithmetic (How far from the end of the array is our target address?)
  return _spacetime[_spacetime.size() - (_additional_vars.end() - it)];
}

getVarAddress() [2/2]

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

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

inlinevirtual

Definition at line 765 of file parsed_function.h.

{ return _dummy; }

gradient()

template<typename Output , typename OutputGradient >

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

inlinevirtual

Definition at line 297 of file parsed_function.h.

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

has_derivatives()

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

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

inlinevirtual

Query if the automatic derivative generation was successful.

Definition at line 91 of file parsed_function.h.

{ return _valid_derivatives; }

init()

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

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

inlinevirtual

The actual initialization process.

Reimplemented from libMesh::FunctionBase< Output >.

Definition at line 763 of file parsed_function.h.

{}

initialized()

template<typename Output >

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

inlineinherited

Returns

true when this object is properly initialized and ready for use, false otherwise.

Definition at line 210 of file function_base.h.

Referenced by libMesh::MeshFunction::MeshFunction().

{
  return (this->_initialized);
}

is_time_dependent()

template<typename Output >

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

inlineinherited

Returns

true when the function this object represents is actually time-dependent, false otherwise.

Definition at line 224 of file function_base.h.

Referenced by libMesh::CompositeFunction< Output >::attach_subfunction(), CompositeFunctionTest::testTimeDependence(), and ParsedFunctionTest::testTimeDependence().

{
  return (this->_is_time_dependent);
}

operator()() [1/5]

template<typename Output , typename OutputGradient >

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

inlineoverridevirtual

Returns

The scalar function value at coordinate p and time time, which defaults to zero.

Pure virtual, so you have to override it.

Implements libMesh::FunctionBase< Output >.

Definition at line 279 of file parsed_function.h.

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

operator()() [2/5]

template<typename Output, typename OutputGradient >

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

inlineoverridevirtual

Evaluation function for time-dependent vector-valued functions.

Sets output values in the passed-in output DenseVector.

Pure virtual, so you have to override it.

Implements libMesh::FunctionBase< Output >.

Definition at line 317 of file parsed_function.h.

{
  set_spacetime(p, time);

  unsigned int size = output.size();

  libmesh_assert_equal_to (size, parsers.size());

  // The remaining locations in _spacetime are currently fixed at construction
  // but could potentially be made dynamic
  for (unsigned int i=0; i != size; ++i)
    output(i) = eval(*parsers[i], "f", i);
}

operator()() [3/5]

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.

Definition at line 245 of file function_base.h.

{
  // Call the time-dependent function with t=0.
  this->operator()(p, 0., output);
}

operator()() [4/5]

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

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

inlinevirtual

Returns

The scalar function value at coordinate p and time time, which defaults to zero.

Pure virtual, so you have to override it.

Implements libMesh::FunctionBase< Output >.

Definition at line 755 of file parsed_function.h.

  { return 0.; }

operator()() [5/5]

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

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

inlinevirtual

Evaluation function for time-dependent vector-valued functions.

Sets output values in the passed-in output DenseVector.

Pure virtual, so you have to override it.

Implements libMesh::FunctionBase< Output >.

Definition at line 759 of file parsed_function.h.

                                                    {}

operator=() [1/4]

template<typename Output , typename OutputGradient >

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

inline

Definition at line 236 of file parsed_function.h.

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

operator=() [2/4]

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

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

default

operator=() [3/4]

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

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

delete

operator=() [4/4]

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

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

delete

partial_reparse()

template<typename Output , typename OutputGradient >

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

inlineprotected

Re-parse with minor changes to expression.

Definition at line 522 of file parsed_function.h.

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

      // Parse (and optimize if possible) the subexpression.
      // Add some basic constants, to Real precision.
      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);

      // optimize original function
      fp->Optimize();

      // generate derivatives through automatic differentiation
      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));

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

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

reparse()

template<typename Output , typename OutputGradient >

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

inline

Re-parse with new expression.

Definition at line 248 of file parsed_function.h.

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

  // 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
  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[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));
}

set_inline_value()

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.

Note

Forever after, the variable value will take the given constant, independent of input variables, in every subexpression where it is already defined.

Currently only works if the inline variable is not redefined within any one subexpression.

Definition at line 458 of file parsed_function.h.

Referenced by libMesh::ParsedFunctionParameter< T >::set(), and ParsedFunctionTest::testInlineSetter().

{
  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);
}

set_is_time_dependent()

template<typename Output >

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

inlineinherited

Function to set whether this is a time-dependent function or not.

This is intended to be only used by subclasses who cannot natively determine time-dependence. In such a case, this function should be used immediately following construction.

Definition at line 217 of file function_base.h.

{
  this->_is_time_dependent = is_time_dependent;
}

set_spacetime()

template<typename Output , typename OutputGradient >

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

inlineprivate

Set the _spacetime argument vector.

Definition at line 652 of file parsed_function.h.

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

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

Member Data Documentation

_additional_vars

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

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

private

Definition at line 188 of file parsed_function.h.

_dummy

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

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

private

Definition at line 771 of file parsed_function.h.

Referenced by libMesh::ParsedFunction< T >::getVarAddress().

_expression

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

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

private

Definition at line 170 of file parsed_function.h.

Referenced by libMesh::ParsedFunction< T >::expression().

_initial_vals

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

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

private

Definition at line 189 of file parsed_function.h.

_initialized

template<typename Output = Number>

bool libMesh::FunctionBase< Output >::_initialized

protectedinherited

When init() was called so that everything is ready for calls to operator() (...), then this bool is true.

Definition at line 184 of file function_base.h.

Referenced by libMesh::AnalyticFunction< Output >::AnalyticFunction(), libMesh::ConstFunction< Output >::ConstFunction(), and libMesh::WrappedFunction< Output >::WrappedFunction().

_is_time_dependent

template<typename Output = Number>

bool libMesh::FunctionBase< Output >::_is_time_dependent

protectedinherited

Cache whether or not this function is actually time-dependent.

Definition at line 189 of file function_base.h.

Referenced by libMesh::CompositeFunction< Output >::attach_subfunction(), and libMesh::ConstFunction< Output >::ConstFunction().

_master

template<typename Output = Number>

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

protectedinherited

Const pointer to our master, initialized to nullptr.

There may be cases where multiple functions are required, but to save memory, one master handles some centralized data.

Definition at line 178 of file function_base.h.

_spacetime

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

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

private

Definition at line 173 of file parsed_function.h.

_subexpressions

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

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

private

Definition at line 171 of file parsed_function.h.

_valid_derivatives

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

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

private

Definition at line 184 of file parsed_function.h.

Referenced by libMesh::ParsedFunction< T >::has_derivatives().

dt_parsers

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

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

private

Definition at line 183 of file parsed_function.h.

dx_parsers

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

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

private

Definition at line 176 of file parsed_function.h.

dy_parsers

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

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

private

Definition at line 178 of file parsed_function.h.

dz_parsers

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

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

private

Definition at line 181 of file parsed_function.h.

parsers

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

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

private

Definition at line 172 of file parsed_function.h.

variables

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

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

private

Definition at line 187 of file parsed_function.h.

---

The documentation for this class was generated from the following file:

• include/numerics/parsed_function.h