struct for running a protocol of subsequently tightening precision More...

#include <SCFProtocol.h>

Collaboration diagram for madness::SCFProtocol:

[legend]

Public Member Functions
	SCFProtocol (World &w, const CalculationParameters &param)

bool	approx (const double a, const double b) const
	compare two positive doubles to be equal

void	drop_last_rung ()
	drop the last rung, i.e. stop one step short of the full precision

bool	finished () const

void	infer_thresholds (const double prec)
	infer thresholds for a given rung of the ladder

void	initialize ()

bool	on_last_rung () const
	true if the current rung is the last one

SCFProtocol &	operator++ ()
	go to the next rung of the ladder

void	set_start_index (const std::size_t i)
	start at a given rung rather than at the first

std::size_t	size () const
	number of rungs in the ladder

std::size_t	start_index () const
	index of the rung this protocol will start at

Public Attributes
bool	converged
	flag if protocol has converged

double	current_prec
	current precision

double	dconv
	density convergence of SCF calculations

double	econv
	energy convergence of SCF calculations

double	end_prec
	final precision

double	start_prec
	starting precision, typically 1.e-4

double	thresh
	numerical precision of representing functions

World &	world

Private Attributes
std::size_t	index
	current rung

std::vector< double >	protocol
	the ladder, from CalculationParameters

double	user_dconv
	density convergence provided by user

double	user_econv
	energy convergence provided by user

Detailed Description

struct for running a protocol of subsequently tightening precision

The ladder is CalculationParameters::protocol() and nothing else – the same list moldft walks, so both engines refine through identical steps and k follows from SCF::set_protocol's thresh->k table. econv and dconv are convergence criteria applied at each rung, relaxed to the rung's own threshold the way SCF::solve already relaxes dconv: you cannot converge a quantity tighter than the basis represents it.

Constructor & Destructor Documentation

◆ SCFProtocol()

madness::SCFProtocol::SCFProtocol	(	World &	w,
		const CalculationParameters &	param
	)

inline

References current_prec, end_prec, infer_thresholds(), MADNESS_CHECK_THROW, madness::nonlinear_vector_solver(), protocol, and start_prec.

Member Function Documentation

◆ approx()

bool madness::SCFProtocol::approx	(	const double	a,
		const double	b
	)		const

inline

compare two positive doubles to be equal

References a, std::abs(), and b.

◆ drop_last_rung()

void madness::SCFProtocol::drop_last_rung ( )

inline

drop the last rung, i.e. stop one step short of the full precision

used for cheap pre-iterations; never empties the ladder

References end_prec, index, protocol, and set_start_index().

◆ finished()

bool madness::SCFProtocol::finished ( ) const

inline

References converged.

◆ infer_thresholds()

void madness::SCFProtocol::infer_thresholds ( const double prec )

inline

infer thresholds for a given rung of the ladder

The rung sets the representation threshold. econv and dconv are the user's, but never tighter than the rung can support.

dconv needs care. The BSH residual cannot fall much below the threshold the orbitals are represented at, and nemo tests bsh_norm < dconv strictly, so a dconv equal to the rung's threshold is unreachable and the rung burns maxiter without converging. Intermediate rungs therefore use the long-standing 0.1*sqrt(thresh) relaxation – 1e-3 at thresh 1e-4, 1e-4 at thresh 1e-6 – which is comfortably looser than the rung; they are only a stepping stone, so there is nothing to gain from converging them tightly. The last rung is the answer, so it honours the user's dconv (never demanding tighter than the representation supports).

References dconv, econv, madness::nonlinear_vector_solver(), on_last_rung(), thresh, user_dconv, and user_econv.

Referenced by SCFProtocol(), initialize(), operator++(), and set_start_index().