Base class for LIMEX time integrator. More...

#include <limex_integrator.hpp>

Inheritance diagram for ug::LimexTimeIntegrator< TDomain, TAlgebra >:

Classes
class	ThreadData
	Contains all data for parallel execution of time steps. More...

Public Types
typedef TAlgebra	algebra_type

typedef algebra_type::matrix_type	matrix_type

typedef algebra_type::vector_type	vector_type

typedef GridFunction< TDomain, TAlgebra >	grid_function_type

typedef INonlinearTimeIntegrator< TDomain, TAlgebra >	base_type

typedef base_type::solver_type	solver_type

typedef IDomainDiscretization< algebra_type >	domain_discretization_type

typedef LinearImplicitEuler< algebra_type >	timestep_type

typedef AitkenNevilleTimex< vector_type >	timex_type

typedef INonlinearTimeIntegrator< TDomain, TAlgebra >	itime_integrator_type

typedef SimpleTimeIntegrator< TDomain, TAlgebra >	time_integrator_type

typedef ISubDiagErrorEst< vector_type >	error_estim_type

typedef std::vector< SmartPtr< ThreadData > >	thread_vector_type

Public Types inherited from ug::INonlinearTimeIntegrator< TDomain, TAlgebra >
typedef ITimeIntegrator< TDomain, TAlgebra >	base_type

typedef base_type::vector_type	vector_type

typedef IOperatorInverse< vector_type >	solver_type

typedef AssembledOperator< TAlgebra >	assembled_operator_type

Public Types inherited from ug::ITimeIntegrator< TDomain, TAlgebra >
typedef TAlgebra	algebra_type

typedef TAlgebra::vector_type	vector_type

typedef TAlgebra::matrix_type	matrix_type

typedef TDomain	domain_type

typedef GridFunction< TDomain, TAlgebra >	grid_function_type

Public Member Functions
void	set_debug_for_timestepper (SmartPtr< IDebugWriter< algebra_type > > spDebugWriter)
	forward debug info to time integrators

	LimexTimeIntegrator (int nstages)

void	set_tolerance (double tol)
	tolerance

void	set_stepsize_safety_factor (double rho)

void	set_stepsize_reduction_factor (double sigma)

void	set_stepsize_greedy_order_factor (double sigma)

void	set_max_reductions (size_t nred)

void	set_asymptotic_order (size_t q)

void	set_start_step (size_t step)

void	add_error_estimator (SmartPtr< error_estim_type > spErrorEstim)
	add an error estimator

void	add_stage_base (size_t nsteps, SmartPtr< solver_type > solver, SmartPtr< domain_discretization_type > spDD, SmartPtr< domain_discretization_type > spGamma=SPNULL)
	add a new stage (at end of list)

void	add_stage (size_t nsteps, SmartPtr< solver_type > solver, SmartPtr< domain_discretization_type > spDD)

void	add_stage_ext (size_t nsteps, SmartPtr< solver_type > solver, SmartPtr< domain_discretization_type > spDD, SmartPtr< domain_discretization_type > spGamma)

void	add_stage (size_t i, size_t nsteps, SmartPtr< domain_discretization_type > spDD, SmartPtr< solver_type > solver)
	! TODO: remove this function!

SmartPtr< timestep_type >	get_time_stepper (size_t i)

bool	apply (SmartPtr< grid_function_type > u, number t1, ConstSmartPtr< grid_function_type > u0, number t0)
	Integrating from t0 -> t1.

number	get_cost (size_t i)

number	get_gamma (size_t i)

number	get_workload (size_t i)

void	set_time_derivative (SmartPtr< grid_function_type > udot)
	setter for time derivative info (optional for setting $\Gamma$)

SmartPtr< grid_function_type >	get_time_derivative ()
	getter for time derivative info (optional for setting $\Gamma$)

bool	has_time_derivative ()
	status for time derivative info (optional for setting $\Gamma$)

void	enable_matrix_cache ()
	Select classic LIMEX.

void	disable_matrix_cache ()
	Select approximate Newton (default)

void	select_cost_strategy (SmartPtr< ILimexCostStrategy > cost)

void	set_space (SmartPtr< IGridFunctionSpace< grid_function_type > > spSpace)
	set banach space (e.g. for computing consistency error)

void	interrupt ()
	interrupt execution of apply() by external call via observer

void	set_conservative (bool c)

std::string	config_string () const

Public Member Functions inherited from ug::INonlinearTimeIntegrator< TDomain, TAlgebra >
void	set_solver (SmartPtr< solver_type > solver)

ConstSmartPtr< solver_type >	get_solver () const

SmartPtr< solver_type >	get_solver ()

void	set_dt_min (double min)

double	get_dt_min ()

void	set_dt_max (double max)

double	get_dt_max ()

void	set_reduction_factor (double dec)

double	get_reduction_factor ()

void	set_increase_factor (double inc)

