conventional_CL.h

Go to the documentation of this file.

//---------------------------------------------------------------------------
//
//    FCST: Fuel Cell Simulation Toolbox
//
//    Copyright (C) 2006-13 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: conventional_cl.h
//    - Description: Class characterizing the conventional catalyst layer and methods for computing effective properties. It also provides interface to various material classes used in catalyst layer.
//    - Developers: Peter Dobson (2011) and Madhur Bhaiya (2013)
//    - Id: $Id: conventional_CL.h 1465 2013-08-30 22:42:25Z madhur $ 
//
//---------------------------------------------------------------------------

#ifndef _FUELCELLSHOP__CONVENTIONAL_CL__H
#define _FUELCELLSHOP__CONVENTIONAL_CL__H

// Include deal.II classes
#include<base/parameter_handler.h>
#include<base/point.h>
#include <base/function.h>
#include <lac/vector.h>
#include <fe/fe_values.h>

// Include FCST classes
#include "catalyst_layer.h"
#include "polymer_electrolyte_material_base.h"
#include "catalyst_support_base.h"
#include "catalyst_base.h"
#include "base_kinetics.h"
#include "platinum.h"
#include "nafion.h"
#include "carbon.h"
#include "geometries.h"
#include "boost/shared_ptr.hpp"

//Include STL
#include <cmath>
#include <iostream>
#include <algorithm>


namespace FuelCellShop
{
    namespace Layer
    {
        template <int dim>
        class ConventionalCL :
        public CatalystLayer<dim>
        {
        public:
            
            static const std::string concrete_name;
            


            ConventionalCL();
            
            ~ConventionalCL();
                       
            

            
            virtual void print_layer_properties() const;
            
            virtual inline void get_volume_fraction(double &epsilon_S_out, 
                                                    double &epsilon_V_out, 
                                                    double &epsilon_N_out) const
            {
                epsilon_S_out = epsilon_S;
                epsilon_V_out = epsilon_V;
                epsilon_N_out = epsilon_N;
            }
            
            virtual inline double get_V_Pt() const
            {
                return V_Pt;
            }
            
            inline double get_active_area_Pt() const
            {
                return Av;
            }
            



            virtual void effective_gas_diffusivity(const double& , double& ) const;
            
            virtual void effective_gas_diffusivity(Table< 2, Tensor< 2, dim > >&) const;
            
            virtual void effective_electron_conductivity(double& ) const;
            
            virtual void effective_electron_conductivity(Tensor<2,dim>& ) const;
            
            virtual void derivative_effective_electron_conductivity(std::vector<double>& ) const;
            
            virtual void effective_proton_conductivity(double& ) const;
            virtual void effective_proton_conductivity(std::vector<double>& ) const;
            virtual void derivative_effective_proton_conductivity(std::map< VariableNames, std::vector<double> >& ) const;
            
            virtual void effective_water_diffusivity(double& ) const;
            virtual void effective_water_diffusivity(std::vector<double>& ) const;
            virtual void derivative_effective_water_diffusivity(std::map< VariableNames, std::vector<double> >& ) const;

            
        protected:


            ConventionalCL(std::string name);
            
            void declare_parameters (const std::string& cl_section_name, 
                                     ParameterHandler &param) const;
                                     
            void set_parameters ( const std::vector<std::string>& name_dvar, 
                                  const std::vector<double>& value_dvar, 
                                  const std::string& cl_section_name, 
                                  ParameterHandler &param ) const;
                                  
            void initialize (ParameterHandler &param);

            void compute_volume_fraction();
            
            void compute_Av();
            void derivative_effective_proton_conductivity_wrt_electrolyte_loading(double& ) const;
            
            void derivative_volume_fractions(double &Depsilon_S, 
                                             double &Depsilon_V, 
                                             double &Depsilon_N) const;
                                             
            void get_method_transport_property_pores(std::string& method)
            {
                method = method_eff_property_pores;
            };
            
            void get_method_transport_property_electrolyte(std::string& method)
            {
                method = method_eff_property_electrolyte;
            };
            
            void get_method_transport_property_solid(std::string& method)
            {
                method = method_eff_property_solid;
            };
            
            inline double depsilon_S_cat_dprc_Pt(const double V_Pt, 
                                                const double prc_Pt) const
            {
                return -(V_Pt*1e-3)/(rho_c*pow(prc_Pt,2.0));
            }
            
            inline double depsilon_S_cat_dVPt(const double prc_Pt) const
            {
                return  (1/rho_Pt + (1-prc_Pt)/(prc_Pt*rho_c))*(1e-3);
            }
            
            inline double depsilon_V_cat_depsilon_S_cat() const
            {
                return -1;
            }
            
            inline double depsilon_V_cat_depsilon_N_cat() const
            {
                return -1;
            }
            
            //-- Composition
            double epsilon_N;
            double epsilon_V;
            double epsilon_S;
            double epsilon_W;
            
            //-- Catalyst properties
            double rho_Pt;
            double rho_c;
            double prc_Pt;
            double V_Pt;
            double M_Pt;
            double Av;
            std::string method_Av;
            std::string method_porosity;
            double L_CL;
            
            //-- Electrolyte properties
            double rho_N;
            double loading_N;
            double prc_N;
            
            // Network characteristics
            std::string method_eff_property_pores;
            double porosity_th;
            double porosity_mu;
            double porosity_gamma;
            
            std::string method_eff_property_solid;
            double solid_electron_conductivity;
            double solid_th;
            double solid_mu;
            std::string method_eff_property_electrolyte;
            double electrolyte_proton_conductivity;
            double electrolyte_th;
            double electrolyte_mu;
            double sigma_p;
            
            double E0;
        };
    }
}

#endif