pzinterpolationspace.h

Go to the documentation of this file.

#ifndef PZINTERPOLATIONSPACE_H
#define PZINTERPOLATIONSPACE_H

#include "pzcompel.h"
class TPZMaterialData;

class TPZInterpolationSpace : public TPZCompEl
{
public:
    
    public:
virtual int ClassId() const override;

                
                TPZInterpolationSpace();
                
                virtual ~TPZInterpolationSpace();
                
                TPZInterpolationSpace(TPZCompMesh &mesh, const TPZInterpolationSpace &copy);
                
                TPZInterpolationSpace(TPZCompMesh &mesh, const TPZInterpolationSpace &copy, std::map<int64_t,int64_t> &gl2lcElMap);
                
                TPZInterpolationSpace(TPZCompMesh &mesh, const TPZInterpolationSpace &copy, int64_t &index);
                
                TPZInterpolationSpace(TPZCompMesh &mesh, TPZGeoEl *gel, int64_t &index);
                
                virtual void Print(std::ostream &out = std::cout) const override;
                
                int NSideShapeF(int side) const
    {
        return NShapeF();
    }
                
    virtual int NSideConnects(int iside) const = 0;
                
    virtual int SideConnectLocId(int icon,int is) const = 0;
//    {
//        return icon;
//    }
                                
                int64_t SideConnectIndex(int icon,int is) const
    {
        int locid = SideConnectLocId(icon, is);
        return ConnectIndex(locid);
    }
                
                TPZConnect &SideConnect(int icon,int is) const
    {
        return Connect(SideConnectLocId(icon,is));
    }
    
                virtual int NShapeF() const = 0;
                
                virtual int NConnectShapeF(int icon, int order) const = 0;
                
                virtual int MaxOrder();
    
    virtual void AdjustIntegrationRule();
    
    virtual int ComputeIntegrationOrder() const override;
                
    
    virtual void SetIntegrationRule(int order) override{
        std::cout << "TPZInterpolationSpace::SetIntegrationRule called\n";
    }
    

                virtual void Shape(TPZVec<REAL> &qsi,TPZFMatrix<REAL> &phi,TPZFMatrix<REAL> &dphidxi) = 0;
    
    
    
                
                virtual void ComputeShape(TPZVec<REAL> &intpoint, TPZVec<REAL> &X, TPZFMatrix<REAL> &jacobian, TPZFMatrix<REAL> &axes,
                                                                                                                  REAL &detjac, TPZFMatrix<REAL> &jacinv, TPZFMatrix<REAL> &phi, TPZFMatrix<REAL> &dphi, TPZFMatrix<REAL> &dphidx);

    static void Convert2Axes(const TPZFMatrix<REAL> &dphi, const TPZFMatrix<REAL> &jacinv, TPZFMatrix<REAL> &dphidx);

                
                virtual void SideShapeFunction(int side, TPZVec<REAL> &point, TPZFMatrix<REAL> &phi, TPZFMatrix<REAL> &dphi)
    {
        TPZGeoEl *gel = Reference();
        TPZManVector<REAL,3> ptout(gel->Dimension());
        Reference()->ProjectPoint(side, point, gel->NSides()-1, ptout);
        Shape(ptout, phi, dphi);
    }
                
    public:
    
    
    virtual void ComputeShape(TPZVec<REAL> &intpoint, TPZMaterialData &data);
                
                virtual void InitMaterialData(TPZMaterialData &data);
                
                virtual void ComputeRequiredData(TPZMaterialData &data,
                                                                                                                                                 TPZVec<REAL> &qsi);
                
                virtual void ComputeRequiredData(TPZVec<REAL> &intpointtemp, TPZVec<TPZTransform<REAL> > &trvec, TPZVec<TPZMaterialData> &datavec)
  {
                                PZError << "This Should never be called in this class, only in its children" << std::endl;
                                DebugStop();
                }

                
                virtual void ComputeNormal(TPZMaterialData & data);
                
                void VectorialProd(TPZVec<REAL> & ivec, TPZVec<REAL> & jvec, TPZVec<REAL> & kvec, bool unitary = false);
                
                virtual void CalcStiff(TPZElementMatrix &ek, TPZElementMatrix &ef) override;
                
                virtual void CalcResidual(TPZElementMatrix &ef) override;
                
                virtual void InitializeElementMatrix(TPZElementMatrix &ek, TPZElementMatrix &ef);
                
                virtual void InitializeElementMatrix(TPZElementMatrix &ef);
                
                void MinMaxSolutionValues(TPZVec<STATE> &min, TPZVec<STATE> &max);
                
                virtual const TPZIntPoints &GetIntegrationRule() const override = 0;
    
                virtual TPZIntPoints &GetIntegrationRule() = 0;
    
                virtual REAL InnerRadius();
                
                virtual void Solution(TPZVec<REAL> &qsi,int var,TPZVec<STATE> &sol) override;
                
                void InterpolateSolution(TPZInterpolationSpace &coarsel);
                
                void CreateInterfaces(bool BetweenContinuous = false);
                
                TPZInterfaceElement * CreateInterface(int side, bool BetweenContinuous = false);
                
                int ExistsInterface(TPZGeoElSide geosd);
                
                void RemoveInterfaces();
                
                void RemoveInterface(int side);
                
    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 ComputeError(int errorid, TPZVec<REAL> &error) override;
                
                virtual TPZVec<STATE> IntegrateSolution(int variable) const override;
    
    virtual void Integrate(int variable, TPZVec<STATE> & value) override;//AQUIFRAN
    
//              virtual void IntegrateSolution(TPZVec<STATE> & value);
                
                void ProjectFlux(TPZElementMatrix &ek, TPZElementMatrix &ef) override;
                
protected:
                
                int fPreferredOrder;
                
public:
                
                virtual void SetPreferredOrder ( int order ) = 0;
                
                virtual int GetPreferredOrder () { return fPreferredOrder; }
                
                virtual void PRefine ( int order ) = 0;
    
    virtual int GetSideOrient(int side);
    
    virtual void SetSideOrient(int side, int sideorient);
                
public:
                
                virtual void Write(TPZStream &buf, int withclassid) const override;
                
                virtual void Read(TPZStream &buf, void *context) override;
                
                void BuildTransferMatrix(TPZInterpolationSpace &coarsel, TPZTransform<> &t, TPZTransfer<STATE> &transfer);
                
protected:
                
    void ExpandShapeFunctions(TPZVec<int64_t> &connectlist, TPZVec<int> &dependencyorder, TPZVec<int> &blocksizes, TPZFMatrix<REAL> &phi, TPZFMatrix<REAL> &dphi);
                
};

#endif