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 <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>
#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"
#include "porous_layer.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 
                    {
                        deallog<<"Pointer not initialized"<<std::endl;
                        abort();    
                    }
                }
                else
                {
                    deallog<<"Concrete name in FuelCellShop::MicroScale::BasePSD::create_psd does not exist"<<std::endl;
                    abort();
                }
                
                pointer->initialize(param);
                
                return pointer;
            }
            


            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;
            }
            


            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_global_saturated_permeability(double& ) const = 0;
            
            virtual  void get_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_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 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 P_b;
            
            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