app_cathode_KG.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------------
//
// FCST: Fuel Cell Simulation Toolbox
//
// Copyright (C) 2006-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: app_cathode_KG.h
// - Description: This class solves
//              - steady-state
//              - compressible
//              - isothermal
//                Kerkhof-Geboers fluid transport equations for a
//              - single-phase
//              - multi-component
//                case coupled with
//              - electron transport equation
//              - proton transport equation
//                in a fuel cell cathode
// - Developers: Valentin N. Zingan, University of Alberta
//
// -----------------------------------------------------------------------------------

#ifndef _FCST_APPLICATION_APP_CATHODE_KG_H_
#define _FCST_APPLICATION_APP_CATHODE_KG_H_
//-- dealII
#include <deal.II/base/function_parser.h>
//-- OpenFCST
#include <application_core/optimization_block_matrix_application.h>
#include <equations/compressible_multi_component_KG_equations_coupled.h>
#include <equations/electron_transport_equation.h>
#include <equations/proton_transport_equation.h>
#include <equations/reaction_source_terms.h>
#include <equations/reaction_source_terms_KG.h>
#include <utils/operating_conditions.h>
#include <utils/scaling.h> // For scaling equations and residuals to help with convergence with MUMPS
#include <postprocessing/data_out.h>
#include <postprocessing/data_out_mass_transport.h>
#include <postprocessing/response_current_density.h>
#include <postprocessing/response_mass_flux.h> //For calculating the mass flux at a boundary

using namespace dealii;
using namespace FuelCell::ApplicationCore;

namespace FuelCell
{
    namespace Application
    {
        
        template<int dim>
        class AppCathodeKG : public OptimizationBlockMatrixApplication<dim>
        {
        public:
            

            
            AppCathodeKG( boost::shared_ptr<ApplicationData> data = boost::shared_ptr<ApplicationData>() );
            
            ~AppCathodeKG();
            
            virtual void declare_parameters(ParameterHandler& param);
            
            virtual void initialize(ParameterHandler& param);
            
            virtual void initialize_solution(FEVector&                        initial_guess,
                                             std::shared_ptr< Function<dim> > function = std::shared_ptr< Function<dim> >());
            
            

            
            virtual void cell_matrix(MatrixVector&                                 cell_matrices,
                                     const typename DoFApplication<dim>::CellInfo& cell_info);
            
            virtual void cell_residual(FEVector&                                     cell_res,
                                       const typename DoFApplication<dim>::CellInfo& cell_info);
            
            virtual void bdry_matrix(MatrixVector&                                 bdry_matrices,
                                     const typename DoFApplication<dim>::FaceInfo& bdry_info);
            
            virtual void bdry_residual(FEVector&                                     bdry_res,
                                       const typename DoFApplication<dim>::FaceInfo& bdry_info);
            
            

            
            virtual void dirichlet_bc(std::map<unsigned int, double>& boundary_values) const;
            
            

            
            virtual void data_out(const std::string& filename,
                                  const FEVectors&   src);
            
            virtual void cell_responses(std::vector<double>&                          dst,
                                        const typename DoFApplication<dim>::CellInfo& cell_info,
                                        const FEVector&                               aux);
            
             virtual void bdry_responses(std::vector<double>&                                                     dst,
                                         const typename FuelCell::ApplicationCore::DoFApplication<dim>::FaceInfo& bdry_info,
                                         const FuelCell::ApplicationCore::FEVector&                               src);
            
            
        protected:
            

            
            void make_variable_boundary_data(FEVector& initial_guess);
            
            FuelCell::Scaling Scale;
            
            bool applyScaling = false;
            
            


            FuelCell::OperatingConditions OC;
            
            std::map<unsigned int, std::string> gasSpeciesMap;
            
            std::string oxygen_density_name;
            
            std::string hydrogen_density_name;
            
            void set_gas_species(std::map<unsigned int, std::string> tmp, std::vector< FuelCellShop::Material::PureGas* >& gases);
            

            

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

            
            FuelCellShop::Layer::Channel<dim> CChannel;
            
            bool withCChannel = false;
            
            bool anode = false;
            
            boost::shared_ptr< FuelCellShop::Layer::GasDiffusionLayer<dim> > CGDL;
            
            boost::shared_ptr< FuelCellShop::Layer::MicroPorousLayer<dim> > CMPL;
            
            boost::shared_ptr< FuelCellShop::Layer::CatalystLayer<dim> > CCL;
            
            

            
            FuelCellShop::Equation::CompressibleMultiComponentKGEquationsCoupled<dim> fluid_transport_equations;
            
            FuelCellShop::Equation::ElectronTransportEquation<dim> electron_transport_equation;
            
            FuelCellShop::Equation::ProtonTransportEquation<dim> proton_transport_equation;
            
            FuelCellShop::Equation::ReactionSourceTermsKG<dim> reaction_source_terms;
            


            FuelCellShop::PostProcessing::ORRCurrentDensityResponse<dim> ORRCurrent;
            FuelCellShop::PostProcessing::HORCurrentDensityResponse<dim> HORCurrent;
            FuelCellShop::PostProcessing::MassFluxResponse<dim>  mass_flux_response;
        };
        
    } // Application
    
} // FuelCell

#endif