convergence_accelerator.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Ruben Zorrilla
//                   Philipp Bucher
//
//
 
#if !defined(KRATOS_CONVERGENCE_ACCELERATOR )
#define  KRATOS_CONVERGENCE_ACCELERATOR
 
// System includes
 
// External includes
 
// Project includes
#include "includes/define.h"
#include "includes/kratos_parameters.h"
 
namespace Kratos
{
 
 
 
template<class TSparseSpace, class TDenseSpace>
class ConvergenceAccelerator
{
 
public:
 
 
    typedef typename TSparseSpace::VectorType                             VectorType;
    typedef typename TSparseSpace::MatrixType                             MatrixType;
 
    typedef typename TSparseSpace::VectorPointerType               VectorPointerType;
    typedef typename TSparseSpace::MatrixPointerType               MatrixPointerType;
 
    typedef typename TDenseSpace::VectorType                         DenseVectorType;
    typedef typename TDenseSpace::MatrixType                         DenseMatrixType;
 
    typedef typename TDenseSpace::MatrixPointerType           DenseMatrixPointerType;
    typedef typename TDenseSpace::VectorPointerType           DenseVectorPointerType;
 
    // Counted pointer of ConvergenceAccelerator
    KRATOS_CLASS_POINTER_DEFINITION(ConvergenceAccelerator);
 
 
    // Default constructor
    ConvergenceAccelerator() = default;
 
    // Constructor with Parameters
    ConvergenceAccelerator(Parameters ThisParameters) {}
 
    // Deleted copy constructor
    ConvergenceAccelerator(const ConvergenceAccelerator& Other) = delete;
 
    // Default destructor
    virtual ~ConvergenceAccelerator() = default;
 
 
    virtual void Initialize()
    {
    }
 
    virtual void InitializeSolutionStep()
    {
    }
 
    virtual void InitializeNonLinearIteration()
    {
    }
 
    virtual void UpdateSolution(
        const VectorType& rResidualVector,
        VectorType& rIterationGuess)
    {
    }
 
    virtual void FinalizeNonLinearIteration()
    {
    }
 
    virtual void FinalizeSolutionStep()
    {
    }
 
    virtual void Finalize()
    {
    }
 
    virtual void Clear()
    {
    }
 
    virtual void SetEchoLevel(int Level)
    {
        mEchoLevel = Level;
    }
 
    int GetEchoLevel()
    {
        return mEchoLevel;
    }
 
    virtual bool IsBlockNewton() const
    {
        return false;
    }
 
protected:
 
    // Level of echo for the convergence accelerator
    int mEchoLevel;
 
 
    virtual void ComputeJacobianApproximation()
    {
        KRATOS_ERROR << "Interface Jacobian approximation cannot be computed with this convergence accelerator." << std::endl;
    }
 
    virtual DenseMatrixPointerType pGetInverseJacobianApproximation()
    {
        KRATOS_ERROR << "Interface Jacobian approximation is not available for this convergence accelerator." << std::endl;
    }
 
    virtual std::size_t GetProblemSize() const
    {
        KRATOS_ERROR << "Problem size is not available for this convergence accelerator." << std::endl;
    }
 
}; // Class ConvergenceAccelerator
 
 
} 
 
#endif // KRATOS_CONVERGENCE_ACCELERATOR  defined