pzbndcond.h

Go to the documentation of this file.

#ifndef BNDCONDHPP
#define BNDCONDHPP

#include <iostream>
#include <map>

#include "pzreal.h"
#include "pzdiscgal.h"
#include "pzvec.h"
#include "pzmanvector.h"
#include "pzfmatrix.h"
#include "tpzautopointer.h"

template <class T, int N>
class TPZManVector;

class TPZBndCond : public TPZDiscontinuousGalerkin {
                
                friend class TPZMaterial;
    
protected:
    
    class TPZ_BCDefine : public TPZSavable {
       
        public :
        TPZFNMatrix<6,STATE> fBCVal2;

        TPZAutoPointer<TPZFunction<STATE> > fForcingFunction;
        
        TPZAutoPointer<TPZFunction<STATE> > fForcingFunctionExact;
        
        TPZAutoPointer<TPZFunction<STATE> > fTimeDependentForcingFunction;
        
        TPZAutoPointer<TPZFunction<STATE> > fTimedependentFunctionExact;
        
        TPZAutoPointer<TPZFunction<STATE> > fBCForcingFunction;
        
        TPZAutoPointer<TPZFunction<STATE> > fTimedependentBCForcingFunction;            

        TPZ_BCDefine() : fBCVal2(), fForcingFunction(NULL), fForcingFunctionExact(NULL),fTimeDependentForcingFunction(NULL),
                        fTimedependentFunctionExact(NULL), fBCForcingFunction(NULL),fTimedependentBCForcingFunction(NULL)
        {
            
        }
        TPZ_BCDefine(TPZFMatrix<STATE> Val2) : fBCVal2(), fForcingFunction(NULL), fForcingFunctionExact(NULL),fTimeDependentForcingFunction(NULL),
                fTimedependentFunctionExact(NULL), fBCForcingFunction(NULL),fTimedependentBCForcingFunction(NULL)
        {
            
        }
        TPZ_BCDefine(const TPZ_BCDefine &cp) : fBCVal2(cp.fBCVal2), fForcingFunction(cp.fForcingFunction),fForcingFunctionExact(cp.fForcingFunctionExact),
                fTimeDependentForcingFunction(cp.fTimeDependentForcingFunction), fTimedependentFunctionExact(cp.fTimedependentFunctionExact),
                fBCForcingFunction(cp.fBCForcingFunction),fTimedependentBCForcingFunction(cp.fTimedependentBCForcingFunction)
        {
            
        }
        TPZ_BCDefine &operator=(const TPZ_BCDefine &cp)
        {
            fBCVal2 = cp.fBCVal2;
            fForcingFunction = cp.fForcingFunction;
            fForcingFunctionExact = cp.fForcingFunctionExact;
            fTimeDependentForcingFunction = cp.fTimeDependentForcingFunction;
            fTimedependentFunctionExact = cp.fTimedependentFunctionExact;
            fBCForcingFunction = cp.fBCForcingFunction;
            fTimedependentBCForcingFunction = cp.fTimedependentBCForcingFunction;
            return *this;
        }
        ~TPZ_BCDefine()
        {
            
        }        int ClassId() const override;
        void Read(TPZStream &buf, void *context) override;
        void Write(TPZStream &buf, int withclassid) const override;

    };
    
    TPZVec<TPZ_BCDefine> fBCs;
    
                int                             fType;
                TPZFNMatrix<9,STATE> fBCVal1;
                TPZFNMatrix<3,STATE> fBCVal2;
                TPZMaterial * fMaterial;
                
                void (*fValFunction)(TPZVec<REAL> &loc, TPZFMatrix<STATE> &Val1, TPZVec<STATE> &Val2, int &BCType);
                
