tpzdohrsubstructCondense.h

Go to the documentation of this file.

#ifndef TPZDOHRSUBSTRUCTCONDENSE_H
#define TPZDOHRSUBSTRUCTCONDENSE_H

#include "pzfmatrix.h"
#include "tpzautopointer.h"
#include "pzstepsolver.h"
#include "pzysmp.h"
#include "pzmatred.h"
#include "TPZSavable.h"

template<class TVar>
class TPZDohrSubstructCondense : public TPZSavable
{
                public:
            
            public:
int ClassId() const override;

            
                                TPZDohrSubstructCondense();

                                ~TPZDohrSubstructCondense();

                                enum EWeightType {CorrectWeight, Uniform};

                                enum ENumbering {Submesh, InternalFirst, ExternalFirst};

                                static EWeightType fWeightType;

                                int NumEquations()
                                {
                                                return fNumExternalEquations;
                                }

                                void AdjustResidual(TPZFMatrix<TVar> &r_global);
                                void Contribute_rc_local(TPZFMatrix<TVar> &residual_local, TPZFMatrix<TVar> &rc_local) const;
                                void Contribute_Kc(TPZMatrix<TVar> &Kc, TPZVec<int> &coarseindex);
                                void Contribute_v1_local(TPZFMatrix<TVar> &v1_local, TPZFMatrix<TVar> &invKc_rc) const;
                                void Contribute_v2_local(TPZFMatrix<TVar> &residual_local, TPZFMatrix<TVar> &v2_local);
                                void Contribute_v3_local(TPZFMatrix<TVar> &v3, TPZFMatrix<TVar> &v1Plusv2) const;
                                void Print(std::ostream &out) const;

                                void ContributeKULocal(const TVar alpha, const TPZFMatrix<TVar> &u, TPZFMatrix<TVar> &z) const;
                                void ContributeDiagonalLocal(TPZFMatrix<TVar> &StiffnessDiag);
                                void ComputeWeightsLocal(TPZFMatrix<TVar> &StiffnessDiagLocal);
                                void ContributeRhs(TPZFMatrix<TVar> &rhs);
                                void UGlobal(TPZFMatrix<TVar> &Uext, TPZFMatrix<TVar> &UGlobal);
                                void Initialize();

                                void GetCoarseResidual(TPZFMatrix<TVar> &rc, TPZVec<int> &indices);

                                void GetCoarseStiffness(TPZMatrix<TVar> &stiff, TPZVec<int> &indices);

                                static void PermuteScatter(const TPZVec<int> &permute, const TPZFMatrix<TVar> &input, TPZFMatrix<TVar> &output, int first, int last);
                                static void PermuteGather(const TPZVec<int> &permute, const TPZFMatrix<TVar> &input, TPZFMatrix<TVar> &output, int first, int last);

                                void Write(TPZStream &buf, int withclassid) const override;

                                void Read(TPZStream &input, void *context) override;

                public:
                                void PrepareSystems();
                                void SolveSystemPhi();
                                void AddInternalSolution(TPZFMatrix<TVar> &sol);

                                TPZAutoPointer<TPZMatRed<TVar, TPZFMatrix<TVar> > > fMatRedComplete;
                                int fNEquations; 

                                int fNumInternalEquations;

                                int fNumExternalEquations;
                                TPZVec<int> fCoarseNodes;

                                TPZFMatrix<TVar> fPhiC; //Phí(i)
                                TPZFMatrix<TVar> fPhiC_Weighted_Condensed;

                                TPZManVector<TVar> fWeights; //W(i) = diagonal(fWeights)
                                TPZFMatrix<TVar> fKCi; //K(ci)

                                std::map<std::pair<ENumbering, ENumbering> , TPZVec<int> > fPermutationsScatter;

                                bool wasRealloc;

                                void ReallocMatRed() 
                                {
                                                if(!wasRealloc) {
                                                                std::cout << "TPZDohrSubstructCondense::ReallocMatRed\n";
                                                                fMatRed.ReallocForNuma(0);
                fMatRed->ReallocSolver();
                                                                fMatRedComplete.ReallocForNuma(0);
                
                                                                wasRealloc = true;
                                                }
                                }

                                TPZVec<int> &GatherVec(ENumbering origin, ENumbering destination)
                                {
                                                return fPermutationsScatter[std::pair<ENumbering,ENumbering>(destination,origin)];
                                }

                                TPZVec<int> &ScatterVec(ENumbering origin, ENumbering destination)
                                {
                                                return fPermutationsScatter[std::pair<ENumbering,ENumbering>(origin,destination)];
                                }

                                const TPZVec<int> &GatherVec(ENumbering origin, ENumbering destination) const;

                                const TPZVec<int> &ScatterVec(ENumbering origin, ENumbering destination) const;

                                mutable TPZAutoPointer<TPZMatRed<TVar, TPZFMatrix<TVar> > > fMatRed; //R(Ii)*K(i)*R(Ii)invertida
                                TPZFMatrix<TVar> fLocalLoad; //F(i) - Actually it's a vector
                                TPZFMatrix<TVar> fLocalWeightedResidual; //W(i)*R(i)*r - Actually it's a vector

                                TPZFMatrix<TVar> fAdjustSolution;
};

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

#endif