the CG method as a solver for linear operators More...

#include <cg.h>

Inheritance diagram for ug::CG< TVector >:

Public Types
typedef IPreconditionedLinearOperatorInverse< vector_type >	base_type
	Base type.

typedef TVector	vector_type
	Vector type.

Public Types inherited from ug::IPreconditionedLinearOperatorInverse< TVector >
typedef ILinearOperatorInverse< TVector, TVector >	base_type
	Base class.

typedef TVector	codomain_function_type
	Range space.

typedef TVector	domain_function_type
	Domain space.

Public Types inherited from ug::ILinearOperatorInverse< X, Y >
typedef Y	codomain_function_type
	Range space.

typedef X	domain_function_type
	Domain space.

Public Types inherited from ug::ILinearIterator< X, Y >
typedef Y	codomain_function_type
	Range space.

typedef X	domain_function_type
	Domain space.

Public Types inherited from ug::VectorDebugWritingObject< TVector >
typedef TVector	vector_type
	type of vector

Public Member Functions
void	add_postprocess_corr (SmartPtr< IPProcessVector< vector_type > > p)
	adds a post-process for the iterates

virtual bool	apply_return_defect (vector_type &x, vector_type &b)
	Solve J(u)*x = b, such that x = J(u)^{-1} b.

	CG ()
	constructors

	CG (SmartPtr< ILinearIterator< vector_type, vector_type > > spPrecond)

	CG (SmartPtr< ILinearIterator< vector_type, vector_type > > spPrecond, SmartPtr< IConvergenceCheck< vector_type > > spConvCheck)

virtual const char *	name () const
	name of solver

void	remove_postprocess_corr (SmartPtr< IPProcessVector< vector_type > > p)
	removes a post-process for the iterates

virtual bool	supports_parallel () const
	returns if parallel solving is supported

Public Member Functions inherited from ug::IPreconditionedLinearOperatorInverse< TVector >
virtual bool	apply (TVector &x, const TVector &b)

virtual std::string	config_string () const
	returns information about configuration parameters

std::string	config_string_preconditioner_convergence_check () const
	returns config information of convergence check and preconditioner

virtual bool	init (SmartPtr< ILinearOperator< TVector, TVector > > J, const TVector &u)
	initializes the solver for an operator

virtual bool	init (SmartPtr< ILinearOperator< TVector, TVector > > L)
	initializes the solver for an operator

	IPreconditionedLinearOperatorInverse ()
	Empty constructor.

	IPreconditionedLinearOperatorInverse (SmartPtr< ILinearIterator< TVector, TVector > > spPrecond)
	constructor setting the preconditioner

	IPreconditionedLinearOperatorInverse (SmartPtr< ILinearIterator< TVector, TVector > > spPrecond, SmartPtr< IConvergenceCheck< TVector > > spConvCheck)
	constructor setting the preconditioner

void	set_compute_fresh_defect_when_finished (bool bRecompute)
	for debug: computes norm again after whole calculation of apply

void	set_preconditioner (SmartPtr< ILinearIterator< TVector, TVector > > spPrecond)
	sets the preconditioner

SmartPtr< ILinearIterator< TVector, TVector > >	preconditioner ()

ConstSmartPtr< ILinearIterator< TVector, TVector > >	preconditioner () const

Public Member Functions inherited from ug::ILinearOperatorInverse< X, Y >
virtual bool	apply (Y &u, const X &f)=0
	applies inverse operator, i.e. returns u = A^{-1} f

virtual bool	apply_return_defect (Y &u, X &f)=0
	applies inverse operator, i.e. returns u = A^{-1} f and returns defect d := f - A*u

virtual bool	apply_update_defect (Y &u, X &f)
	compute new correction c = Bd and update defect d := d - Ac

virtual SmartPtr< ILinearIterator< X, Y > >	clone ()
	clone

SmartPtr< IConvergenceCheck< X > >	convergence_check ()
	returns the convergence check

ConstSmartPtr< IConvergenceCheck< X > >	convergence_check () const
	returns the convergence check

number	defect () const
	returns the current defect

	ILinearOperatorInverse ()
	constructor setting convergence check to (100, 1e-12, 1e-12, true)

	ILinearOperatorInverse (SmartPtr< IConvergenceCheck< X > > spConvCheck)
	Default constructor.

virtual bool	init (SmartPtr< ILinearOperator< Y, X > > J, const Y &u)
	initializes for the inverse for a linearized operator at linearization point u

virtual bool	init (SmartPtr< ILinearOperator< Y, X > > L)
	initializes for the inverse for a linear operator

SmartPtr< ILinearOperator< Y, X > >	linear_operator ()
	returns the current Operator this Inverse Operator is initialized for

number	reduction () const
	returns the current relative reduction

void	set_convergence_check (SmartPtr< IConvergenceCheck< X > > spConvCheck)
	set the convergence check

virtual int	standard_offset () const
	returns the standard offset for output

int	step () const
	returns the current number of steps

virtual	~ILinearOperatorInverse ()
	virtual destructor

