Multi vector quasi-Newton update scheme. More...

#include <IQNIMVJAcceleration.hpp>

Inheritance diagram for precice::acceleration::IQNIMVJAcceleration:

Collaboration diagram for precice::acceleration::IQNIMVJAcceleration:

Public Member Functions
	IQNIMVJAcceleration (double initialRelaxation, bool forceInitialRelaxation, int maxIterationsUsed, int pastTimeWindowsReused, int filter, double singularityLimit, std::vector< int > dataIDs, const impl::PtrPreconditioner &preconditioner, bool alwaysBuildJacobian, int imvjRestartType, int chunkSize, int RSLSreusedTimeWindows, double RSSVDtruncationEps)
	Constructor.

virtual	~IQNIMVJAcceleration ()
	Destructor, empty.

virtual void	initialize (const DataMap &cplData)
	Initializes the acceleration.

virtual void	specializedIterationsConverged (const DataMap &cplData)
	Marks a iteration sequence as converged.

Public Member Functions inherited from precice::acceleration::BaseQNAcceleration
	BaseQNAcceleration (double initialRelaxation, bool forceInitialRelaxation, int maxIterationsUsed, int timeWindowsReused, int filter, double singularityLimit, std::vector< int > dataIDs, impl::PtrPreconditioner preconditioner)

virtual	~BaseQNAcceleration ()
	Destructor, empty.

virtual std::vector< int >	getDataIDs () const
	Returns all IQN involved data IDs.

virtual void	performAcceleration (DataMap &cplData)
	Performs one acceleration step.

virtual void	iterationsConverged (const DataMap &cplData)
	Marks a iteration sequence as converged.

virtual void	exportState (io::TXTWriter &writer)
	Exports the current state of the acceleration to a file.

virtual void	importState (io::TXTReader &reader)
	Imports the last exported state of the acceleration from file.

virtual int	getDeletedColumns () const
	how many QN columns were deleted in this time window

virtual int	getDroppedColumns () const
	how many QN columns were dropped (went out of scope) in this time window

virtual int	getLSSystemCols () const
	: computes number of cols in least squares system, i.e, number of cols in _matrixV, _matrixW, _qrV, etc.. This is only necessary if some procs do not have any nodes on the coupling interface. In this case, the matrices are not constructed and we have no information about the number of cols. This info is needed for intra-participant communication. Number of its =! _cols in general.

Public Member Functions inherited from precice::acceleration::Acceleration
virtual	~Acceleration ()=default

Static Public Attributes
static const int	NO_RESTART = 0

static const int	RS_ZERO = 1

static const int	RS_LS = 2

static const int	RS_SVD = 3

static const int	RS_SLIDE = 4

Static Public Attributes inherited from precice::acceleration::Acceleration
static const int	NOFILTER = 0

static const int	QR1FILTER = 1

static const int	QR1FILTER_ABS = 2

static const int	QR2FILTER = 3

static const int	PODFILTER = 4

Private Member Functions
virtual void	computeQNUpdate (const DataMap &cplData, Eigen::VectorXd &xUpdate)
	: computes the IQNIMVJ update using QR decomposition of V, furthermore it updates the inverse of the system jacobian

virtual void	updateDifferenceMatrices (const DataMap &cplData)
	: updates the V, W matrices (as well as the matrices for the secondary data)

virtual void	computeUnderrelaxationSecondaryData (const DataMap &cplData)
	: computes underrelaxation for the secondary data

void	computeNewtonUpdate (const DataMap &cplData, Eigen::VectorXd &update)
	: computes the quasi-Newton update vector based on the matrices V and W using a QR decomposition of V. The decomposition is not re-computed en-block in every iteration but updated so that the new added column in V is incorporated in the decomposition.

void	computeNewtonUpdateEfficient (const DataMap &cplData, Eigen::VectorXd &update)
	: computes the quasi-Newton update vector based on the same numerics as above. However, it exploits the fact that the matrix W_til can be updated according to V and W via the formula W_til.col(j) = W.col(j) - J_inv * V.col(j). Then, pure matrix-vector products are sufficient to compute the update within one iteration, i.e., (1) x1 := J_prev(-res) (2) y := Z(-res) (3) xUp := W_tily + x1 The Jacobian matrix only needs to be set up in the very last iteration of one time window, i.e. in iterationsConverged.

