olb::util::TimeIntegrator< T, P > Class Template Reference

Integration with the trapezoid rule. More...

#include <benchmarkUtil.h>

Collaboration diagram for olb::util::TimeIntegrator< T, P >:

Public Member Functions
	TimeIntegrator (T lowerBound, T upperBound, T dt)
void	takeValue (int iT, T value)
void	reset (T lowerBound, T upperBound, T dt)
T	getResult ()

Protected Attributes
T	_lowerBound
T	_upperBound
T	_dt
int	_firstStep
int	_secondStep
int	_lastStep
int	_prelastStep
std::conditional_t<(P==0), T, KahanSummator< T > >	result

Detailed Description

template<typename T, int P = 1>
class olb::util::TimeIntegrator< T, P >

Integration with the trapezoid rule.

Compute L^P norm on a time interval with the trapezoid rule. For p < infinity, the exact physical interval bounds are respected via linear interpolation from the two neighboring time steps inside the integration domain. P=0 corresponds to the L^\infty norm. For ADf data types, the derivatives of the result contain the derivatives of the integral w.r.t. the derivation variables. Both integrands and integration limits may depend on the derivation variables.

Definition at line 217 of file benchmarkUtil.h.

Constructor & Destructor Documentation

TimeIntegrator()

template<typename T , int P = 1>

olb::util::TimeIntegrator< T, P >::TimeIntegrator ( T lowerBound, T upperBound, T dt )

inline

Definition at line 232 of file benchmarkUtil.h.

                                                   :
    _lowerBound(lowerBound),
    _upperBound(upperBound),
    _dt(dt),
    _firstStep(_lowerBound > 0 ? _lowerBound / dt + 1.0 : _lowerBound / dt),
    _secondStep(_firstStep + 1),
    _lastStep(_upperBound > 0 ? _upperBound / dt : _upperBound / dt - 1.0),
    _prelastStep(_lastStep - 1)
  {
    OLB_ASSERT((_secondStep < _prelastStep),
      "Time integration needs smaller time steps.\n");
    if constexpr (P==0) {
      result = T(0);
    }
  }

References olb::util::TimeIntegrator< T, P >::_prelastStep, olb::util::TimeIntegrator< T, P >::_secondStep, OLB_ASSERT, and olb::util::TimeIntegrator< T, P >::result.

Member Function Documentation

getResult()

template<typename T , int P = 1>

T olb::util::TimeIntegrator< T, P >::getResult ( )

inline

Definition at line 314 of file benchmarkUtil.h.

  {
    using BT = BaseType<T>;
    if constexpr (P==0) {
      return result;
    } else {
      return util::pow(result.getSum(), BT(1) / P);
    }
    __builtin_unreachable();
  }

References olb::util::pow(), and olb::util::TimeIntegrator< T, P >::result.

Here is the call graph for this function:

reset()

template<typename T , int P = 1>

void olb::util::TimeIntegrator< T, P >::reset ( T lowerBound, T upperBound, T dt )

inline

Definition at line 295 of file benchmarkUtil.h.

  {
    _lowerBound = lowerBound;
    _upperBound = upperBound;
    _dt = dt;
    _firstStep = _lowerBound / dt + 1.0;
    _secondStep = _firstStep + 1;
    _lastStep = _upperBound / dt;
    _prelastStep = _lastStep - 1;
    if constexpr (P==0) {
      result = T(0);
    } else {
      result.initialize();
    }
    if (_secondStep >= _prelastStep) {
      throw std::runtime_error("Time integration needs smaller time steps.\n");
    }
  }

References olb::util::TimeIntegrator< T, P >::_dt, olb::util::TimeIntegrator< T, P >::_firstStep, olb::util::TimeIntegrator< T, P >::_lastStep, olb::util::TimeIntegrator< T, P >::_lowerBound, olb::util::TimeIntegrator< T, P >::_prelastStep, olb::util::TimeIntegrator< T, P >::_secondStep, olb::util::TimeIntegrator< T, P >::_upperBound, and olb::util::TimeIntegrator< T, P >::result.

takeValue()

template<typename T , int P = 1>

void olb::util::TimeIntegrator< T, P >::takeValue ( int iT, T value )

inline

Definition at line 248 of file benchmarkUtil.h.

  {
    if (iT >= _firstStep && iT <= _lastStep) {
      if constexpr (P == 0) {
        result = util::max(result, util::abs(value));
      }
      else {
        const T time(iT * _dt);
        T weight(_dt);
 
        /*
        // linear extrapolation at interval bounds
        // was deactivated due to instability
        if (iT == _firstStep) {
          T offset (_lowerBound - time);
          weight = 0.5 * _dt - 0.5 * (2.0 - offset / _dt) * offset;
          //weight = 0.5 * _dt + time - _lowerBound;
        }
        else if (iT == _secondStep) {
          T offset (_lowerBound - (time - _dt));
          weight = _dt - 0.5 * offset * offset / _dt;
        }
        else if (iT == _prelastStep) {
          T offset (_upperBound - (time + _dt));
          weight = _dt - 0.5 * offset * offset / _dt;
        }
        else if (iT == _lastStep) {
          T offset (_upperBound - time);
          weight = 0.5 * _dt + 0.5 * (2.0 + offset / _dt) * offset;
          //weight = 0.5 * _dt + offset;
        }
        */
 
        // constant extrapolation at interval bounds
        if (iT == _firstStep) {
          weight = 0.5 * _dt + time - _lowerBound;
        }
        else if (iT == _lastStep) {
          T offset (_upperBound - time);
          weight = 0.5 * _dt + offset;
        }
 
        result.add(weight * util::pow(value, P));
      }
    }
  }

References olb::util::TimeIntegrator< T, P >::_dt, olb::util::TimeIntegrator< T, P >::_firstStep, olb::util::TimeIntegrator< T, P >::_lastStep, olb::util::TimeIntegrator< T, P >::_lowerBound, olb::util::TimeIntegrator< T, P >::_upperBound, olb::util::abs(), olb::util::max(), olb::util::pow(), and olb::util::TimeIntegrator< T, P >::result.

Here is the call graph for this function:

Member Data Documentation

_dt

template<typename T , int P = 1>

T olb::util::TimeIntegrator< T, P >::_dt

protected

Definition at line 222 of file benchmarkUtil.h.

_firstStep

template<typename T , int P = 1>

int olb::util::TimeIntegrator< T, P >::_firstStep

protected

Definition at line 224 of file benchmarkUtil.h.

_lastStep

template<typename T , int P = 1>

int olb::util::TimeIntegrator< T, P >::_lastStep

protected

Definition at line 226 of file benchmarkUtil.h.

_lowerBound

template<typename T , int P = 1>

T olb::util::TimeIntegrator< T, P >::_lowerBound

protected

Definition at line 220 of file benchmarkUtil.h.

_prelastStep

template<typename T , int P = 1>

int olb::util::TimeIntegrator< T, P >::_prelastStep

protected

Definition at line 227 of file benchmarkUtil.h.

_secondStep

template<typename T , int P = 1>

int olb::util::TimeIntegrator< T, P >::_secondStep

protected

Definition at line 225 of file benchmarkUtil.h.

_upperBound

template<typename T , int P = 1>

T olb::util::TimeIntegrator< T, P >::_upperBound

protected

Definition at line 221 of file benchmarkUtil.h.

result

template<typename T , int P = 1>

std::conditional_t< (P==0), T, KahanSummator<T> > olb::util::TimeIntegrator< T, P >::result

protected

Definition at line 229 of file benchmarkUtil.h.

---

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

• src/utilities/benchmarkUtil.h