pzstepsolver.h

Go to the documentation of this file.

#ifndef TPZSTEPSOLVER_H
#define TPZSTEPSOLVER_H
#include "pzsolve.h"

#include "pzfmatrix.h"

#include "TPZStream.h"

#include <list>

template<class TVar>
class TPZStepSolver: public TPZMatrixSolver<TVar>
{
public:
                TPZStepSolver(TPZAutoPointer<TPZMatrix<TVar> > refmat = 0);
                
                TPZStepSolver(const TPZStepSolver<TVar> & copy);
                
                virtual ~TPZStepSolver();
                
                void SetSOR(const int64_t numiterations, const REAL overrelax, const REAL tol, const int64_t FromCurrent);
                
                void SetSSOR(const int64_t numiterations, const REAL overrelax, const REAL tol, const int64_t FromCurrent);
                
                void SetJacobi(const int64_t numiterations, const REAL tol, const int64_t FromCurrent);
                
                void SetCG(const int64_t numiterations, const TPZMatrixSolver<TVar> &pre, const REAL tol, const int64_t FromCurrent);
                
                void SetGMRES(const int64_t numiterations, const int numvectors, const TPZMatrixSolver<TVar> &pre, const REAL tol, const int64_t FromCurrent);
                
                void SetBiCGStab(const int64_t numiterations, const TPZMatrixSolver<TVar> &pre, const REAL tol, const int64_t FromCurrent);
                
                void SetDirect(const DecomposeType decomp);
                
                void SetMultiply();
                
                virtual TPZSolver<TVar> *Clone() const override
                {
                                return new TPZStepSolver<TVar>(*this);
                }
                
                void SetTolerance(REAL tol)
                {
                                fTol = tol;
                }
    
    REAL GetTolerance() const
    {
        return fTol;
    }
                
                void ResetSolver();
    
    virtual typename TPZMatrixSolver<TVar>::MSolver Solver() override
    {
        return fSolver;
    }
                
                std::list<int64_t> &Singular()
                {
                                return fSingular;
                }
                
                virtual void ResetMatrix() override;

                virtual void UpdateFrom(TPZAutoPointer<TPZMatrix<TVar> > matrix) override
                {
                                if (fPrecond)
                                                fPrecond->UpdateFrom(matrix);
                                TPZMatrixSolver<TVar>::UpdateFrom(matrix);
                }
                
    
                void Solve(const TPZFMatrix<TVar> &F, TPZFMatrix<TVar> &result, TPZFMatrix<TVar> *residual = 0) override;
    
    virtual void Decompose() override;
    
                void SetPreconditioner(TPZSolver<TVar> &solve);
    
    int NumIterations()
    {
        return fNumIterations;
    }
    
    TPZSolver<TVar> *PreConditioner()
    {
        return fPrecond;
    }
                
                public:
    int ClassId() const override;

                void Write(TPZStream &buf, int withclassid) const override;
                void Read(TPZStream &buf, void *context) override;
                
                
private:
                typename TPZMatrixSolver<TVar>::MSolver fSolver;
                DecomposeType fDecompose;
    
    int64_t fMaxIterations;
    
                int64_t fNumIterations;
                int fNumVectors;
                REAL fTol;
                REAL fOverRelax;
                
                TPZSolver<TVar> *fPrecond;
                int64_t fFromCurrent;
                
                std::list<int64_t> fSingular;
};

template<class TVar>
int TPZStepSolver<TVar>::ClassId() const{
    return Hash("TPZStepSolver") ^ TPZMatrixSolver<TVar>::ClassId() << 1;
}
#endif