One specific implementation of LinearEigensystem using Davidson's algorithm with modifications to manage near linear dependencies, and consequent numerical noise, in candidate expansion vectors. More...

#include <LinearEigensystemRSPT.h>

Inheritance diagram for molpro::linalg::itsolv::LinearEigensystemRSPT< R, Q, P >:

[legend]

Collaboration diagram for molpro::linalg::itsolv::LinearEigensystemRSPT< R, Q, P >:

[legend]

Detailed Description

template<class R, class Q = R, class P = std::map<size_t, typename R::value_type>>
class molpro::linalg::itsolv::LinearEigensystemRSPT< R, Q, P >

One specific implementation of LinearEigensystem using Davidson's algorithm with modifications to manage near linear dependencies, and consequent numerical noise, in candidate expansion vectors.

TODO add more documentation and examples

Template Parameters

R
Q
P

Public Types
using	SolverTemplate = IterativeSolverTemplate< LinearEigensystem, R, Q, P >

Public Member Functions
	LinearEigensystemRSPT (const std::shared_ptr< ArrayHandlers< R, Q, P > > &handlers, const std::shared_ptr< Logger > &logger_=std::make_shared< Logger >())

bool	nonlinear () const override

bool	linearEigensystem () const override

size_t	end_iteration (const VecRef< R > &parameters, const VecRef< R > &action) override
	constructs next perturbed wavefunction

size_t	end_iteration (std::vector< R > &parameters, std::vector< R > &action) override

size_t	end_iteration (R &parameters, R &actions) override

void	precondition (std::vector< R > &parameters, std::vector< R > &action) const
	Applies the Davidson preconditioner.

std::vector< scalar_type >	eigenvalues () const override

virtual std::vector< scalar_type >	working_set_eigenvalues () const override

void	report (std::ostream &cout, bool endl=true) const override

void	set_hermiticity (bool hermitian) override

bool	get_hermiticity () const override

void	set_options (const Options &options) override

std::shared_ptr< Options >	get_options () const override

Public Member Functions inherited from molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >
	IterativeSolverTemplate ()=delete

	IterativeSolverTemplate (const IterativeSolverTemplate< Solver, R, Q, P > &)=delete

	IterativeSolverTemplate (IterativeSolverTemplate< Solver, R, Q, P > &&) noexcept=default

IterativeSolverTemplate< Solver, R, Q, P > &	operator= (const IterativeSolverTemplate< Solver, R, Q, P > &)=delete

IterativeSolverTemplate< Solver, R, Q, P > &	operator= (IterativeSolverTemplate< Solver, R, Q, P > &&) noexcept=default

void	set_logger (std::shared_ptr< Logger > logger) override

Logger &	logger () override

int	add_vector (const VecRef< R > &parameters, const VecRef< R > &actions) override

int	add_vector (std::vector< R > &parameters, std::vector< R > &actions) override

int	add_vector (R &parameters, R &actions, value_type value=0) override

size_t	add_p (const CVecRef< P > &pparams, const array::Span< value_type > &pp_action_matrix, const VecRef< R > &parameters, const VecRef< R > &actions, fapply_on_p_type apply_p) override

void	clearP () override

void	solution (const std::vector< int > &roots, const VecRef< R > &parameters, const VecRef< R > &residual) override

void	solution (const std::vector< int > &roots, std::vector< R > &parameters, std::vector< R > &residual) override

void	solution (R &parameters, R &residual) override

void	solution_params (const std::vector< int > &roots, std::vector< R > &parameters) override

void	solution_params (const std::vector< int > &roots, const VecRef< R > &parameters) override

void	solution_params (R &parameters) override

std::vector< size_t >	suggest_p (const CVecRef< R > &solution, const CVecRef< R > &residual, size_t max_number, value_type_abs threshold) override

const std::vector< int > &	working_set () const override

size_t	n_roots () const override

void	set_n_roots (size_t roots) override

void	set_options (const Options &options) override

std::shared_ptr< Options >	get_options () const override

const std::vector< value_type_abs > &	errors () const override

const Statistics &	statistics () const override