double	get_increase_factor ()

Public Member Functions inherited from ug::ITimeIntegrator< TDomain, TAlgebra >
virtual	~ITimeIntegrator ()
	virtual destructor

virtual void	init (grid_function_type const &u)
	init operator depending on a function u

void	init ()
	init operator

void	prepare (grid_function_type &u)
	prepares functions for application

void	apply (grid_function_type &u1, const grid_function_type &u0)
	Apply operator.

void	set_time_step (double dt)
	Set initial time step.

double	get_time_step ()

void	set_precision_bound (double precisionBound)

void	set_no_log_out (bool bNoLogOut)

Public Member Functions inherited from ug::LimexTimeIntegratorConfig
	LimexTimeIntegratorConfig (unsigned int nstages)

std::string	config_string () const

Protected Member Functions
void	init_integrator_threads (ConstSmartPtr< grid_function_type > u)
	Initialize integrator threads (w/ solutions)

int	apply_integrator_threads (number dtcurr, ConstSmartPtr< grid_function_type > u0, number t0, size_t nstages)
	(Tentatively) apply integrators

void	join_integrator_threads ()
	e.g. wait for all threads to complete

void	update_integrator_threads (ConstSmartPtr< grid_function_type > ucommon, number t)
	Override thread-wise solutions with common solution.

void	dispose_integrator_threads ()
	Dispose integrator threads (w/ solutions)

number &	monitor (size_t k, size_t q)

void	init_gamma ()
	aux: compute exponents gamma_k (for roots)

void	update_cost ()
	Updating workloads A_i for computing T_ii.

void	update_monitor ()
	convergence monitor

size_t	find_optimal_solution (const std::vector< number > &eps, size_t ntest, size_t &qpred)

Protected Attributes
SmartPtr< error_estim_type >	m_spErrorEstimator

std::vector< size_t >	m_vSteps
	generating sequence for extrapolation

std::vector< ThreadData >	m_vThreadData
	vector with thread information

std::vector< number >	m_gamma
	gamma_i: exponent

std::vector< number >	m_costA
	Cost A_i (for completing stage i)

std::vector< number >	m_monitor
	Convergence monitor \alpha.

std::vector< number >	m_workload

std::vector< number >	m_lambda

std::vector< size_t >	m_num_reductions
	history of reductions

std::vector< number >	m_consistency_error
	Consistency error.

SmartPtr< grid_function_type >	m_spDtSol
	Time derivative.

SmartPtr< ILimexCostStrategy >	m_spCostStrategy

SmartPtr< IGridFunctionSpace< grid_function_type > >	m_spBanachSpace
	metric space

bool	m_bInterrupt

int	m_limex_step
	Current counter.

Protected Attributes inherited from ug::INonlinearTimeIntegrator< TDomain, TAlgebra >
SmartPtr< solver_type >	m_spSolver

TimeStepBounds	m_dtBounds

Protected Attributes inherited from ug::ITimeIntegrator< TDomain, TAlgebra >
double	m_dt

double	m_lower_tim

double	m_upper_tim

double	m_precisionBound

bool	m_bNoLogOut

Protected Attributes inherited from ug::LimexTimeIntegratorConfig
unsigned int	m_nstages
	Number of Aitken-Neville stages.

double	m_tol

double	m_rhoSafety

double	m_sigmaReduction

double	m_greedyOrderIncrease

size_t	m_max_reductions

size_t	m_asymptotic_order
	For PDEs, we may apply an symptotic order reduction.

bool	m_useCachedMatrices

unsigned int	m_conservative

Detailed Description

template<class TDomain, class TAlgebra>
class ug::LimexTimeIntegrator< TDomain, TAlgebra >

Base class for LIMEX time integrator.

Member Function Documentation

◆ apply()

template<class TDomain, class TAlgebra>

bool ug::LimexTimeIntegrator< TDomain, TAlgebra >::apply	(	SmartPtr< grid_function_type >	u,
		number	t1,
		ConstSmartPtr< grid_function_type >	u0,
		number	t0 )

virtual

Integrating from t0 -> t1.

< active number of stages <= kmax

Implements ug::ITimeIntegrator< TDomain, TAlgebra >.

◆ dispose_integrator_threads()

template<class TDomain, class TAlgebra>

void ug::LimexTimeIntegrator< TDomain, TAlgebra >::dispose_integrator_threads ( )

protected

Dispose integrator threads (w/ solutions)

Create private solutions for each thread

◆ init_integrator_threads()

template<class TDomain, class TAlgebra>

void ug::LimexTimeIntegrator< TDomain, TAlgebra >::init_integrator_threads ( ConstSmartPtr< grid_function_type > u )

protected

Initialize integrator threads (w/ solutions)

Create private solutions for each thread

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

time_disc/limex_integrator.hpp

Classes

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Member Function Documentation

◆ apply()

◆ dispose_integrator_threads()

◆ init_integrator_threads()