pztransientanalysis.h

Go to the documentation of this file.

#ifndef TRANSIENTANALH
#define TRANSIENTANALH

#include "pzanalysis.h"
#include "pznonlinanalysis.h"
#include "pzcompel.h"
#include "pzfmatrix.h"
#include "pzvec.h"
#include <iostream>
#include <list>

class TPZCompMesh;

class TPZFStructMatrix;

template<class TRANSIENTCLASS>
class TPZTransientAnalysis : public TPZNonLinearAnalysis {
                
public:
                
                static double gTime;
                
                double GetgTime(){ return gTime; }
                
                TPZTransientAnalysis(TPZCompMesh *mesh, bool IsLinear = false, std::ostream &out = std::cout);
                
                ~TPZTransientAnalysis();
                
                virtual void Assemble();
                
                virtual void RunTransient(std::ostream &out = std::cout, bool FromBegining = true, bool linesearch = true);
                
                virtual void RunExplicit(std::ostream &out = std::cout, bool FromBegining = true);
                
                virtual void PostProcess(int resolution){ TPZAnalysis::PostProcess(resolution);}
                
                virtual void PostProcess(int resolution, int dimension);
                
                virtual void PostProcess(TPZVec<REAL> &loc, std::ostream &out = std::cout);
                
                void SetConvergence(int niter, REAL eps, bool ForceAllSteps = true);
                
                void SetSaveFrequency(int SaveFrequency, int resolution);
                
                void SetSaveSolution(int SaveFrequency);
                
                std::list< std::pair<TPZFMatrix<STATE>, STATE> > & GetSavedSolutions();
                
                void SetNewtonConvergence(int niter, REAL eps);
                
                REAL & TimeStep();
                
                void SetInitialSolution(TPZFMatrix<STATE> & InitialSol);
                
                void SetInitialSolutionAsZero();
                
                int GetCurrentIter();
    
protected:
                
                bool fIsLinearProblem;
                
                REAL fTimeStep;
                
                int fCurrentIter;
                
                int fNIter;
                
                REAL fSteadyTol;
                
                bool fForceAllSteps;
                
                int fSaveFrequency;  
                int fDXResolution;
                
                int fSaveSolutionVecFrequency;
                
                std::list< std::pair< TPZFMatrix<STATE>, STATE> > fSavedSolutionVec;
                
                void SaveCurrentSolutionVec();
                
                int fNewtonMaxIter;
                
                REAL fNewtonTol;
                
                void SetImplicit();
                
                void SetExplicit();
                
                void SetLastState();
                
                void SetCurrentState();
                
                void SetMassMatrix();
                
                void SetFluxOnly();
                
                void SetAllMaterialsDeltaT();
                
                void ComputeLinearTangentMatrix();
                
                void ComputeMassMatrix();
                
                void ComputeFluxOnly();
                
};

template<class TRANSIENTCLASS>
inline void TPZTransientAnalysis< TRANSIENTCLASS >::SetConvergence(int niter, REAL eps, bool ForceAllSteps){
                this->fNIter = niter;
                this->fSteadyTol = eps;
                this->fForceAllSteps = ForceAllSteps;
}

template<class TRANSIENTCLASS>
inline void TPZTransientAnalysis< TRANSIENTCLASS >::SetSaveFrequency(int SaveFrequency, int resolution){
                this->fSaveFrequency = SaveFrequency;
                this->fDXResolution = resolution;
}

template<class TRANSIENTCLASS>
inline void TPZTransientAnalysis< TRANSIENTCLASS >::SetNewtonConvergence(int niter, REAL eps){
                this->fNewtonMaxIter = niter;
                this->fNewtonTol = eps;
}

template<class TRANSIENTCLASS>
inline REAL & TPZTransientAnalysis< TRANSIENTCLASS >::TimeStep(){
                return this->fTimeStep;
}

template<class TRANSIENTCLASS>
inline int TPZTransientAnalysis< TRANSIENTCLASS >::GetCurrentIter(){
                return this->fCurrentIter;
}

#endif