MemoizedFunctionInterface Class Reference

Implementation of Function that memoizes (caches) former evaluations in an unordered map using a hash of the evaluation locations as the key. More...

#include <MemoizedFunctionInterface.h>

Inheritance diagram for MemoizedFunctionInterface:

Public Member Functions
	MemoizedFunctionInterface (const InputParameters &parameters)
virtual void	meshChanged () override
void	useCache (bool use)
	Enable/disable the cache. More...
virtual Real	value (Real time, const Point &point) const final

Protected Member Functions
virtual Real	evaluateValue (Real time, const Point &point)=0
	Used in derived classes, equivalent to Function::value() More...
void	invalidateCache ()
	Called by derived classes to invalidate the cache, perhaps due to a state change. More...

Private Attributes
std::unordered_map< hashing::HashValue, Real >	_cache
	Cached evaluations for each point. More...
Real	_current_time
	Stores the time evaluation of the cache. More...
bool	_enable_cache
	Flag for whether to cache values. More...
bool	_respect_time
	Flag for whether changes in time invalidate the cache. More...

Detailed Description

Implementation of Function that memoizes (caches) former evaluations in an unordered map using a hash of the evaluation locations as the key.

The purpose is to allow for quick evaluation of a complex function that may be reevaluated multiple times without changing the actual outputs.

Definition at line 28 of file MemoizedFunctionInterface.h.

Constructor & Destructor Documentation

MemoizedFunctionInterface()

MemoizedFunctionInterface::MemoizedFunctionInterface

(

const InputParameters &

parameters

)

Definition at line 32 of file MemoizedFunctionInterface.C.

  : Function(parameters),
    _enable_cache(getParam<bool>("enable_cache")),
    _respect_time(getParam<bool>("respect_time"))
{
}

Member Function Documentation

evaluateValue()

virtual Real MemoizedFunctionInterface::evaluateValue ( Real  time, const Point &  point  )

protectedpure virtual

Used in derived classes, equivalent to Function::value()

Implemented in FunctionSeries.

Referenced by value().

invalidateCache()

void MemoizedFunctionInterface::invalidateCache ( )

protected

Called by derived classes to invalidate the cache, perhaps due to a state change.

Definition at line 84 of file MemoizedFunctionInterface.C.

{
  _cache.clear();
}

Referenced by MutableCoefficientsFunctionInterface::coefficientsChanged(), meshChanged(), useCache(), and value().

meshChanged()

void MemoizedFunctionInterface::meshChanged ( )

overridevirtual

Definition at line 40 of file MemoizedFunctionInterface.C.

{
  // The mesh has changed, which invalidates the cache
  invalidateCache();
}

useCache()

void MemoizedFunctionInterface::useCache

(

bool

use

)

Enable/disable the cache.

Definition at line 75 of file MemoizedFunctionInterface.C.

{
  _enable_cache = use;
 
  if (!_enable_cache)
    invalidateCache();
}

Referenced by FXFluxBC::FXFluxBC(), FXValueBC::FXValueBC(), and FXValuePenaltyBC::FXValuePenaltyBC().

value()

Real MemoizedFunctionInterface::value ( Real  time, const Point &  point  ) const

finalvirtual

Definition at line 47 of file MemoizedFunctionInterface.C.

{
  MemoizedFunctionInterface * ptr = const_cast<MemoizedFunctionInterface *>(this);
 
  if (_enable_cache)
  {
    // Start the cache over if we are at a new time step
    if (_respect_time && time != _current_time)
    {
      _current_time = time;
      ptr->invalidateCache();
    }
 
    // Try to insert a new value into the cache
    auto result = _cache.insert({hashing::hashCombine(time, point), 0.0});
 
    // Evaluate and apply if the insertion worked, i.e. the element didn't exist
    if (result.second)
      result.first->second = ptr->evaluateValue(time, point);
 
    // Return the cached value
    return result.first->second;
  }
 
  return ptr->evaluateValue(time, point);
}

Member Data Documentation

_cache

std::unordered_map<hashing::HashValue, Real> MemoizedFunctionInterface::_cache

mutableprivate

Cached evaluations for each point.

Definition at line 59 of file MemoizedFunctionInterface.h.

Referenced by invalidateCache(), and value().

_current_time

Real MemoizedFunctionInterface::_current_time

mutableprivate

Stores the time evaluation of the cache.

Definition at line 62 of file MemoizedFunctionInterface.h.

Referenced by value().

_enable_cache

bool MemoizedFunctionInterface::_enable_cache

private

Flag for whether to cache values.

Definition at line 65 of file MemoizedFunctionInterface.h.

Referenced by useCache(), and value().

_respect_time

bool MemoizedFunctionInterface::_respect_time

private

Flag for whether changes in time invalidate the cache.

Definition at line 68 of file MemoizedFunctionInterface.h.

Referenced by value().

---

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

• functional_expansion_tools/include/functions/MemoizedFunctionInterface.h
• functional_expansion_tools/src/functions/MemoizedFunctionInterface.C