PSD_HO.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__HO__PSD_H
#define _FUELCELLSHOP__HO__PSD_H

// Include OpenFCST routines:
#include <microscale/PSD_base.h>

using namespace dealii;


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

            HOPSD();    
            
            HOPSD (std::string name);
            
            virtual ~HOPSD();
             
             void initialize ( ParameterHandler &param );
             
             void declare_parameters (ParameterHandler &param) const;
             
             inline void set_temperature (const SolutionVariable& T_in)
             {
                 Assert( T_in.get_variablename() == temperature_of_REV, ExcMessage("Wrong solution variable passed in PSD::set_temperature.") );
                 this->T_vector = T_in;
             }
             
             inline void set_capillary_pressure (const SolutionVariable& C_in)
             {
                 Assert( C_in.get_variablename() == capillary_pressure, ExcMessage("Wrong solution variable passed in PSD::capillary_pressure.") );
                 this->Capillary_pressure_vector = C_in;
                 
                 critical_radius_is_initialized = false;
                 saturation_is_initialized = false;
                 critical_radius_computed.clear();
                 saturation_computed.clear();
             }
             
             inline void set_critical_radius()
             {
                 get_critical_radius(critical_radius_computed);
                 
                 critical_radius_is_initialized = true;
             }
             
             inline void set_saturation()
             {
                 get_saturation(saturation_computed);
                 
                 saturation_is_initialized = true;
             }
             static const std::string concrete_name;


             const std::type_info& get_base_type() const
             {
                 return typeid(HOPSD<dim>);
             }
            
            virtual  void get_saturation(std::vector<double>& S) const ;
            virtual  void get_derivative_saturation(std::vector<double>& ) const ;
            
            virtual  void get_global_saturated_permeability(double& saturated_permeability) const ;
            virtual  void get_global_saturated_permeability(const double,double& ) const ;
            virtual  void get_pore_HO_liquid_saturated_permeability(std::vector<double>& saturated_HO_permeability) const ;
            
            virtual  void get_derivative_pore_HO_liquid_saturated_permeability(std::vector<double>& ) const ;
            
            virtual  void get_derivative_pore_HO_liquid_saturated_permeability(const double porosity, const std::vector<double> S,
                                                                               const std::vector<double> ds_dp,
                                                                               std::vector<double>& ) const ;
            
            virtual  void get_pore_HO_liquid_saturated_permeability(const double porosity, const std::vector<double> S,
                                                                    std::vector<double>& saturated_HO_permeability) const ;
            
            virtual  void get_relative_liquid_permeability(std::vector<double>& liquid_permeability) const ;
            
            virtual  void get_derivative_relative_liquid_permeability(std::vector<double>& ) const ;
            
            virtual  void get_pore_HO_gas_saturated_permeability(std::vector<double>& saturated_HO_permeability) const ;
            
            virtual void  get_pore_HO_gas_saturated_permeability(const double porosity, const std::vector<double> S,
                                                                 std::vector<double>& saturated_HO_permeability) const ;
            
            virtual  void get_relative_gas_permeability(std::vector<double>& gas_permeability) const ;
            
            virtual  void get_liquid_gas_interfacial_surface(std::vector<double>& HO_liquid_gas_interfacial_surface_a) const ;
            
            virtual  void get_liquid_gas_interfacial_surface_withoutPb(std::vector<double>& HO_liquid_gas_interfacial_surface) const ;
            
            virtual  void get_derivative_liquid_gas_interfacial_surface_increment(std::vector<double>& ) const ;
            virtual  void get_derivative_liquid_gas_interfacial_surface(std::vector<double>& ) const ;
            
            virtual  void get_pore_HO_wetted_wall_surface_area(std::vector<double>& HO_wetted_wall_surface_area) const ;
            
            virtual  void get_wetted_wall_surface_area(std::vector<double>& wetted_wall_surface_area) const ;
            
            virtual  void get_pore_knudsen_radius_C2(std::vector<double>& knudsen_radius_C2) const ;
            
            virtual  void get_pore_knudsen_radius_C4(std::vector<double>& knudsen_radius_C4) const ;
            
            virtual  void get_knudsen_radius(std::vector<double>& knudsen_radius) const ;
            
            virtual  void get_diffusivity() const ;
            
            
            virtual  void get_critical_radius(std::vector<double>& dst) const;
            virtual void get_derivate_critical_radius(std::vector<double>& dst) const;
            virtual  void get_maximum_cross_sectional_areas(double&) const;
            
            virtual void get_PSD_plot(const std::vector<double> ,std::vector<double>&) const;
            
            
        protected:
            


            virtual boost::shared_ptr<FuelCellShop::MicroScale::BasePSD <dim>> create_replica (const std::string &psd_section_name)
            {
                return boost::shared_ptr<FuelCellShop::MicroScale::BasePSD <dim>> (new FuelCellShop::MicroScale::HOPSD<dim> (psd_section_name));
            }   
            


            static HOPSD<dim> const* PROTOTYPE;
            
            // DATA //
            

            
            std::vector<double> fHO_k;
            
            std::vector<double> rHO_k;            
            
            std::vector<double> sHO_k;
            
            double contact_angle_HO;
            
            SolutionVariable T_vector;
            
            SolutionVariable Capillary_pressure_vector;
            
            double pressure_c;
            
            std::vector<double> critical_radius_computed;
            
            bool critical_radius_is_initialized;
            
            std::vector<double> saturation_computed;
            
            bool saturation_is_initialized;

        };
        
    } // PSD
    
}  // FuelCellShop

#endif