                public :
    TPZBndCond(TPZBndCond & bc) : TPZRegisterClassId(&TPZBndCond::ClassId),
    TPZDiscontinuousGalerkin(bc), fBCs(bc.fBCs), fType(-1), fBCVal1(bc.fBCVal1),
    fBCVal2(bc.fBCVal2), fMaterial(0), fValFunction(NULL){
                                fMaterial = bc.fMaterial;
                                fType = bc.fType;
        fForcingFunction = bc.fForcingFunction;
        fForcingFunctionExact = bc.fForcingFunctionExact;
        fTimeDependentForcingFunction = bc.fTimeDependentForcingFunction;
        fTimedependentFunctionExact = bc.fTimedependentFunctionExact;
        fBCForcingFunction = bc.fBCForcingFunction;
        fTimedependentBCForcingFunction = bc.fTimedependentBCForcingFunction;
                }
                TPZBndCond() : TPZRegisterClassId(&TPZBndCond::ClassId),
    TPZDiscontinuousGalerkin(), fBCs(), fType(-1), fBCVal1(),
    fBCVal2(), fMaterial(0), fValFunction(NULL){
                }
                TPZBndCond(int matid) : TPZRegisterClassId(&TPZBndCond::ClassId),
    TPZDiscontinuousGalerkin(matid), fBCs(0), fType(-1), fBCVal1(),
    fBCVal2(), fMaterial(0), fValFunction(NULL){
                }
    ~TPZBndCond(){}
                
                TPZBndCond(TPZMaterial * material,int id,int type,TPZFMatrix<STATE> &val1,TPZFMatrix<STATE> &val2) :
    TPZRegisterClassId(&TPZBndCond::ClassId), TPZDiscontinuousGalerkin(id), fBCs(), fBCVal1(val1), fBCVal2(val2), fValFunction(NULL) {
                                //creates a new material
                                if(!material)
                                {
                                                std::cout << __PRETTY_FUNCTION__ << " Creating boundary condition with NULL material" << std::endl;
            DebugStop();
                                }
                                fMaterial = material;
                                fType = type;
                                
                }
                
                TPZBndCond(TPZBndCond &copy, TPZMaterial * ref) : TPZRegisterClassId(&TPZBndCond::ClassId), 
    TPZDiscontinuousGalerkin(copy), fBCs(copy.fBCs), fType(copy.fType),
                fBCVal1(copy.fBCVal1), fBCVal2(copy.fBCVal2), fMaterial(ref), fValFunction(copy.fValFunction) {
    
        fForcingFunction = copy.fForcingFunction;
        fForcingFunctionExact = copy.fForcingFunctionExact;
        fTimeDependentForcingFunction = copy.fTimeDependentForcingFunction;
        fTimedependentFunctionExact = copy.fTimedependentFunctionExact;
        fBCForcingFunction = copy.fBCForcingFunction;
        fTimedependentBCForcingFunction = copy.fTimedependentBCForcingFunction;
        
    }
                
                
                void SetValFunction(void (*fp)(TPZVec<REAL> &loc, TPZFMatrix<STATE> &Val1, TPZVec<STATE> &Val2, int &BCType)){
                                fValFunction = fp;
                }
                
                void SetForcingFunction(int loadcase, TPZAutoPointer<TPZFunction<STATE> > func)
    {
        if (loadcase == 0) {
            TPZMaterial::SetForcingFunction(func);
        }
        else {
            fBCs[loadcase].fForcingFunction = func;
        }
                }

                void SetForcingFunctionExact(int loadcase, TPZAutoPointer<TPZFunction<STATE> > func)
    {
        if (loadcase == 0) {
            TPZMaterial::SetForcingFunctionExact(func);
        }
        else {
            fBCs[loadcase].fForcingFunctionExact = func;
        }
    }

    void SetTimeDependentForcingFunction(int loadcase, TPZAutoPointer<TPZFunction<STATE> > func)
    {
        if (loadcase == 0) {
            TPZMaterial::SetTimeDependentForcingFunction(func);
        }
        else {
            fBCs[loadcase].fTimeDependentForcingFunction = func;
        }
    }

