pzfunction.h

Go to the documentation of this file.

#ifndef PZFUNCTION_H
#define PZFUNCTION_H

#include "TPZSavable.h"
#include "pzvec.h"
#include "pzfmatrix.h"

template<class TVar>
class TPZFunction : public virtual TPZSavable {
public:
                
                TPZFunction(){
            
        }
                
                ~TPZFunction(){
            
        }
    
                virtual void Execute(const TPZVec<REAL> &x, TPZVec<TVar> &f, TPZFMatrix<TVar> &df)
    {
        DebugStop();
    }
                
                virtual void Execute(const TPZVec<REAL> &x, REAL time, TPZVec<TVar> &f, TPZFMatrix<TVar> &gradf){
        DebugStop();
    }

    virtual void Execute(const TPZVec<REAL> &x, const TPZFMatrix<REAL> &axes, TPZVec<TVar> &f, TPZFMatrix<TVar> &df){
        DebugStop();
    }
    
    virtual void Execute(const TPZVec<REAL> &x, TPZVec<TVar> &f){
        DebugStop();
    }

    virtual int PolynomialOrder() const {
        return 1;
    }
    
    virtual int NFunctions() const
    {
        return 1;
    }
    
    virtual void Print(std::ostream &out)
    {
        out << __PRETTY_FUNCTION__ << std::endl;
        out << "Polynomial Order = " << PolynomialOrder() << std::endl;
    }
    
public:
    int ClassId() const override;

    void Write(TPZStream &buf, int withclassid) const override{ //ok
    }

    void Read(TPZStream &buf, void *context) override{ //ok
    }
                
};

template<class TVar>
int TPZFunction<TVar>::ClassId() const{
    return Hash("TPZFunction") ^ ClassIdOrHash<TVar>()<<1;
}

template<class TVar>
class TPZDummyFunction : public TPZFunction<TVar>
{
                
    void (*fFunc)(const TPZVec<REAL> &x, TPZVec<TVar> &f);
    void (*fFunc2)(const TPZVec<REAL> &x, TPZVec<TVar> &f, TPZFMatrix<TVar> &gradf);
    void (*fFunc3)(const TPZVec<REAL> &x, REAL ftime, TPZVec<TVar> &f, TPZFMatrix<TVar> &gradf);
    
    int fPorder;
public:
                
                TPZDummyFunction() : TPZRegisterClassId(&TPZDummyFunction::ClassId), TPZFunction<TVar>(), fPorder(-1)
    {
        fFunc = 0;
                                fFunc2 = 0;
                                fFunc3 = 0;                     
    }
                
                virtual ~TPZDummyFunction()
    {
        
    }
    
    TPZDummyFunction(void (*FuncPtr)(const TPZVec<REAL> &x, TPZVec<TVar> &val), int polynomialorder )
    : TPZRegisterClassId(&TPZDummyFunction::ClassId)
    {
        fFunc = FuncPtr;
                                fFunc2 = 0;
                                fFunc3 = 0;
                                fPorder = polynomialorder;
    }
    
    TPZDummyFunction(void (*FuncPtr)(const TPZVec<REAL> &x, TPZVec<TVar> &val, TPZFMatrix<TVar> &gradf), int polynomialorder )
    : TPZRegisterClassId(&TPZDummyFunction::ClassId)
    {
                                fFunc = 0;
        fFunc2 = FuncPtr;                       
                                fFunc3 = 0;
        fPorder = polynomialorder;
    }
                
    TPZDummyFunction(void (*FuncPtr)(const TPZVec<REAL> &x, REAL ftime, TPZVec<TVar> &val, TPZFMatrix<TVar> &gradf), int polynomialorder ) : TPZRegisterClassId(&TPZDummyFunction::ClassId)
    {
                                fFunc = 0;
        fFunc2 = 0;                             
                                fFunc3 = FuncPtr;
        fPorder = polynomialorder;
    }           
    
    TPZDummyFunction(const TPZDummyFunction &cp) : TPZRegisterClassId(&TPZDummyFunction::ClassId), 
    fFunc(cp.fFunc), fFunc2(cp.fFunc2), fFunc3(cp.fFunc3), fPorder(cp.fPorder)
    {
        
    }
    

    TPZDummyFunction &operator=(const TPZDummyFunction &cp)
    {
        fFunc = cp.fFunc;
                                fFunc2 = cp.fFunc2;
                                fFunc3 = cp.fFunc3;
        fPorder = cp.fPorder;
        return *this;
    }
                virtual void Execute(const TPZVec<REAL> &x, TPZVec<TVar> &f, TPZFMatrix<TVar> &df)  override
    {
        if (!fFunc2) {
                                                if (!fFunc)
                                                                DebugStop();
                                                else {
                                                                df.Zero();
                                                                fFunc(x, f);
                                                }
                                }
        else
            fFunc2(x, f, df);
    }
                
                virtual void Execute(const TPZVec<REAL> &x, REAL ftime, TPZVec<TVar> &f, TPZFMatrix<TVar> &gradf)  override
    {
        if (!fFunc3) {
                                                DebugStop();
                                }
        fFunc3(x, ftime, f, gradf);
    }           
    
                virtual void Execute(const TPZVec<REAL> &x, const TPZFMatrix<REAL> &axes, TPZVec<TVar> &f, TPZFMatrix<TVar> &df) override {
        DebugStop();
    }
    
    virtual void Execute(const TPZVec<REAL> &x, TPZVec<TVar> &f) override {
                                if (!fFunc) {
                                                DebugStop();
                                }
        fFunc(x,f);
    }
    
                virtual int NFunctions() const override
    {
        return 1;
    }
    
    void SetPolynomialOrder(int porder)
    {
        fPorder = porder;
    }
                
                virtual int PolynomialOrder() const override
    {
#ifdef PZDEBUG
        if (fPorder == -1) {
            DebugStop();
        }
#endif
        return fPorder;
    }
                
                public:
    int ClassId() const override;

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

template<class TVar>
int TPZDummyFunction<TVar>::ClassId() const{
    return TPZFunction<TVar>::ClassId() ^ Hash("TPZDummyFunction");
}

#endif