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
//    - $Id: porous_layer.h 2605 2014-08-15 03:36:44Z secanell $
//
//---------------------------------------------------------------------------

#ifndef _FUELCELLSHOP__POROUS__LAYER_H
#define _FUELCELLSHOP__POROUS__LAYER_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 "algorithm"
#include <boost/concept_check.hpp>

// FCST
#include "base_layer.h"
#include "PureGas.h"
#include "GasMixture.h"
#include "utils/fcst_constants.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_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;
        }
        
        

        
        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 print_layer_properties() const;
        
        


         void effective_gas_diffusion_coefficient(const FuelCellShop::Material::PureGas* solute_gas,
                                                            const FuelCellShop::Material::PureGas* solvent_gas,
                                                            const SolutionVariable& T_in,
                                                            const SolutionVariable& p_in,
                                                            std::vector<double>& D_b) const;
         void effective_gas_diffusion_coefficient(const FuelCellShop::Material::PureGas* solute_gas,
                                                            const FuelCellShop::Material::PureGas* solvent_gas,
                                                            const SolutionVariable& T_in,
                                                            const SolutionVariable& p_in,
                                                            std::vector<double>& D_b,
                                                            std::vector<double>& dD_b_dT) const;
         void effective_molecular_gas_diffusion_coefficient(const FuelCellShop::Material::PureGas* solute_gas,
                                                            const FuelCellShop::Material::PureGas* solvent_gas,
                                                            const SolutionVariable& T_in,
                                                            const SolutionVariable& p_in,
                                                            std::vector<double>& D_m) const;
                                                            
         void effective_molecular_gas_diffusion_coefficient(const FuelCellShop::Material::PureGas* solute_gas,
                                                            const FuelCellShop::Material::PureGas* solvent_gas,
                                                            const SolutionVariable& T_in,
                                                            const SolutionVariable& p_in,
                                                            std::vector<double>& D_m,
                                                            std::vector<double>& dD_m_dT) const;
        
        void Knudsen_diffusion(const FuelCellShop::Material::PureGas* solute_gas,
                               const SolutionVariable& T_in,
                               std::vector<double>& D_k) const;
                               
        void 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 pcapillary(std::vector<double>&) const
            {
                const std::type_info& info = typeid(*this);
                FcstUtilities::log << "Calling parent porous layer"<< std::endl; 
            }
    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;
        }
        
        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();
        }
        
        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;
        
        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 T_vector;
        
        SolutionVariable s_vector;
        
        Table< 2, double > D_ECtheory;
        
        std::vector< Table< 2, double > > dD_ECtheory_dx;
        
        std::vector<double> D_bulk;
        
        std::vector<double> dD_bulk_dT;
        
        
};

} // Layer

} // FuelCellShop

#endif