catalyst_layer.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: catalyst_layer.h
//    - Description: Class characterizing the base catalyst layer and defining interface methods.
//    - Developers: Marc Secanell (2011-2013) and Madhur Bhaiya (2013)
//    - Id: $Id: catalyst_layer.h 2605 2014-08-15 03:36:44Z secanell $ 
//
//---------------------------------------------------------------------------

#ifndef _FUELCELLSHOP__LAYER_CATALYST_LAYER_H
#define _FUELCELLSHOP__LAYER_CATALYST_LAYER_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 "fcst_constants.h"
#include "base_layer.h"
#include "porous_layer.h"
#include "base_kinetics.h"
#include "polymer_electrolyte_material_base.h"
#include "catalyst_support_base.h"
#include "catalyst_base.h"
#include "platinum.h"
#include "carbon.h"
#include "nafion.h"
#include "PureGas.h"
#include "GasMixture.h"
#include "PSD_base.h"

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

class MultiScaleCLTest;

namespace FuelCellShop
{
    namespace Layer
    {
        template <int dim>
        class CatalystLayer :
        public PorousLayer<dim>
        {
            
        public:

            
            friend class ::MultiScaleCLTest;
            


            static void declare_CatalystLayer_parameters (const std::string &cl_section_name, 
                                                          ParameterHandler &param)
            {
                for (typename FuelCellShop::Layer::CatalystLayer<dim>::_mapFactory::iterator iterator = FuelCellShop::Layer::CatalystLayer<dim>::get_mapFactory()->begin(); 
                     iterator != FuelCellShop::Layer::CatalystLayer<dim>::get_mapFactory()->end(); 
                iterator++)
                     {
                         iterator->second->declare_parameters(cl_section_name, param);
                     }   
            }
            
            static boost::shared_ptr<FuelCellShop::Layer::CatalystLayer<dim> > create_CatalystLayer (const std::string& cl_section_name, 
                                                                                                     ParameterHandler &param)
            {
                boost::shared_ptr<FuelCellShop::Layer::CatalystLayer<dim> > pointer;
                
                std::string concrete_name;
                param.enter_subsection("Fuel cell data");
                {
                    param.enter_subsection(cl_section_name);
                    {
                        concrete_name = param.get("Catalyst layer type");
                        //FcstUtilities::log << "name: "<<concrete_name.c_str()<<std::endl;
                    }
                    param.leave_subsection();
                }
                param.leave_subsection();
                
                typename FuelCellShop::Layer::CatalystLayer<dim>::_mapFactory::iterator iterator = FuelCellShop::Layer::CatalystLayer<dim>::get_mapFactory()->find(concrete_name);
                
                if (iterator != FuelCellShop::Layer::CatalystLayer<dim>::get_mapFactory()->end())
                {
                    if (iterator->second)
                    {
                        pointer = iterator->second->create_replica(cl_section_name);
                    }
                    else 
                    {
                        FcstUtilities::log<<"Pointer not initialized"<<std::endl;
                        abort();    
                    }
                }
                else
                {
                    FcstUtilities::log<<"Concrete name in FuelCellShop::Layer::CatalystLayer<dim>::create_CatalystLayer does not exist"<<std::endl;
                    abort();
                }
                
                pointer->initialize(param);
                
                return pointer;
            }
            


            virtual void set_constant_solution(const double& value, const VariableNames& name)
            {
                FuelCellShop::Layer::BaseLayer<dim>::set_constant_solution(value, name);
                
                if (name == temperature_of_REV)
                {
                    this->electrolyte->set_T(value);
                }
                
                else if (name == total_pressure)
                {
                    this->kinetics->set_p_t(value);
                    this->electrolyte->set_p_t(value);
                }
                else if (name == membrane_water_content)
                {
                    this->electrolyte->set_lambda(value);
                }
            }
            
            virtual void set_solution(const std::vector< SolutionVariable >&);
            
            virtual void set_derivative_flags(const std::vector<VariableNames>& flags)
            {
                this->derivative_flags = flags;
                this->kinetics->set_derivative_flags(flags);
                this->electrolyte->set_derivative_flags(flags);
            }
            
            void set_reaction_kinetics(const ReactionNames rxn_name)
            {
                this->kinetics->set_reaction_kinetics(rxn_name);
                this->catalyst->set_reaction_kinetics(rxn_name);
            }
          


            const std::type_info& get_base_type() const
            {
                return typeid(CatalystLayer<dim>);
            }

            virtual void get_volume_fractions(std::map<std::string, double>& )
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
            };
            
            virtual inline void get_loadings(std::map<std::string, double>& )
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl; 
            };
            
            
            virtual void set_cell_id(const unsigned int& id){
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                        << " called in Class "
                        << info.name() << std::endl;
            }



