app_pemfc_capillary_twophase_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_capillary_twophase_nonisothermal.h 21-05-2013
//    - Description: Class designed to solve a two-phase, non-isothermal PEMFC model.
//    - Developers: Jie Zhou
//    - Id: $ $
//
//---------------------------------------------------------------------------

#ifndef _FUELCELL__APP_PEMFC_CAPILLARY_TWOPHASE_NONISOTHERMAL__H
#define _FUELCELL__APP_PEMFC_CAPILLARY_TWOPHASE_NONISOTHERMAL__H


//-- OpenFCST
#include <application_core/optimization_block_matrix_application.h>
#include <utils/operating_conditions.h>
#include <layers/gas_diffusion_layer.h>
#include <layers/micro_porous_layer.h>
#include <layers/catalyst_layer.h>
#include <layers/membrane_layer.h>
#include <materials/PureGas.h>
#include <microscale/PSD_base.h>

#include <equations/thermal_transport_equation.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 <equations/capillary_transport_equation.h>

#include <postprocessing/data_out.h>
#include <postprocessing/response_capillary_related.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>

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

            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 AppPemfcCapillaryTwoPhaseNIThermal
        :
        public FuelCell::ApplicationCore::OptimizationBlockMatrixApplication<dim>
        {
        public:
            

    
            AppPemfcCapillaryTwoPhaseNIThermal (boost::shared_ptr<FuelCell::ApplicationCore::ApplicationData> data = 
            boost::shared_ptr<FuelCell::ApplicationCore::ApplicationData> ());
        
            ~AppPemfcCapillaryTwoPhaseNIThermal ();
            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);
      
            void initialize_solution(FuelCell::ApplicationCore::FEVector& initial_guess,
                                     std::shared_ptr<Function<dim> > initial_function);
            


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

            
            virtual void bdry_responses(std::vector<double>&                                                     dst,
                                        const typename FuelCell::ApplicationCore::DoFApplication<dim>::FaceInfo& bdry_info,
                                        const FuelCell::ApplicationCore::FEVector& src);
                                      
                                      
        protected:



            boost::shared_ptr< FuelCellShop::Geometry::GridBase<dim> > grid;
            
            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::CapillaryPressureEquation<dim> capillary_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::FicksTransportEquation<dim> ficks_oxygen_nitrogen;
            
            FuelCellShop::Equation::FicksTransportEquation<dim> ficks_water_nitrogen;
            
            FuelCellShop::Equation::FicksTransportEquation<dim> ficks_water_hydrogen;
        
            std::vector<std::string> design_var;
            
            std::vector<double> design_var_value;
            

            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;
      
        private:
      
            double l_channel; 
            
            double l_land; 
            
            double time_k;
        };
    }
}

#endif //_FUELCELL__AppPemfcTwoPhaseNIThermal_H