void	report (std::ostream &cout, bool endl=true) const override

void	iteration_report () const

void	summary_report () const

void	report () const override

void	set_convergence_threshold (value_type_abs thresh) override

value_type_abs	convergence_threshold () const override

void	set_convergence_threshold_value (value_type_abs thresh) override

value_type_abs	convergence_threshold_value () const override

void	set_verbosity (Verbosity v) override

void	set_verbosity (int v) override

Verbosity	get_verbosity () const override

void	set_max_iter (int n) override

int	get_max_iter () const override

void	set_max_p (int n) override

int	get_max_p () const override

void	set_p_threshold (value_type_abs threshold) override

value_type_abs	get_p_threshold () const override

const subspace::Dimensions &	dimensions () const override
	Access dimensions of the subspace.

scalar_type	value () const override

void	set_profiler (molpro::profiler::Profiler &profiler) override

const std::shared_ptr< molpro::profiler::Profiler > &	profiler () const override

bool	solve (const VecRef< R > &parameters, const VecRef< R > &actions, const Problem< R > &problem, bool generate_initial_guess=false) override

bool	solve (R &parameters, R &actions, const Problem< R > &problem, bool generate_initial_guess=false) override

bool	solve (std::vector< R > &parameters, std::vector< R > &actions, const Problem< R > &problem, bool generate_initial_guess=false) override

bool	test_problem (const Problem< R > &problem, R &v0, R &v1, int verbosity, value_type_abs threshold) const override

Public Attributes
value_type_abs	propose_rspace_norm_thresh = precision_scaled<value_type_abs>(1e-10)
	vectors with norm less than threshold can be considered null (rescaled to the working precision)

value_type_abs	propose_rspace_svd_thresh

Protected Member Functions
void	construct_residual (const std::vector< int > &roots, const CVecRef< R > &params, const VecRef< R > &actions) override
	Constructs residual for given roots provided their parameters and actions.

Protected Member Functions inherited from molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >
	IterativeSolverTemplate (std::shared_ptr< subspace::IXSpace< R, Q, P > > xspace, std::shared_ptr< subspace::ISubspaceSolver< R, Q, P > > solver, std::shared_ptr< ArrayHandlers< R, Q, P > > handlers, std::shared_ptr< Statistics > stats, std::shared_ptr< Logger > logger)

virtual	~IterativeSolverTemplate ()

virtual void	set_value_errors ()
	Implementation class should overload this to set errors in the current values (e.g. change in eigenvalues)

size_t	solve_and_generate_working_set (const VecRef< R > &parameters, const VecRef< R > &action)
	Solves the subspace problems and selects the working set of roots, returning their parameters and residual in parameters and action.

template<typename TTT >
void	check_consistent_number_of_roots_and_solutions (const std::vector< TTT > &roots, const size_t nparams)

bool	end_iteration_needed () override

void	finalize () override

Static Protected Member Functions
static std::string	str (const std::vector< scalar_type > &a)

Protected Attributes
std::vector< scalar_type >	m_rspt_values
	perturbation series for the eigenvalue

Protected Attributes inherited from molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >
std::shared_ptr< ArrayHandlers< R, Q, P > >	m_handlers
	Array handlers.

std::shared_ptr< subspace::IXSpace< R, Q, P > >	m_xspace
	manages the subspace and associated data

std::shared_ptr< subspace::ISubspaceSolver< R, Q, P > >	m_subspace_solver
	solves the subspace problem

std::vector< value_type_abs >	m_errors
	errors from the most recent solution

std::vector< value_type_abs >	m_value_errors
	value errors from the most recent solution

std::vector< int >	m_working_set
	indices of roots in the working set

size_t	m_nroots {0}
	number of roots the solver is searching for

value_type_abs	m_convergence_threshold {1.0e-8}
	residual norms less than this mark a converged solution

value_type_abs	m_convergence_threshold_value
	value changes less than this mark a converged solution

std::shared_ptr< Statistics >	m_stats
	accumulates statistics of operations performed by the solver

std::shared_ptr< Logger >	m_logger
	logger

bool	m_normalise_solution = false
	whether to normalise the solutions

