pzcondensedcompel.h

Go to the documentation of this file.

#ifndef TPZCONDENSEDCOMPELH
#define TPZCONDENSEDCOMPELH

#include "pzcompel.h"
#include "pzmatred.h"
#include "pzmanvector.h"
#include "pzelmat.h"

#ifdef USING_BLAS
//#define USING_DGER
#ifdef USING_MKL
#include <mkl.h>
#elif MACOSX
#include <Accelerate/Accelerate.h>
#else
#include "cblas.h"
#endif
#endif



class TPZCondensedCompEl : public TPZCompEl
{

    //TPZMatRed<REAL, TPZFMatrix<REAL> > fCondensed;
    int64_t fNumInternalEqs = 0;
    int64_t fNumTotalEqs = 0;
                TPZMatRed<STATE, TPZFMatrix<STATE> > fCondensed;
    TPZCompEl *fReferenceCompEl;
    TPZManVector<int64_t,27> fIndexes; 
    bool fKeepMatrix = true;
    void Resequence();

public:
    
    TPZCondensedCompEl(TPZCompEl *ref, bool keepmatrix = true);
    
    TPZCondensedCompEl(const TPZCondensedCompEl &copy, TPZCompMesh &mesh);
    
    virtual ~TPZCondensedCompEl();

                virtual void Print(std::ostream &out = std::cout) const override;

    void Unwrap();
    
                virtual void SetConnectIndex(int inode, int64_t index) override;
    
                virtual int NConnects() const override 
    {
        return fReferenceCompEl->NConnects();
    }
                
                virtual int64_t ConnectIndex(int i) const override 
    {
        return fReferenceCompEl->ConnectIndex(fIndexes[i]);
    }

    TPZCompEl * ReferenceCompEl(){
        return fReferenceCompEl;
    }
    
    virtual bool NeedsComputing(const std::set<int> &materialids) override
    {
        if(fReferenceCompEl)
        {
            return fReferenceCompEl->NeedsComputing(materialids);
        }
        else
        {
            return false;
        }
    }

    
    virtual void LoadElementReference() override
    {
        if(fReferenceCompEl)
        {
            fReferenceCompEl->LoadElementReference();
        }
    }

    virtual void BuildCornerConnectList(std::set<int64_t> &connectindexes) const override;
                
    void SetKeepMatrix(bool keep)
    {
        fKeepMatrix = keep;
    }
    
                virtual int Dimension() const override
    {
        return fReferenceCompEl->Dimension();
    }
                virtual TPZCompEl *Clone(TPZCompMesh &mesh) const override
    {
        return new TPZCondensedCompEl(*this,mesh);
    }

                virtual void LoadSolution() override;
    
    virtual void TransferMultiphysicsElementSolution() override
    {
        if(fReferenceCompEl)
        {
            fReferenceCompEl->TransferMultiphysicsElementSolution();
        }
    }


                virtual TPZCompEl *ClonePatchEl(TPZCompMesh &mesh,
                                                                                                                                                std::map<int64_t,int64_t> & gl2lcConMap,
                                                                                                                                                std::map<int64_t,int64_t> & gl2lcElMap) const override;

private:
                virtual void ComputeSolution(TPZVec<REAL> &qsi,
                                                                                                                                 TPZSolVec &sol, TPZGradSolVec &dsol,TPZFMatrix<REAL> &axes) override;
    
public:
    virtual void ComputeSolution(TPZVec<REAL> &qsi, TPZMaterialData &data) override ;
    
    virtual TPZVec<STATE> IntegrateSolution(const std::string &varname, const std::set<int> &matids) override
    {
        return fReferenceCompEl->IntegrateSolution(varname, matids);
    }
    virtual TPZVec<STATE> IntegrateSolution(int var) const override
    {
        return fReferenceCompEl->IntegrateSolution(var);
    }
                virtual void ComputeSolution(TPZVec<REAL> &qsi,
                                                                                                                                 TPZVec<REAL> &normal,
                                                                                                                                 TPZSolVec &leftsol, TPZGradSolVec &dleftsol,TPZFMatrix<REAL> &leftaxes,
                                                                                                                                 TPZSolVec &rightsol, TPZGradSolVec &drightsol,TPZFMatrix<REAL> &rightaxes) override;
                
                virtual void ComputeSolution(TPZVec<REAL> &qsi, TPZFMatrix<REAL> &phi, TPZFMatrix<REAL> &dphix,
                                                                                                                                 const TPZFMatrix<REAL> &axes, TPZSolVec &sol, TPZGradSolVec &dsol) override;

    virtual void Assemble() override;
                virtual void CalcStiff(TPZElementMatrix &ek,TPZElementMatrix &ef) override;
                
                
                virtual void CalcResidual(TPZElementMatrix &ef) override;
    
    virtual bool HasMaterial(const std::set<int> &materialids) const override;
    
    void EvaluateError(std::function<void(const TPZVec<REAL> &loc,TPZVec<STATE> &val,TPZFMatrix<STATE> &deriv)> func,
                                  TPZVec<REAL> &errors, bool store_errors) override {
        fReferenceCompEl->EvaluateError(func, errors, store_errors);
    }
    
                virtual void CreateGraphicalElement(TPZGraphMesh & graphmesh, int dimension) override
    {
        fReferenceCompEl->CreateGraphicalElement(graphmesh, dimension);
    }
    

    int ComputeIntegrationOrder() const override {
        std::cout << "This method should not be called. " << __PRETTY_FUNCTION__ << std::endl;
        DebugStop();
                                return 0;
    }

virtual int ClassId() const override;


};

#endif