TPZInterfaceEl.h

Go to the documentation of this file.

//$Id: TPZInterfaceEl.h,v 1.60 2010-06-17 17:46:56 phil Exp $

#ifndef ELEMINTERFACEHH
#define ELEMINTERFACEHH

#include "pzcompel.h"
#include "pzinterpolationspace.h"
#include "pzgeoel.h"
#include "pzcmesh.h"
#include "pzfmatrix.h"
#include "pzvec.h"
#include "pzreal.h"

#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include <iostream>
#include "TPZCompElDisc.h"
#include "pzmaterialdata.h"


class TPZInterfaceElement : public TPZCompEl {
                
                private :
                
                TPZCompElSide fLeftElSide;
                
                TPZCompElSide fRightElSide;
                
                TPZManVector<REAL,3> fCenterNormal;
    
  //  TPZIntPoints *fIntegrationRule;
    virtual void InitializeIntegrationRule() override;

                void DecreaseElConnected();
                
                void IncrementElConnected();
                
protected:
                
                void InitMaterialData(TPZMaterialData &data, TPZInterpolationSpace *left);
    
    void InitMaterialData(TPZMaterialData &data);
                
                void ComputeRequiredData(TPZMaterialData &data,
                                                                                                                 TPZInterpolationSpace *elem,
                                                                                                                 TPZVec<REAL> &IntPoint);
    
    virtual void ComputeRequiredData(TPZMaterialData &data,
                             TPZVec<REAL> &qsi);
    
    virtual void ComputeRequiredData(TPZVec<REAL> &intpointtemp, TPZVec<TPZTransform<> > &trvec, TPZVec<TPZMaterialData> &datavec){
        DebugStop();
    }
    
    
public:
                
                void GetConnects(TPZCompElSide &elside, TPZVec<TPZConnect*> &connects, TPZVec<int64_t> &connectindex);
                
                void NeighbourSolution(TPZCompElSide & Neighbor, TPZVec<REAL> & qsi, TPZSolVec &sol, TPZGradSolVec &dsol, TPZFMatrix<REAL> &NeighborAxes);
                
protected:
                
public:
                bool CheckConsistencyOfMappedQsi(TPZCompElSide &Neighbor, TPZVec<REAL> &qsi, TPZVec<REAL>&NeighIntPoint);
                
                void ComputeSideTransform(TPZCompElSide &Neighbor, TPZTransform<> &transf);
protected:
                void ComputeNormal(TPZVec<REAL>&qsi, TPZVec<REAL> &normal);
                
                void ComputeNormal(TPZFMatrix<REAL> &axes, TPZVec<REAL> &normal);
                
                void ComputeCenterNormal(TPZVec<REAL> &normal);
                
public:
                
                void InitializeElementMatrix(TPZElementMatrix &ef);
                void InitializeElementMatrix(TPZElementMatrix &ek, TPZElementMatrix &ef);
                
                void MapQsi(TPZCompElSide &Neighbor, TPZVec<REAL> &qsi, TPZVec<REAL> &NeighIntPoint);
                
                enum CalcStiffOptions{ENone = -1, EStandard /*Deprecated*/ = 0, EPenalty, EContDisc,EReferred};
                
                TPZInterfaceElement(TPZCompMesh &mesh,TPZGeoEl *geo,int64_t &index,TPZCompElSide & left, TPZCompElSide &right);
                
                TPZInterfaceElement(TPZCompMesh &mesh, const TPZInterfaceElement &copy);

                TPZInterfaceElement(TPZCompMesh &mesh,
                                                                                                const TPZInterfaceElement &copy,
                                                                                                std::map<int64_t,int64_t> &gl2lcConIdx,
                                                                                                std::map<int64_t,int64_t> &gl2lcElIdx);

                TPZInterfaceElement(TPZCompMesh &mesh, const TPZInterfaceElement &copy, int64_t &index);
                
                TPZInterfaceElement();
                
                TPZInterfaceElement(TPZCompMesh &mesh,TPZGeoEl *geo,int64_t &index);
                
                ~TPZInterfaceElement();
                
