pzmultiphysicselement.h

Go to the documentation of this file.

#ifndef PZMULTIPHYSICSELEMENTH
#define PZMULTIPHYSICSELEMENTH 

#include <iostream>

#include "pzcompel.h"
#include "pzgeoelbc.h"
#include "pzfunction.h"

class TPZMultiphysicsInterfaceElement;

class TPZMultiphysicsElement : public TPZCompEl {
                
protected:
    
    std::list<TPZOneShapeRestraint> fRestraints;
    
    TPZManVector<int,5> fActiveApproxSpace;
    
public:
                TPZMultiphysicsElement() : TPZCompEl()
                {
                }
                TPZMultiphysicsElement(TPZCompMesh &mesh, TPZGeoEl *ref, int64_t &index) : TPZCompEl(mesh, ref, index)
                {
                }
  
  TPZMultiphysicsElement(TPZCompMesh &mesh, const TPZMultiphysicsElement &copy);
  
                virtual ~TPZMultiphysicsElement()
                {
        TPZGeoEl *reference = Reference();
        if (reference) {
            reference->ResetReference();
        }
                }
                
                virtual void AddElement(TPZCompEl *cel, int64_t mesh) = 0;
    
    virtual void AddElement(const TPZCompElSide &cel, int64_t mesh) = 0;
    
    virtual TPZCompEl *Element(int64_t elindex) = 0;
                
    virtual TPZManVector<TPZCompElSide,5>   &ElementVec() = 0;
    
                virtual TPZCompEl *ReferredElement(int64_t mesh) = 0;
    
    virtual int64_t NMeshes() = 0;
                
                virtual void SetConnectIndexes(TPZVec<int64_t> &indexes) = 0;
                
                virtual void AffineTransform(TPZVec<TPZTransform<> > &trVec) const = 0;
                
                virtual void InitMaterialData(TPZVec<TPZMaterialData > &dataVec, TPZVec<int64_t> *indices = 0) = 0;
    
    virtual void ComputeRequiredData(TPZVec<REAL> &point, TPZVec<TPZTransform<> > &trvec, TPZVec<TPZMaterialData> &datavec, TPZVec<int64_t> indices);
    
    virtual void ComputeRequiredData(TPZMaterialData &data,
                                     TPZVec<REAL> &qsi)
    {
        
    }
    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 EvaluateError(TPZFunction<STATE> &func,
                               TPZVec<STATE> &errors, bool store_error);

                virtual void CalcStiff(TPZElementMatrix &ek,TPZElementMatrix &ef) override = 0 ;
                
                virtual void CreateGraphicalElement(TPZGraphMesh &grmesh, int dimension) override =0 ;
                
                //virtual void CreateGraphicalElement(TPZGraphMesh &grmesh, std::set<int> dimension, std::set<int> dimension)=0;                
    
    void CreateInterfaces();
    
    bool ExistsInterface(int side);
    
    TPZMultiphysicsInterfaceElement * CreateInterface(int side);
    
    void RemoveInterfaces();
    
    void RemoveInterface(int side);
    
    virtual const TPZIntPoints &GetIntegrationRule() const override = 0 ;
    
    virtual TPZIntPoints &GetIntegrationRule() = 0;
    
    virtual void InitializeIntegrationRule() override = 0 ;

    virtual void PolynomialOrder(TPZVec<int> &order) const = 0;
    
    virtual int ComputeIntegrationOrder() const override;
    
    virtual void BuildCornerConnectList(std::set<int64_t> &connectindexes) const override
    {
        std::cout << "To Be Implemented\n";
        DebugStop();
    }

    virtual void TransferMultiphysicsElementSolution() override;
    
    virtual void SetActiveApproxSpaces(TPZManVector<int,5> & active_approx_space)
    {
#ifdef PZDEBUG
        if(fActiveApproxSpace.size()!= ElementVec().size()){
            DebugStop();
        }
#endif
        fActiveApproxSpace = active_approx_space;
        
    }
    
    virtual TPZManVector<int,5> & GetActiveApproxSpaces()
    {
        return fActiveApproxSpace;
        
    }
    
    virtual bool IsActiveApproxSpaces(int space_index)
    {
        return fActiveApproxSpace[space_index];
    }
    
    virtual void Solution(TPZVec<REAL> &qsi,int var,TPZVec<STATE> &sol) override  = 0 ;
    
    virtual void AddShapeRestraint(TPZOneShapeRestraint restraint) override
    {
        fRestraints.push_back(restraint);
    }
    
    virtual std::list<TPZOneShapeRestraint> GetShapeRestraints() const override
    {
        return fRestraints;
    }

};

#endif