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
//    - $Id: app_pemfc.h 2605 2014-08-15 03:36:44Z secanell $
//
//---------------------------------------------------------------------------

#ifndef _FUELCELL__APP_PEMFC__H
#define _FUELCELL__APP_PEMFC__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/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 appframe classes
#include "block_matrix_application.h"

#include "optimization_block_matrix_application.h"
#include "solver_utils.h"
#include "newton_w_line_search.h"
#include "newton_w_3pp.h"
#include "linear_solvers.h"

#include "operating_conditions.h"
#include "design_MPL.h"
#include "PureGas.h"
#include "PureLiquid.h"
#include "design_fibrous_GDL.h"
#include "homogeneous_CL.h"
#include "nafion_membrane.h"
#include "GasMixture.h"
#include "geometries.h"
#include "geometry.h"
#include "fcst_constants.h"
#include "tafel_kinetics.h"
#include "double_trap_kinetics.h"
#include "dual_path_kinetics.h"
//#include "appshop_cell.h"
//#include "appshop_residual.h"

// Equation Classes
#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"

// Post-processing
#include "postprocessing/data_out.h"
#include "postprocessing/response_current_density.h"
#include "postprocessing/response_water_sorption.h"

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

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

            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(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::NewFicksTransportEquation<dim> ficks_oxygen_nitrogen;
            FuelCellShop::Equation::NewFicksTransportEquation<dim> ficks_water_nitrogen;
            FuelCellShop::Equation::NewFicksTransportEquation<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