multi_scale_CL.h

Go to the documentation of this file.

//---------------------------------------------------------------------------
//
//    FCST: Fuel Cell Simulation Toolbox
//
//    Copyright (C) 2014 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: multi_scale_CL.h
//    - Description: Class characterizing the catalyst layer and defining effective properties
//    - Developers: M. Secanell, Peter Dobson, Philip Wardlaw, Michael Moore, Madhur Bhaiya
//    - $Id: multi_scale_CL.h 2605 2014-08-15 03:36:44Z secanell $
//
//---------------------------------------------------------------------------

#ifndef _FUELCELLSHOP__LAYER__MULTISCALE_CL__LAYER_H
#define _FUELCELLSHOP__LAYER__MULTISCALE_CL__LAYER_H

//Include Boost classes
#include <boost/smart_ptr.hpp>

// Include deal.II classes
#include<base/parameter_handler.h>
#include <base/function.h>

// Include FCST classes
#include "utils/fcst_constants.h"
#include "utils/fcst_utilities.h"
#include "layers/conventional_CL.h"
#include "microscale/micro_scale_base.h"

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


namespace FuelCellShop
{
    namespace Layer
    {
        template <int dim>
        class MultiScaleCL :
        public ConventionalCL<dim>
        {
        public:
            static const std::string concrete_name;
            
            
            virtual void set_cell_id(const unsigned int& id){
                cell_id_ = id;
            }




            ~MultiScaleCL();
            


            virtual void current_density ( std::vector<double>& current );
            
            virtual void current_density (std::vector<double>& current, std::vector<double>& effectiveness );           
            
            virtual void derivative_current_density ( std::map< VariableNames, std::vector<double> >& );
            
            virtual void print_layer_properties() const;
            

            /*
             * Public member function which returns a boost::shared pointer of template type T.
             *
             *
             * \param T is the type of object you are requestiong, e.g., FuelCellShop::Material::CatalystSupportBase
             *
             * <h3>Usage</h3>
             * To be used by MicroScale objects in order to get resources such as materials or
             * kinetics. Currently the MicroScaleCL provides resources of the following types:
             *
             * -FuelCellShop::Kinetics::BaseKinetics
             * -FuelCellShop::Material::CatalystBase
             * -FuelCellShop::Material::PolymerElectrolyteBase
             * -FuelCellShop::Material::CatalystSupportBase
             *
             * The above types may be used as template arguments for this function.
             *
             * @code
             *
             * //We wish to link the following kinetics pointer to the
             * //kinetics object pointed to by the MultiScaleCL
             *
             * boost::shared_ptr< FuelCellShop::Kinetics::BaseKinetics > kinetics;
             *
             * //To get a kinetics pointer from an instance of MultiScaleCL we do
             * //the following:
             *  kinetics = layer->get_resource<FuelCellShop::Kinetics::BaseKinetics>();
             *
             *
             * @endcode
             *
             */
            template<typename T>
            inline boost::shared_ptr<T>
            get_resource(){

                boost::shared_ptr<void> ptr;


                if(typeid(T) == typeid(FuelCellShop::Kinetics::BaseKinetics))
                {
                    ptr = this->kinetics;
                }
                else if(typeid(T) == typeid(FuelCellShop::Material::CatalystBase))
                {
                    ptr = this->catalyst;
                }
                else if(typeid(T) == typeid(FuelCellShop::Material::PolymerElectrolyteBase))
                {
                    ptr = this->electrolyte;
                }
                else if(typeid(T) == typeid(FuelCellShop::Material::CatalystSupportBase))
                {
                    ptr = this->catalyst_support;
                }
                else
                {
                    std::string msg = std::string(typeid(*this).name()) + " does not have object type " + std::string(typeid(T).name());
                    throw std::runtime_error(msg);
                }

                return boost::static_pointer_cast<T>(ptr);

            }


            /*
             * A list of properties that the MultiScaleCl shares publicly using
             * the get_properties interface.
             *
             * Used by MicroScale objects
             */
            enum Properties{
                void_fraction=0,
                solid_fraction,
                ionomer_fraction,
                active_area_scaled,
                pressure,
                cell_id
            };


            /*
             * Public member function for getting properties of the MultiScaleCL
             * needed by MicroScale object.
             */
            inline std::map<Properties, double> get_properties(){

                std::map<Properties, double> properties;

                properties[solid_fraction] = this->epsilon_S.at(this->local_material_id());
                properties[void_fraction] = this->epsilon_V.at(this->local_material_id());
                properties[ionomer_fraction] = this->epsilon_N.at(this->local_material_id());
                //The following active area scaling is part of the scaling described by equation 2.90 of Philip Wardlaw's MSc. thesis, and previously by Peter Dobson
                properties[active_area_scaled] = this->Av.at(this->local_material_id()) / (1.0 - this->epsilon_V.at(this->local_material_id()));
                properties[pressure] = this->constant_solutions.at(total_pressure);
                properties[cell_id] = double(cell_id_);
                return properties;
            }

            virtual SolutionMap get_coverages();


           
        protected:
          
          


            MultiScaleCL ( );
            
            MultiScaleCL ( std::string name );
            
            
            
            void declare_parameters ( ParameterHandler &param ) const
            {
               declare_parameters(this->name, param);                
            }

            void initialize ( ParameterHandler &param );

          
          
          
          
          
          
          
          
          
          


            //MultiScaleCL(const std::string& cl_section_name);

            /*MultiScaleCL(const std::string& name,
                          FuelCellShop::Material::PolymerElectrolyteBase*,
                          FuelCellShop::Material::CatalystSupportBase*,
                          FuelCellShop::Material::CatalystBase*);   
            */
            void declare_parameters (const std::string& cl_section_name, 
                                     ParameterHandler &param) const;
                                     
            


            virtual boost::shared_ptr<FuelCellShop::Layer::CatalystLayer<dim> > create_replica (const std::string &cl_section_name)
            {
                return boost::shared_ptr<FuelCellShop::Layer::CatalystLayer<dim> > (new FuelCellShop::Layer::MultiScaleCL<dim> (cl_section_name));
            }   


            static MultiScaleCL<dim> const* PROTOTYPE;
            


            void compute_void_fraction();
            
            void initialize_micro_scale(ParameterHandler &param);
            
            SolutionMap micro_scale_current(std::map<VariableNames ,SolutionVariable>& solutionMap, const unsigned int& sol_index, const unsigned int& thread_index);
            
            
            void solve_current_derivatives_average(std::map< VariableNames, std::vector<double> >& Dcurrent);
            
            void solve_current_derivatives_at_each_node(std::map< VariableNames, std::vector<double> >& Dcurrent);

            bool average_cell_current;
            std::map<unsigned int, std::vector<boost::shared_ptr<FuelCellShop::MicroScale::MicroScaleBase>>> micro;
            
            /*Solution map used for storing coverages */
            SolutionMap coverage_map;

            unsigned int cell_id_;

        };
        
    } // Layer
    
}  // FuelCellShop

#endif