TPZMultiphysicsInterfaceEl.h

Go to the documentation of this file.

#ifndef TPZMULTIPHYSICSINTERFACEELH
#define TPZMULTIPHYSICSINTERFACEELH 

#include <iostream>

#include "pzcompel.h"
#include "pzmultiphysicselement.h"


class TPZMultiphysicsInterfaceElement : public TPZCompEl {

protected:

                TPZCompElSide   fLeftElSide;
                                
                TPZCompElSide   fRightElSide;
    
    TPZManVector<int64_t,20> fConnectIndexes;
    
    TPZManVector<int64_t,3> fLeftElIndices;
    
    TPZManVector<int64_t,3> fRightElIndices;
    
                
public:
                TPZMultiphysicsInterfaceElement();
                
                TPZMultiphysicsInterfaceElement(TPZCompMesh &mesh, TPZGeoEl *ref, int64_t &index, TPZCompElSide left, TPZCompElSide right);
    
    TPZMultiphysicsInterfaceElement(TPZCompMesh &mesh, const TPZMultiphysicsInterfaceElement &copy);
    
    TPZMultiphysicsInterfaceElement(TPZCompMesh &mesh, const TPZMultiphysicsInterfaceElement &copy, std::map<int64_t,int64_t> & gl2lcConMap,
                                                                                                                                                std::map<int64_t,int64_t> & gl2lcElMap);
                
                virtual TPZCompEl *Clone(TPZCompMesh &mesh) const override 
    {
        return new TPZMultiphysicsInterfaceElement(mesh,*this);
    }
                
                virtual TPZCompEl *ClonePatchEl(TPZCompMesh &mesh,
                                                                                                                                                std::map<int64_t,int64_t> & gl2lcConMap,
                                                                                                                                                std::map<int64_t,int64_t> & gl2lcElMap) const override
    {
        return new TPZMultiphysicsInterfaceElement(mesh,*this,gl2lcConMap,gl2lcElMap);
    }
                
                void IncrementElConnected();    
                
                virtual ~TPZMultiphysicsInterfaceElement();
                
                void ComputeSideTransform(TPZManVector<TPZCompElSide> &Neighbor, TPZManVector<TPZTransform<> > &transf);
                
                void MapQsi(TPZManVector<TPZCompElSide> &Neighbor, TPZVec<REAL> &qsi, TPZVec<REAL> &NeighIntPoint);
    
    void SetLeftRightElement(const TPZCompElSide &leftel, const TPZCompElSide &rightel);
    
    void SetLeftRightElementIndices(const TPZVec<int64_t> &lefindices, const TPZVec<int64_t> &rightindices);
    
                void GetLeftRightElement(TPZCompElSide &leftel, TPZCompElSide &rightel);
                
                virtual void SetConnectIndex(int inode, int64_t index) override
    {
        fConnectIndexes[inode] = index;
    }
                
                virtual int NConnects() const override;
                
                virtual int64_t ConnectIndex(int i) const override;
                

                virtual int Dimension() const override
    {
        return Reference()->Dimension();
    }

    void CalcStiff(TPZElementMatrix &ek, TPZElementMatrix &ef) override;
    
    void CalcStiff(TPZElementMatrix &ef);

    void CreateIntegrationRule();
    
    const TPZIntPoints & GetIntegrationRule() const override;
    
    virtual int ComputeIntegrationOrder() const override;
    
    virtual void ComputeRequiredData(TPZVec<REAL> &intpointtemp, TPZVec<TPZTransform<> > &trvec, TPZVec<TPZMaterialData> &datavec);

    void InitializeElementMatrix(TPZElementMatrix &ek, TPZElementMatrix &ef);
    
    void InitializeElementMatrix(TPZElementMatrix &ef);
    
    
    TPZCompElSide Left() const
    {
        return fLeftElSide;
    }
    
                TPZCompEl *RightElement() const {
                                return fRightElSide.Element();
                }
                
                TPZCompEl *LeftElement() const {
                                return fLeftElSide.Element();
                }

    void ComputeCenterNormal(TPZVec<REAL> &normal) const;
    
   // void ComputeNormal(TPZVec<REAL> &qsi, TPZVec<REAL> &normal);
    
                virtual void Print(std::ostream &out = std::cout) const override;
                
    void InitMaterialData(TPZMaterialData &center_data, TPZVec<TPZMaterialData> &data_left, TPZVec<TPZMaterialData> &data_right);
    
    void InitMaterialData(TPZMaterialData &data);
    
    virtual void ComputeRequiredData(TPZMaterialData &data, TPZVec<REAL> &point);
    
    void ComputeRequiredData(TPZVec<REAL> &point, TPZVec<TPZTransform<> > &trvec, TPZMultiphysicsElement *Neighbour, TPZVec<TPZMaterialData> &data);
                
                void ComputeSideTransform(TPZCompElSide &Neighbor, TPZTransform<> &transf);
    
    TPZCompElSide Right() const
    {
        return fRightElSide;
    }
    
    virtual int nmeshes()
    {
        if (fLeftElSide) {
            TPZMultiphysicsElement *mfcel = dynamic_cast<TPZMultiphysicsElement *>(fLeftElSide.Element());
            if(mfcel)
            {
                return mfcel->NMeshes();
            }
        }
        if (fRightElSide) {
            TPZMultiphysicsElement *mfcel = dynamic_cast<TPZMultiphysicsElement *>(fRightElSide.Element()); 
            if (mfcel) {
                return mfcel->NMeshes();
            }
        }
        return 1;
    }
                
    virtual void BuildCornerConnectList(std::set<int64_t> &connectindexes) const override
    {
        TPZCompEl *left = fLeftElSide.Element();
        TPZCompEl *right = fRightElSide.Element();
        left->BuildCornerConnectList(connectindexes);
        right->BuildCornerConnectList(connectindexes);
    }
                
                virtual void Solution(TPZVec<REAL> &qsi,int var,TPZVec<STATE> &sol) override;
                
                virtual void CreateGraphicalElement(TPZGraphMesh &grmesh, int dimension) override;
    
    virtual int NumberOfCompElementsInsideThisCompEl() override {
        
        if (fLeftElSide) {
            TPZMultiphysicsElement *mfcel = dynamic_cast<TPZMultiphysicsElement *>(fLeftElSide.Element());
            if(mfcel)
            {
                return mfcel->NMeshes();
            }
        }
        if (fRightElSide) {
            TPZMultiphysicsElement *mfcel = dynamic_cast<TPZMultiphysicsElement *>(fRightElSide.Element());
            if (mfcel) {
                return mfcel->NMeshes();
            }
        }
        return 0;

    }           

    public:
virtual int ClassId() const override;

void EvaluateError(std::function<void(const TPZVec<REAL> &loc,TPZVec<STATE> &val,TPZFMatrix<STATE> &deriv)> fp,
                                  TPZVec<REAL> &/*errors*/, bool store_error) override {
//        LOGPZ_WARN(logger, "EvaluateError is called.");
//        DebugStop();
    }

    
};

#endif