            virtual void effective_gas_diffusivity(const double&, const double&, double&) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
            };

            virtual void effective_gas_diffusivity(std::vector< Tensor<2,dim> >& ) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
            };
            virtual void derivative_effective_gas_diffusivity(std::map< VariableNames, std::vector< Tensor<2,dim> > >& ) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
            };
            
            
            virtual void effective_gas_diffusivity(Table< 2, Tensor<2,dim> >&) const
            {
                 const std::type_info& info = typeid(*this);
                 FcstUtilities::log << "Pure function " << __FUNCTION__
                 << " called in Class "
                 << info.name() << std::endl;
            };
            
            virtual void effective_electron_conductivity(double& ) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
            };
            virtual void effective_electron_conductivity(Tensor<2,dim>& ) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
            };
            virtual void derivative_effective_electron_conductivity(std::vector<double>& ) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
            };
            virtual void derivative_effective_electron_conductivity(std::vector<Tensor<2,dim> >& ) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
            };
            
            virtual void effective_proton_conductivity(double& ) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
            };
            virtual void effective_proton_conductivity(std::vector<double>& ) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
            };
            virtual void derivative_effective_proton_conductivity(std::map< VariableNames, std::vector<double> >& ) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
            };
            
            virtual void effective_thermal_conductivity(double& ) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
            };
            virtual void effective_thermal_conductivity(Tensor<2,dim>& ) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
            };
            virtual void effective_thermal_conductivity(std::vector< Tensor<2,dim> >& ) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;    
            }
            virtual void derivative_effective_thermal_conductivity(std::vector<double>& ) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
            };
            virtual void derivative_effective_thermal_conductivity(std::vector<Tensor<2,dim> >& ) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
            };
            
            virtual void effective_water_diffusivity(double& ) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
            };
            virtual void effective_water_diffusivity(std::vector<double>& ) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
            }
            
            virtual void derivative_effective_water_diffusivity(std::map< VariableNames, std::vector<double> >& ) const
            {
               const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
            }
            
            virtual void effective_thermoosmotic_diffusivity(std::vector<double>& ) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
            };
            
            virtual void derivative_effective_thermoosmotic_diffusivity(std::map< VariableNames, std::vector<double> >& ) const
            {
               const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
            }
            
            virtual void gas_permeablity(double& ) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
            };
            virtual void gas_permeablity(Tensor<2,dim>& ) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
            };
            virtual void derivative_gas_permeablity(std::vector<double>& ) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
            };
            virtual void derivative_gas_permeablity(std::vector<Tensor<2,dim> >& ) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
            };
            
            virtual void liquid_permeablity(std::vector< Tensor<2,dim> >& ) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
            };
            virtual void derivative_liquid_permeablity(std::map< VariableNames, std::vector< Tensor<2,dim> > >& ) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
            };
            
            virtual void pcapillary(std::vector<double>&) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl; 
            };
            virtual void dpcapillary_dsat(std::vector<double> &) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
            };
            virtual void derivative_dpcapillary_dsat(std::map< VariableNames, std::vector<double> > &) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
            };
            
            virtual void interfacial_surface_area(std::vector<double>&) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
            };
            virtual void derivative_interfacial_surface_area(std::map< VariableNames, std::vector<double> >&) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
            };
            
            


            virtual void current_density(std::vector<double>&)
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
            };
            
            virtual void current_density(std::vector<double>&current, std::vector<double>&effectiveness)
            {
                for (unsigned int i = 0; i<effectiveness.size(); ++i)
                    effectiveness[i] = 0;
                
                this->current_density(current);
            };
            
            virtual void derivative_current_density(std::map< VariableNames, std::vector<double> >& )
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
            };
            
            virtual double get_active_area_Pt() const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
                return 0.0;
            };
            
            virtual inline FuelCellShop::Material::PolymerElectrolyteBase* get_electrolyte() const
            {   
                return this->electrolyte.get();
            }
            
            
            virtual inline FuelCellShop::Kinetics::BaseKinetics* get_kinetics() const
            {
                return this->kinetics.get();
            }
            
 
            inline std::string get_kinetics_type(){
                return kinetics_type;
            }


            virtual SolutionMap get_coverages();




        protected:
            


            CatalystLayer();
            
            ~CatalystLayer();
            
            CatalystLayer(const std::string& name);
                       
            
            virtual void declare_parameters (const std::string& name, ParameterHandler &param) const;
                                         
            void initialize (ParameterHandler &param);
            
  


            typedef std::map< std::string, CatalystLayer<dim>* > _mapFactory;      



            static _mapFactory * get_mapFactory()
            {
                static _mapFactory mapFactory;
                return &mapFactory;
            }                               


            virtual boost::shared_ptr<FuelCellShop::Layer::CatalystLayer<dim> > create_replica (const std::string &name)
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
            }
            


            std::string diffusion_species_name;
            
            bool default_materials;
            
            std::string catalyst_type;
            
            std::string catalyst_support_type;

            std::string electrolyte_type;

            std::string kinetics_type;
            
            std::string PSD_type;
            boost::shared_ptr< FuelCellShop::Material::PolymerElectrolyteBase > electrolyte;
            
            boost::shared_ptr< FuelCellShop::Material::CatalystSupportBase > catalyst_support;

            boost::shared_ptr< FuelCellShop::Material::CatalystBase > catalyst;
            
            boost::shared_ptr< FuelCellShop::Kinetics::BaseKinetics > kinetics;
            
            /*** Pointer to the PSD object*/
            boost::shared_ptr< FuelCellShop::MicroScale::BasePSD<dim> > PSD;
            
            unsigned int n_quad;
            
            std::map<VariableNames ,SolutionVariable> solutions;
            
            VariableNames reactant;
            
            #ifdef DEBUG

            /* A list of common variable names that are set to the layer
             *
             * When running in debug this list will be compared with provided list of
             * solutions, in order to check application is consistent in providing solutions.
             *
             * Inconsistent provision of solutions can lead to invalid results.
             */
            std::vector<VariableNames> common_names;

            #endif


        };
        
    } // Layer
    
}  // FuelCellShop
    
#endif // _FUELCELLSHOP__LAYER__CATALYST_LAYER_H