porous_layer.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: porous_layer.h
//    - Description: Child of base layer that implements common functionality for handling gases.
//    - Developers: M. Secanell, Madhur Bhaiya and Valentin Zingan
//
//---------------------------------------------------------------------------

#ifndef _FUELCELLSHOP__POROUS__LAYER_H
#define _FUELCELLSHOP__POROUS__LAYER_H

//Include STL
#include <algorithm>
#include <boost/concept_check.hpp>

// FCST
#include <microscale/PSD_base.h>
#include <microscale/PSD_HI.h>
#include <microscale/PSD_HO.h>
#include <microscale/PSD_dual.h>
#include <microscale/PSD_none.h>
#include <layers/base_layer.h>
#include <materials/PureGas.h>
#include <materials/GasMixture.h>
#include <utils/fcst_constants.h>
#include <utils/fcst_units.h>





using namespace dealii;

namespace FuelCellShop
{
namespace Layer
{
    
    template<int dim>
    class PorousLayer : public BaseLayer<dim>
    {
    public:
        


        void set_gases_and_compute (std::vector<FuelCellShop::Material::PureGas*>& gases_in,
                                    const double& pressure_in,
                                    const double& temperature_in);

        void compute_gas_diffusion (FuelCellShop::Material::PureGas* solute_gas,
                                    FuelCellShop::Material::PureGas* solvent_gas);

        inline void set_gases (std::vector<FuelCellShop::Material::PureGas*>& gases_in,
                               const double& pressure_in)
        {
            Assert(gases_in.size() >= 2, ExcMessage("Number of gases should be more than or equal to two in PorousLayer::set_gases method."));
            this->gases = gases_in;
            this->pressure = pressure_in;
            
            gas_mixture = nullptr;
        }
        
        inline void set_gas_mixture(FuelCellShop::Material::GasMixture& rgas_mixture)
        {
            gas_mixture = &rgas_mixture;
            gases.clear();
        }
        
        inline void set_porosity_permeability_tortuosity_booleans(const bool& rporosity_is_constant,
                                                                  const bool& rpermeability_is_constant,
                                                                  const bool& rtortuosity_is_constant)
        {
            porosity_is_constant     = rporosity_is_constant;
            permeability_is_constant = rpermeability_is_constant;
            tortuosity_is_constant   = rtortuosity_is_constant;
        }
        
        inline void set_pressure (const SolutionVariable& p_in)
        {
            Assert( p_in.get_variablename() == total_pressure, ExcMessage("Wrong solution variable passed in PorousLayer::set_pressure.") );
            this->p_vector = p_in;
        }
        
        inline void set_temperature (const SolutionVariable& T_in)
        {
            Assert( T_in.get_variablename() == temperature_of_REV, ExcMessage("Wrong solution variable passed in PorousLayer::set_temperature.") );
            this->T_vector = T_in;
        }
        
        inline void set_saturation (const SolutionVariable& s_in)
        {
            Assert( s_in.get_variablename() == liquid_water_saturation, ExcMessage("Wrong solution variable passed in PorousLayer::set_saturation.") );
            this->s_vector = s_in;
        }        
        
        inline void set_capillary_pressure (const SolutionVariable& p_in)
        {
            Assert( p_in.get_variablename() == capillary_pressure, ExcMessage("Wrong solution variable passed in PorousLayer::set_capillary_pressure.") );
            this->capillary_pressure_vector = p_in;
        }
        


        FuelCellShop::Material::PureGas* get_gas_pointer(int index) const
        {
            Assert(index > 0 || index < gases.size(), ExcIndexRange(index,0,gases.size()));
            return gases[index];
        };
        
        std::vector<FuelCellShop::Material::PureGas*> get_gases() const {
            return this->gases; }
        
        const FuelCellShop::Material::GasMixture* const get_gas_mixture() const {
            return this->gas_mixture; }
        
        void get_gas_index(FuelCellShop::Material::PureGas* gas_type, int& index) const;

        void get_T_and_p(double &T, double &p) const {
            T = this->temperature;
            p = this->pressure;
        }

        void get_p(double& p) const {
            p = this->pressure; }

        const bool& get_porosity_is_constant() const 
        {
            return porosity_is_constant; 
        }
        
        const bool& get_permeability_is_constant() const  {
            return permeability_is_constant; }
        
        const bool& get_tortuosity_is_constant() const  {
            return tortuosity_is_constant; }
        
        inline double get_porosity() const {
            AssertThrow( porosity_is_constant , ExcInternalError() );
            return porosity;
        }
        
        inline void get_porosity(std::vector<double>& dst) const {
            AssertThrow( porosity_is_constant , ExcInternalError() );
            
            for(unsigned int q = 0; q < dst.size(); ++q)
                dst[q] = this->get_porosity();
        }
        
