base_kinetics.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: base_kinetics.h
//    - Description: Base Kinetics. It implements the interface for other kinetics classes
//        and some common methods.
//    - Developers: M. Moore, M. Bhaiya, M. Secanell and V. Zingan
//
//---------------------------------------------------------------------------

#ifndef _FUELCELLSHOP__BASE__KINETICS_H
#define _FUELCELLSHOP__BASE__KINETICS_H

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

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

// Include OpenFCST routines:
#include <layers/base_layer.h>
#include <materials/catalyst_base.h>
#include <materials/polymer_electrolyte_material_base.h>
#include <utils/fcst_constants.h>
#include <application_core/system_management.h>

using namespace dealii;

namespace FuelCellShop
{
    namespace Kinetics
    {
        class BaseKinetics
        {
        public:

            virtual ~BaseKinetics()
            {};
            

            static void declare_Kinetics_parameters (ParameterHandler &param)
            {

                for (typename FuelCellShop::Kinetics::BaseKinetics::_mapFactory::iterator iterator = FuelCellShop::Kinetics::BaseKinetics::get_mapFactory()->begin();
                     iterator != FuelCellShop::Kinetics::BaseKinetics::get_mapFactory()->end();
                iterator++)
                     {
                         iterator->second->declare_parameters(param);
                     }
            }

             static boost::shared_ptr<FuelCellShop::Kinetics::BaseKinetics > create_Kinetics (ParameterHandler &param,
                                                                                              std::string kinetics_name)
             {

                 boost::shared_ptr<FuelCellShop::Kinetics::BaseKinetics > pointer;

                 typename FuelCellShop::Kinetics::BaseKinetics::_mapFactory::iterator iterator = FuelCellShop::Kinetics::BaseKinetics::get_mapFactory()->find(kinetics_name);

                 if (iterator != FuelCellShop::Kinetics::BaseKinetics::get_mapFactory()->end())
                 {
                     if (iterator->second)
                     {
                         pointer = iterator->second->create_replica();
                     }
                     else
                     {
                         FcstUtilities::log<<"Pointer not initialized"<<std::endl;
                         abort();
                     }
                 }
                 else
                 {
                     FcstUtilities::log<<"Concrete name does not exist"<<std::endl;
                     abort();
                 }

                 pointer->initialize(param);

                 return pointer;
             }



            void set_electrolyte_potential(const SolutionVariable& phi)
            {
                Assert( phi.get_variablename() == protonic_electrical_potential, ExcMessage("Wrong solution variable passed in BaseKinetics::set_electrolyte_potential.") );
                phi_m = phi;
            }
            void set_solid_potential(const SolutionVariable& phi)
            {
                Assert( phi.get_variablename() == electronic_electrical_potential, ExcMessage("Wrong solution variable passed in BaseKinetics::set_solid_potential.") );
                phi_s = phi;
            }
            void set_temperature(const SolutionVariable& temperature)
            {
                Assert( temperature.get_variablename() == temperature_of_REV, ExcMessage("Wrong solution variable passed in BaseKinetics::set_temperature") );
                T = temperature;
            }
            void set_reactant_concentrations(const std::vector<SolutionVariable>& conc_vec)
            {
                Assert( conc_vec.size() > 0, ExcMessage("Atleast one reactant concentration should be passed inside BaseKinetics::set_reactant_concentrations. !!") );

                for ( unsigned int i=0; i<conc_vec.size(); ++i )
                {
                    Assert( (conc_vec[i].get_variablename() != hydrogen_molar_fraction &&
                            conc_vec[i].get_variablename() != oxygen_molar_fraction   &&
                            conc_vec[i].get_variablename() != water_molar_fraction), ExcMessage("Molar fractions can't be setup using BaseKinetics::set_reactant_concentrations.") );

                    reactants_map[ conc_vec[i].get_variablename() ] = conc_vec[i];
                }
            }

            void set_derivative_flags(const std::vector<VariableNames>& flags)
            {
                derivative_flags = flags;
            };

            void set_catalyst(FuelCellShop::Material::CatalystBase* cat_in)
            {
                catalyst = cat_in;
            }

            void set_electrolyte(FuelCellShop::Material::PolymerElectrolyteBase* electrolyte_in)
            {
                electrolyte = electrolyte_in;
            }

            virtual void set_reaction_kinetics(const ReactionNames  name)
            {
                name_reaction_kinetics = name;
            }

            void set_p_t(const double& P_Tot)
            {
                p_total = P_Tot;
            }


            inline ReactionNames get_reaction_name() const
            {
                return name_reaction_kinetics;
            }

            FuelCellShop::Material::CatalystBase* get_cat() const
            {
                return catalyst;

            }

            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 derivative_current (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 void compute_coverages(const std::string& name_species,
                                           std::vector<double>& coverage) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name()  << std::endl;
            };
            virtual void OH_coverage(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 O_coverage(std::vector<double>& ) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name()  << std::endl;
            }


            virtual bool has_coverage(const VariableNames& type){
                return false;
            }


        protected:



            typedef std::map< std::string, BaseKinetics* > _mapFactory;



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



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



            BaseKinetics()
            {
                //FcstUtilities::log << "Creating kinetics object of type ";

                catalyst = NULL;
                electrolyte = NULL;

                // Universal constants
                R = Constants::R();
                F = Constants::F();
                K = Constants::K();

                kin_param_initialized = false;
            };

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

            };

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



            virtual void init_kin_param() = 0;

            bool kin_param_initialized;

            ReactionNames name_reaction_kinetics;

            std::vector<VariableNames> derivative_flags;

            unsigned int n_quad;

            FuelCellShop::Material::CatalystBase* catalyst;
            FuelCellShop::Material::PolymerElectrolyteBase* electrolyte;



            double R;
            double F;
            //Boltzmann constant
            double K;



            double p_total;

            std::map< VariableNames, SolutionVariable > reactants_map;

            SolutionVariable phi_m;

            SolutionVariable phi_s
            ;
            SolutionVariable T;

        }; // BaseKinetics
    } // Kinetics
} // FuelCellShop

#endif