                virtual int IsInterface() override { return 1; }
                
                
                void SetLeftRightElements(TPZCompElSide & left, TPZCompElSide & right);
                
                virtual TPZCompEl *Clone(TPZCompMesh &mesh) const override{
                                return new TPZInterfaceElement(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 TPZInterfaceElement(mesh, *this, gl2lcConMap,gl2lcElMap);
                }
                
                TPZCompEl * CloneInterface(TPZCompMesh &aggmesh,int64_t &index, /*TPZCompElDisc **/TPZCompElSide & left, /*TPZCompElDisc **/ TPZCompElSide &right) const;
                
                void VolumeEls(TPZCompEl &thirdel);
                
                TPZCompEl *RightElement() const {
                                return fRightElSide.Element();
                }
                
                TPZCompEl *LeftElement() const {
                                return fLeftElSide.Element();
                }
                
                TPZCompElSide &LeftElementSide(){ return this->fLeftElSide; }
                
                TPZCompElSide &RightElementSide(){ return this->fRightElSide; }
                
                void CenterNormal(TPZVec<REAL> &CenterNormal) const;
    
    void SetCenterNormal(const TPZVec<REAL> &CenterNormal)
    {
        fCenterNormal = CenterNormal;
    }
                
                void Normal(TPZFMatrix<REAL> &axes, TPZVec<REAL> &normal);
                
                void Normal(TPZVec<REAL>&qsi, TPZVec<REAL> &normal);
                
                virtual int NConnects() const override;
                
                int NRightConnects() const;
                
                int NLeftConnects() const;
                
                int64_t ConnectIndex(int i) const override;
                
                void SetConnectIndex(int node, int64_t index) override;

    virtual void BuildCornerConnectList(std::set<int64_t> &connectindexes) const override;
                
                int Dimension() const override{
                                return this->Reference()->Dimension();
                }
                
                MElementType Type() override { return EInterface; }
                
                virtual void LoadSolution() override{
                                //NOTHING TO BE DONE HERE
                }
                
                virtual void CalcStiff(TPZElementMatrix &ek, TPZElementMatrix &ef) override;
                
                virtual void CalcResidual(TPZElementMatrix &ef) override;
                
                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 ComputeSolution(TPZVec<REAL> &qsi,
                                                                                                                                 TPZSolVec &sol, TPZGradSolVec &dsol,TPZFMatrix<REAL> &axes) override;
                
    virtual void ComputeSolution(TPZVec<REAL> &qsi,
                                 TPZMaterialData &data) override;
    
                void VetorialProd(TPZVec<REAL> &ivet,TPZVec<REAL> &jvet,TPZVec<REAL> &kvet);
                
                void Print(std::ostream &out = std::cout) const override;
                
                virtual void CreateGraphicalElement(TPZGraphMesh & graphmesh, int dimension) override{
                                //Nothing to be done here
                }
                
                static int ExistInterfaces(TPZCompElSide &comp);
                
                static int FreeInterface(TPZCompMesh &cmesh);
                
                void CloneInterface(TPZCompMesh *aggmesh);
                
                static int main(TPZCompMesh &cmesh);
                
    virtual void EvaluateError(std::function<void(const TPZVec<REAL> &loc,TPZVec<STATE> &val,TPZFMatrix<STATE> &deriv)> func,
                               TPZVec<REAL> &errors, bool store_error) override;
                
                virtual void ComputeErrorFace(int errorid,
                                                                                                                                  TPZVec<STATE> &errorL,
                                                                                                                                  TPZVec<STATE> &errorR);
                
                virtual void Integrate(int variable, TPZVec<STATE> & value) override;
                
                void IntegrateInterface(int variable, TPZVec<REAL> & value);
                
                void EvaluateInterfaceJump(TPZSolVec &jump, int opt);
                
                public:
    
    int ComputeIntegrationOrder() const override;
    
virtual int ClassId() const override;

                virtual void Write(TPZStream &buf, int withclassid) const override;
                
                virtual void Read(TPZStream &buf, void *context) override;
                
};

#endif