Solves a system of linear equation, A x = b. More...

#include <LinearEquationsDavidson.h>

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

Collaboration diagram for molpro::linalg::itsolv::LinearEquationsDavidson< 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::LinearEquationsDavidson< R, Q, P >

Solves a system of linear equation, A x = b.

The equations are solved using a Krylov subspace projection method with the P and D space. This is the same approach as LinearEigenvalue.

Residual

The residual is scaled down by the norm of the RHS vector so that thresholds are consistent.

Value

The value of solution i is $\chi_{ii}=\langle b_i|x_i\rangle$ , the diagonal element of the susceptibility (second-order property) when the equations are for first-order perturbed wavefunctions. The value error used with the value convergence threshold is the absolute change in $\chi_{ii}$ since the previous iteration, without the scaling applied to the residual. With the augmented Hessian it is instead the change in the subspace eigenvalue.

Preconditioner

Augmented Hessian

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

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

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

bool	nonlinear () const override

size_t	end_iteration (const VecRef< R > &parameters, const VecRef< R > &action) override

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

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

void	add_equations (const CVecRef< R > &rhs) override

void	add_equations (const R &rhs) override

void	add_equations (const std::vector< R > &rhs) override

CVecRef< Q >	rhs () const override

void	set_norm_thresh (value_type_abs thresh)
	Set threshold on the norm of parameters that should be considered null.

value_type_abs	get_norm_thresh () const

void	set_svd_thresh (value_type_abs thresh)

value_type_abs	get_svd_thresh () const

void	set_reset_D (size_t n)
	Set the period in iterations for resetting the D space, 0 for never.

size_t	get_reset_D () const

void	set_reset_D_maxQ_size (size_t n)
	Set the maximum size of Q space after resetting the D space.

int	get_reset_D_maxQ_size () const

void	set_max_size_qspace (std::size_t n)

std::size_t	get_max_size_qspace () const

void	set_min_size_qspace (std::size_t n)

std::size_t	get_min_size_qspace () const

void	set_hermiticity (bool hermitian) override

bool	get_hermiticity () const override

void	set_augmented_hessian (const value_type_abs parameter)
	Set value of augmented hessian parameter. If 0, than augmented Hessian is not used.

value_type_abs	get_augmented_hessian () const

void	set_options (const Options &options) override

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

void	report (std::ostream &cout, bool endl=true) 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

void	set_profiler (std::shared_ptr< 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

Protected Member Functions
std::vector< value_type >	values () const
	The values chi_ii = <b_i\|x_i> of the current solutions, or with the augmented Hessian the subspace eigenvalues.

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

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	combine_errors ()
	Implementation class can overload this to combine the errors of solutions, once those of all are known.

virtual void	compute_errors (const std::vector< int > &roots, const CVecRef< R > &params, const CVecRef< R > &residuals, std::vector< value_type_abs > &errors)
	Computes the errors of roots, given their parameters and residuals; by default the norms of the residuals.

virtual bool	linearEigensystem () const

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

bool	verbosity_at_least (Verbosity v) const
	Whether output of verbosity v is printed in solve(); everything is printed if no verbosity was set.

void	generate_initial_guess_from_diagonals (const VecRef< R > &parameters, const Q &diagonals)
	Fills parameters with unit vectors at the positions of the lowest diagonal elements.

std::vector< P >	select_pspace (const Q &diagonals)
	Selects the P space from the lowest diagonal elements, subject to max_p and p_threshold.

size_t	initialise_pspace (const std::vector< P > &pspace, const Problem< R > &problem, const VecRef< R > &parameters, const VecRef< R > &actions)
	Adds the P space to the subspace using the P-space kernel provided by problem; returns the working-set size.

Protected Attributes
RSpaceOptions< value_type_abs >	rspace_opts
	Options concerning R-space handling.

QSpaceOptions	qspace_opts
	Options concerning Q-space handling.

detail::DSpaceResetter< Q >	m_dspace_resetter
	resets D space

bool	m_hermiticity = true
	whether the problem is hermitian or not

std::vector< value_type >	m_last_values
	the values from the previous iteration

bool	m_resetting_in_progress = false
	whether D space resetting is in progress

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

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