        void get_porosity(std::vector<double>&             dst,
                          const std::vector< Point<dim> >& points) const;
                          
        void get_permeability(std::vector< SymmetricTensor<2,dim> >& dst) const;
        
        void get_permeability(std::vector< SymmetricTensor<2,dim> >& dst, 
                              const std::vector< Point<dim> >&       points) const;
        
        void get_SQRT_permeability(std::vector< SymmetricTensor<2,dim> >& dst) const;
        
        void get_SQRT_permeability(std::vector< SymmetricTensor<2,dim> >& dst, 
                                   const std::vector< Point<dim> >&       points) const;
        
        void get_permeability_INV(std::vector< SymmetricTensor<2,dim> >& dst) const;
        
        void get_permeability_INV(std::vector< SymmetricTensor<2,dim> >& dst, 
                                  const std::vector< Point<dim> >&       points) const;
        
        void get_SQRT_permeability_INV(std::vector< SymmetricTensor<2,dim> >& dst) const;
        
        void get_SQRT_permeability_INV(std::vector< SymmetricTensor<2,dim> >& dst, 
                                       const std::vector< Point<dim> >&       points) const;
        
        void get_Forchheimer_permeability(std::vector< SymmetricTensor<2,dim> >& dst) const;
        
        void get_Forchheimer_permeability(std::vector< SymmetricTensor<2,dim> >& dst, 
                                          const std::vector< Point<dim> >&       points) const;
        
        void get_tortuosity(std::vector< SymmetricTensor<2,dim> >& dst) const;
        
        void get_tortuosity(std::vector< SymmetricTensor<2,dim> >& dst, 
                            const std::vector< Point<dim> >&       points) const;
                
        virtual void effective_gas_diffusivity(std::vector< Tensor<2,dim> >&) const 
        {};
        
        virtual void effective_gas_diffusivity(Table<2, double>& D_eff ) const
        {
            const std::type_info& info = typeid(*this);
            FcstUtilities::log << "Pure function " << __FUNCTION__
            << " called in Class "
            << info.name() << std::endl;
        };
        
        virtual void effective_gas_diffusivity(Table< 2, Tensor<2,dim> > &D_eff ) const
        {
            const std::type_info& info = typeid(*this);
            FcstUtilities::log << "Pure function " << __FUNCTION__
            << " called in Class "
            << info.name() << std::endl;
        };
        
        virtual void derivative_effective_gas_diffusivity(std::map< VariableNames, std::vector< Tensor<2,dim> > >&) const 
        {};
        
         virtual void gas_diffusion_coefficient(std::vector<double>& D_b) const
         {
             D_b = this->D_bulk;
         }
         
         virtual void gas_diffusion_coefficient(std::vector<double>& D_b,
                                                std::vector<double>& dD_b_dT) const
         {
             D_b = this->D_bulk;
             dD_b_dT = this->dD_bulk_dT;
         }

        void molecular_gas_diffusion_coefficient(std::vector<double>& D_m) const         
        {
            D_m = this->D_molecular;
        }
        
         void molecular_gas_diffusion_coefficient(std::vector<double>& D_m,
                                                  std::vector<double>& dD_m_dT) const
         {
             D_m = this->D_molecular;
             dD_m_dT = this->dD_molecular_dT;
         }
        
        void Knudsen_diffusion(std::vector<double>& D) const
        {
            D = this->D_k;
        }
                               
        void Knudsen_diffusion(std::vector<double>& D,
                               std::vector<double>& dD_dT) const
        {
             D = this->D_k;
             dD_dT = this->dD_k_dT;
        }
        virtual void pcapillary(std::vector<double>&) const
        {
            const std::type_info& info = typeid(*this);
            FcstUtilities::log << "Calling parent porous layer"<< std::endl; 
        }
        
        virtual void saturation_from_capillary_equation(std::vector<double>&) const
        {
            const std::type_info& info = typeid(*this);
            FcstUtilities::log << "Calling parent porous layer"<< std::endl; 
        }
        
        virtual void derivative_saturation_from_capillary_equation_PSD(std::vector<double>&) const
        {
            const std::type_info& info = typeid(*this);
            FcstUtilities::log << "Calling parent porous layer"<< std::endl; 
        }
        
        virtual void saturated_liquid_permeablity_PSD(double&) const
        {
            const std::type_info& info = typeid(*this);
            FcstUtilities::log << "Calling parent porous layer"<< std::endl; 
        }
        
        virtual void interfacial_surface_area_PSD(std::vector<double>&) const
        {
            const std::type_info& info = typeid(*this);
            FcstUtilities::log << "Calling parent porous layer"<< std::endl; 
        }
        