void	pseudoInverse (Eigen::MatrixXd &pseudoInverse)
	: computes the pseudo inverse of V multiplied with V^T, i.e., Z = (V^TV)^-1V^T via QR-dec

void	buildJacobian ()
	: computes a explicit representation of the Jacobian, i.e., n x n matrix

void	buildWtil ()
	: re-computes the matrix _Wtil = ( W - J_prev * V) instead of updating it according to V

void	restartIMVJ ()
	: restarts the imvj method, i.e., drops all stored matrices Wtil and Z and computes a initial guess of the Jacobian based on the given restart strategy: RS-LS: Perform a IQN-LS least squares initial guess with _RSLSreusedTimeWindows RS-SVD: Update a truncated SVD decomposition of the SVD with rank-1 modifications from Wtil*Z RS-Zero: Start with zero information, initial guess J = 0.

virtual void	removeMatrixColumn (int columnIndex)
	: Removes one iteration from V,W matrices and adapts _matrixCols.

void	removeMatrixColumnRSLS (int columnINdex)
	: Removes one column form the V_RSLS and W_RSLS matrices and adapts _matrixCols_RSLS

Private Attributes
Eigen::MatrixXd	_invJacobian
	stores the approximation of the inverse Jacobian of the system at current time window.

Eigen::MatrixXd	_oldInvJacobian
	stores the approximation of the inverse Jacobian from the previous time window.

Eigen::MatrixXd	_Wtil
	stores the sub result (W-J_prev*V) for the current iteration

std::vector< Eigen::MatrixXd >	_WtilChunk
	stores all Wtil matrices within the current chunk of the imvj restart mode, disabled if _imvjRestart = false.

std::vector< Eigen::MatrixXd >	_pseudoInverseChunk
	stores all pseudo inverses within the current chunk of the imvj restart mode, disabled if _imvjRestart = false.

Eigen::MatrixXd	_matrixV_RSLS
	stores columns from previous _RSLSreusedTimeWindows time windows if RS-LS restart-mode is active

Eigen::MatrixXd	_matrixW_RSLS
	stores columns from previous _RSLSreusedTimeWindows time windows if RS-LS restart-mode is active

std::deque< int >	_matrixCols_RSLS
	number of cols per time window

impl::PtrParMatrixOps	_parMatrixOps
	encapsulates matrix-matrix and matrix-vector multiplications for serial and parallel execution

impl::SVDFactorization	_svdJ
	holds and maintains a truncated SVD decomposition of the Jacobian matrix

bool	_alwaysBuildJacobian
	If true, the less efficient method to compute the quasi-Newton update is used, that explicitly builds the Jacobian in each iteration. If set to false this is only done in the very last iteration and the update is computed based on MATVEC products.

int	_imvjRestartType
	: Indicates the type of the imvj restart-mode:

bool	_imvjRestart
	: If true, the imvj method is used with the restart chunk based approach that avoids to explicitly build and store the Jacobian. If false, the Jacobian is stored and build, however, no truncation of information is present.

int	_chunkSize
	: Number of time windows between restarts for the imvj method in restart mode

int	_RSLSreusedTimeWindows
	: Number of reused time windows at restart if restart-mode = RS-LS

int	_nbRestarts
	tracks the number of restarts of IMVJ

double	_avgRank

Additional Inherited Members
Public Types inherited from precice::acceleration::Acceleration
using	DataMap = std::map<int, cplscheme::PtrCouplingData>
	Map from data ID to data values.

Protected Member Functions inherited from precice::acceleration::BaseQNAcceleration
int	getLSSystemRows ()

virtual void	splitCouplingData (const DataMap &cplData)
	Splits up QN system vector back into the coupling data.

virtual void	applyFilter ()
	Applies the filter method for the least-squares system, defined in the configuration.

void	writeInfo (const std::string &s, bool allProcs=false)
	Wwrites info to the _infostream (also in parallel)

Protected Member Functions inherited from precice::acceleration::Acceleration
void	checkDataIDs (const DataMap &cplData) const
	Checks if all dataIDs are contained in cplData.

void	concatenateCouplingData (const DataMap &cplData, const std::vector< DataID > &dataIDs, Eigen::VectorXd &targetValues, Eigen::VectorXd &targetOldValues) const
	Concatenates all coupling data involved into a single vector.