Public Member Functions inherited from ug::ILinearIterator< X, Y >
SmartPtr< IDamping< X, Y > >	damping ()
	returns the scaling

	ILinearIterator ()
	constructor

	ILinearIterator (const ILinearIterator< X, Y > &parent)
	copy constructor

void	set_damp (number factor)
	sets the damping to a constant factor

void	set_damp (SmartPtr< IDamping< X, Y > > spScaling)
	sets a scaling for the correction

virtual	~ILinearIterator ()
	virtual destructor

Public Member Functions inherited from ug::VectorDebugWritingObject< TVector >
virtual void	set_debug (SmartPtr< IVectorDebugWriter< vector_type > > spDebugWriter)
	set debug writer

SmartPtr< IVectorDebugWriter< vector_type > >	vector_debug_writer ()
	returns the debug writer

ConstSmartPtr< IVectorDebugWriter< vector_type > >	vector_debug_writer () const

bool	vector_debug_writer_valid () const
	returns true if the debug writer is set

	VectorDebugWritingObject ()

	VectorDebugWritingObject (SmartPtr< IVectorDebugWriter< vector_type > > spDebugWriter)

void	write_debug (const vector_type &vec, const char *filename)
	writing debug output for a vector (if debug writer set)

virtual	~VectorDebugWritingObject ()
	virtual destructor

Protected Member Functions
void	enter_precond_debug_section (int loopCnt)
	debugger section for the preconditioner

void	prepare_conv_check ()
	adjust output of convergence check

number	VecProd (vector_type &a, vector_type &b)

void	write_debugXR (vector_type &x, vector_type &r, int loopCnt)
	debugger output: solution and residual

Protected Member Functions inherited from ug::VectorDebugWritingObject< TVector >
void	enter_vector_debug_writer_section (const char *secDir)
	enters a debugging section

void	enter_vector_debug_writer_section (std::string secDir)
	enters a debugging section

void	leave_vector_debug_writer_section ()
	leaves a debugging section

void	print_debugger_message (const char *msg)
	prints a debugger message (listing all the sections)

void	print_debugger_message (std::string msg)
	prints a debugger message (listing all the sections)

virtual void	write_debug (const vector_type &vec, std::string name)
	writing debug output for a vector (if debug writer set)

Protected Attributes
PProcessChain< vector_type >	m_corr_post_process
	postprocessor for the correction in the iterations

Protected Attributes inherited from ug::IPreconditionedLinearOperatorInverse< TVector >
bool	m_bRecompute
	flag if fresh defect should be computed when finish for debug purpose

SmartPtr< ILinearIterator< TVector, TVector > >	m_spPrecond
	Iterator used in the iterative scheme to compute the correction and update the defect.

Protected Attributes inherited from ug::ILinearOperatorInverse< X, Y >
SmartPtr< IConvergenceCheck< X > >	m_spConvCheck
	smart pointer holding the convergence check

SmartPtr< ILinearOperator< Y, X > >	m_spLinearOperator
	Operator that is inverted by this Inverse Operator.

Protected Attributes inherited from ug::ILinearIterator< X, Y >
SmartPtr< IDamping< X, Y > >	m_spDamping
	the scaling

Protected Attributes inherited from ug::VectorDebugWritingObject< TVector >
SmartPtr< IVectorDebugWriter< vector_type > >	m_spVectorDebugWriter
	Debug Writer.

Detailed Description

template<typename TVector>
class ug::CG< TVector >

the CG method as a solver for linear operators

This class implements the CG - method for the solution of linear operator problems like A*x = b, where the solution x = A^{-1} b is computed.

For detailed description of the algorithm, please refer to:

Barrett, Berry, Chan, Demmel, Donatom Dongarra, Eijkhout, Pozo, Romine, Van der Vorst, "Templates for the Solution of Linear Systems: Building Blocks for Iterative Methods", p.13, Fig, 2.5
Saad, "Iterative Methods For Sparse Linear Systems", p277, Alg. 9.1

Template Parameters

TVector vector type

Member Typedef Documentation

◆ base_type

template<typename TVector >

typedef IPreconditionedLinearOperatorInverse<vector_type> ug::CG< TVector >::base_type

Base type.

◆ vector_type

template<typename TVector >

typedef TVector ug::CG< TVector >::vector_type

Vector type.

Constructor & Destructor Documentation

◆ CG() [1/3]

template<typename TVector >

ug::CG< TVector >::CG ( )

inline

constructors

◆ CG() [2/3]

template<typename TVector >

ug::CG< TVector >::CG ( SmartPtr< ILinearIterator< vector_type, vector_type > > spPrecond )

inline

◆ CG() [3/3]

template<typename TVector >

ug::CG< TVector >::CG	(	SmartPtr< ILinearIterator< vector_type, vector_type > >	spPrecond,
		SmartPtr< IConvergenceCheck< vector_type > >	spConvCheck
	)

inline

Member Function Documentation

◆ add_postprocess_corr()

template<typename TVector >

