membrane_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: membrane_layer.h
//    - Description: (base) class for membrane layers
//    - Developers: Marc Secanell (2013) and Madhur Bhaiya (2012-13)
//    - Id: $Id: membrane_layer.h 2605 2014-08-15 03:36:44Z secanell $ 
//
//---------------------------------------------------------------------------

#ifndef _FUELCELLSHOP__MEMBRANE_LAYER_H
#define _FUELCELLSHOP__MEMBRANE_LAYER_H

// Include FCST classes
#include <layers/base_layer.h>
#include <materials/polymer_electrolyte_material_base.h>
#include <materials/nafion.h>


namespace FuelCellShop
{
    namespace Layer
    {
        template <int dim>
        class MembraneLayer :
        public BaseLayer<dim>
        {
        public:


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



            const std::type_info& get_base_type() const
            {
                return typeid(MembraneLayer<dim>);
            }
                                    
            virtual void set_derivative_flags(const std::vector<VariableNames>& flags)
            {
                this->derivative_flags = flags;
                this->electrolyte->set_derivative_flags(flags);
            }
            
            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);
                }
            }
            
            FuelCellShop::Material::PolymerElectrolyteBase* get_electrolyte() const
            {
                return this->electrolyte.get();
            }
            


            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_oxygen_diffusivity(double&) const;
            virtual void effective_oxygen_diffusivity(std::vector<double>&) const;
            virtual void derivative_effective_oxygen_diffusivity(std::map< VariableNames, std::vector<double> >&) const;
            
            virtual void effective_thermal_conductivity(double&) const;
            virtual void effective_thermal_conductivity(std::vector<double>&) const;
            virtual void effective_thermal_conductivity(std::vector< Tensor<2,dim> >&) const;
            virtual void derivative_effective_thermal_conductivity(std::vector< std::vector<double> >&) const;
            virtual void derivative_effective_thermal_conductivity(std::vector< 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;
            
            
            
        protected:


            MembraneLayer();
            MembraneLayer(std::string name);
            
            ~MembraneLayer();
            
            void declare_parameters(ParameterHandler &param) const
            {
                this->declare_parameters(this->name, param);
            }  
            
            virtual void declare_parameters (const std::string& name, 
                                             ParameterHandler &param) const;           
                                   
            void initialize (ParameterHandler &param);


            typedef std::map< std::string, MembraneLayer<dim>* > _mapFactory;      
            
            static _mapFactory * get_mapFactory()
            {
                static _mapFactory mapFactory;
                return &mapFactory;
            }  
            virtual boost::shared_ptr<FuelCellShop::Layer::MembraneLayer<dim> > create_replica (std::string &name)
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
            }            
                                                                          


             std::string electrolyte_type;
             
             boost::shared_ptr< FuelCellShop::Material::PolymerElectrolyteBase > electrolyte;    
            
            
        };
        
    }
}

#endif