Static Protected Member Functions inherited from precice::acceleration::Acceleration
static void	applyRelaxation (double omega, DataMap &cplData)
	performs a relaxation given a relaxation factor omega

Protected Attributes inherited from precice::acceleration::BaseQNAcceleration
logging::Logger	_log {"acceleration::BaseQNAcceleration"}

impl::PtrPreconditioner	_preconditioner
	Preconditioner for least-squares system if vectorial system is used.

double	_initialRelaxation
	Constant relaxation factor used for first iteration.

int	_maxIterationsUsed
	Maximum number of old data iterations kept.

int	_timeWindowsReused
	Maximum number of old time windows (with data values) kept.

std::vector< int >	_dataIDs
	Data IDs of data to be involved in the IQN algorithm.

std::vector< int >	_secondaryDataIDs
	Data IDs of data not involved in IQN coefficient computation.

bool	_firstIteration = true
	Indicates the first iteration, where constant relaxation is used.

bool	_firstTimeWindow = true

bool	_hasNodesOnInterface = true

bool	_forceInitialRelaxation

bool	_resetLS = false
	If true, the LS system has been modified (reset or recomputed) in such a way, that mere updating of matrices _Wtil, Q, R etc.. is not feasible any more and need to be recomputed.

Eigen::VectorXd	_oldXTilde
	Solver output from last iteration.

Eigen::VectorXd	_residuals
	Current iteration residuals of IQN data. Temporary.

std::map< int, Eigen::VectorXd >	_secondaryResiduals
	Current iteration residuals of secondary data.

Eigen::MatrixXd	_matrixV
	Stores residual deltas.

Eigen::MatrixXd	_matrixW
	Stores x tilde deltas, where x tilde are values computed by solvers.

impl::QRFactorization	_qrV
	Stores the current QR decomposition ov _matrixV, can be updated via deletion/insertion of columns.

int	_filter
	filter method that is used to maintain good conditioning of the least-squares system Either of two types: QR1FILTER or QR2Filter

double	_singularityLimit
	Determines sensitivity when two matrix columns are considered equal.

std::deque< int >	_matrixCols
	Indices (of columns in W, V matrices) of 1st iterations of time windows.

std::vector< int >	_dimOffsets
	Stores the local dimensions, i.e., the offsets in _invJacobian for all processors.

std::ostringstream	_infostringstream
	write some debug/acceleration info to file

std::fstream	_infostream

int	its = 0

int	tWindows = 0

Detailed Description

Multi vector quasi-Newton update scheme.

Performs a multi vector quasi-Newton to accelerate the convergence of implicit coupling iterations. A multi Broyden update, together with the reuse of the approximate inverse Jacobian from the old time window are used to approximate the inverse Jacobian. After every coupling iteration, the data values used are enhanced by the new coupling iterates.

If more coupling data is present than used to compute the IQNIMVJ acceleration, this data is relaxed using the same linear combination as computed for the IQNIMVJ-related data. The data is called "secondary" henceforth and additional old value and data matrices are needed for it.

Definition at line 33 of file IQNIMVJAcceleration.hpp.

Constructor & Destructor Documentation

◆ IQNIMVJAcceleration()

precice::acceleration::IQNIMVJAcceleration::IQNIMVJAcceleration	(	double	initialRelaxation,
		bool	forceInitialRelaxation,
		int	maxIterationsUsed,
		int	pastTimeWindowsReused,
		int	filter,
		double	singularityLimit,
		std::vector< int >	dataIDs,
		const impl::PtrPreconditioner &	preconditioner,
		bool	alwaysBuildJacobian,
		int	imvjRestartType,
		int	chunkSize,
		int	RSLSreusedTimeWindows,
		double	RSSVDtruncationEps )

Constructor.

Definition at line 31 of file IQNIMVJAcceleration.cpp.

◆ ~IQNIMVJAcceleration()

precice::acceleration::IQNIMVJAcceleration::~IQNIMVJAcceleration ( )

virtualdefault

Destructor, empty.

Member Function Documentation

◆ buildJacobian()

void precice::acceleration::IQNIMVJAcceleration::buildJacobian ( )

private

: computes a explicit representation of the Jacobian, i.e., n x n matrix

— compute inverse Jacobian —

J_inv = J_inv_n + (W - J_inv_n*V)*(V^T*V)^-1*V^T

assumes that J_prev, V, W are already preconditioned