fapply_on_p_type	m_apply_p = {}
	function that evaluates effect of action on the P space projection

std::optional< Verbosity >	m_verbosity = {}
	how much output to print in solve()

int	m_max_iter = 100
	maximum number of iterations in solve()

size_t	m_max_p = 0
	maximum size of P space

value_type_abs	m_p_threshold = std::numeric_limits<value_type_abs>::max()
	threshold for selecting P space

bool	m_end_iteration_needed = true
	whether end_iteration should be called after any preconditioner

Member Typedef Documentation

◆ SolverTemplate

template<class R , class Q = R, class P = std::map<size_t, typename R::value_type>>

using molpro::linalg::itsolv::LinearEigensystemRSPT< R, Q, P >::SolverTemplate = IterativeSolverTemplate<LinearEigensystem, R, Q, P>

Constructor & Destructor Documentation

◆ LinearEigensystemRSPT()

template<class R , class Q = R, class P = std::map<size_t, typename R::value_type>>

molpro::linalg::itsolv::LinearEigensystemRSPT< R, Q, P >::LinearEigensystemRSPT	(	const std::shared_ptr< ArrayHandlers< R, Q, P > > &	handlers,
		const std::shared_ptr< Logger > &	logger_ = `std::make_shared<Logger>()`
	)

inlineexplicit

Member Function Documentation

◆ construct_residual()

template<class R , class Q = R, class P = std::map<size_t, typename R::value_type>>

void molpro::linalg::itsolv::LinearEigensystemRSPT< R, Q, P >::construct_residual	(	const std::vector< int > &	roots,
		const CVecRef< R > &	params,
		const VecRef< R > &	actions
	)

inlineoverrideprotectedvirtual

Constructs residual for given roots provided their parameters and actions.

Implements molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >.

◆ eigenvalues()

template<class R , class Q = R, class P = std::map<size_t, typename R::value_type>>

std::vector< scalar_type > molpro::linalg::itsolv::LinearEigensystemRSPT< R, Q, P >::eigenvalues ( ) const

inlineoverride

◆ end_iteration() [1/3]

template<class R , class Q = R, class P = std::map<size_t, typename R::value_type>>

size_t molpro::linalg::itsolv::LinearEigensystemRSPT< R, Q, P >::end_iteration	(	const VecRef< R > &	parameters,
		const VecRef< R > &	action
	)

inlineoverride

constructs next perturbed wavefunction

Parameters

parameters	output new parameters for the subspace.
residual	preconditioned residuals.

Returns: number of significant parameters to calculate the action for

◆ end_iteration() [2/3]

template<class R , class Q = R, class P = std::map<size_t, typename R::value_type>>

size_t molpro::linalg::itsolv::LinearEigensystemRSPT< R, Q, P >::end_iteration	(	R &	parameters,
		R &	actions
	)

inlineoverride

◆ end_iteration() [3/3]

template<class R , class Q = R, class P = std::map<size_t, typename R::value_type>>

size_t molpro::linalg::itsolv::LinearEigensystemRSPT< R, Q, P >::end_iteration	(	std::vector< R > &	parameters,
		std::vector< R > &	action
	)

inlineoverride

◆ get_hermiticity()

template<class R , class Q = R, class P = std::map<size_t, typename R::value_type>>

bool molpro::linalg::itsolv::LinearEigensystemRSPT< R, Q, P >::get_hermiticity ( ) const

inlineoverride

◆ get_options()

template<class R , class Q = R, class P = std::map<size_t, typename R::value_type>>

std::shared_ptr< Options > molpro::linalg::itsolv::LinearEigensystemRSPT< R, Q, P >::get_options ( ) const

inlineoverride

◆ linearEigensystem()

template<class R , class Q = R, class P = std::map<size_t, typename R::value_type>>

bool molpro::linalg::itsolv::LinearEigensystemRSPT< R, Q, P >::linearEigensystem ( ) const

inlineoverridevirtual

Reimplemented from molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >.

◆ nonlinear()

template<class R , class Q = R, class P = std::map<size_t, typename R::value_type>>

