app_pemfc.h

Go to the documentation of this file.

//---------------------------------------------------------------------------
//
//    FCST: Fuel Cell Simulation Toolbox
//
//    Copyright (C) 2009-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.h
//    - Description:
//    - Developers: M. Secanell, P. Dobson, M. Bhaiya
//
//---------------------------------------------------------------------------

#ifndef _FUELCELL__APP_PEMFC__H
#define _FUELCELL__APP_PEMFC__H
//-- OpenFCST
#include <application_core/optimization_block_matrix_application.h>
#include <utils/operating_conditions.h>
#include <layers/design_MPL.h>
#include <materials/PureGas.h>
#include <materials/PureLiquid.h>
#include <layers/design_fibrous_GDL.h>
#include <layers/homogeneous_CL.h>
#include <layers/nafion_membrane.h>
#include <materials/GasMixture.h>
#include <reactions/tafel_kinetics.h>
#include <reactions/double_trap_kinetics.h>
#include <reactions/dual_path_kinetics.h>

#include <equations/reaction_source_terms.h>
#include <equations/proton_transport_equation.h>
#include <equations/lambda_transport_equation.h>
#include <equations/electron_transport_equation.h>
#include <equations/sorption_source_terms.h>
#include <equations/ficks_transport_equation.h>

#include <postprocessing/data_out.h>
#include <postprocessing/response_current_density.h>
#include <postprocessing/response_water_sorption.h>


namespace FuelCell
{

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

            void vector_value (const Point<dim> &p,
                               Vector<double> &v) const;

        private:
            FuelCell::OperatingConditions* OC;

            boost::shared_ptr< FuelCellShop::Geometry::GridBase<dim> > grid;
        };

    } //end namespace InitialSolution


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

        public:

            AppPemfc (boost::shared_ptr<FuelCell::ApplicationCore::ApplicationData> data = boost::shared_ptr<FuelCell::ApplicationCore::ApplicationData> ());

            ~AppPemfc ();
            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){};

            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(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 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 &basename,
                                  const FuelCell::ApplicationCore::FEVectors &src);

 
            void data_out(std::string basename, const FuelCell::ApplicationCore::FEVectors vectors, std::vector< std::string > solution_names);

        protected:



            std::vector<std::string> equation_names;
            std::vector<std::string> component_names;



            OperatingConditions OC;



            //FuelCellShop::Material::Nafion electrolyte;

            //FuelCellShop::Material::CarbonBlack catalyst_support;

            //FuelCellShop::Material::Platinum catalyst;

            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::MicroPorousLayer<dim> > AMPL;

            boost::shared_ptr<FuelCellShop::Layer::CatalystLayer<dim> > ACL;

            boost::shared_ptr<FuelCellShop::Layer::MembraneLayer<dim> > ML;


            boost::shared_ptr<FuelCellShop::Layer::CatalystLayer<dim> > CCL;

            boost::shared_ptr<FuelCellShop::Layer::MicroPorousLayer<dim> > CMPL;

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


            FuelCellShop::PostProcessing::ORRCurrentDensityResponse<dim> ORRCurrent;
            FuelCellShop::PostProcessing::HORCurrentDensityResponse<dim> HORCurrent;
            FuelCellShop::PostProcessing::WaterSorptionResponse<dim> WaterSorption;



            FuelCellShop::Equation::ProtonTransportEquation<dim> proton_transport;

            FuelCellShop::Equation::LambdaTransportEquation<dim> lambda_transport;

            FuelCellShop::Equation::ElectronTransportEquation<dim> electron_transport;

            FuelCellShop::Equation::FicksTransportEquation<dim> ficks_oxygen_nitrogen;
            FuelCellShop::Equation::FicksTransportEquation<dim> ficks_water_nitrogen;
            FuelCellShop::Equation::FicksTransportEquation<dim> ficks_water_hydrogen;

            FuelCellShop::Equation::ReactionSourceTerms<dim> reaction_source_terms;

            FuelCellShop::Equation::SorptionSourceTerms<dim> sorption_source_terms;

            std::vector<std::string> design_var;

            std::vector<double> design_var_value;

        private:

            double l_channel; 

            double l_land; 
            
            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.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.leave_subsection();
                }
                param.leave_subsection();
                param.enter_subsection("Discretization");
                {
                    param.set("Element","FESystem[FE_Q(1)^5]");
                }
                param.leave_subsection();
            }

        };

    }

}

#endif //_FUELCELL__APPPEMFC_H