dummy_CL.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
//
// FCST: Fuel Cell Simulation Toolbox
//
// Copyright (C) 2006-2015 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: This class characterizes a conventional catalyst layer
//                and defines constant effective properties
// - Developers: Marc Secanell and Madhur Bhaiya
//
// ----------------------------------------------------------------------------

#ifndef _FUELCELLSHOP__DUMMY_CL__H
#define _FUELCELLSHOP__DUMMY_CL__H

// Include FCST classes
#include <utils/fcst_units.h>
#include <layers/catalyst_layer.h>



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;

            void effective_gas_diffusivity(std::vector< Tensor<2,dim> >& prop_eff_vec) const;
            
            void derivative_effective_gas_diffusivity(std::map< VariableNames, std::vector< Tensor<2,dim> > >&dprop_eff)  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.at(this->local_material_id());
            }
            void set_cell_id(const unsigned int& ){}

            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]",
                                                 "4:0.02514", //1atm, 353K
                                                 Patterns::Map( Patterns::Integer(0,255), Patterns::Double(0) ),
                                                 "Oxygen diffusion coefficient given by experiment");
                            param.declare_entry ("Water vapour diffusion coefficient, [cm^2/s]",
                                                 "4:0.29646",
                                                 Patterns::Map( Patterns::Integer(0,255), Patterns::Double(0) ),
                                                 "Water vapour diffusion coefficient given by experiment");
                            param.declare_entry ("Electrical conductivity, [S/cm]",
                                                 "4:40", // [S/cm]
                                                 Patterns::Map( Patterns::Integer(0,255), Patterns::Double(0) ),
                                                 "Effective cond. if given is used, otherwise conductivity of the raw material. Units [S/cm]");
                            param.declare_entry ("Protonic conductivity, [S/cm]",
                                                 "4:40", // [S/cm]
                                                 Patterns::Map( Patterns::Integer(0,255), Patterns::Double(0) ),
                                                 "Effective cond. if given is used, otherwise conductivity of the raw material. Units [S/cm]");
                            param.declare_entry ("Active area [cm^2/cm^3]",
                                                 "4:2.0e5",
                                                 Patterns::Map( Patterns::Integer(0,255), Patterns::Double(0)));
                        }
                        param.leave_subsection();

                    }
                    param.leave_subsection();
                }
                param.leave_subsection();

            }





            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;



            std::map< unsigned int, double > D_O2;
            std::map< unsigned int, double > D_wv;
            std::map< unsigned int, double > sigma_e;
            std::map< unsigned int, double > sigma_m;
            std::map< unsigned int, double > Av;
        };
    }
}

#endif