agglomerate_base.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
//
// FCST: Fuel Cell Simulation Toolbox
//
// Copyright (C) 2006-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: AgglomerateBase
// - Description: Base class for agglomerate objects, implements MicroScaleBase
// - Developers: Philip Wardlaw, Peter Dobson, Michael Moore, Marc Secanell, University of Alberta
// - $Id: agglomerate_base.h 2605 2014-08-15 03:36:44Z secanell $
//
// ----------------------------------------------------------------------------

#ifndef _FUELCELLSHOP__LAYER__AGGLOMERATE_BASE_H
#define _FUELCELLSHOP__LAYER__AGGLOMERATE_BASE_H

//FCST materials and kinetics classes
#include <catalyst_base.h>
#include <polymer_electrolyte_material_base.h>
#include <base_kinetics.h>
#include <double_trap_kinetics.h>
#include <tafel_kinetics.h>
#include <dual_path_kinetics.h>

//Micro scale base class
#include <micro_scale_base.h>
#include <random>
#include <limits>       // std::numeric_limits


namespace FuelCellShop
{
    namespace MicroScale
    {
        class AgglomerateBase: public MicroScaleBase
        {


        public:

            /*
             * Destructor
             */
            virtual ~AgglomerateBase(){};

            virtual void print_properties();



            virtual void set_solution(const std::map<VariableNames,SolutionVariable>&,const VariableNames&, const int&);

            virtual std::vector<double> compute_derivative_current ()
            {
                Assert(false, ExcPureFunctionCalled());
                return std::vector<double>(sol_names.size(), 0.0);
            }


            virtual bool has_derivatives()
            {
                return has_derivatives_;
            }




            /*
             *  Agglomerate will deep copy it's pointers (kinetics, materials), use this for parallel execution.
             *
             * \warning This following function determines reaction name based on type of kinetics model
             * \warning which may not necessarily be correct and only will work for currently
             * \warning implemented kinetics models.
             * \warning A more robust mothod of determining the reaction name at this scope is required.
             * \warning Use of new kineitics models, or existing kinetics models for different reactions
             * \warning will result in a bugs.
             */
            virtual void make_thread_safe(ParameterHandler &param, unsigned int thread_index);


        protected:

            /*
             * Method for setting up film thickness or porosity depending on parameters
             * called in initialize() or adjust_poly adjust_polydisperse_structure().
             */
            void _initialize_film_porosity();



            /*
             * Type defs to make accessing layer info a bit easier
             */

            typedef FuelCellShop::Layer::MultiScaleCL<deal_II_dimension>::Properties CLPropNames;
            typedef std::map<CLPropNames, double> CL_Properties;


            /*
             * Constructor, sets up some constants
             */
            AgglomerateBase()
            {
                //Constants
                R = Constants::R();
                F = Constants::F();
                permittivity_0 = Constants::E0() *1e-2; // cm
                pi = Constants::Pi();

            }


            /*
             * Protected virtual member function for declaring parameters, pure
             * in MicroScaleBase, implemented here in AgglomerateBase.
             * Parameter structure is hierarchical, therefore children should
             * call their parent's declare parameter function from their own declare
             * parameter function.
             */
            virtual void declare_parameters (ParameterHandler &param) const;

            /*
             * Protected virtual member function for initializing parameters, pure
             * in MicroScaleBase, implemented here in AgglomerateBase.
             * Parameter structure is hierarchical, therefore children should
             * call their parent's initialize function from their own declare
             * parameter function.
             */
            virtual void initialize (ParameterHandler &param);

            /*
             * Pure virtual function for returning film thickness in nano meters.
             *
             * Must be implemented in child, where informed unit conversion will occur.
             */
            virtual double get_film_thickness() = 0;

            /*
             * Pure virtual function for returning agglomerate radius in nano meters.
             *
             * Must be implemented in child, where informed unit conversion will occur.
             */
            virtual double get_radius() = 0;

            virtual double compute_thickness_agg ();

            virtual double compute_epsilon_agg ();

            virtual double compute_epsilon_N ( const double delta_agg, const double thickness_agg ) const;

            virtual  double compute_depsilonN_dthickness ( const double thickness_agg ) const;

            virtual double compute_depsilonN_depsilon_agg () const;

            virtual double compute_n() const;

            virtual double compute_dn_depsilon_agg() const;


            boost::shared_ptr<FuelCellShop::Material::CatalystBase > catalyst;

            boost::shared_ptr<FuelCellShop::Material::PolymerElectrolyteBase> electrolyte;

            boost::shared_ptr<FuelCellShop::Kinetics::BaseKinetics> kinetics;

            std::map<VariableNames, SolutionVariable> solutions;
            std::vector<VariableNames> sol_names;
            VariableNames reactant,tempReactantName;
            int sol_index;


            double permittivity_0; //permittivity of free space (scaled in constructor)
            double pi;
            double F; //Faraday's Constant
            double R; //Gas constant (molar)

            /*
             * Pressure of domain in pascals
             */
            double P;

            /*
             * Active area, [cm^2/cm^3], Scaled to solid fraction by MSCL,
             * scaled to agglomerate core by non abstract agglomerate classes
             */
            double AV;

            /*
             * Radius of the agglomerate, typically [nm], but units may depend
             * on non abstract child
             */
            double r_agg;

            /*
             *  Thickness of the ionomer thin film, typically [nm], but units may depend
             * on non abstract child
             */
            double delta_agg;

            /*
             *  Porosity % of the ionomer thin film
             */
            double epsilon_agg;

            /*
             * Concentration of primary reactant at the boundary, [mol/cm^3]
             */
            double c_R;

            /*
             * Boolean determining whether or not the agglomerate object returns derivatives.
             */
            bool has_derivatives_;

            /*
             * Concentration of protons at the boundary, [mol/cm^3]
             */
            double c_H;

            /*
             *  Electrolyte (Membrane) phase potential at the boundary, [V]
             */
            double phi_M;

            /*
             * Solid phase potential through the agglomerate, [V]
             */
            double phi_S;

            /*
             * Value of the boundary between the thin film and agglomerate domain
             *
             * Dimensionless (0.0 to 1.0)
             */
            double interface;

            /*
             * Oxygen Diffusion, [cm^2/s]
             */
            double D_R_N;

            double H_R_N;

            /*
             * Variable used to select if thickness or porosity should be constant
             */
            std::string fixed_agg_variable;

            /*
             * Number of agglomerates in CL domain
             */
            double n_agg;





        };
    }
}

#endif