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

A Function defined by a std::string. More...

#include <parsed_function.h>

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

Public Member Functions
	ParsedFunction (const std::string &expression, const std::vector< std::string > *additional_vars=nullptr, const std::vector< Output > *initial_vals=nullptr)
ParsedFunction &	operator= (const ParsedFunction &)=delete
	ParsedFunction (const ParsedFunction &)=default
	ParsedFunction (ParsedFunction &&)=default
ParsedFunction &	operator= (ParsedFunction &&)=default
virtual	~ParsedFunction ()=default
void	reparse (const std::string &expression)
virtual Output	operator() (const Point &p, const Real time=0) override
virtual bool	has_derivatives ()
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
virtual Output	component (unsigned int i, const Point &p, Real time) override
const std::string &	expression ()
virtual Output &	getVarAddress (const std::string &variable_name)
virtual std::unique_ptr< FunctionBase< Output > >	clone () const override
Output	get_inline_value (const std::string &inline_var_name) const
void	set_inline_value (const std::string &inline_var_name, Output newval)
	ParsedFunction (const std::string &, const std::vector< std::string > *=nullptr, const std::vector< Output > *=nullptr)
	ParsedFunction (ParsedFunction &&)=delete
	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 > &)
virtual void	init ()
virtual void	clear ()
virtual Output &	getVarAddress (const std::string &)
virtual std::unique_ptr< FunctionBase< Output > >	clone () const
void	operator() (const Point &p, DenseVector< Output > &output)
bool	initialized () const
void	set_is_time_dependent (bool is_time_dependent)
bool	is_time_dependent () const

Protected Member Functions
void	partial_reparse (const std::string &expression)
std::size_t	find_name (const std::string &varname, const std::string &expr) const
bool	expression_is_time_dependent (const std::string &expression) const

Protected Attributes
const FunctionBase *	_master
bool	_initialized
bool	_is_time_dependent

Private Member Functions
void	set_spacetime (const Point &p, const Real time=0)
Output	eval (FunctionParserADBase< Output > &parser, const std::string &libmesh_dbg_var(function_name), unsigned int libmesh_dbg_var(component_idx)) const

Private Attributes
std::string	_expression
std::vector< std::string >	_subexpressions
std::vector< FunctionParserADBase< Output > >	parsers
std::vector< Output >	_spacetime
std::vector< FunctionParserADBase< Output > >	dx_parsers
std::vector< FunctionParserADBase< Output > >	dy_parsers
std::vector< FunctionParserADBase< Output > >	dz_parsers
std::vector< 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 defined by a std::string.

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

Definition at line 59 of file parsed_function.h.

Constructor & Destructor Documentation

ParsedFunction() [1/6]

template<typename Output, typename OutputGradient >

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

inlineexplicit

Definition at line 210 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(expression);
  this->_initialized = true;
}

ParsedFunction() [2/6]

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

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

default

The remaining special functions can be defaulted for this class.

Note

Despite the fact that the underlying FunctionParserADBase class is not move-assignable or move-constructible, it is still possible for this class to be move-assigned and move-constructed, because FunctionParserADBase objects only appear within std::vectors in this class, and std::vectors can generally still be move-assigned and move-constructed even when their contents cannot. There are some allocator-specific exceptions to this, but it should be guaranteed to work for std::allocator in C++14 and beyond. See also: https://stackoverflow.com/q/42051917/659433

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 ( const std::string &  , const std::vector< std::string > *  = nullptr, const std::vector< Output > *  = nullptr  )

inline

Definition at line 717 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 743 of file parsed_function.h.

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

{}

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 357 of file parsed_function.h.