(1) computation of pseudo inverse Z = (V^TV)^-1 * V^T

(2) Multiply J_prev * V =: W_tilde

(3) compute invJacobian = W_til*Z

where Z = (V^T*V)^-1*V^T via QR-dec and back-substitution dimension: (n x n) * (n x m) = (n x m), and W_til = (W - J_inv_n*V) parallel: (n_global x n_local) * (n_local x m) = (n_local x m)

Definition at line 316 of file IQNIMVJAcceleration.cpp.

Here is the call graph for this function:

◆ buildWtil()

void precice::acceleration::IQNIMVJAcceleration::buildWtil ( )

private

: re-computes the matrix _Wtil = ( W - J_prev * V) instead of updating it according to V

PRECONDITION: Assumes that V, W, J_prev are already preconditioned,

Definition at line 274 of file IQNIMVJAcceleration.cpp.

Here is the call graph for this function:

◆ computeNewtonUpdate()

void precice::acceleration::IQNIMVJAcceleration::computeNewtonUpdate	(	const DataMap &	cplData,
		Eigen::VectorXd &	update )

private

: computes the quasi-Newton update vector based on the matrices V and W using a QR decomposition of V. The decomposition is not re-computed en-block in every iteration but updated so that the new added column in V is incorporated in the decomposition.

This method rebuilds the Jacobian matrix and the matrix W_til in each iteration which is not necessary and thus inefficient.

— update inverse Jacobian —

J_inv = J_inv_n + (W - J_inv_n*V)*(V^T*V)^-1*V^T

(1) computation of pseudo inverse Z = (V^TV)^-1 * V^T

(2) Multiply J_prev * V =: W_tilde

(3) compute invJacobian = W_til*Z

where Z = (V^T*V)^-1*V^T via QR-dec and back-substitution dimension: (n x n) * (n x m) = (n x m), and W_til = (W - J_inv_n*V) parallel: (n_global x n_local) * (n_local x m) = (n_local x m)

(4) solve delta_x = - J_inv * res

Definition at line 455 of file IQNIMVJAcceleration.cpp.

Here is the call graph for this function:

◆ computeNewtonUpdateEfficient()

void precice::acceleration::IQNIMVJAcceleration::computeNewtonUpdateEfficient	(	const DataMap &	cplData,
		Eigen::VectorXd &	update )

private

: computes the quasi-Newton update vector based on the same numerics as above. However, it exploits the fact that the matrix W_til can be updated according to V and W via the formula W_til.col(j) = W.col(j) - J_inv * V.col(j). Then, pure matrix-vector products are sufficient to compute the update within one iteration, i.e., (1) x1 := J_prev*(-res) (2) y := Z(-res) (3) xUp := W_til*y + x1 The Jacobian matrix only needs to be set up in the very last iteration of one time window, i.e. in iterationsConverged.

— update inverse Jacobian efficient, — If normal mode is used: Do not recompute W_til in every iteration and do not build the entire Jacobian matrix. This is only necessary if the coupling iteration has converged, namely in the last iteration.

If restart-mode is used: The Jacobian is never build. Store matrices Wtil^q and Z^q for the last M time windows. After M time windows, a restart algorithm is performed basedon the restart-mode type, either Least-Squares restart (IQN-ILS like) or maintaining of a updated truncated SVD decomposition of the SVD.

J_inv = J_inv_n + (W - J_inv_n*V)*(V^T*V)^-1*V^T

ASSUMPTION: All objects are scaled with the active preconditioner

(1) computation of pseudo inverse Z = (V^TV)^-1 * V^T

(2) Construction of _Wtil = (W - J_prev * V), should be already present due to updated computation

Avoid computation of Z*Wtil = Jtil \in (n x n). Rather do matrix-vector computations [ J_prev*(-res) ] + [Wtil * [Z * (-res)] ] '--— 1 ----—' '--— 2 -—' '-----— 3 ------—'

(3) compute r_til = Z*(-residual) where Z = (V^T*V)^-1*V^T via QR-dec and back-substitution

dimension: (m x n) * (n x 1) = (m x 1), parallel: (m x n_local) * (n x 1) = (m x 1)

(4) compute _Wtil * r_til

dimension: (n x m) * (m x 1) = (n x 1), parallel: (n_local x m) * (m x 1) = (n_local x 1)

Note: r_til is not distributed but locally stored on each proc (dimension m x 1)