void ug::CG< TVector >::add_postprocess_corr ( SmartPtr< IPProcessVector< vector_type > > p )

inline

adds a post-process for the iterates

References ug::PProcessChain< TVector >::add(), ug::CG< TVector >::m_corr_post_process, and p.

◆ apply_return_defect()

template<typename TVector >

virtual bool ug::CG< TVector >::apply_return_defect	(	vector_type &	x,
		vector_type &	b
	)

inlinevirtual

Solve J(u)*x = b, such that x = J(u)^{-1} b.

References ug::IPreconditionedLinearOperatorInverse< TVector >::apply(), ug::PProcessChain< TVector >::apply(), ug::ILinearOperatorInverse< X, Y >::convergence_check(), ug::CG< TVector >::enter_precond_debug_section(), ug::VectorDebugWritingObject< TVector >::leave_vector_debug_writer_section(), ug::ILinearOperatorInverse< X, Y >::linear_operator(), ug::CG< TVector >::m_corr_post_process, p, ug::IPreconditionedLinearOperatorInverse< TVector >::preconditioner(), ug::CG< TVector >::prepare_conv_check(), PROFILE_BEGIN_GROUP, ug::PST_ADDITIVE, ug::PST_CONSISTENT, ug::ILinearOperatorInverse< X, Y >::step(), UG_LOG, UG_THROW, ug::CG< TVector >::VecProd(), ug::VecScaleAdd(), and ug::CG< TVector >::write_debugXR().

◆ enter_precond_debug_section()

template<typename TVector >

void ug::CG< TVector >::enter_precond_debug_section ( int loopCnt )

inlineprotected

debugger section for the preconditioner

References ug::VectorDebugWritingObject< TVector >::enter_vector_debug_writer_section(), and ug::VectorDebugWritingObject< TVector >::vector_debug_writer_valid().

Referenced by ug::CG< TVector >::apply_return_defect().

◆ name()

template<typename TVector >

virtual const char * ug::CG< TVector >::name ( ) const

inlinevirtual

name of solver

Implements ug::ILinearOperatorInverse< X, Y >.

Referenced by ug::CG< TVector >::prepare_conv_check().

◆ prepare_conv_check()

template<typename TVector >

void ug::CG< TVector >::prepare_conv_check ( )

inlineprotected

adjust output of convergence check

References ug::ILinearOperatorInverse< X, Y >::convergence_check(), ug::CG< TVector >::name(), ug::IPreconditionedLinearOperatorInverse< TVector >::preconditioner(), and s.

Referenced by ug::CG< TVector >::apply_return_defect().

◆ remove_postprocess_corr()

template<typename TVector >

void ug::CG< TVector >::remove_postprocess_corr ( SmartPtr< IPProcessVector< vector_type > > p )

inline

removes a post-process for the iterates

References ug::CG< TVector >::m_corr_post_process, p, and ug::PProcessChain< TVector >::remove().

◆ supports_parallel()

template<typename TVector >

virtual bool ug::CG< TVector >::supports_parallel ( ) const

inlinevirtual

returns if parallel solving is supported

Implements ug::ILinearOperatorInverse< X, Y >.

References ug::IPreconditionedLinearOperatorInverse< TVector >::preconditioner().

◆ VecProd()

template<typename TVector >

number ug::CG< TVector >::VecProd	(	vector_type &	a,
		vector_type &	b
	)

inlineprotected

Referenced by ug::CG< TVector >::apply_return_defect().

◆ write_debugXR()

template<typename TVector >

void ug::CG< TVector >::write_debugXR	(	vector_type &	x,
		vector_type &	r,
		int	loopCnt
	)

inlineprotected

debugger output: solution and residual

References ug::VectorDebugWritingObject< TVector >::vector_debug_writer_valid(), and ug::VectorDebugWritingObject< TVector >::write_debug().

Referenced by ug::CG< TVector >::apply_return_defect().

Member Data Documentation

◆ m_corr_post_process

template<typename TVector >

PProcessChain<vector_type> ug::CG< TVector >::m_corr_post_process

protected

postprocessor for the correction in the iterations

These postprocess operations are applied to the preconditioned defect before the orthogonalization. The goal is to prevent the useless kernel parts to prevail in the (floating point) arithmetics.

Referenced by ug::CG< TVector >::add_postprocess_corr(), ug::CG< TVector >::apply_return_defect(), and ug::CG< TVector >::remove_postprocess_corr().

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

ugbase/lib_algebra/operator/linear_solver/cg.h

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

◆ base_type

◆ vector_type

Constructor & Destructor Documentation

◆ CG() [1/3]

◆ CG() [2/3]

◆ CG() [3/3]

Member Function Documentation

◆ add_postprocess_corr()

◆ apply_return_defect()

◆ enter_precond_debug_section()

◆ name()

◆ prepare_conv_check()

◆ remove_postprocess_corr()

◆ supports_parallel()

◆ VecProd()

◆ write_debugXR()

Member Data Documentation

◆ m_corr_post_process