{
  return libmesh_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 745 of file parsed_function.h.

  {
    return libmesh_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 322 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 270 of file parsed_function.h.

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

eval()

template<typename Output, typename OutputGradient >

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

inlineprivate

Evaluate the ith FunctionParser and check the result.

Definition at line 653 of file parsed_function.h.

{
#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
                   << " of expression '"
                   << function_name
                   << "' 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;
#else
  return parser.Eval(_spacetime.data());
#endif
}

expression()

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

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

inline

Definition at line 120 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 ( const std::string &  expression ) const

inlineprotected

Returns

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

Definition at line 617 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 ( const std::string &  varname, const std::string &  expr  ) const

inlineprotected

Helper function for parsing out variable names.

Definition at line 595 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 ( const std::string &  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 367 of file parsed_function.h.

Referenced by 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) +
        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)));
      if (fp.Parse(new_subexpression, variables) != -1) // -1 for success
        libmesh_error_msg
          ("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 ( const std::string &  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 341 of file parsed_function.h.

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

  if (it == _additional_vars.end())
    libmesh_error_msg("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 ( const std::string &  )

inlinevirtual

Definition at line 744 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 279 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 104 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 742 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 206 of file function_base.h.

{
  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 220 of file function_base.h.

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

{
  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 261 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 299 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 241 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 734 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 738 of file parsed_function.h.

                                                    {}

operator=() [1/4]

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

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

delete

This class cannot be (default) copy assigned because the underlying FunctionParserADBase class does not define a custom copy assignment operator, and manually manages memory.

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 ( const std::string &  expression )

inlineprotected

Re-parse with minor changes to expression.

Definition at line 505 of file parsed_function.h.

{
  _expression = 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
      if (_subexpressions.back().empty())
        libmesh_error_msg("ERROR: FunctionParser is unable to parse empty expression.\n");

      // Parse (and optimize if possible) the subexpression.
      // Add some basic constants, to Real precision.
      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)));
      if (fp.Parse(_subexpressions.back(), variables) != -1) // -1 for success
        libmesh_error_msg
          ("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();
      parsers.push_back(fp);

      // generate derivatives through automatic differentiation
      FunctionParserADBase<Output> dx_fp(fp);
      if (dx_fp.AutoDiff("x") != -1) // -1 for success
        _valid_derivatives = false;
      dx_parsers.push_back(dx_fp);
#if LIBMESH_DIM > 1
      FunctionParserADBase<Output> dy_fp(fp);
      if (dy_fp.AutoDiff("y") != -1) // -1 for success
        _valid_derivatives = false;
      dy_parsers.push_back(dy_fp);
#endif
#if LIBMESH_DIM > 2
      FunctionParserADBase<Output> dz_fp(fp);
      if (dz_fp.AutoDiff("z") != -1) // -1 for success
        _valid_derivatives = false;
      dz_parsers.push_back(dz_fp);
#endif
      FunctionParserADBase<Output> dt_fp(fp);
      if (dt_fp.AutoDiff("t") != -1) // -1 for success
        _valid_derivatives = false;
      dt_parsers.push_back(dt_fp);

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

reparse()

template<typename Output , typename OutputGradient >

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

inline

Re-parse with new expression.

Definition at line 230 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 (std::size_t i=0; i < _additional_vars.size(); ++i)
    {
      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->partial_reparse(expression);

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

set_inline_value()

template<typename Output, typename OutputGradient >

void libMesh::ParsedFunction< Output, OutputGradient >::set_inline_value ( const std::string &  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 441 of file parsed_function.h.

Referenced by 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);
}

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 213 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 633 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 201 of file parsed_function.h.

_dummy

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

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

private

Definition at line 750 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 183 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 202 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 180 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 185 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 174 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 186 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 184 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 197 of file parsed_function.h.

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

dt_parsers

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

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

private

Definition at line 196 of file parsed_function.h.

dx_parsers

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

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

private

Definition at line 189 of file parsed_function.h.

dy_parsers

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

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

private

Definition at line 191 of file parsed_function.h.

dz_parsers

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

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

private

Definition at line 194 of file parsed_function.h.

parsers

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

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

private

Definition at line 185 of file parsed_function.h.

variables

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

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

private

Definition at line 200 of file parsed_function.h.

---

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

• parsed_function.h