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

#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 "fcst_utilities.h"
#include "boost/shared_ptr.hpp"
#include <base/types.h>

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

using namespace dealii;

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 void get_volume_fractions(std::map<std::string, double>& volume_fractions)
            {
                //Assert( mat_id != numbers::invalid_material_id, ExcMessage("Graded Catalyst Layers needs its material id.") );

                compute_volume_fraction();
                volume_fractions["Solid"] = epsilon_S.at(this->local_material_id());
                volume_fractions["Void"] = epsilon_V.at(this->local_material_id());
                volume_fractions["Ionomer"] = epsilon_N.at(this->local_material_id());

            }
            
             virtual inline void get_loadings(std::map<std::string, double> & info)
             {
                //Assert( mat_id != numbers::invalid_material_id, ExcMessage("Graded/Homogeneous Catalyst Layers needs its material id.") );
               info["V_Pt"] = V_Pt.at(this->local_material_id());
                 info["loading_N"] = loading_N.at(this->local_material_id());
                 info["IC_ratio"] = IC_ratio.at(this->local_material_id());
                 info["prc_Pt"] = prc_Pt.at(this->local_material_id());
             };
            
             inline double get_V_Pt(const unsigned int mat_id = numbers::invalid_material_id) const
             {
                Assert( mat_id != numbers::invalid_material_id, ExcMessage("Graded/Homogeneous Catalyst Layers needs its material id.") );
                // this is blah-blah return, change later
                 return V_Pt.at(this->local_material_id());
             }
            
             virtual double get_active_area_Pt() const
             {
                //Assert( mat_id != numbers::invalid_material_id, ExcMessage("Graded Catalyst Layers needs its material id.") );
                // this is blah-blah return, change later
                 return Av.at(this->local_material_id());
             }
            

            
            virtual void effective_gas_diffusivity(const double&,
                                                       const double&,
                                                       double&) const;

            virtual void effective_gas_diffusivity(std::vector< Tensor<2,dim> >&) const;
            virtual void derivative_effective_gas_diffusivity(std::map< VariableNames, std::vector< Tensor<2,dim> > >&) 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;
            
            virtual void effective_thermal_conductivity(double&) const;
            virtual void effective_thermal_conductivity(std::vector< Tensor<2,dim> >&) const;
            virtual void derivative_effective_thermal_conductivity(std::vector< Tensor<2,dim> >&) const;
            
            virtual void effective_thermoosmotic_diffusivity(std::vector<double>&) const;
            virtual void derivative_effective_thermoosmotic_diffusivity(std::map< VariableNames, std::vector<double> >&) const;
            
            virtual void liquid_permeablity(std::vector< Tensor<2,dim> >&) const;
            virtual void derivative_liquid_permeablity(std::map< VariableNames, std::vector< Tensor<2,dim> > >&) const;
            
            virtual void pcapillary(std::vector<double>&) const;
            virtual void dpcapillary_dsat(std::vector<double> &) const;
            virtual void derivative_dpcapillary_dsat(std::map< VariableNames, std::vector<double> > &) const;
            
            virtual void interfacial_surface_area(std::vector<double>&) const;
            virtual void derivative_interfacial_surface_area(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 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) const
            {
                method = method_eff_property_pores;
            };
            
            void get_method_transport_property_electrolyte(std::string& method) const
            {
                method = method_eff_property_electrolyte;
            };
            
            void get_method_transport_property_solid(std::string& method) const
            {
                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
            std::map< unsigned int, double> epsilon_N;
            std::map< unsigned int, double> epsilon_V;
            std::map< unsigned int, double> epsilon_S;
            std::map< unsigned int, double> epsilon_W;
            
            //-- Catalyst properties
            double rho_Pt;
            double rho_c;
            std::map< unsigned int, double> prc_Pt;
            std::map< unsigned int, double> V_Pt;
            std::map< unsigned int, double> M_Pt;
            std::map< unsigned int, double> Av;
            std::string method_Av;
            std::string method_porosity;
            std::map< unsigned int, double> L_CL;
            
            //-- Electrolyte properties
            double rho_N;
            std::map< unsigned int, double> loading_N;
            std::map< unsigned int, double> IC_ratio;
            
            std::map< unsigned int, 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_th;
            double solid_mu;
            std::string method_eff_property_electrolyte;
            double electrolyte_th;
            double electrolyte_mu;

            
            std::string method_eff_thermal;
            std::map< unsigned int, double> k_T;
            
            std::string method_rel_liquid_permeability;
            std::map< unsigned int, double> s_irr;
            std::map< unsigned int, double> abs_permeability;
            
            std::string method_capillary_function;
        };
    }
}

#endif