    void SetTimeDependentFunctionExact(int loadcase, TPZAutoPointer<TPZFunction<STATE> > func)
    {
        if (loadcase == 0) {
            TPZMaterial::SetTimeDependentFunctionExact(func);
        }
        else {
            fBCs[loadcase].fTimedependentFunctionExact = func;
        }
    }     

    void SetBCForcingFunction(int loadcase, TPZAutoPointer<TPZFunction<STATE> > func)
    {
        if (loadcase == 0) {
            TPZMaterial::SetBCForcingFunction(func);
        }
        else {
            fBCs[loadcase].fBCForcingFunction = func;
        }
    }

    void SetTimedependentBCForcingFunction(int loadcase, TPZAutoPointer<TPZFunction<STATE> > func)
    {
        if (loadcase == 0) {
            TPZMaterial::SetTimedependentBCForcingFunction(func);
        }
        else {
            fBCs[loadcase].fTimedependentBCForcingFunction = func;
        }
    }
    
    TPZAutoPointer<TPZFunction<STATE> > GetTimedependentBCForcingFunction(int loadcase)
    {
        if (loadcase == 0) {
            return this->fTimedependentBCForcingFunction;
        }
        else {
            return fBCs[loadcase].fTimedependentBCForcingFunction;
        }
    }
                
                void SetMaterial(TPZMaterial * mat) { fMaterial = mat;}
                
                int Dimension() const override { return fMaterial->Dimension(); }
                
                virtual int NFluxes() override { return fMaterial->NFluxes(); }
                
                virtual int NStateVariables() const override { return fMaterial->NStateVariables(); }
                
                virtual int NEvalErrors() override {return fMaterial->NEvalErrors();}
                
                int Type() { return fType; }
                
                void SetType(int type){ this->fType = type; }
                
                TPZFMatrix<STATE> &Val1() { return fBCVal1; }
                
                TPZFMatrix<STATE> &Val2(int loadcase = 0) 
    {
        if (loadcase == 0 || loadcase > fBCs.size() ) {
            return fBCVal2;
        }
        return fBCs[loadcase-1].fBCVal2;
    }
                
                TPZMaterial * Material() const { return fMaterial; }
    
    void SetLoadCases(TPZVec<TPZFMatrix<STATE> > &val2vec)
    {
        fBCs.Resize(val2vec.size()-1);
        fBCVal2 = val2vec[0];
        for (int i=0; i<val2vec.size()-1; i++) {
            fBCs[i] = val2vec[i+1];
        }
    }
    
    virtual int MinimumNumberofLoadCases() override
    {
        return 1+fBCs.size();
    }
                
                void Flux(TPZVec<REAL> &x, TPZVec<STATE> &Sol, TPZFMatrix<STATE> &DSol, TPZFMatrix<REAL> &axes, TPZVec<STATE> &flux) override {
                                flux.Fill(0.);
                }
                
                void Print(std::ostream & out = std::cout) override {
                                out << " Boundary condition number = " << Id() << "\n";
                                out << " boundary condition type = " << fType << "\n";
                                out << " val1 = \n"; fBCVal1.Print("fBCVal1",out);
                                out << " val2 = \n"; fBCVal2.Print("fBCVal2",out);
                                if (HasForcingFunction()) out << " has forcing function\n";
                                else out << "has no forcing function\n";
                }
                
                void UpdateBCValues(TPZManVector<REAL,3> & x);
                
                /*
                 @brief this method will be used only in case of multiphysics simulation
                 */
                void UpdateBCValues(TPZVec<TPZMaterialData> &datavec);
                
                virtual void Contribute(TPZMaterialData &data, REAL weight, TPZFMatrix<STATE> &ek, TPZFMatrix<STATE> &ef) override;
                
                virtual void Contribute(TPZVec<TPZMaterialData> &datavec, REAL weight, TPZFMatrix<STATE> &ek, TPZFMatrix<STATE> &ef) override;
                