(5) xUp = J_prev * (-res) + Wtil*Z*(-res)

restart-mode: sum_q { Wtil^q * [ Z^q * (-res) ] }, where r_til = Z^q * (-res) is computed first and then xUp := Wtil^q * r_til

Definition at line 355 of file IQNIMVJAcceleration.cpp.

Here is the call graph for this function:

◆ computeQNUpdate()

void precice::acceleration::IQNIMVJAcceleration::computeQNUpdate	(	const DataMap &	cplData,
		Eigen::VectorXd &	xUpdate )

privatevirtual

: computes the IQNIMVJ update using QR decomposition of V, furthermore it updates the inverse of the system jacobian

The inverse Jacobian

   J_inv = J_inv_n + (W - J_inv_n*V)*(V^T*V)^-1*V^T

is computed and the resulting quasi-Newton update is returned. Used matrices (V, W, Wtil, invJacobian, oldINvJacobian) are scaled with the used preconditioner.

The MVJ- quasi-Newton update Either compute efficient, omitting to build the Jacobian in each iteration or inefficient. INVARIANT: All objects, J_inv, J_old_inv, W, V, Wtil, xUpdate, res, etc. are unscaled. Only the QR-decomposition of V is scaled and thus needs to be unscaled before using it in multiplications with the other matrices.

Implements precice::acceleration::BaseQNAcceleration.

Definition at line 208 of file IQNIMVJAcceleration.cpp.

Here is the call graph for this function:

◆ computeUnderrelaxationSecondaryData()

void precice::acceleration::IQNIMVJAcceleration::computeUnderrelaxationSecondaryData ( const DataMap & cplData )

privatevirtual

: computes underrelaxation for the secondary data

Implements precice::acceleration::BaseQNAcceleration.

Definition at line 117 of file IQNIMVJAcceleration.cpp.

Here is the call graph for this function:

◆ initialize()

void precice::acceleration::IQNIMVJAcceleration::initialize ( const DataMap & cplData )

virtual

Initializes the acceleration.

Reimplemented from precice::acceleration::BaseQNAcceleration.

Definition at line 72 of file IQNIMVJAcceleration.cpp.

Here is the call graph for this function:

◆ pseudoInverse()

void precice::acceleration::IQNIMVJAcceleration::pseudoInverse ( Eigen::MatrixXd & pseudoInverse )

private

: computes the pseudo inverse of V multiplied with V^T, i.e., Z = (V^TV)^-1V^T via QR-dec

computation of pseudo inverse matrix Z = (V^TV)^-1 * V^T as solution to the equation R*z = Q^T(i) for all columns i, via back substitution.

Definition at line 237 of file IQNIMVJAcceleration.cpp.

Here is the call graph for this function:

◆ removeMatrixColumn()

void precice::acceleration::IQNIMVJAcceleration::removeMatrixColumn ( int columnIndex )

privatevirtual

: Removes one iteration from V,W matrices and adapts _matrixCols.

Reimplemented from precice::acceleration::BaseQNAcceleration.

Definition at line 786 of file IQNIMVJAcceleration.cpp.

Here is the call graph for this function:

◆ removeMatrixColumnRSLS()

void precice::acceleration::IQNIMVJAcceleration::removeMatrixColumnRSLS ( int columnINdex )

private

: Removes one column form the V_RSLS and W_RSLS matrices and adapts _matrixCols_RSLS

Definition at line 801 of file IQNIMVJAcceleration.cpp.

Here is the call graph for this function:

◆ restartIMVJ()

void precice::acceleration::IQNIMVJAcceleration::restartIMVJ ( )

private

: restarts the imvj method, i.e., drops all stored matrices Wtil and Z and computes a initial guess of the Jacobian based on the given restart strategy: RS-LS: Perform a IQN-LS least squares initial guess with _RSLSreusedTimeWindows RS-SVD: Update a truncated SVD decomposition of the SVD with rank-1 modifications from Wtil*Z RS-Zero: Start with zero information, initial guess J = 0.

computation of pseudo inverse matrix Z = (V^TV)^-1 * V^T as solution to the equation R*z = Q^T(i) for all columns i, via back substitution.

Definition at line 493 of file IQNIMVJAcceleration.cpp.

Here is the call graph for this function:

◆ specializedIterationsConverged()

