app_pemfc_nonisothermal.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_pemfc_nonisothermal.h 21-05-2013
//    - Description: Class designed to solve a non-isothermal PEMFC model.
//    - Developers: Madhur Bhaiya
//    - Id: $Id: app_pemfc_nonisothermal.h 2605 2014-08-15 03:36:44Z secanell $
//
//---------------------------------------------------------------------------

#ifndef _FUELCELL__APP_PEMFC_NONISOTHERMAL__H
#define _FUELCELL__APP_PEMFC_NONISOTHERMAL__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/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 "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 "operating_conditions.h"
#include "geometries.h"

#include "gas_diffusion_layer.h"
#include "micro_porous_layer.h"
#include "catalyst_layer.h"
#include "membrane_layer.h"
#include "PureGas.h"

// Equation Classes
#include "thermal_transport_equation.h"
#include "reaction_source_terms.h"
#include "proton_transport_equation.h"
#include "lambda_transport_equation.h"
#include "electron_transport_equation.h"
#include "sorption_source_terms.h"
#include "new_ficks_transport_equation.h"

#include "postprocessing/data_out.h"
#include "postprocessing/response_current_density.h"
#include "postprocessing/response_ohmic_heat.h"
#include "postprocessing/response_sorption_heat.h"
#include "postprocessing/response_reaction_heat.h"
#include "postprocessing/response_water_sorption.h"

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


namespace FuelCell
{
    namespace InitialSolution
    {
        template <int dim>
        class AppPemfcNIThermalIC
        :
        public Function<dim>
        {
        public:
            AppPemfcNIThermalIC (FuelCell::OperatingConditions* OC,
                                 boost::shared_ptr< FuelCellShop::Geometry::GridBase<dim> > grid,
                                 FuelCell::SystemManagement* system_mgmt);
            ~AppPemfcNIThermalIC ();

            void vector_value (const Point<dim> &p,
                               Vector<double> &v) const;
      
        private:
            FuelCell::OperatingConditions* OC;
            
            boost::shared_ptr< FuelCellShop::Geometry::GridBase<dim> > grid;
            
            FuelCell::SystemManagement* system;
        };
    } //end namespace InitialSolution
  

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

    
            AppPemfcNIThermal (boost::shared_ptr<FuelCell::ApplicationCore::ApplicationData> data = 
            boost::shared_ptr<FuelCell::ApplicationCore::ApplicationData> ());
        
            ~AppPemfcNIThermal ();
            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(ParameterHandler& param);
        
            virtual void initialize(ParameterHandler& param);
      
            virtual void initialize_solution (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 void check_responses();
            
            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);
            
            virtual void cell_dresponses_dl(std::vector<std::vector<double> >& /*cell_df_dl*/,
                                            const typename DoFApplication<dim>::CellInfo& /*info*/,
                                            const FuelCell::ApplicationCore::FEVector& /*sol*/) {};
                                        
            virtual void global_dresponses_dl(std::vector<std::vector<double> >& df_dl,
                                            const FuelCell::ApplicationCore::FEVector& sol);
            virtual void cell_dresponses_du(std::vector<FuelCell::ApplicationCore::FEVector >& /*cell_df_du*/,
            const typename DoFApplication<dim>::CellInfo& /*info*/,
            std::vector<std::vector<double> >& /*src*/) {};
                                        
            virtual void global_dresponses_du(std::vector<FuelCell::ApplicationCore::FEVector >& df_du,
                                            const FuelCell::ApplicationCore::FEVector& src);
            
            
            virtual double evaluate (const FuelCell::ApplicationCore::FEVectors& src);
            
            virtual void data_out(const std::string& filename, 
                                  const FuelCell::ApplicationCore::FEVectors& src);                                      
                                      
        protected:
            

            
            FuelCell::OperatingConditions OC;
      

            
            FuelCellShop::Material::WaterVapor water;
            
            FuelCellShop::Material::Oxygen oxygen;
            
            FuelCellShop::Material::Nitrogen nitrogen;
            
            FuelCellShop::Material::Hydrogen hydrogen;
            

