dummy_CL.h

Go to the documentation of this file.

//---------------------------------------------------------------------------
//
//    FCST: Fuel Cell Simulation Toolbox
//
//    Copyright (C) 2006-13 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: dummy_cl.h
//    - Description: Class characterizing the conventional catalyst layer and defining constant effective properties
//    - Developers: Marc Secanell and Madhur Bhaiya
//    - $Id: dummy_CL.h 1373 2013-08-21 00:34:53Z madhur $ 
//
//---------------------------------------------------------------------------


#ifndef _FUELCELLSHOP__DUMMY_CL__H
#define _FUELCELLSHOP__DUMMY_CL__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 FCST classes
#include "fcst_units.h"
#include "catalyst_layer.h"
#include "base_kinetics.h"

//Include STL
#include<cmath>
#include<iostream>


namespace FuelCellShop
{
    namespace Layer
    {
        template <int dim>
        class DummyCL :
        public CatalystLayer<dim>
        {
        public:
            
            
            static const std::string concrete_name;
            
            


            DummyCL();
           
            ~DummyCL();
            
            virtual void declare_parameters (ParameterHandler &param) const
            {
               declare_parameters(this->name, param);                
            };

            virtual void initialize (ParameterHandler &param);
            


            virtual void effective_gas_diffusivity(Table< 2, Tensor< 2, dim > >&) const;

            virtual void effective_electron_conductivity(double& ) const;

            virtual void effective_electron_conductivity(Tensor<2,dim>& ) const;

            virtual void effective_proton_conductivity(double& ) const;
            
            virtual void effective_proton_conductivity(std::vector<double>& ) const;
            
            virtual void derivative_effective_proton_conductivity(std::map< VariableNames, std::vector<double> >& ) const;
            

            inline double get_active_area_Pt() const
            {
                return Av;   
            }
                                    
            virtual void current_density(std::vector<double>&);
            virtual void derivative_current_density(std::map< VariableNames, std::vector<double> >& );
            virtual void current_density(std::vector<double>& current, std::vector<double>& effectiveness)
            {
                current_density(current);
                effectiveness.assign(current.size(), 1.0);
            }
            
        private:


            DummyCL(const std::string& name);
            
            void declare_parameters (const std::string& name, 
                                     ParameterHandler &param) const
            {
                
                FuelCellShop::Layer::CatalystLayer<dim>::declare_parameters(name, param);
                
                param.enter_subsection("Fuel cell data");
                {
                    param.enter_subsection(name);
                    {
                        param.enter_subsection(concrete_name); //-- Transport for the anisotropic case:
                        {
                            param.declare_entry ("Oxygen diffusion coefficient, [cm^2/s]",
                                                 "0.02514", //1atm, 353K
                                                 Patterns::Double(),
                                                 "Oxygen diffusion coefficient given by experiment");
                            param.declare_entry ("Water vapour diffusion coefficient, [cm^2/s]",
                                                 "0.29646", 
                                                 Patterns::Double(),
                                                 "Water vapour diffusion coefficient given by experiment");
                            param.declare_entry ("Electrical conductivity, [S/cm]",
                                                 "40", // [S/cm]
                                                 Patterns::Double(),
                                                 "Effective cond. if given is used, otherwise conductivity of the raw material. Units [S/cm]");
                            param.declare_entry ("Protonic conductivity, [S/cm]",
                                                 "40", // [S/cm]
                                                 Patterns::Double(),
                                                 "Effective cond. if given is used, otherwise conductivity of the raw material. Units [S/cm]");
                            param.declare_entry ("Active area [cm^2/cm^3]",
                                                 "2.0e5",
                                                 Patterns::Double());    
                        }
                        param.leave_subsection();
                        
                    }
                    param.leave_subsection();        
                }
                param.leave_subsection();
                
            }
            
            void set_parameters (const std::vector<std::string>& name_dvar,
                                 const std::vector<double>& value_dvar,
                                 const std::string& cl_section_name, 
                                 ParameterHandler &param) const;
                                 
            


            virtual boost::shared_ptr<FuelCellShop::Layer::CatalystLayer<dim> > create_replica (const std::string &name)
            {
                return boost::shared_ptr<FuelCellShop::Layer::CatalystLayer<dim> > (new FuelCellShop::Layer::DummyCL<dim> (name));
            }   
            static DummyCL<dim> const* PROTOTYPE;
            


            double D_O2;
            double D_wv;
            double sigma_e;       
            double sigma_m;     
            double Av;
        };
    }
}

#endif