TPZCompElLagrange.h

Go to the documentation of this file.

//
//  TPZCompElLagrange.h
//  PZ
//
//  Created by Philippe Devloo on 11/2/13.
//
//

#ifndef __PZ__TPZCompElLagrange__
#define __PZ__TPZCompElLagrange__

#include <iostream>

#include "pzcompel.h"
#include "pzcmesh.h"

class TPZCompElLagrange : public TPZCompEl
{
    
public:
    
    struct TLagrange
    {
        int64_t fConnect[2];
        int fIdf[2];
        
        TLagrange()
        {
            fConnect[0] = -1;
            fConnect[1] = -1;
            fIdf[0] = -1;
            fIdf[1] = -1;
        }
    };
    
private:
    
    TPZManVector<TLagrange,3> fDef;
    
public:
    
    TPZCompElLagrange() : TPZRegisterClassId(&TPZCompElLagrange::ClassId),
    TPZCompEl(), fDef()
    {
    }
    
    TPZCompElLagrange(const TPZCompElLagrange &copy) : TPZRegisterClassId(&TPZCompElLagrange::ClassId),
    TPZCompEl(copy)
    {
        fDef = copy.fDef;
        
    }
    
    TPZCompElLagrange(TPZCompMesh &mesh, int64_t connect1, int idf1, int64_t connect2, int idf2, int64_t &index) : TPZRegisterClassId(&TPZCompElLagrange::ClassId),
    TPZCompEl(mesh,0,index), fDef(1)
    {
        fDef[0].fConnect[0] = connect1;
        fDef[0].fConnect[1] = connect2;
        fDef[0].fIdf[0] = idf1;
        fDef[0].fIdf[1] = idf2;
        mesh.ConnectVec()[connect1].IncrementElConnected();
        mesh.ConnectVec()[connect2].IncrementElConnected();
#ifdef PZDEBUG
        TPZConnect &c1 = mesh.ConnectVec()[connect1];
        TPZConnect &c2 = mesh.ConnectVec()[connect2];
        if (idf1 >= c1.NShape()*c1.NState()) {
            DebugStop();
        }
        if (idf2 >= c2.NShape()*c2.NState()) {
            DebugStop();
        }
#endif
    }
    
    TPZCompElLagrange(TPZCompMesh &mesh, const TPZVec<TLagrange> &Dependencies, int64_t &index) : TPZRegisterClassId(&TPZCompElLagrange::ClassId),
    TPZCompEl(mesh,0,index), fDef(Dependencies)
    {
    }
    
                TPZCompElLagrange(TPZCompMesh &mesh, const TPZCompEl &copy) : TPZRegisterClassId(&TPZCompElLagrange::ClassId),
    TPZCompEl(mesh,copy)
    {
        const TPZCompElLagrange *lcop = dynamic_cast<const TPZCompElLagrange *>(&copy);
        if (!lcop) {
            DebugStop();
        }
        fDef = lcop->fDef;
    }
                
                TPZCompElLagrange(TPZCompMesh &mesh, const TPZCompEl &copy, std::map<int64_t,int64_t> &gl2lcElMap) : TPZRegisterClassId(&TPZCompElLagrange::ClassId),
    TPZCompEl(mesh,copy,gl2lcElMap)
    {
        const TPZCompElLagrange *lcop = dynamic_cast<const TPZCompElLagrange *>(&copy);
        if (!lcop) {
            DebugStop();
        }
        fDef = lcop->fDef;
        
    }
                
                TPZCompElLagrange(TPZCompMesh &mesh, const TPZCompEl &copy, int64_t &index) : TPZRegisterClassId(&TPZCompElLagrange::ClassId),
    TPZCompEl(mesh,copy,index)
    {
        const TPZCompElLagrange *lcop = dynamic_cast<const TPZCompElLagrange *>(&copy);
        if (!lcop) {
            DebugStop();
        }
        fDef = lcop->fDef;
        
    }
    
    virtual ~TPZCompElLagrange();
                
                virtual TPZCompEl *Clone(TPZCompMesh &mesh) const override
    {
        return new TPZCompElLagrange(mesh,*this);
    }
                
                virtual TPZCompEl *ClonePatchEl(TPZCompMesh &mesh,
                                                                                                                                                std::map<int64_t,int64_t> & gl2lcConMap,
                                                                                                                                                std::map<int64_t,int64_t> & gl2lcElMap) const override;

                virtual int NConnects() const override
    {
        return 2*fDef.size();
    }
                
                virtual int64_t ConnectIndex(int i) const override
    {
        if (i>=0 && i < 2*fDef.size()) {
            return fDef[i/2].fConnect[i%2];
        }
        DebugStop();
        return -1;
    }
                
                virtual int Dimension() const override
    {
        return 0;
    }
    
    void CreateGraphicalElement(TPZGraphMesh &, int) override
    {
    }
    
    void EvaluateError(std::function<void(const TPZVec<REAL> &loc,TPZVec<STATE> &val,TPZFMatrix<STATE> &deriv)> fp,
                                  TPZVec<REAL> &/*errors*/, bool store_error) override {
        return;
    }


                
    virtual void BuildCornerConnectList(std::set<int64_t> &connectindexes) const override
    {
        for (int64_t i=0; i<fDef.size(); i++) {
            connectindexes.insert(fDef[i].fConnect[0]);
            connectindexes.insert(fDef[i].fConnect[1]);
        }
    }
    
                virtual void SetConnectIndex(int inode, int64_t index) override
    {
        if (inode >= 0 && inode < 2*fDef.size()) {
            fDef[inode/2].fConnect[inode%2] = index;
        }
        else
        {
            DebugStop();
        }
    }
                
                virtual void CalcStiff(TPZElementMatrix &ek,TPZElementMatrix &ef) override;
                
                //virtual void CalcResidual(TPZElementMatrix &ef);
                
    void InitializeElementMatrix(TPZElementMatrix &ek, TPZElementMatrix &ef);
    public:
int ClassId() const override;


};

#endif /* defined(__PZ__TPZCompElLagrange__) */