app_thermal_test.h

Go to the documentation of this file.

//---------------------------------------------------------------------------
//
//    FCST: Fuel Cell Simulation Toolbox
//
//    Copyright (C) 2013 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: app_thermal_test.h 21-05-2013
//    - Description: Class designed to test thermal transport equation.
//    - Developers: Madhur Bhaiya
//    - Id: $Id: app_thermal_test.h 2605 2014-08-15 03:36:44Z secanell $
//
//---------------------------------------------------------------------------

#ifndef _FUELCELL__APP_THERMAL_TEST__H
#define _FUELCELL__APP_THERMAL_TEST__H

// Include deal.II classes
#include "base/parameter_handler.h"
#include "base/function_lib.h"
#include "base/function.h"
#include "base/quadrature_lib.h"

#include "lac/block_vector.h"
#include "lac/full_matrix.h"
#include "lac/solver_cg.h"
#include "lac/solver_gmres.h"
#include "lac/precondition.h"
#include "lac/precondition_block.h"
#include "lac/block_matrix_array.h"
#include "lac/sparse_ilu.h"
#include "lac/sparse_direct.h"

#include "grid/grid_generator.h"
#include "grid/tria_accessor.h"
#include "grid/tria_iterator.h"
#include "grid/tria_boundary_lib.h"

#include "fe/fe_values.h"

#include "numerics/vector_tools.h"
#include "numerics/matrix_tools.h"
#include "numerics/error_estimator.h"

#include "boost/shared_ptr.hpp"

// Include FuelCell classes
#include "fcst_constants.h"
#include "optimization_block_matrix_application.h"
#include "solver_utils.h"
#include "linear_solvers.h"

#include "geometries.h"

#include "gas_diffusion_layer.h"

// Equation Classes
#include "thermal_transport_equation.h"

//Include STL
#include <fstream>
#include <iostream>
#include <sstream>
#include <cmath>
#include <vector>
#include <algorithm>


namespace FuelCell
{
    namespace InitialSolution
    {
        template <int dim>
        class AppThermalTestIC
        :
        public Function<dim>
        {
        public:
            AppThermalTestIC (const std::string& type);
            virtual ~AppThermalTestIC (){};

            virtual double value (const Point<dim> &p,
                                  const unsigned int component = 0) const;
                                  
        private:
            
            std::string case_type;
        };
    } //end namespace InitialSolution
  

    namespace Application
    {
        //---------------------------------------------------------------------------
        //---------------------------------------------------------------------------
        //---------------------------------------------------------------------------
        template <int dim>
        class AppThermalTest
        :
        public FuelCell::ApplicationCore::OptimizationBlockMatrixApplication<dim>
        {
        public:
            

    
            AppThermalTest (boost::shared_ptr<FuelCell::ApplicationCore::ApplicationData> data = boost::shared_ptr<FuelCell::ApplicationCore::ApplicationData> ());
        
            virtual ~AppThermalTest (){};
            virtual void declare_parameters(ParameterHandler& param);
        
            virtual void set_parameters(const std::vector<std::string>& name_dvar,
                                        const std::vector<double>& value_dvar,
                                        ParameterHandler& param){};    
        
            void initialize_triangulation(ParameterHandler& param);
        
            virtual void initialize(ParameterHandler& param);
      
            virtual void initialize_solution (FuelCell::ApplicationCore::FEVector& initial_guess,
                                              std::shared_ptr<Function<dim> > initial_function = std::shared_ptr<Function<dim> >());
            


            virtual void cell_matrix(FuelCell::ApplicationCore::MatrixVector& cell_matrices,
                                     const typename DoFApplication<dim>::CellInfo& cell);  
            virtual void cell_residual(FuelCell::ApplicationCore::FEVector& cell_vector,
                                       const typename DoFApplication<dim>::CellInfo& cell);
            
            virtual void bdry_matrix(FuelCell::ApplicationCore::MatrixVector& bdry_matrices,
                                     const typename DoFApplication<dim>::FaceInfo& bdry_info);
            
            virtual void bdry_residual(FuelCell::ApplicationCore::FEVector& bdry_vector,
                                       const typename DoFApplication<dim>::FaceInfo& bdry_info);
        
            virtual void dirichlet_bc(std::map<unsigned int, double>& boundary_values) const;
      
            virtual double estimate(const FuelCell::ApplicationCore::FEVectors& sol);

            
            virtual void data_out(const std::string& basename,
                                  const FuelCell::ApplicationCore::FEVectors& vectors);
            
            virtual void cell_responses (std::vector<double>& resp,
                                        const typename DoFApplication<dim>::CellInfo& info,
                                        const FuelCell::ApplicationCore::FEVector& sol){};
            virtual void global_responses (std::vector<double>& resp,
                                            const FuelCell::ApplicationCore::FEVector& sol){};
                                      
                                      
        protected:
            


            boost::shared_ptr< FuelCellShop::Layer::GasDiffusionLayer<dim> > test_layer;
        


            FuelCellShop::Equation::ThermalTransportEquation<dim> thermal_transport;
            
            std::string case_type;
            

        };
    }
}

#endif //_FUELCELL__AppThermalTest_H