        virtual void relative_liquid_permeability_PSD(std::vector< Tensor<2,dim> >& ) const
        {
            const std::type_info& info = typeid(*this);
            FcstUtilities::log << "Calling parent porous layer"<< std::endl; 
        }
        
        virtual void derivative_relative_liquid_permeablity_PSD(std::vector<double>& ) const
        {
            const std::type_info& info = typeid(*this);
            FcstUtilities::log << "Calling parent porous layer"<< std::endl; 
        }
        
        virtual void derivative_interfacial_surface_area_PSD(std::vector<double>& ) const
        {
            const std::type_info& info = typeid(*this);
            FcstUtilities::log << "Calling parent porous layer"<< std::endl; 
        }


        void compute_Knudsen_diffusion(const FuelCellShop::Material::PureGas* solute_gas,
                                       const SolutionVariable& T_in,
                                       std::vector<double>& D_k) const;
                               
        void compute_Knudsen_diffusion(const FuelCellShop::Material::PureGas* solute_gas,
                                       const SolutionVariable& T_in,
                                       std::vector<double>& D_k,
                                       std::vector<double>& dD_k_dT) const;
            

        virtual void print_layer_properties() const;
        
    protected:
        

        
        PorousLayer(const std::string& name)
        :
        FuelCellShop::Layer::BaseLayer<dim>(name)
        {
            this->derivative_flags.push_back(total_pressure);
            this->derivative_flags.push_back(temperature_of_REV);
            porosity_is_constant     = true;
            permeability_is_constant = true;
            tortuosity_is_constant   = true;
            gases.clear();
            gas_mixture = nullptr;
            PSD = nullptr;
            psd_pointer = nullptr;
        }
        
        PorousLayer()
        :
        FuelCellShop::Layer::BaseLayer<dim>()
        {}
        
        PorousLayer(const std::string&                  name,
                    FuelCellShop::Material::GasMixture& gas_mixture)
        :
        FuelCellShop::Layer::BaseLayer<dim>(name),
        gas_mixture(&gas_mixture)
        {
            this->derivative_flags.push_back(total_pressure);
            this->derivative_flags.push_back(temperature_of_REV);
            porosity_is_constant     = true;
            permeability_is_constant = true;
            tortuosity_is_constant   = true;
            gases.clear();
            PSD = nullptr;
            psd_pointer = nullptr;
        }
        
        virtual ~PorousLayer()
        {}
        
        virtual void declare_parameters (const std::string &name, ParameterHandler &param) const;
        
        virtual void declare_parameters (ParameterHandler &param) const
        {
            declare_parameters(this->name, param);
        }
        
        virtual void initialize (ParameterHandler &param);
        

        
        void print_caller_name(const std::string& caller_name) const;
                               


        virtual void gas_diffusion_coefficients(Table< 2, double > &) const;
        
        virtual void derivative_gas_diffusion_coefficients(std::vector< Table< 2, double > >&) const;
        
        
        // DATA //
        

        
        FuelCellShop::Material::GasMixture* gas_mixture;
        
        std::vector<FuelCellShop::Material::PureGas*> gases;
        
        bool porosity_is_constant;
        
        bool permeability_is_constant;
        
        bool tortuosity_is_constant;
        
        double porosity;
        
        bool use_Bosanquet;
        
        double Knudsen_radius;
        
        SymmetricTensor<2,dim> permeability;
        
        SymmetricTensor<2,dim> SQRT_permeability;
        
        SymmetricTensor<2,dim> permeability_INV;
        
        SymmetricTensor<2,dim> SQRT_permeability_INV;
        
        SymmetricTensor<2,dim> Forchheimer_permeability;
        
        SymmetricTensor<2,dim> tortuosity;
        
        std::string diffusion_species_name;
        
        double temperature;
        
        double pressure;

        SolutionVariable p_vector;
        
        SolutionVariable T_vector;
        
        SolutionVariable s_vector;
        
        SolutionVariable capillary_pressure_vector;
        
        Table< 2, double > D_ECtheory;
        
        std::vector< Table< 2, double > > dD_ECtheory_dx;
        
        std::vector<double> D_molecular;
        
        std::vector<double> dD_molecular_dT;
        
        std::vector<double> D_k;
        
        std::vector<double> dD_k_dT;
        
        std::vector<double> D_bulk;
        
        std::vector<double> dD_bulk_dT;
        
        bool PSD_is_used;
        
        std::string PSD_type;
        
        boost::shared_ptr< FuelCellShop::MicroScale::BasePSD<dim> > PSD; //psd_pointer
        
        FuelCellShop::MicroScale::BasePSD<dim> * psd_pointer;

        FuelCellShop::Material::PureGas* solute_gas;
        
        FuelCellShop::Material::PureGas* solvent_gas;
        
        
};

} // Layer

} // FuelCellShop

#endif