transient_base.h

Go to the documentation of this file.

//---------------------------------------------------------------------------
//
//    FCST: Fuel Cell Simulation Toolbox
//
//    Copyright (C) 2015 by Energy Systems Design Laboratory, University of Alberta
//
//    This software is distributed under the MIT License.
//    For more information, see the README file in /doc/LICENSE
//
//    - Class: transient_base.h
//    - Description: Base class for a variety of transient solvers
//    - Developers: A. Kosakian, University of Alberta
//
//---------------------------------------------------------------------------

#ifndef __transient_base_h
#define __transient_base_h

#include <application_core/application_wrapper.h>

#include <sys/stat.h>
#include <fstream>

using namespace dealii;
using namespace FuelCell::ApplicationCore;

namespace FuelCell
{
namespace ApplicationCore
{
    class TransientBase: public ApplicationWrapper
    {
    public:
        TransientBase(ApplicationBase& app);

        virtual void declare_parameters (ParameterHandler& param);

        virtual void initialize (ParameterHandler& param);

        virtual void solve(FuelCell::ApplicationCore::FEVector& u,
                           const FuelCell::ApplicationCore::FEVectors& in_vectors) = 0;     

    protected:      
        void debug_output(const FEVector& sol);
        
        void responses_output();       
        
        void error_output(const double& err);       
        
        void tau_output();   
        
        void initialize_u_old(const FEVector u, const double n_ref, const FEVector old_solution, const bool force=true);
        
        void ats_Richardson(FEVector& u, const FEVector u1, const FEVector u2, int scheme_order, bool& solution_accepted);
        
        bool print_last_layer_only;        

        bool debug_solution;

        unsigned int debug;
        
        unsigned int step;

        std::string ats_method;

        double tau;
        
        double max_tau;
        
        double min_tau;
        
        int max_ats_it;
        
        FEVector u_old;
        
        int ar_freq;
        
        double total_time;

        double time;        

        /*
         * Absolute error of the solution in the l2 norm (defined here as L2 norm of the solution divided by the square root of number of DoFs minus one).
         */
        double abs_err_estimate;
        
        /*
         * Relative error of the solution in the l2 norm (defined here as L2 norm of the solution divided by the square root of number of DoFs minus one).
         */
        double rel_err_estimate;
        
        /*
         * Tolerance used for the absolute error of the solution.
         */
        double abs_error_tolerance;
        
        /*
         * Tolerance used for the relative error of the solution.
         */
        double rel_error_tolerance;
        
        /*
         * If true, solution error from each time layer will be output to Solution_error.dat.
         */
        bool output_error;
        
        /*
         * If true, time step from each time layer will be output to Time_step.dat.
         */
        bool output_tau;        
        
        std::ofstream responses_outfile;
        
        std::ofstream error_outfile;       
        
        std::ofstream tau_outfile;            
        
        const std::string fname_err="Solution_error.dat";          
        
        const std::string fname_tau="Time_step.dat";         
        
        /*
         * Returns true if and only if file exists.
         */
        bool file_exists(const std::string& file)
        {
            struct stat buf;
            return (stat(file.c_str(), &buf) ==0);
        }        
        
        std::vector<double> all_time_values;
        
        /*
         * True if simulations is healthy (everything went fine). Used to notify the user in case something went wrong and assertions did not work properly.
         */
        bool everything_is_fine=true;
        
        /*
         * Number of mesh refinements.
         */
        unsigned int n_ref;
        
    private:        
        std::string fname;
        
        std::ofstream streamOut;
        
       const std::string get_time_stepping_method_names() const
       {
           std::stringstream result;
           
           result << "None"
                  << "|"
                  << "Richardson";
           
           return result.str();
       }
       
       double precaution_factor;
    };
}
}

#endif