PSD_HI.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__HI__PSD_H
#define _FUELCELLSHOP__HI__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 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 "PSD_base.h"

using namespace dealii;

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


            HIPSD();
                                    
            HIPSD (std::string name);

            ~HIPSD() {}
            
            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;
                
                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;
            
            


            virtual  void get_saturation(std::vector<double>& S) const ;
            
            virtual  void get_global_saturated_permeability(double& saturated_permeability) const ;
            
            virtual  void get_pore_HI_liquid_saturated_permeability(std::vector<double>& liquid_permeability) const ;
            
            virtual  void get_relative_liquid_permeability(std::vector<double>& liquid_permeability) const ;
            
            virtual  void get_pore_HI_gas_saturated_permeability(std::vector<double>& saturated_HI_permeability) const ;
            
            virtual  void get_relative_gas_permeability(std::vector<double>& gas_permeability) const ;
            
            virtual  void get_liquid_gas_interfacial_surface(std::vector<double>& HI_liquid_gas_interfacial_surface) const ;
            
            virtual  void get_pore_HI_wetted_wall_surface_area(std::vector<double>& HI_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_C1(std::vector<double>& knudsen_radius_C1) const ;
            
            virtual  void get_pore_knudsen_radius_C3(std::vector<double>& knudsen_radius_C3) 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  const double get_maximum_cross_sectional_areas() 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::HIPSD<dim> (psd_section_name));
            }   


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

            
            std::vector<double> fHI_k;
            
            std::vector<double> rHI_k;            
            
            std::vector<double> sHI_k;
            
            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