TPZStructMatrixBase.h

Go to the documentation of this file.

#ifndef TPZSTRUCTMATRIXBASE_H
#define TPZSTRUCTMATRIXBASE_H

#include "TPZEquationFilter.h"
#include "tpzautopointer.h"

class TPZCompMesh;

template <class T> class TPZMatrix;

template <class T> class TPZFMatrix;

class TPZGuiInterface;

class TPZStructMatrixBase : public TPZSavable {
public:
    virtual void SetMesh(TPZCompMesh *);

    virtual void SetMesh(TPZAutoPointer<TPZCompMesh>);

    virtual TPZStructMatrixBase *Clone() = 0;

    virtual TPZMatrix<STATE> * Create() = 0;

    virtual void Assemble(TPZMatrix<STATE> &stiffness, TPZFMatrix<STATE> &rhs,
                          TPZAutoPointer<TPZGuiInterface> guiInterface) = 0;

    virtual void Assemble(TPZFMatrix<STATE> &rhs,
                          TPZAutoPointer<TPZGuiInterface> guiInterface) = 0;

    virtual TPZMatrix<STATE> *
    CreateAssemble(TPZFMatrix<STATE> &rhs,
                   TPZAutoPointer<TPZGuiInterface> guiInterface);

    virtual void FilterEquations(TPZVec<int64_t> &origindex, TPZVec<int64_t> &destindex) const;
    
    virtual void SetMaterialIds(const std::set<int> &materialids);

    inline virtual void SetNumThreads(int n) {
        this->fNumThreads = n;
    }

    inline virtual int GetNumThreads() const {
        return this->fNumThreads;
    }

    inline virtual void SetEquationRange(int64_t mineq, int64_t maxeq) {
        fEquationFilter.Reset();
        fEquationFilter.SetMinMaxEq(mineq, maxeq);
    }

    inline virtual bool HasRange() const {
        return fEquationFilter.IsActive();
    }

    inline virtual TPZEquationFilter &EquationFilter() {
        return fEquationFilter;
    }

    inline virtual int64_t NReducedEquations() const {
        return fEquationFilter.NActiveEquations();
    }

    inline virtual TPZCompMesh *Mesh() const {
        return fMesh;
    }
    
    virtual bool ShouldCompute(int matid) const
    {
        const unsigned int size = fMaterialIds.size();
        return size == 0 || fMaterialIds.find(matid) != fMaterialIds.end();
    }
    virtual const std::set<int> &MaterialIds()
    {
        return fMaterialIds;
    }
    
    public:
    int ClassId() const override;
    void Read(TPZStream& buf, void* context) override;
    void Write(TPZStream& buf, int withclassid) const override;
    virtual ~TPZStructMatrixBase() {}
  protected:
    TPZStructMatrixBase();
    TPZStructMatrixBase(const TPZStructMatrixBase &);
    TPZStructMatrixBase(TPZCompMesh *);
    TPZStructMatrixBase(TPZAutoPointer<TPZCompMesh>);

  protected:
    TPZCompMesh *fMesh;
    TPZAutoPointer<TPZCompMesh> fCompMesh;
    TPZEquationFilter fEquationFilter;
    std::set<int> fMaterialIds;
    int fNumThreads;
};


#include "pzstrmatrix.h"
typedef TPZStructMatrixOR TPZStructMatrix;

//#include "pzstrmatrixst.h"
//typedef TPZStructMatrixST TPZStructMatrix;

//#include "pzstrmatrixcs.h"
//typedef TPZStructMatrixCS TPZStructMatrix;

//#include "pzstrmatrixgc.h"
//typedef TPZStructMatrixGC TPZStructMatrix;

//#include "pzstrmatrixot.h"
//typedef TPZStructMatrixOT TPZStructMatrix;

//#include "TPZStrMatrixGCTP.h"
//typedef TPZStructMatrixGCTP TPZStructMatrix;

//https://trac.macports.org/wiki/MigrationTBB
//#include "pzstrmatrixtbb.h"
//typedef TPZStructMatrixTBB TPZStructMatrix;

//#include "pzstrmatrixflowtbb.h"
//typedef TPZStructMatrixTBBFlow TPZStructMatrix;

#endif // TPZSTRUCTMATRIXBASE_H