reaction_source_terms_KG.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
//
// FCST: Fuel Cell Simulation Toolbox
//
// Copyright (C) 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: reaction_source_terms_KG.h
// - Description: This class is used to assemble both cell matrix and cell residual
//                for reaction source terms in the catalyst layers for various equation classes
// - Developers: Marc Secanell, 2015
//
// ----------------------------------------------------------------------------
#ifndef _FCST_FUELCELLSHOP_EQUATION_REACTION_SOURCE_TERMS_KG_H_
#define _FCST_FUELCELLSHOP_EQUATION_REACTION_SOURCE_TERMS_KG_H_

#include <equations/equation_base.h>
#include <equations/reaction_heat.h>
#include <equations/reaction_source_terms_base.h>

namespace FuelCellShop
{
    namespace Equation
    {
        template<int dim>
        class ReactionSourceTermsKG : public ReactionSourceTermsBase<dim>
        {
        public:



            ReactionSourceTermsKG(FuelCell::SystemManagement& system_management,boost::shared_ptr< FuelCell::ApplicationCore::ApplicationData > data = 
            boost::shared_ptr< FuelCell::ApplicationCore::ApplicationData >());

            virtual ~ReactionSourceTermsKG();

            virtual void declare_parameters(ParameterHandler& param) const;

            virtual void initialize(ParameterHandler& param);

            inline void set_cathode_kinetics(FuelCellShop::Kinetics::BaseKinetics* kinetics)
            {
                cathode_kinetics = kinetics;
            }

            inline void set_anode_kinetics(FuelCellShop::Kinetics::BaseKinetics* kinetics)
            {
                anode_kinetics = kinetics;
            }




            virtual void assemble_cell_matrix(FuelCell::ApplicationCore::MatrixVector&                                 cell_matrices,
                                              const typename FuelCell::ApplicationCore::DoFApplication<dim>::CellInfo& cell_info,
                                              FuelCellShop::Layer::BaseLayer<dim>* const                               layer);

            virtual void assemble_cell_residual(FuelCell::ApplicationCore::FEVector&                                     cell_residual,
                                                const typename FuelCell::ApplicationCore::DoFApplication<dim>::CellInfo& cell_info,
                                                FuelCellShop::Layer::BaseLayer<dim>* const                               layer);




            virtual void adjust_internal_cell_couplings( std::vector< couplings_map >& dst,
                                                         const std::vector< FuelCellShop::Material::PureGas* >& gases = std::vector< FuelCellShop::Material::PureGas* >() );

            virtual void print_equation_info() const;

            inline FuelCellShop::Kinetics::BaseKinetics* get_cathode_kinetics() const
            {
                return cathode_kinetics;
            }

            inline FuelCellShop::Kinetics::BaseKinetics* get_anode_kinetics() const
            {
                return anode_kinetics;
            }


        protected:



            virtual void make_assemblers_generic_constant_data();

            virtual void make_assemblers_cell_constant_data(const typename FuelCell::ApplicationCore::DoFApplication<dim>::CellInfo& cell_info);

            virtual void make_assemblers_cell_variable_data(const typename FuelCell::ApplicationCore::DoFApplication<dim>::CellInfo& cell_info,
                                                            FuelCellShop::Layer::BaseLayer<dim>* const layer);




            FuelCellShop::Kinetics::BaseKinetics* cathode_kinetics;

            FuelCellShop::Kinetics::BaseKinetics* anode_kinetics;




            unsigned int last_iter_cell;
            
            

            
            virtual void make_matrix_block_indices();
            
            virtual void make_residual_indices();
            
            unsigned int n_species;
            
            unsigned int indexO2;
            
            unsigned int indexH2;
            
            unsigned int indexH2O;
            
            double multiplierO2;
            
            double multiplierH2;
            
            double multiplierH2O;
            
            std::vector<double> molar_mass;
            
            std::vector< FEValuesExtractors::Scalar > density_extractors;
            
            FEValuesExtractors::Scalar electronic_electrical_potential_extractor;
            
            FEValuesExtractors::Scalar protonic_electrical_potential_extractor;
            
            std::vector<double> T_mixture;
            
            std::vector<double> ORR_current_density;
            
            std::vector<double> DORR_current_density_Doxygen_concentration;
            
            std::vector<double> DORR_current_density_Delectronic_electrical_potential;
            
            std::vector<double> DORR_current_density_Dprotonic_electrical_potential;
            
            std::vector<double> HOR_current_density;
            
            std::vector<double> DHOR_current_density_Dhydrogen_concentration;
            
            std::vector<double> DHOR_current_density_Delectronic_electrical_potential;
            
            std::vector<double> DHOR_current_density_Dprotonic_electrical_potential;
            
            std::vector< std::vector<double> > density_old;
            
            std::vector<double> electronic_electrical_potential_old;
            
            std::vector<double> protonic_electrical_potential_old;
            
            std::vector< std::vector< std::vector<double> > > phi_density;
            
            std::vector< std::vector<double> > phi_electronic_electrical_potential;
            
            std::vector< std::vector<double> > phi_protonic_electrical_potential;
            
            std::string eq_generic_prefix;
            
            std::vector<std::string> eq_postfixes;
            
            std::vector<std::string> var_postfixes;
            
            std::string eq_name;
            
            std::string var_name;
            

            inline void set_species_couplings (unsigned int reacting_species_equation_number, unsigned int species_number, std::vector< couplings_map >& equation_map)
            {
                unsigned int index = reacting_species_equation_number;
                unsigned int g = species_number;
                
                eq_name = "Kerkhof-Geboers Fluid Transport Equations - steady-state - compressible - isothermal - single-phase - multi-component - mass conservation - " + eq_postfixes[g-1];
                          
                couplings_map::iterator iter = equation_map[index].find(eq_name);
                
                if( iter != equation_map[index].end() )
                {
                    iter->second["electronic_electrical_potential"] = DoFTools::always;
                    iter->second["protonic_electrical_potential"]   = DoFTools::always;
                }
                else
                    AssertThrow( false, ExcInternalError() );
            }
            
            inline void set_density_couplings (unsigned int species_number, couplings_map::iterator iter)
            {

                if( species_number != -1 )
                {
                    var_name = "density_" + var_postfixes[species_number-1];
                    iter->second[var_name] = DoFTools::always;
                }
                else
                    AssertThrow( false, ExcNotImplemented() );
            }
        };
             
    } // Equation
             
} // FuelCellShop
        
#endif