pzintel.h

Go to the documentation of this file.

#ifndef PZINTEL_H
#define PZINTEL_H

#include "pzcompel.h"
#include "pzinterpolationspace.h"
//#include "pzmaterial.h"
struct TPZElementMatrix;

class TPZIntPoints;
#include "TPZCompElDisc.h"
#include "TPZOneShapeRestraint.h"
#include "pzblockdiag.h"

class TPZInterpolatedElement : public TPZInterpolationSpace {

protected:
                
                void UpdateNeighbourSideOrder(int side, TPZVec<TPZCompElSide> &elvec);
                
                static int ComputeSideOrder(TPZVec<TPZCompElSide> &elementset);
                
                
public:
                TPZInterpolatedElement(TPZCompMesh &mesh, TPZGeoEl *reference, int64_t &index);
                
                TPZInterpolatedElement(TPZCompMesh &mesh, const TPZInterpolatedElement &copy);
                
                TPZInterpolatedElement ( TPZCompMesh &mesh,
                                                                                                                const TPZInterpolatedElement &copy,
                                                                                                                std::map<int64_t,int64_t> & gl2lcElMap);
                
                TPZInterpolatedElement();
                virtual ~TPZInterpolatedElement();
                
                virtual void SetCreateFunctions(TPZCompMesh *mesh) override;
            int ClassId() const override;
                
                void Write(TPZStream &buf, int withclassid) const override;
                
                void Read(TPZStream &buf, void *context) override;
                
                virtual void Print(std::ostream &out = std::cout) const override;
                
                int NShapeF() const override;
                
                int NSideShapeF(int side) const;
                
                virtual int NSideConnects(int iside) const override = 0;
                
                virtual int SideConnectLocId(int icon,int is) const override = 0;
                
                virtual int MidSideConnectLocId(int is) const;
                
    virtual TPZConnect &MidSideConnect(int is) const;
    
                
                int64_t SideConnectIndex(int icon,int is) const;
                
                TPZConnect &SideConnect(int icon,int is);
                
                virtual int Dimension() const override = 0;
                
                virtual int NCornerConnects() const = 0;
                
                virtual int NConnects() const  override = 0;
    
    virtual void BuildCornerConnectList(std::set<int64_t> &connectindexes) const override;

                
                virtual void GetInterpolationOrder(TPZVec<int> &ord) = 0;
                
                virtual int PreferredSideOrder(int iside) = 0;
                
                int AdjustPreferredSideOrder(int side, int order);
                
                virtual int EffectiveSideOrder(int side) const = 0;
                
    bool VerifyConstraintConsistency(int side, TPZCompElSide large) const;
                virtual void SetConnectIndex(int i, int64_t connectindex) override = 0;
                
                virtual void SetIntegrationRule(int order) override {
                                std::cout << "TPZInterpolatedElement::SetIntegrationRule called\n";
                }
                
                virtual void SetPreferredOrder(int order)  override = 0;
                
public:
                virtual void SetSideOrder(int side, int order) = 0;
                
                virtual void ForceSideOrder(int side, int order);
                
public:
                
                
                virtual void SideShapeFunction(int side, TPZVec<REAL> &point, TPZFMatrix<REAL> &phi, TPZFMatrix<REAL> &dphi) override = 0;
                
public:
                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 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,
                                                                                                                                 TPZVec<REAL> &normal,
                                                                                                                                 TPZSolVec &leftsol, TPZGradSolVec &dleftsol,TPZFMatrix<REAL> &leftaxes,
                                                                                                                                 TPZSolVec &rightsol, TPZGradSolVec &drightsol,TPZFMatrix<REAL> &rightaxes) override;
                
                virtual REAL CompareElement(int var, char *matname) override;
                
                void Divide(int64_t index,TPZVec<int64_t> &sub,int interpolatesolution = 0) override;
                
                void PRefine(int order) override;
                
                virtual void RestrainSide(int side, TPZInterpolatedElement *neighbour, int neighbourside);
                
                enum MInsertMode {EInsert,EDelete};
                
                virtual void RemoveSideRestraintsII(MInsertMode mode);
                
                virtual void RemoveSideRestraintWithRespectTo(int side, const TPZCompElSide &neighbour);
                
                void RecomputeRestraints(int side);
                
    virtual void AddShapeRestraint(TPZOneShapeRestraint restraint) override
    {
        DebugStop();
    }
    
                virtual void BuildTransferMatrix(TPZInterpolatedElement &coarsel, TPZTransform<> &t, TPZTransfer<STATE> &transfer);
                
                virtual int64_t CreateMidSideConnect(int side);
                
                virtual void IdentifySideOrder(int side);
                
                void CheckConstraintConsistency(int side);
                
                void CheckConstraintConsistency();
                
                virtual  int CheckElementConsistency();
                
                int CompareShapeF(int sides, int sidel, TPZFMatrix<REAL> &phis, TPZFMatrix<REAL> &dphis, TPZFMatrix<REAL> &phil, TPZFMatrix<REAL> &dphil, TPZTransform<> &transform);
                
                virtual TPZTransform<> TransformSideToElement(int side) = 0;
                
public:
                
                virtual void SetInterface(int /*side*/, int64_t /*index*/) { }
                virtual int Interface(int /*side*/) { return -1; }
                virtual int CanHaveInterface() { return 0; }
                virtual void DeleteInterfaces() { }
                REAL MeanSolution(int var);
                void CalcIntegral(TPZElementMatrix &ef);
                
};

#endif