polymer_electrolyte_material_base.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: polymer_electrolyte_material_base.h
//    - Description: base class for polymer electrolyte materials e.g. Nafion
//    - Developers: M. Secanell and Madhur Bhaiya
//    - Id: $Id: polymer_electrolyte_material_base.h 2605 2014-08-15 03:36:44Z secanell $ 
//
//---------------------------------------------------------------------------

#ifndef _FUELCELLSHOP_POLYMER_ELECTROLYTE_MATERIAL_BASE__H
#define _FUELCELLSHOP_POLYMER_ELECTROLYTE_MATERIAL_BASE__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 "materials/base_material.h"
#include "utils/fcst_constants.h"
#include "materials/PureGas.h"

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


namespace FuelCellShop
{
    namespace Material
    {
        class PolymerElectrolyteBase 
        :
        public BaseMaterial
        {
        public:


            static void declare_PolymerElectrolyte_parameters (ParameterHandler &param)
            {
                
                for (typename FuelCellShop::Material::PolymerElectrolyteBase::_mapFactory::iterator iterator = FuelCellShop::Material::PolymerElectrolyteBase::get_mapFactory()->begin(); 
                     iterator != FuelCellShop::Material::PolymerElectrolyteBase::get_mapFactory()->end(); 
                iterator++)
                     {
                         iterator->second->declare_parameters(param);
                     }        
            }
                        
             static boost::shared_ptr<FuelCellShop::Material::PolymerElectrolyteBase > create_PolymerElectrolyte (ParameterHandler &param,
                                                                                                                  std::string polymer_electrolyte_name)
             {       
                 boost::shared_ptr<FuelCellShop::Material::PolymerElectrolyteBase > pointer;

                 typename FuelCellShop::Material::PolymerElectrolyteBase::_mapFactory::iterator iterator = FuelCellShop::Material::PolymerElectrolyteBase::get_mapFactory()->find(polymer_electrolyte_name);
                 
                 if (iterator != FuelCellShop::Material::PolymerElectrolyteBase::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 in FuelCellShop::Material::PolymerElectrolyteBase::create_PolymerElectrolyte does not exist"<<std::endl;
                     abort();
                 }
                 
                 pointer->initialize(param);
                 
                 return pointer;
             }
  

            
            virtual void sorption_isotherm(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 sorption_isotherm_derivative(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 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 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 proton_conductivity_derivative(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 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 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 water_diffusivity_derivative(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 electroosmotic_drag(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 electroosmotic_drag_derivative(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 thermoosmotic_coeff(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 thermoosmotic_coeff_derivative(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 oxygen_diffusivity(double&) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
            }
            virtual void hydrogen_diffusivity(double&) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
            }
            virtual void oxygen_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 oxygen_diffusivity_derivative(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 proton_diffusivity(double&) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
            }

            virtual void sorption_enthalpy(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 sorption_enthalpy_derivative(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 double get_Hlambda(const double&) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
            }
            
            virtual double get_dHlambda_dT(const double&) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
            }
            
            virtual double get_d2Hlambda_dT2(const double&) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
            }
            

            
            inline double get_density() const
            {
                return rho_M;
            }
            
            inline double get_H_O2() const
            {
                return H_O2;
            }
            
            inline double get_H_H2() const
            {
                return H_H2;
            }
            
            inline double get_EW() const
            {
                return EW;
            }
            
            inline double get_permittivity() const
            {
                return permittivity;
            }
            
            

            
            inline void set_p_t(const double& p_t)
            {
                p_total = p_t;
            }
            
            inline void set_T (const double& Temp)
            {
                T = Temp;
            }
            
            inline void set_lambda(const double& L)
            {
                lambda = L;
            }
            
            inline void set_membrane_water_content(const FuelCellShop::SolutionVariable& l_in)
            {
                Assert( ((l_in.is_initialized()) && (l_in.get_variablename() == membrane_water_content)),
                        ExcMessage("Input solution variable not initialized properly in PolymerElectrolyteBase::set_membrane_water_content method.") );
                
                lambda_var = l_in;
                
                if ( !T_var.is_initialized() )
                    T_var = FuelCellShop::SolutionVariable(T, lambda_var.size(), temperature_of_REV);
            }
            
            inline void set_temperature(const FuelCellShop::SolutionVariable& T_in)
            {
                Assert( ((T_in.is_initialized()) && (T_in.get_variablename() == temperature_of_REV)),
                        ExcMessage("Input solution variable not initialized properly in PolymerElectrolyteBase::set_temperature method.") );
                
                T_var = T_in;
                
                if ( !lambda_var.is_initialized() )
                    lambda_var = FuelCellShop::SolutionVariable(lambda, T_var.size(), membrane_water_content);
            }
            
            inline void set_water_molar_fraction(const FuelCellShop::SolutionVariable& x_in)
            {
                Assert( ((x_in.is_initialized()) && (x_in.get_variablename() == water_molar_fraction)),
                        ExcMessage("Input solution variable not initialized properly in PolymerElectrolyteBase::set_water_molar_fraction method.") );
                
                xwater_var = x_in;
                
                if ( !T_var.is_initialized() )
                    T_var = FuelCellShop::SolutionVariable(T, xwater_var.size(), temperature_of_REV);
            }
            
        protected:


            PolymerElectrolyteBase(std::string name)
            : BaseMaterial(name)
            {
                lambda = 12.0;
                T = 0.0;        // Used for assertion to throw error, if temperature values are not set.
                p_total = 0.0;  // Used for assertion to throw error, if pressure values are not set.
                
                water_mat = new FuelCellShop::Material::WaterVapor;
            };
            
            PolymerElectrolyteBase()
            : FuelCellShop::Material::BaseMaterial()
            {
                lambda = 12.0;
                T = 0.0;        // Used for assertion to throw error, if temperature values are not set.
                p_total = 0.0;  // Used for assertion to throw error, if pressure values are not set.
                
                water_mat = new FuelCellShop::Material::WaterVapor;
            };
            
            virtual ~PolymerElectrolyteBase()
            {
                delete water_mat;
            };
            
            virtual void declare_parameters(ParameterHandler &param) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name()  << std::endl;
            };
                       
            virtual void initialize (ParameterHandler &param)
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name()  << std::endl;
            };



            typedef std::map< std::string, FuelCellShop::Material::PolymerElectrolyteBase* > _mapFactory;      
            


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


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


            double EW;
            
            double rho_M;
            
            double H_O2;
            double H_H2;
            double permittivity;
            
            
            double T;
            
            double lambda;
            
            double p_total;
            
            
            double sigma_p;
            
            double diffusion_w;
            
            double given_n_drag;
            
            double given_thermoosmotic_coeff;
            
            double given_enthalpy_sorption;
            
            double D_O2;
            
            double D_H2;

            double D_Protons;
            

            
            std::string method_conductivity;

            std::string method_sorption;
            
            std::string method_diffusivity;
            
            std::string method_electroosmotic_drag;
            
            std::string method_thermoosmosis;
            
            std::string method_enthalpy_sorption;
            

            
            FuelCellShop::SolutionVariable lambda_var;
            
            FuelCellShop::SolutionVariable T_var;
            
            FuelCellShop::SolutionVariable xwater_var;


            FuelCellShop::Material::WaterVapor* water_mat;    
        };
    }
}

#endif