pzsolve.h

Go to the documentation of this file.

#ifndef TPREH
#define TPREH

#include "pzfmatrix.h"

template<class TVar>
class TPZMatrixSolver;

template<class TVar>
class TPZSolver: public TPZSavable
{

public:
    
    public:
int ClassId() const override;

                virtual void Solve(const TPZFMatrix<TVar> &F, TPZFMatrix<TVar> &result,
                                                                                   TPZFMatrix<TVar>  *residual = 0) = 0;
    
    virtual void Decompose()
    {
    }
                
                virtual TPZSolver *Clone() const = 0;
                virtual ~TPZSolver();
                
                virtual void ResetMatrix()
                {
                }
                virtual void UpdateFrom(TPZAutoPointer<TPZMatrix<TVar> > matrix)
                {
                                std::cout << __PRETTY_FUNCTION__ << " called\n";
                }

};


template<class TVar>
int TPZSolver<TVar>::ClassId() const{
    return Hash("TPZSolver") ^ ClassIdOrHash<TVar>() << 1;
}

#define TPZMATRIXSOLVER_ID 28291005;


template<class TVar>
class TPZMatrixSolver: public TPZSolver<TVar>
{
                
public:
                enum MSolver
                {
                                ENoSolver, EJacobi, ESOR, ESSOR, ECG, EGMRES, EBICGSTAB, EDirect, EMultiply
                };

                TPZMatrixSolver(TPZAutoPointer<TPZMatrix<TVar> >  Refmat);
                
                TPZMatrixSolver();
                
                TPZMatrixSolver(const TPZMatrixSolver<TVar> &Source);
                
                virtual ~TPZMatrixSolver();
                
                virtual void SetMatrix(TPZAutoPointer<TPZMatrix<TVar> > Refmat)
    {
        fContainer = Refmat;
    }
                
                virtual void UpdateFrom(TPZAutoPointer<TPZMatrix<TVar> > matrix) override
                {
                                if (fReferenceMatrix == matrix && matrix)
                                {
                                                if(this->fContainer) this->fContainer->UpdateFrom(matrix);
                                }
                }
                void ResetMatrix() override;
                
                virtual void SetReferenceMatrix(TPZAutoPointer<TPZMatrix<TVar> > matrix)
                {
                                fReferenceMatrix = matrix;
                }
                
                TPZAutoPointer<TPZMatrix<TVar> > Matrix() const
                {
                                return fContainer;
                }
                
    void ReallocMatrix() {
        fContainer.ReallocForNuma(0);
    }
    
                void ShareMatrix(TPZMatrixSolver<TVar> & other);
                
    virtual MSolver Solver()
    {
        return ENoSolver;
    }

protected:
                
private:
                TPZAutoPointer<TPZMatrix<TVar> > fContainer;
protected:
                TPZAutoPointer<TPZMatrix<TVar> > fReferenceMatrix;

protected:
                TPZFMatrix<TVar>  fScratch;
public:
                public:
int ClassId() const override;

                void Write(TPZStream &buf, int withclassid) const override;
                void Read(TPZStream &buf, void *context) override;
};

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

#endif  // TPREH