bool molpro::linalg::itsolv::LinearEigensystemRSPT< R, Q, P >::nonlinear ( ) const

inlineoverride

◆ precondition()

template<class R , class Q = R, class P = std::map<size_t, typename R::value_type>>

void molpro::linalg::itsolv::LinearEigensystemRSPT< R, Q, P >::precondition	(	std::vector< R > &	parameters,
		std::vector< R > &	action
	)		const

inline

Applies the Davidson preconditioner.

◆ report()

template<class R , class Q = R, class P = std::map<size_t, typename R::value_type>>

void molpro::linalg::itsolv::LinearEigensystemRSPT< R, Q, P >::report	(	std::ostream &	cout,
		bool	endl = `true`
	)		const

inlineoverride

◆ set_hermiticity()

template<class R , class Q = R, class P = std::map<size_t, typename R::value_type>>

void molpro::linalg::itsolv::LinearEigensystemRSPT< R, Q, P >::set_hermiticity ( bool hermitian )

inlineoverride

◆ set_options()

template<class R , class Q = R, class P = std::map<size_t, typename R::value_type>>

void molpro::linalg::itsolv::LinearEigensystemRSPT< R, Q, P >::set_options ( const Options & options )

inlineoverride

◆ str()

template<class R , class Q = R, class P = std::map<size_t, typename R::value_type>>

static std::string molpro::linalg::itsolv::LinearEigensystemRSPT< R, Q, P >::str ( const std::vector< scalar_type > & a )

inlinestaticprotected

◆ working_set_eigenvalues()

template<class R , class Q = R, class P = std::map<size_t, typename R::value_type>>

virtual std::vector< scalar_type > molpro::linalg::itsolv::LinearEigensystemRSPT< R, Q, P >::working_set_eigenvalues ( ) const

inlineoverridevirtual

Member Data Documentation

◆ m_rspt_values

template<class R , class Q = R, class P = std::map<size_t, typename R::value_type>>

std::vector<scalar_type> molpro::linalg::itsolv::LinearEigensystemRSPT< R, Q, P >::m_rspt_values

protected

perturbation series for the eigenvalue

◆ propose_rspace_norm_thresh

template<class R , class Q = R, class P = std::map<size_t, typename R::value_type>>

value_type_abs molpro::linalg::itsolv::LinearEigensystemRSPT< R, Q, P >::propose_rspace_norm_thresh = precision_scaled<value_type_abs>(1e-10)

vectors with norm less than threshold can be considered null (rescaled to the working precision)

◆ propose_rspace_svd_thresh

template<class R , class Q = R, class P = std::map<size_t, typename R::value_type>>

value_type_abs molpro::linalg::itsolv::LinearEigensystemRSPT< R, Q, P >::propose_rspace_svd_thresh

Initial value:

=

precision_scaled<value_type_abs>(1e-12)

molpro::linalg::itsolv::create_LinearEigensystem

std::unique_ptr< LinearEigensystem< R, Q, P > > create_LinearEigensystem(const LinearEigensystemOptions &options, const std::shared_ptr< ArrayHandlers< R, Q, P > > &handlers=std::make_shared< molpro::linalg::itsolv::ArrayHandlers< R, Q, P > >())

Definition SolverFactory.h:111

the smallest singular value in the subspace that can be allowed when constructing the working set. Smaller singular values will lead to deletion of parameters from the Q space

Detailed Description

Public Types

Public Member Functions

Public Attributes

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Member Typedef Documentation

◆ SolverTemplate

Constructor & Destructor Documentation

◆ LinearEigensystemRSPT()

Member Function Documentation

◆ construct_residual()

◆ eigenvalues()

◆ end_iteration() [1/3]

◆ end_iteration() [2/3]

◆ end_iteration() [3/3]

◆ get_hermiticity()

◆ get_options()

◆ linearEigensystem()

◆ nonlinear()

◆ precondition()

◆ report()

◆ set_hermiticity()

◆ set_options()

◆ str()

◆ working_set_eigenvalues()

Member Data Documentation

◆ m_rspt_values

◆ propose_rspace_norm_thresh

◆ propose_rspace_svd_thresh