micro_porous_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: micro_porous_layer.h
//    - Description: Base Micro-Porous Layer Class. It implements the interface for other micro-porous layer classes
//        and some common methods.
//    - Developers: M. Secanell
//    - $Id: micro_porous_layer.h 2605 2014-08-15 03:36:44Z secanell $
//
//---------------------------------------------------------------------------

#ifndef _FUELCELLSHOP__MICRO_POROUS_LAYER_H
#define _FUELCELLSHOP__MICRO_POROUS_LAYER_H

// FCST classes
#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 MicroPorousLayer : 
        public  PorousLayer<dim>
        {
        public:
            

            
            static const std::string concrete_name;
            



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

            
            //void declare_parameters (ParameterHandler &param) const
            //{
            //    FuelCellShop::Layer::MicroPorousLayer<dim>::declare_parameters(this->name,param);
            //}
            
            void initialize (ParameterHandler &param);
            
            


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


            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, 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 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 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 bool set_method_effective_transport_property_solid(std::string)
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
                
                return false;
            };
            virtual void effective_transport_property_solid(const double& property, 
                                                            double& effective_property) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
                
            };
            
            virtual void effective_transport_property_solid(const Tensor<2,dim>& property, 
                                                            Tensor<2,dim>& effective_property) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
                
            };
            
            
            
        protected: 


            MicroPorousLayer();
            
            MicroPorousLayer(const std::string& name);
            
            ~MicroPorousLayer();
                       
            void declare_parameters (const std::string& name, 
                                     ParameterHandler &param) const;
                                     

            


            typedef std::map< std::string, MicroPorousLayer<dim>* > _mapFactory;      
            
            static _mapFactory * get_mapFactory()
            {
                static _mapFactory mapFactory;
                return &mapFactory;
            }  
            virtual boost::shared_ptr<FuelCellShop::Layer::MicroPorousLayer<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 PSD_type;
             
             /*** Pointer to the PSD object*/
             boost::shared_ptr< FuelCellShop::MicroScale::BasePSD<dim> > PSD;
        };
        
    }
    
}  // FuelCellShop

#endif // _FUELCELLSHOP__MICRO_POROUS_LAYER_H