pzconslaw.h

Go to the documentation of this file.

#ifndef PZCONSLAW_H
#define PZCONSLAW_H

#include <iostream>
#include "TPZMaterial.h"
#include "pzfmatrix.h"
#include "pzvec.h"
#include "pzdiscgal.h"
#include "Hash/TPZHash.h"

enum TPZTimeDiscr
{
                None_TD = -1,
                Explicit_TD = 0,
                ApproxImplicit_TD = 1,
                Implicit_TD = 2,
                Unknown_TD = 3
};

enum TPZContributeTime
{
                None_CT = -1,
                Last_CT = 0,
                Advanced_CT = 1
};

enum TPZResidualType
{
                None_RT = -1,
                Residual_RT = 0,
                Flux_RT = 1
};

class TPZConservationLaw  : public TPZDiscontinuousGalerkin
{
public:
                TPZConservationLaw(int nummat,REAL timeStep,int dim);
                TPZConservationLaw(const TPZConservationLaw &cp) : TPZDiscontinuousGalerkin(cp), TPZRegisterClassId(&TPZConservationLaw::ClassId),
                fDim(cp.fDim),fTimeStep(cp.fTimeStep),fCFL(cp.fCFL), fGamma(cp.fGamma),fContributionTime(cp.fContributionTime)
                ,fResidualType(cp.fResidualType)
                {
                }
                
                virtual ~TPZConservationLaw();
                
                int Dimension() const override;
                
                REAL TimeStep();
                
                void SetTimeStep(REAL timeStep);
                
                virtual REAL SetTimeStep(REAL maxveloc,REAL deltax,int degree)=0;
                
                REAL CFL();
                
                void SetCFL(REAL CFL);
                
                REAL Gamma();
                
                void SetGamma(int gamma);
                
                void SetContributionTime(TPZContributeTime time);
                
                void SetResidualType(TPZResidualType type);
                
                virtual int NStateVariables() const override = 0;
                
                virtual STATE Pressure(TPZVec<STATE> &U)=0;
                
                virtual void Print(std::ostream & out) override;
                
                virtual std::string Name() override = 0;
                
                virtual int VariableIndex(const std::string &name) override = 0;
                
                virtual int NSolutionVariables(int var) override = 0;
                
                virtual int NFluxes() override;
                
protected:
                virtual void Solution(TPZVec<STATE> &Sol,TPZFMatrix<STATE> &DSol,
                                                                                                  TPZFMatrix<REAL> &axes,int var,
                                                                                                  TPZVec<STATE> &Solout) override = 0;
public:
                virtual void Solution(TPZMaterialData &data, int var, TPZVec<STATE> &Solout) override
                {
                                TPZDiscontinuousGalerkin::Solution(data,var,Solout);
                }
                
                virtual void Contribute(TPZMaterialData &data,
                                                                                                                REAL weight,
                                                                                                                TPZFMatrix<STATE> &ek,TPZFMatrix<STATE> &ef) override = 0;
                
                virtual void Contribute(TPZMaterialData &data,
                                                                                                                REAL weight,
                                                                                                                TPZFMatrix<STATE> &ef) override
                {
                                TPZDiscontinuousGalerkin::Contribute(data,weight,ef);
                }
                virtual void ContributeInterface(TPZMaterialData &data,TPZMaterialData &dataleft,TPZMaterialData &dataright,
                                                                                                                                                 REAL weight,
                                                                                                                                                 TPZFMatrix<STATE> &ek,TPZFMatrix<STATE> &ef) override = 0;
                virtual void ContributeInterface(TPZMaterialData &data,TPZMaterialData &dataleft,TPZMaterialData &dataright,
                                                                                                                                                 REAL weight,
                                                                                                                                                 TPZFMatrix<STATE> &ef) override
                {
                                TPZDiscontinuousGalerkin::ContributeInterface(data,dataleft,dataright,weight,ef);
                }
                virtual void ContributeBC(TPZMaterialData &data,
                                                                                                                  REAL weight,
                                                                                                                  TPZFMatrix<STATE> &ek,TPZFMatrix<STATE> &ef,
                                                                                                                  TPZBndCond &bc) override = 0;
                virtual void ContributeBC(TPZMaterialData &data,
                                                                                                                  REAL weight,
                                                                                                                  TPZFMatrix<STATE> &ef,
                                                                                                                  TPZBndCond &bc) override
                {
                                TPZDiscontinuousGalerkin::ContributeBC(data,weight,ef,bc);
                }
                
        int ClassId() const override{
            return Hash("TPZConservationLaw") ^ TPZDiscontinuousGalerkin::ClassId() << 1;
        }
                
                void Write(TPZStream &buf, int withclassid) const override;
                
                void Read(TPZStream &buf, void *context) override;
                
protected:
                
                int fDim;
                
                REAL fTimeStep;
                
                REAL fCFL;
                
                REAL fGamma;
                
                TPZContributeTime fContributionTime;
                
                TPZResidualType fResidualType;
                
};

inline int TPZConservationLaw::Dimension() const
{
                return fDim;
}

inline REAL TPZConservationLaw::CFL()
{
                return fCFL;
}

inline void TPZConservationLaw::SetCFL(REAL CFL)
{
                //if(CFL > 1e3) CFL = 1e3;
                fCFL = CFL;
}

inline void TPZConservationLaw::SetGamma(int gamma)
{
                fGamma = gamma;
}

inline REAL TPZConservationLaw::Gamma()
{
                return fGamma;
}

inline void TPZConservationLaw::SetTimeStep(REAL timeStep)
{
                fTimeStep = timeStep;
}

inline REAL TPZConservationLaw::TimeStep()
{
                if(fResidualType == Residual_RT)return fTimeStep;
                return 1.;
}
inline int TPZConservationLaw::NFluxes()
{
                return 1;
}

inline void TPZConservationLaw::SetContributionTime(TPZContributeTime time)
{
                fContributionTime = time;
}


inline void TPZConservationLaw::SetResidualType(TPZResidualType type)
{
                fResidualType = type;
}

#endif