pzeuleranalysis.h

Go to the documentation of this file.

#ifndef PZEULERANALYSIS_H
#define PZEULERANALYSIS_H

#ifndef STATE_COMPLEX

#include "pzanalysis.h"
#include "pzcmesh.h"
#include "pzflowcmesh.h"
#include "pzadmchunk.h"
#include "TPZMaterial.h"
#include "pzconslaw.h"
#include "pzstrmatrix.h"
#include "pzsolve.h"
#include "pzdxmesh.h"
#include "pzstepsolver.h"
#include "pzblockdiag.h"

#include <iostream>

class TPZEulerAnalysis : public TPZAnalysis
{
                
public:
                TPZEulerAnalysis();
                TPZEulerAnalysis(TPZFlowCompMesh *mesh,std::ostream &out = std::cout);
                ~TPZEulerAnalysis();

                void WriteCMesh( const char * str);
                
                virtual void Run(std::ostream &out, const std::string & dxout, int dxRes);
                
                virtual void Run(std::ostream &out)
                {
                                std::cout <<__PRETTY_FUNCTION__ << " should never be called!!!\n";
                                TPZAnalysis::Run(out);
                }
                
                void SetAdvancedState();
                
                void SetLastState();
                
                void SetContributionTime(TPZContributeTime time);
                
                void SetEvolCFL(int EvolCFL);
                
                
                void UpdateSolAndRhs(TPZFMatrix<STATE> & deltaSol, REAL & epsilon);
                
                void UpdateHistory();
                
                void BufferLastStateAssemble();
                
                REAL EvaluateFluxEpsilon();
                
                virtual void Assemble();
                
                virtual void AssembleRhs();
                
                int Solve(REAL & res, TPZFMatrix<STATE> * residual, TPZFMatrix<STATE> & delSol);
                
                virtual void Solve()
                {
                                std::cout << __PRETTY_FUNCTION__ << " should never be called\n";
                                TPZAnalysis::Solve();
                }
                int RunNewton(REAL & epsilon, int & numIter);
                
                REAL ComputeTimeStep();
                
                void SetNewtonCriteria(REAL epsilon, int maxIter);
                
                void SetTimeIntCriteria(REAL epsilon, int maxIter);
                
                TPZDXGraphMesh * PrepareDXMesh(const std::string &dxout, int dxRes);
                
                void SetBlockDiagonalPrecond(TPZBlockDiagonal<STATE> * blockDiag);
                
                int LineSearch(REAL &residual, TPZFMatrix<STATE> &sol0, TPZFMatrix<STATE> &dir);
    void CompareRhs();
                
                void CFLControl(REAL & lastEpsilon, REAL & epsilon, REAL & epsilon_Newton, REAL & timeStep);
    void SetGMResFront(REAL tol, int numiter, int numvectors);
    void SetFrontalSolver();
    void SetGMResBlock(REAL tol, int numiter, int numvec);
                
protected:
                
                TPZFlowCompMesh * fFlowCompMesh;
                
                TPZFMatrix<STATE> fRhsLast;
                
                REAL fNewtonEps;
                int fNewtonMaxIter;
                
                REAL fTimeIntEps;
                int fTimeIntMaxIter;
                
                int fEvolCFL;
                
                TPZBlockDiagonal<STATE> * fpBlockDiag;
                
                int fTotalNewton;
                
                int fHasFrontalPreconditioner;
                
};

#endif

#endif