            boost::shared_ptr< FuelCellShop::Layer::GasDiffusionLayer<dim> > AGDL; 
            boost::shared_ptr< FuelCellShop::Layer::GasDiffusionLayer<dim> > CGDL; 
            boost::shared_ptr< FuelCellShop::Layer::MicroPorousLayer<dim> > AMPL; 
            boost::shared_ptr< FuelCellShop::Layer::MicroPorousLayer<dim> > CMPL; 
            boost::shared_ptr< FuelCellShop::Layer::CatalystLayer<dim> > ACL; 
            boost::shared_ptr< FuelCellShop::Layer::CatalystLayer<dim> > CCL; 
            boost::shared_ptr< FuelCellShop::Layer::MembraneLayer<dim> > ML; 

        


            FuelCellShop::Equation::ThermalTransportEquation<dim> thermal_transport;
            
            FuelCellShop::Equation::ProtonTransportEquation<dim> proton_transport;
            
            FuelCellShop::Equation::LambdaTransportEquation<dim> lambda_transport;
            
            FuelCellShop::Equation::ElectronTransportEquation<dim> electron_transport;
            
            FuelCellShop::Equation::ReactionSourceTerms<dim> reaction_source_terms;
            
            FuelCellShop::Equation::SorptionSourceTerms<dim> sorption_source_terms;
            
            FuelCellShop::Equation::NewFicksTransportEquation<dim> ficks_oxygen_nitrogen;
            
            FuelCellShop::Equation::NewFicksTransportEquation<dim> ficks_water_nitrogen;
            
            FuelCellShop::Equation::NewFicksTransportEquation<dim> ficks_water_hydrogen;
            

            FuelCellShop::PostProcessing::ORRCurrentDensityResponse<dim> ORRCurrent;
            
            FuelCellShop::PostProcessing::HORCurrentDensityResponse<dim> HORCurrent;
            
            FuelCellShop::PostProcessing::ProtonOhmicHeatResponse<dim> protonOhmicHeat;
            
            FuelCellShop::PostProcessing::ElectronOhmicHeatResponse<dim> electronOhmicHeat;
            
            FuelCellShop::PostProcessing::SorptionHeatResponse<dim> sorptionHeat;
            
            FuelCellShop::PostProcessing::ORRReactionHeatResponse<dim> catReactionHeat;
            
            FuelCellShop::PostProcessing::HORReactionHeatResponse<dim> anReactionHeat;
            
            FuelCellShop::PostProcessing::WaterSorptionResponse<dim> waterSorption;
        
            std::vector<std::string> design_var;
            
            std::vector<double> design_var_value;
      
        private:
      
            double l_channel; 
            
            double l_land; 
            
            double time_k;
            
            void set_default_parameters_for_application(ParameterHandler &param)
            {
                param.enter_subsection("System management");
                {
                    param.set("Number of solution variables","5");
                    param.enter_subsection("Solution variables");
                    {
                        param.set("Solution variable 1","oxygen_molar_fraction");
                        param.set("Solution variable 2","water_molar_fraction");
                        param.set("Solution variable 3","protonic_electrical_potential");
                        param.set("Solution variable 4","electronic_electrical_potential");
                        param.set("Solution variable 5","membrane_water_content");
                        param.set("Solution variable 6","temperature_of_REV");
                    }
                    param.leave_subsection();
                    
                    param.enter_subsection("Equations");
                    {
                        param.set("Equation 1","Ficks Transport Equation - oxygen");
                        param.set("Equation 2","Ficks Transport Equation - water");
                        param.set("Equation 3","Proton Transport Equation");
                        param.set("Equation 4","Electron Transport Equation");
                        param.set("Equation 5","Membrane Water Content Transport Equation");
                        param.set("Equation 6","Thermal Transport Equation");
                    }
                    param.leave_subsection();
                }
                param.leave_subsection();
                param.enter_subsection("Discretization");
                {
                    param.set("Element","FESystem[FE_Q(1)^6]");
                }
                param.leave_subsection();
            }
        };
    }
}

#endif //_FUELCELL__AppPemfcNIThermal_H