PSD_base.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: PSD_base.h
//    - Description: Base class for pore size distribution model.
//    - Developers: 2009-13 by Marc Secanell, University of Alberta
//                  2013-14 by Jie Zhou, University of Alberta
//    - $ $
//
//---------------------------------------------------------------------------
#ifndef _FUELCELLSHOP__BASE__PSD_H
#define _FUELCELLSHOP__BASE__PSD_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 <math.h> 

// Include OpenFCST routines:
#include <application_core/fcst_variables.h>
#include <application_core/system_management.h>
#include <utils/fcst_utilities.h>
#include <utils/fcst_constants.h>

using namespace dealii;

namespace FuelCellShop
{
    
    
    namespace MicroScale
    {
    template <int dim>
        class BasePSD : public Subscriptor
        {
        public:
            


            virtual ~BasePSD() {}
            

             
            static void declare_PSD_parameters (ParameterHandler &param)
            {
                for (typename FuelCellShop::MicroScale::BasePSD<dim>::_mapFactory::iterator iterator = FuelCellShop::MicroScale::BasePSD<dim>::get_mapFactory()->begin(); 
                     iterator != FuelCellShop::MicroScale::BasePSD<dim>::get_mapFactory()->end(); 
                iterator++)
                     {
                         iterator->second->declare_parameters(param);
                     }
            }
            
            static boost::shared_ptr<FuelCellShop::MicroScale::BasePSD<dim> > create_PSD (const std::string& psd_section_name, 
                                                                                                     ParameterHandler &param)
            {
                boost::shared_ptr<FuelCellShop::MicroScale::BasePSD<dim> > pointer;
                
                std::string concrete_name;
                
                param.enter_subsection("PSD parameters");
                {
                    param.enter_subsection("BasePSD");
                    {
                        concrete_name = param.get("psd type");
                    }
                    param.leave_subsection();
                }
                param.leave_subsection();
                
                typename FuelCellShop::MicroScale::BasePSD<dim>::_mapFactory::iterator iterator = FuelCellShop::MicroScale::BasePSD<dim>::get_mapFactory()->find(concrete_name);
                
                if (iterator != FuelCellShop::MicroScale::BasePSD<dim>::get_mapFactory()->end())
                {
                    if (iterator->second)
                    {
                        pointer = iterator->second->create_replica(psd_section_name);
                    }
                    else 
                    {
                        FcstUtilities::log<<"Pointer not initialized"<<std::endl;
                        abort();    
                    }
                }
                else
                {
                    FcstUtilities::log<<"Concrete name in FuelCellShop::MicroScale::BasePSD::create_psd does not exist"<<std::endl;
                    abort();
                }
                
                pointer->initialize(param);
                
                return pointer;
            }
            

            
            virtual const std::type_info& get_base_type() const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name()  << std::endl;
            }    
            
            
            inline void set_porosity(double porosity )
            {
                this->por = porosity;
            }
            
            inline double get_porosity() const
            {
                return this->por;
            }
            
            inline void set_derivative_flags(const std::vector<VariableNames>& flags)
            {
                this->derivative_flags = flags;
            }
            
            virtual void set_constant_solution(const double& value, const VariableNames& name)
            {
                constant_solutions[name] = value;
            }
            
            virtual void set_solution(const std::vector< SolutionVariable >&)
            {
                const std::type_info& info = typeid(*this);
                deallog << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name()  << std::endl;
            }
            
            virtual inline void set_temperature (const SolutionVariable& T_in)
            {
                const std::type_info& info = typeid(*this);
                deallog << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name()  << std::endl;
            }
            
            virtual inline void set_capillary_pressure (const SolutionVariable& C_in)
            {
                const std::type_info& info = typeid(*this);
                deallog << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name()  << std::endl;
            }
            
            virtual inline void set_critical_radius()
            {             
                const std::type_info& info = typeid(*this);
                deallog << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name()  << std::endl;
                
            }
            virtual inline void get_PSD_plot()
            {               
                const std::type_info& info = typeid(*this);
                deallog << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name()  << std::endl;
            } 
            
            virtual inline void set_saturation()
            {               
                const std::type_info& info = typeid(*this);
                deallog << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name()  << std::endl;
            } 
            
            virtual inline void initialize(ParameterHandler &param)
            {               
                const std::type_info& info = typeid(*this);
                deallog << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name()  << std::endl;
            } 
            


            inline const std::string& name_psd() const
            {
                return name;
            }
            
            virtual void print_psd_properties() const
            {
                const std::type_info& info = typeid(*this);
                deallog << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name()  << std::endl;
            } 
            
            virtual  void get_saturation(std::vector<double>& ) const = 0;
            virtual  void get_derivative_saturation(std::vector<double>& ) const = 0;
            virtual  void get_global_saturated_permeability(double& ) const = 0;
            
            virtual  void get_relative_liquid_permeability(std::vector<double>& ) const = 0;
            
            virtual  void get_derivative_relative_liquid_permeability(std::vector<double>& ) const = 0;
            
            virtual  void get_relative_gas_permeability(std::vector<double>& ) const = 0;
            
            virtual  void get_liquid_gas_interfacial_surface(std::vector<double>& ) const = 0;
            
            virtual  void get_derivative_liquid_gas_interfacial_surface(std::vector<double>& ) const = 0;
            
            virtual  void get_wetted_wall_surface_area(std::vector<double>& ) const = 0;
            
            virtual  void get_knudsen_radius(std::vector<double>& ) const = 0;
            
            
        protected:


            BasePSD()
            {};

            BasePSD(const std::string& name);

            void virtual declare_parameters (ParameterHandler &param) const;
            
            void _initialize (ParameterHandler &param) ;
            


            typedef std::map< std::string, BasePSD<dim>* > _mapFactory;      
            


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


            virtual boost::shared_ptr<FuelCellShop::MicroScale::BasePSD<dim> > create_replica (const std::string &name)
            {
                const std::type_info& info = typeid(*this);
                deallog << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name() << std::endl;
            }
            


            const std::string name;
            
            std::vector<VariableNames> derivative_flags;
            
            std::map< VariableNames, double > constant_solutions;

            double gamma;
            
            double contact_angle;
            
            double lamda;
            
            double F_HI;
            
            double F_HO;
            
            std::vector<double> f_k;
            
            std::vector<double> r_k;            
            
            std::vector<double> s_k;
            
            double por;
        };
        
    } // PSD
    
}  // FuelCellShop

#endif