pzmatred.h

Go to the documentation of this file.

#ifndef _TMATREDHH_
#define _TMATREDHH_

//#include "tintvec.h"
#include "pzmatrix.h"
#include "pzreal.h"
#include "pzfmatrix.h"
#include "pzsolve.h"

template<class TVar>
class TPZVerySparseMatrix;

#ifdef OOPARLIB
#include "pzsaveable.h"
#include "pzmatdefs.h"
#endif

template<class TVar, class TSideMatrix >
class TPZMatRed: public TPZMatrix<TVar>
{
public:
                
                friend class TPZMatRed<TVar, TPZFMatrix<TVar> >;
                friend class TPZMatRed<TVar ,TPZVerySparseMatrix<TVar> >;
                TPZMatRed();
                
                TPZMatRed(const int64_t dim, const int64_t dim00);
                
                template<class TSideCopy>
                TPZMatRed<TVar ,TSideMatrix>(const TPZMatRed<TVar, TSideCopy> &cp): TPZMatrix<TVar>(cp), fK11(cp.fK11), fK01(cp.fK01), fK10(cp.fK10), fF0(cp.fF0), fF1(cp.fF1),fMaxRigidBodyModes(cp.fMaxRigidBodyModes),fNumberRigidBodyModes(cp.fNumberRigidBodyModes), fF0IsComputed(cp.fF0IsComputed)
                {
                                fDim0=cp.fDim0;
                                fDim1=cp.fDim1;
                                fK01IsComputed = cp.fK01IsComputed;
                                fIsReduced = cp.fIsReduced;
                                fSolver = cp.fSolver;
                                
                                if(cp.fK00) fK00 = cp.fK00;
                }
                
                CLONEDEF(TPZMatRed)
                ~TPZMatRed();
                
                virtual int IsSimetric() const override;
                
                void SetReduced()
                {
                                TPZMatrix<TVar>::Resize(fDim1, fDim1);
                                fIsReduced = 1;
                }
                
    void ReallocSolver() {
        fSolver->ReallocMatrix();
    }
                virtual int PutVal(const int64_t row, const int64_t col, const TVar& value) override;
                virtual const TVar &GetVal(const int64_t row, const int64_t col) const override;
                virtual TVar &s(const int64_t row, const int64_t col) override;
                
                virtual int Zero() override;
                
                void SetK00(TPZAutoPointer<TPZMatrix<TVar> > K00);
    
    void SetK01IsComputed (bool directive)
    {
        fK01IsComputed = directive;
    }
    
    void SetF0IsComputed (bool directive)
    {
        fF0IsComputed = directive;
    }
                
                TPZAutoPointer<TPZMatrix<TVar> > K00()
                {
                                return fK00;
                }
                TSideMatrix &K01()
                {
                                return fK01;
                }
                TSideMatrix &K10()
                {
                                return fK10;
                }
    
    TPZFMatrix<TVar> &K11()
    {
        return fK11;
    }
    
    TPZFMatrix<TVar> &F1()
    {
        return fF1;
    }
    
    TPZFMatrix<TVar> &F0()
    {
        return fF0;
    }
    
    int64_t Dim0()
    {
        return fDim0;
    }
    
    int64_t Dim1()
    {
        return fDim1;
    }
    
                void SetSolver(TPZAutoPointer<TPZMatrixSolver<TVar> > solver);
    TPZAutoPointer<TPZMatrixSolver<TVar> > Solver()
    {
        return fSolver;
    }
                void SetF(const TPZFMatrix<TVar> & F);
    
    void SetMaxNumberRigidBodyModes(int maxrigid)
    {
        fMaxRigidBodyModes = maxrigid;
    }
    
    int NumberRigidBodyModes()
    {
        return fNumberRigidBodyModes;
    }
                
                
                void F1Red(TPZFMatrix<TVar> &F1);
                
                void K11Reduced(TPZFMatrix<TVar> &K11, TPZFMatrix<TVar> &F1);
                
                void U1(TPZFMatrix<TVar> & F);
                
                void UGlobal(const TPZFMatrix<TVar> & U1, TPZFMatrix<TVar> & result);
                void UGlobal2(TPZFMatrix<TVar> & U1, TPZFMatrix<TVar> & result);                
                
                void Print(const char *name = NULL, std::ostream &out = std::cout,
                                                   const MatrixOutputFormat = EFormatted) const override;
                
                int Redim(const int64_t dim,const int64_t dim00) override; //Cesar 19/12/00
                
                void MultAdd(const TPZFMatrix<TVar> &x, const TPZFMatrix<TVar> &y, TPZFMatrix<TVar> &z,
                                                                 const TVar alpha, const TVar beta, const int opt) const override;
                
                void SimetrizeMatRed();
                
                public:
int ClassId() const override;

                
                void Write(TPZStream &buf, int withclassid) const override;
                void Read(TPZStream &buf, void *context) override;
                
private:
                
                static void Swap(int64_t *row, int64_t *col);
    
    void DecomposeK00();
                
                TPZAutoPointer<TPZMatrix<TVar> > fK00;
                
                TPZAutoPointer<TPZMatrixSolver<TVar> > fSolver;
                
                TPZFMatrix<TVar> fK11;
    
                TSideMatrix fK01, fK10;
                
                TPZFMatrix<TVar> fF0, fF1;

                int64_t fDim0, fDim1;
                
                bool fIsReduced;
                
                bool fK01IsComputed = false;
                
    bool fF0IsComputed = false;
    
    int fMaxRigidBodyModes;
    
    int fNumberRigidBodyModes;
};

template<class TVar, class TSideMatrix>
int TPZMatRed<TVar,TSideMatrix>::ClassId() const{
    return Hash("TPZMatRed") ^ TPZMatrix<TVar>::ClassId() << 1 ^ TSideMatrix().ClassId() << 2;
}

/************/
/*** Swap ***/
/* @note Modificacao por Philippe Devloo (insercao de inline )*/
template<class TVar, class TSideMatrix>
inline void TPZMatRed<TVar, TSideMatrix>::Swap(int64_t *a, int64_t *b)
{
                int64_t aux = *a;
                *a = *b;
                *b = aux;
}

#endif