void precice::acceleration::IQNIMVJAcceleration::specializedIterationsConverged ( const DataMap & cplData )

virtual

Marks a iteration sequence as converged.

called by the iterationsConverged() method in the BaseQNAcceleration class handles the acceleration specific action after the convergence of one iteration

Restart the IMVJ according to restart type

in case of enforced initial relaxation, the matrices are cleared in case of pastTimeWindowsReused > 0, the columns in _Wtil are outdated, as the Jacobian changes, hence clear in case of pastTimeWindowsReused == 0 and no initial relaxation, pending deletion in performAcceleration

Implements precice::acceleration::BaseQNAcceleration.

Definition at line 680 of file IQNIMVJAcceleration.cpp.

Here is the call graph for this function:

◆ updateDifferenceMatrices()

void precice::acceleration::IQNIMVJAcceleration::updateDifferenceMatrices ( const DataMap & cplData )

privatevirtual

: updates the V, W matrices (as well as the matrices for the secondary data)

Matrices and vectors used in this method as well as the result Wtil are NOT SCALED by the preconditioner.

Reimplemented from precice::acceleration::BaseQNAcceleration.

Definition at line 133 of file IQNIMVJAcceleration.cpp.

Here is the call graph for this function:

Member Data Documentation

◆ _alwaysBuildJacobian

bool precice::acceleration::IQNIMVJAcceleration::_alwaysBuildJacobian

private

If true, the less efficient method to compute the quasi-Newton update is used, that explicitly builds the Jacobian in each iteration. If set to false this is only done in the very last iteration and the update is computed based on MATVEC products.

Definition at line 112 of file IQNIMVJAcceleration.hpp.

◆ _avgRank

double precice::acceleration::IQNIMVJAcceleration::_avgRank

private

Definition at line 139 of file IQNIMVJAcceleration.hpp.

◆ _chunkSize

int precice::acceleration::IQNIMVJAcceleration::_chunkSize

private

: Number of time windows between restarts for the imvj method in restart mode

Definition at line 129 of file IQNIMVJAcceleration.hpp.

◆ _imvjRestart

bool precice::acceleration::IQNIMVJAcceleration::_imvjRestart

private

: If true, the imvj method is used with the restart chunk based approach that avoids to explicitly build and store the Jacobian. If false, the Jacobian is stored and build, however, no truncation of information is present.

Definition at line 126 of file IQNIMVJAcceleration.hpp.

◆ _imvjRestartType

int precice::acceleration::IQNIMVJAcceleration::_imvjRestartType

private

: Indicates the type of the imvj restart-mode:

NO_RESTART: imvj is run on normal mode which builds the Jacobian explicitly
RS-ZERO: imvj is run in restart-mode. After M time windows all stored matrices are dropped
RS-LS: imvj in restart-mode. After M time windows restart with LS approximation for initial Jacobian
RS-SVD: imvj in restart mode. After M time windows, update of an truncated SVD of the Jacobian.

Definition at line 120 of file IQNIMVJAcceleration.hpp.

◆ _invJacobian

Eigen::MatrixXd precice::acceleration::IQNIMVJAcceleration::_invJacobian

private

stores the approximation of the inverse Jacobian of the system at current time window.

Definition at line 79 of file IQNIMVJAcceleration.hpp.

◆ _matrixCols_RSLS

std::deque<int> precice::acceleration::IQNIMVJAcceleration::_matrixCols_RSLS

private

number of cols per time window

Definition at line 100 of file IQNIMVJAcceleration.hpp.

◆ _matrixV_RSLS

Eigen::MatrixXd precice::acceleration::IQNIMVJAcceleration::_matrixV_RSLS

private

stores columns from previous _RSLSreusedTimeWindows time windows if RS-LS restart-mode is active

Definition at line 94 of file IQNIMVJAcceleration.hpp.

◆ _matrixW_RSLS

Eigen::MatrixXd precice::acceleration::IQNIMVJAcceleration::_matrixW_RSLS

private

stores columns from previous _RSLSreusedTimeWindows time windows if RS-LS restart-mode is active

Definition at line 97 of file IQNIMVJAcceleration.hpp.

◆ _nbRestarts

int precice::acceleration::IQNIMVJAcceleration::_nbRestarts

private

tracks the number of restarts of IMVJ

Definition at line 135 of file IQNIMVJAcceleration.hpp.

◆ _oldInvJacobian

