gas_diffusion_layer.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: gas_diffusion_layer.h
//    - Description: Base Gas Diffusion Layer Class. It implements the interface for other gas diffusion layer classes
//        and some common methods.
//    - Developers: M. Secanell
//    - $Id: gas_diffusion_layer.h 2605 2014-08-15 03:36:44Z secanell $
//
//---------------------------------------------------------------------------

#ifndef _FUELCELLSHOP__GAS_DIFFUSION_LAYER_H
#define _FUELCELLSHOP__GAS_DIFFUSION_LAYER_H

// FCST classes
#include "fcst_constants.h"
#include "base_material.h"
#include "base_layer.h"
#include "porous_layer.h"
#include "PSD_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 STL
#include<cmath>
#include<iostream>

using namespace dealii;

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


            static const std::string concrete_name;         
            

            static void declare_GasDiffusionLayer_parameters (const std::string& gdl_section_name, ParameterHandler &param)
            {
                
                for (typename FuelCellShop::Layer::GasDiffusionLayer<dim>::_mapFactory::iterator iterator = FuelCellShop::Layer::GasDiffusionLayer<dim>::get_mapFactory()->begin(); 
                     iterator != FuelCellShop::Layer::GasDiffusionLayer<dim>::get_mapFactory()->end(); 
                iterator++)
                     {
                         iterator->second->declare_parameters(gdl_section_name, param);
                     }        
            }

             static boost::shared_ptr<FuelCellShop::Layer::GasDiffusionLayer<dim> > create_GasDiffusionLayer (const std::string& gld_section_name, 
                                                                                                              ParameterHandler &param)
             {       
                 
                 boost::shared_ptr<FuelCellShop::Layer::GasDiffusionLayer<dim> > pointer; 
                 
                 std::string concrete_name;
                 param.enter_subsection("Fuel cell data");
                 {
                     param.enter_subsection(gld_section_name);
                     {
                         concrete_name = param.get("Gas diffusion layer type");
                         FcstUtilities::log << "name: "<<concrete_name.c_str()<<std::endl;
                     }
                     param.leave_subsection();
                 }
                 param.leave_subsection();
                 
                 typename FuelCellShop::Layer::GasDiffusionLayer<dim>::_mapFactory::iterator iterator = FuelCellShop::Layer::GasDiffusionLayer<dim>::get_mapFactory()->find(concrete_name);
                 
                 if (iterator != FuelCellShop::Layer::GasDiffusionLayer<dim>::get_mapFactory()->end())
                 {
                     if (iterator->second)
                     {
                         pointer = iterator->second->create_replica(gld_section_name);
                     }
                     else 
                     {
                         FcstUtilities::log<<"Pointer not initialized"<<std::endl;
                         abort();
                     }
                 }
                 else
                 {
                     FcstUtilities::log<<"Concrete name in FuelCellShop::Layer::GasDiffusionLayer<dim>::create_GasDiffusionLayer does not exist"<<std::endl;
                     abort();
                 }
                 
                 pointer->initialize(param);
                 
                 return pointer;
             }


            
            virtual void set_diffusion_species_name(std::string &name)
            {
                Assert((name != "oxygen" || name != "nitrogen" || name != "water" || name != "electron"),
                       ExcNotImplemented());
                diffusion_species_name = name;
            };
            


            const std::type_info& get_base_type() const
            {
                return typeid(GasDiffusionLayer<dim>);
            }
            
            virtual void test_class() const;
            


            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(const double&, const double&, 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(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, double>& D_eff ) const;
            virtual void effective_gas_diffusivity(Table< 2, Tensor<2,dim> > &D_eff ) const;

            
            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(const double& /*prop*/, double& /*prop_eff*/) 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 effective_electron_conductivity(const double& /*prop*/, Tensor<2,dim>& /*prop_eff*/) 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_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<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 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<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;
            };
            

        protected:


            typedef std::map< std::string, GasDiffusionLayer<dim>* > _mapFactory;      
            //typedef std::map< std::string, boost::shared_ptr<GasDiffusionLayer<dim> > > _mapFactory;      
            


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


            GasDiffusionLayer();
                       
            ~GasDiffusionLayer();     
            GasDiffusionLayer(const std::string& name);
            
            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);
                       


            virtual boost::shared_ptr<FuelCellShop::Layer::GasDiffusionLayer<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; 
            
            std::string PSD_type;
            
            double porosity;
            
            Tensor<2,dim> tortuosity_tensor;
            
            Tensor<2, dim> thermal_conductivity_tensor;
            
            double electron_conductivity;
            
            Tensor<2, dim> electron_conductivity_tensor;
            
            /*** Pointer to the PSD object*/
            boost::shared_ptr< FuelCellShop::MicroScale::BasePSD<dim> > PSD;
            
        };
        
    }
    
}  // FuelCellShop

#endif // _FUELCELLSHOP__GAS_DIFFUSION_LAYER_H