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 and Madhur Bhaiya
//    - $Id: porous_layer.h 1373 2013-08-21 00:34:53Z madhur $
//
//---------------------------------------------------------------------------

#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"

// FCST
#include "base_layer.h"
#include "PureGas.h"
#include "BinaryDiffusion.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;
            }
            
            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;
            }
            
            


            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;
            }
            
            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;
            }
            
            virtual void print_layer_properties() const
            {
                const std::type_info& info = typeid(*this);
                deallog << "Pure function " << __FUNCTION__
                << " called in Class "
                << info.name()  << std::endl;
            };
            
            virtual bool test_layer() 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);
            };
            
            PorousLayer()
            : FuelCellShop::Layer::BaseLayer<dim> ()
            {};
            
            virtual ~PorousLayer()
            {};
            virtual void declare_parameters (const std::string &name, ParameterHandler &param) const
            {
                FuelCellShop::Layer::BaseLayer<dim>::declare_parameters(name,param);
                
                param.enter_subsection("Fuel cell data");
                {
                    param.enter_subsection(name);
                    {
                        
                    }
                    param.leave_subsection();
                }
                param.leave_subsection();
            }
            
            virtual void declare_parameters (ParameterHandler &param) const
            {
                declare_parameters(this->name, param);
            };
            
            virtual void initialize (ParameterHandler &param);
            
            void set_parameters(const std::string &object_name, 
                                       const std::vector<std::string>& name_dvar,
                                       const std::vector<double>& value_dvar,
                                       ParameterHandler &param)
            {
                FuelCellShop::Layer::BaseLayer<dim>::set_parameters(object_name,name_dvar,value_dvar,param);
                
                param.enter_subsection("Fuel cell data");
                {
                    param.enter_subsection(object_name);
                    {
                        // ADD VARIABLES IF NEEDED
                        //param.set(name_var, value_param);
                    }
                    param.leave_subsection();
                }
                param.leave_subsection();
            };
            
            virtual void set_parameters(const std::vector<std::string>& name_dvar,
                                        const std::vector<double>& value_dvar,
                                        ParameterHandler &param)
            {};



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



            std::string diffusion_species_name; 

            std::vector<FuelCellShop::Material::PureGas*> gases;
            
            double temperature;
            
            double pressure;
            
            SolutionVariable T_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 // _FUELCELLSHOP__GENERIC__LAYER_H