reaction_heat.h

Go to the documentation of this file.

//---------------------------------------------------------------------------
//
//    FCST: Fuel Cell Simulation Toolbox
//
//    Copyright (C) 2011-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: reaction_heat.h
//    - Description: Header file for class computing heat source terms due to electrochemical reaction
//    - Developers: Madhur Bhaiya
//    - $Id: reaction_heat.h 2605 2014-08-15 03:36:44Z secanell $
//
//---------------------------------------------------------------------------

#ifndef _FUELCELLSHOP__REACTION_HEAT_H
#define _FUELCELLSHOP__REACTION_HEAT_H

// FCST classes
#include "base_kinetics.h"
#include "PureLiquid.h"
#include "fcst_constants.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 <deal.II/base/subscriptor.h>

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

using namespace dealii;

namespace FuelCellShop
{
    namespace Equation
    {
        class ReactionHeat
        {
        public:


            ReactionHeat();
            
            ~ReactionHeat();
            
            void set_kinetics(FuelCellShop::Kinetics::BaseKinetics* kin)
            {
                kinetics = kin;
            }
            


            void set_electrolyte_potential(const SolutionVariable& phi)
            {
                Assert( phi.get_variablename() == protonic_electrical_potential, ExcMessage("Wrong solution variable passed in BaseKinetics::set_electrolyte_potential.") );
                phi_m = phi;
            }
            void set_solid_potential(const SolutionVariable& phi)
            {
                Assert( phi.get_variablename() == electronic_electrical_potential, ExcMessage("Wrong solution variable passed in BaseKinetics::set_solid_potential.") );
                phi_s = phi;
            }
            void set_temperature(const SolutionVariable& temperature)
            {
                Assert( temperature.get_variablename() == temperature_of_REV, ExcMessage("Wrong solution variable passed in BaseKinetics::set_temperature") );
                T = temperature;
            }
            void set_derivative_flags(const std::vector<VariableNames>& flags)
            {
                derivative_flags = flags;
            }
            
            void initialize_factors(const bool& flag_irrev_ORR = true,
                                    const bool& flag_irrev_HOR = true,
                                    const bool& flag_rev_heat = true,
                                    const double& rev_heat_ORR_coef = 1.0,
                                    const bool& flag_single_phase_ORR = true)
            {
                factor_irrev_ORR    = flag_irrev_ORR             ?   -1.0                                                  : 0.0;
                factor_rev_ORR      = flag_rev_heat              ?   ((-1.0*rev_heat_ORR_coef)/(2.0*Constants::F()))       : 0.0;
                factor_vap_ORR      = flag_single_phase_ORR      ?   ((-1.0)/(2.0*Constants::F()))                         : 0.0;
                
                factor_irrev_HOR    = flag_irrev_HOR             ?   1.0                                                   : 0.0;
                factor_rev_HOR      = flag_rev_heat              ?   ((rev_heat_ORR_coef-1.0)/(2.0*Constants::F()))        : 0.0;
                
                factors_initialized = true;
            }
            


            void heat_source (std::vector<double>& heat,
                              const std::vector<double>& current) const;
            
            void derivative_heat_source (std::map< VariableNames, std::vector<double> >& heat_derived,
                                         const std::map< VariableNames, std::vector<double> >& current_derived,
                                         const std::vector<double>& current) const;

        protected:


            std::vector<VariableNames> derivative_flags;
            
            FuelCellShop::Kinetics::BaseKinetics* kinetics;
            
            SolutionVariable phi_m;
            SolutionVariable phi_s;
            SolutionVariable T;
            
            double entropy_rxn(const double& Temp) const
            {
                double deltaS = ((8.0*(1.0+log(Temp))) - 92.84) * 4.184; // J/mol-K
                return deltaS;  
            }
            
            double deriv_entropy_rxn(const double& Temp) const
            {
                double dDs_dT = (4.184*8.0)/Temp;
                return dDs_dT;
            }
            
            double factor_irrev_ORR;
            
            double factor_irrev_HOR;
            
            double factor_rev_ORR;
            
            double factor_rev_HOR;
            
            double factor_vap_ORR;
            
            bool factors_initialized;
        };
    } //Thermal 
} //FuelCellShop
#endif //_FUELCELLSHOP__REACTION_HEAT_H