pzconvectionproblem.h

Go to the documentation of this file.

//
//  pzconvectionproblem.h
//  PZ
//
//  Created by Agnaldo Farias on 4/2/13.
//
//

#ifndef __PZ__pzconvectionproblem__
#define __PZ__pzconvectionproblem__

#include "pzdiscgal.h"
//#include "pzfmatrix.h"
//#include "pzmaterial.h"
//#include "pzvec.h"

#include <iostream>


/*
 * \f$ phi*du/dt +  div(ConvDir*u) = f  (Eq. 1)  \f$
 *
 */


class TPZMatConvectionProblem : public TPZDiscontinuousGalerkin {
    
protected:
                REAL fXf;
                
                int fDim;
                
                REAL fRho;
    
                TPZVec<REAL> fConvDir;
    
    //time step
    REAL fTimeStep;
    
    //time of simulation
    REAL fTimeValue;
    
    int fmatId;
    
    //Second order Runge-Kutta
    bool fRungeKuttaTwo;
    
                enum EState { ELastState = 0, ECurrentState = 1 };
    EState gState;

                
public:
    
                TPZMatConvectionProblem();
                
                TPZMatConvectionProblem(int matid, int dim);
    
                virtual ~TPZMatConvectionProblem();
    
    TPZMatConvectionProblem(const TPZMatConvectionProblem &copy);
    
    TPZMatConvectionProblem &operator=(const TPZMatConvectionProblem &copy);
                
                virtual void Print(std::ostream & out) override;
                
                virtual std::string Name()  override { return "TPZMatConvectionProblem"; }
                
                int Dimension() const  override {return fDim;}
    
    int MatId()
    {
        return fmatId;
    }
                
                virtual int NStateVariables() const override;
    
    void SetInternalFlux(REAL flux);
                
                void SetParameters(REAL rho, TPZVec<REAL> &convdir);
                
                void GetParameters(REAL &rho, TPZVec<REAL> &convdir);
    
    void SetLastState(){
        gState = ELastState;
    }
    
                void SetCurrentState(){
        gState = ECurrentState;
    }
    
                void SetTimeStep(REAL delt){
                                fTimeStep = delt;
                }
    
                void SetTimeValue(REAL TimeValue){
                                fTimeValue = TimeValue;
                }
    
    void GetTimeValue(REAL &TimeValue){
                                TimeValue = fTimeValue;
                }


    void SetTrueRungeKuttaTwo(){
        fRungeKuttaTwo = true;
    }
    
    virtual void Contribute(TPZMaterialData &data, 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 ContributeBCInterface(TPZMaterialData &data, TPZMaterialData &dataleft, REAL weight, TPZFMatrix<STATE> &ek,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 int VariableIndex(const std::string &name) override;
                
                virtual int NSolutionVariables(int var) override;
                
                virtual void Solution(TPZMaterialData &data, int var, TPZVec<STATE> &Solout) override;
    
    void Errors(TPZVec<REAL> &x,TPZVec<STATE> &u,
                                                                TPZFMatrix<STATE> &dudx, TPZFMatrix<REAL> &axes, TPZVec<STATE> &flux,
                                                                TPZVec<STATE> &u_exact,TPZFMatrix<STATE> &du_exact,TPZVec<REAL> &values) override;
    public:
virtual int ClassId() const override;

};

#endif /* defined(__PZ__pzconvectionproblem__) */