PSD_dual.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__DUAL__PSD_H
#define _FUELCELLSHOP__DUAL__PSD_H

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



using namespace dealii; 

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


            DualPSD();
            
            DualPSD (std::string name);
            
            virtual ~DualPSD();
            
            void declare_parameters (ParameterHandler &param) const;
            void initialize (ParameterHandler &param );
            
            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;
                
                psd_hi.set_capillary_pressure(C_in);
                psd_ho.set_capillary_pressure(C_in);
            }
            
            inline void set_critical_radius()
            {
                psd_hi.set_critical_radius();
                psd_ho.set_critical_radius();
                
            }
            
            inline void set_saturation()
            {
                psd_hi.set_saturation();
                psd_ho.set_saturation();
            }
            

             


             static const std::string concrete_name;
             
             


             const std::type_info& get_base_type() const
             {
                 return typeid(DualPSD<dim>);
             }
             
            virtual  void get_saturation(std::vector<double>& S) const ;
            virtual  void get_derivative_saturation(std::vector<double>& S) const ;
            virtual  void get_global_saturated_permeability(double& saturated_permeability) const ;
            
            virtual  void get_relative_liquid_permeability(std::vector<double>& liquid_permeability) const ;
            virtual  void get_derivative_relative_liquid_permeability(std::vector<double>& liquid_permeability) const ;
            virtual  void get_relative_gas_permeability(std::vector<double>& gas_permeability) const ;
            
            virtual  void get_liquid_gas_interfacial_surface(std::vector<double>& liquid_gas_interfacial_surface) const ;
            
            virtual  void get_derivative_liquid_gas_interfacial_surface(std::vector<double>&) const ;
            
            virtual  void get_wetted_wall_surface_area(std::vector<double>& wetted_wall_surface_area) const ;
            
            virtual  void get_knudsen_radius(std::vector<double>& knudsen_radius) const ;
            
            virtual  void get_diffusivity() const ;
            
            virtual void get_maximum_cross_sectional_areas(double&) const;
            
            virtual void get_PSD_plot(const std::vector<double> ,std::vector<double>&,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::DualPSD<dim> (psd_section_name));
            }   
            


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

            
            HIPSD<dim> psd_hi;
            
            HOPSD<dim> psd_ho;
            
            double pressure_c;
            
            SolutionVariable T_vector;
            
            SolutionVariable Capillary_pressure_vector;

        };
        
    } // PSD
    
}  // FuelCellShop

#endif