Eigen::MatrixXd precice::acceleration::IQNIMVJAcceleration::_oldInvJacobian

private

stores the approximation of the inverse Jacobian from the previous time window.

Definition at line 82 of file IQNIMVJAcceleration.hpp.

◆ _parMatrixOps

impl::PtrParMatrixOps precice::acceleration::IQNIMVJAcceleration::_parMatrixOps

private

encapsulates matrix-matrix and matrix-vector multiplications for serial and parallel execution

Definition at line 103 of file IQNIMVJAcceleration.hpp.

◆ _pseudoInverseChunk

std::vector<Eigen::MatrixXd> precice::acceleration::IQNIMVJAcceleration::_pseudoInverseChunk

private

stores all pseudo inverses within the current chunk of the imvj restart mode, disabled if _imvjRestart = false.

Definition at line 91 of file IQNIMVJAcceleration.hpp.

◆ _RSLSreusedTimeWindows

int precice::acceleration::IQNIMVJAcceleration::_RSLSreusedTimeWindows

private

: Number of reused time windows at restart if restart-mode = RS-LS

Definition at line 132 of file IQNIMVJAcceleration.hpp.

◆ _svdJ

impl::SVDFactorization precice::acceleration::IQNIMVJAcceleration::_svdJ

private

holds and maintains a truncated SVD decomposition of the Jacobian matrix

Definition at line 106 of file IQNIMVJAcceleration.hpp.

◆ _Wtil

Eigen::MatrixXd precice::acceleration::IQNIMVJAcceleration::_Wtil

private

stores the sub result (W-J_prev*V) for the current iteration

Definition at line 85 of file IQNIMVJAcceleration.hpp.

◆ _WtilChunk

std::vector<Eigen::MatrixXd> precice::acceleration::IQNIMVJAcceleration::_WtilChunk

private

stores all Wtil matrices within the current chunk of the imvj restart mode, disabled if _imvjRestart = false.

Definition at line 88 of file IQNIMVJAcceleration.hpp.

◆ NO_RESTART

const int precice::acceleration::IQNIMVJAcceleration::NO_RESTART = 0

static

Definition at line 35 of file IQNIMVJAcceleration.hpp.

◆ RS_LS

const int precice::acceleration::IQNIMVJAcceleration::RS_LS = 2

static

Definition at line 37 of file IQNIMVJAcceleration.hpp.

◆ RS_SLIDE

const int precice::acceleration::IQNIMVJAcceleration::RS_SLIDE = 4

static

Definition at line 39 of file IQNIMVJAcceleration.hpp.

◆ RS_SVD

const int precice::acceleration::IQNIMVJAcceleration::RS_SVD = 3

static

Definition at line 38 of file IQNIMVJAcceleration.hpp.

◆ RS_ZERO

const int precice::acceleration::IQNIMVJAcceleration::RS_ZERO = 1

static

Definition at line 36 of file IQNIMVJAcceleration.hpp.

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

src/acceleration/IQNIMVJAcceleration.hpp
src/acceleration/IQNIMVJAcceleration.cpp

Public Member Functions

Static Public Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ IQNIMVJAcceleration()

◆ ~IQNIMVJAcceleration()

Member Function Documentation

◆ buildJacobian()

◆ buildWtil()

◆ computeNewtonUpdate()

◆ computeNewtonUpdateEfficient()

◆ computeQNUpdate()

◆ computeUnderrelaxationSecondaryData()

◆ initialize()

◆ pseudoInverse()

◆ removeMatrixColumn()

◆ removeMatrixColumnRSLS()

◆ restartIMVJ()

◆ specializedIterationsConverged()

◆ updateDifferenceMatrices()

Member Data Documentation

◆ _alwaysBuildJacobian

◆ _avgRank

◆ _chunkSize

◆ _imvjRestart

◆ _imvjRestartType

◆ _invJacobian

◆ _matrixCols_RSLS

◆ _matrixV_RSLS

◆ _matrixW_RSLS

◆ _nbRestarts

◆ _oldInvJacobian

◆ _parMatrixOps

◆ _pseudoInverseChunk

◆ _RSLSreusedTimeWindows

◆ _svdJ

◆ _Wtil

◆ _WtilChunk

◆ NO_RESTART

◆ RS_LS

◆ RS_SLIDE

◆ RS_SVD

◆ RS_ZERO