                virtual void ContributeBC(TPZMaterialData &data, REAL weight, TPZFMatrix<STATE> &ek, TPZFMatrix<STATE> &ef, TPZBndCond &bc) override;
                
                virtual void Contribute(TPZMaterialData &data, REAL weight, TPZFMatrix<STATE> &ef) override;
                
                virtual void ContributeBC(TPZMaterialData &data, REAL weight, TPZFMatrix<STATE> &ef, TPZBndCond &bc) override;
                
                virtual void ContributeInterface(TPZMaterialData &data, TPZMaterialData &dataleft, TPZMaterialData &dataright, REAL weight, TPZFMatrix<STATE> &ek, TPZFMatrix<STATE> &ef) override;
    
    virtual void ContributeInterface(TPZMaterialData &data, TPZVec<TPZMaterialData> &dataleft, TPZVec<TPZMaterialData> &dataright, REAL weight, TPZFMatrix<STATE> &ek, TPZFMatrix<STATE> &ef) override;
                
                virtual void ContributeInterface(TPZMaterialData &data, TPZMaterialData &dataleft, TPZMaterialData &dataright, REAL weight, TPZFMatrix<STATE> &ef) override;
                
                virtual void ContributeBCInterface(TPZMaterialData &data, TPZMaterialData &dataleft, REAL weight, TPZFMatrix<STATE> &ek,TPZFMatrix<STATE> &ef,TPZBndCond &bc) override;
                
                virtual void ContributeBCInterface(TPZMaterialData &data, TPZMaterialData &dataleft, REAL weight, TPZFMatrix<STATE> &ef,TPZBndCond &bc) override;
                
                virtual void Errors(TPZVec<REAL> &x,TPZVec<STATE> &sol,TPZFMatrix<STATE> &dsol, TPZFMatrix<REAL> &axes, TPZVec<STATE> &flux,
                                                                TPZVec<STATE> &uexact,TPZFMatrix<STATE> &duexact,TPZVec<REAL> &val) override {
                                val.Fill(0.);
                }
                
                virtual void Clone(std::map<int, TPZMaterial * > &matvec) override;
                
                virtual void InterfaceJump(TPZVec<REAL> &x, TPZSolVec &leftu,TPZSolVec &rightu,TPZSolVec &jump) override;
                
                public:
virtual int ClassId() const override;

                virtual void Write(TPZStream &buf, int withclassid) const override;
                
                virtual void Read(TPZStream &buf, void *context)  override;
                
                void ContributeInterfaceErrors(TPZMaterialData &data, TPZMaterialData &dataleft, TPZMaterialData &dataright,
                                                                                                                                   REAL weight,
                                                                                                                                   TPZVec<STATE> &nkL,
                                                                                                                                   TPZVec<STATE> &nkR,
                                                                                                                                   int &errorid) override;
                
                void  ContributeErrors(TPZMaterialData &data,// aqui
                                                                                                   REAL weight,
                                                                                                   TPZVec<REAL> &nk,
                                                                                                   int &errorid) override {
                                //nothing to be done here
                };
                
                
                virtual void ContributeInterfaceBCErrors(TPZMaterialData &data, TPZMaterialData &dataleft,
                                                                                                                                                                                 REAL weight,
                                                                                                                                                                                 TPZVec<STATE> &nk,
                                                                                                                                                                                 TPZBndCond &bc,
                                                                                                                                                                                 int &errorid
                                                                                                                                                                                 ) override {
                                //nothing to be done here
                }
                
                virtual void FillDataRequirements(TPZMaterialData &data) override;
    
    virtual void FillDataRequirements(TPZVec<TPZMaterialData> &datavec)  override;
    
    virtual void FillDataRequirementsInterface(TPZMaterialData &data, TPZVec<TPZMaterialData > &datavec_left, TPZVec<TPZMaterialData > &datavec_right) override;
                
};

#endif