reaction_source_terms.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: reaction_source_terms.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: Madhur Bhaiya, Marc Secanell, Valentin N. Zingan
// - Id: $Id$
//
// ----------------------------------------------------------------------------

#ifndef _FCST_FUELCELLSHOP_EQUATION_REACTION_SOURCE_TERMS_H_
#define _FCST_FUELCELLSHOP_EQUATION_REACTION_SOURCE_TERMS_H_

#include "utils/fcst_constants.h"

#include "equations/equation_base.h"
#include "equations/reaction_heat.h"

#include "layers/catalyst_layer.h"

#include "reactions/tafel_kinetics.h"
#include "reactions/double_trap_kinetics.h"
#include "reactions/dual_path_kinetics.h"

namespace FuelCellShop
{
    namespace Equation
    {



        DeclException2(VariableNotFoundForKinetics,
                       std::string,
                       std::string,
                       << "For " << arg1 << " kinetics source terms, \"" << arg2 << "\" is not found as one of the solution variables.");


        template<int dim>
        class ReactionSourceTerms : public EquationBase<dim>
        {
        public:



            ReactionSourceTerms(FuelCell::SystemManagement& system_management);

            virtual ~ReactionSourceTerms();

            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 bool get_irrev_heat_ccl() const
            {
                return irrev_heat_ccl;
            }

            inline bool get_irrev_heat_acl() const
            {
                return irrev_heat_acl;
            }

            inline bool get_rev_heat() const
            {
                return rev_heat;
            }

            inline double get_factor_rev_heat_ccl() const
            {
                return factor_rev_heat_ccl;
            }

            inline bool get_water_vap_heat_ccl() const
            {
                return water_vap_heat_ccl;
            }

            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);

            virtual void assemble_matrix_for_equation(FuelCell::ApplicationCore::MatrixVector& cell_matrices,
                                                      const typename FuelCell::ApplicationCore::DoFApplication<dim>::CellInfo& cell_info,
                                                      const std::string& eq_name,
                                                      const FEValuesBase<dim>& test_fe,
                                                      const std::vector< std::vector<double> >& test_shape_functions,
                                                      const double& sourceterm_factor);




            bool irrev_heat_ccl;

            bool irrev_heat_acl;

            bool rev_heat;

            double factor_rev_heat_ccl;

            bool water_vapour_phase;

            bool water_vap_heat_ccl;




            FuelCellShop::Kinetics::BaseKinetics* cathode_kinetics;

            FuelCellShop::Kinetics::BaseKinetics* anode_kinetics;




            FuelCellShop::Equation::ReactionHeat* cathode_reactionheat;

            FuelCellShop::Equation::ReactionHeat* anode_reactionheat;




            VariableInfo x_oxygen;

            VariableInfo x_water;

            VariableInfo phi_s;

            VariableInfo lambda;


            VariableInfo phi_m;

            VariableInfo t_rev;

            VariableInfo s_liquid_water;

            double F;

            double M_water;




            std::vector< std::vector<double> > phi_T_cell;

            std::vector< std::vector<double> > phi_xOxygen_cell;

            std::vector< std::vector<double> > phi_phiS_cell;

            std::vector< std::vector<double> > phi_phiM_cell;

            std::vector< std::vector<double> > phi_xWater_cell;

            std::vector< std::vector<double> > phi_s_cell;

            std::vector<double> current_cell;

            std::vector<double> heat_cell;

            std::vector<double> dcurrent_dphiS_cell;

            std::vector<double> dcurrent_dphiM_cell;

            std::vector<double> dcurrent_dT_cell;

            std::vector<double> dcurrent_dxOxygen_cell;

            std::vector<double> dcurrent_dxWater_cell;

            std::vector<double> dheat_dphiS_cell;

            std::vector<double> dheat_dphiM_cell;

            std::vector<double> dheat_dT_cell;

            std::vector<double> dheat_dxOxygen_cell;

            std::vector<double> dheat_dxWater_cell;

            double active_area_cell;

            double factor_protontranseq_cell;

            double factor_electrontranseq_cell;

            double factor_oxygentranseq_cell;

            double factor_watertranseq_cell;

            double factor_saturationtranseq_cell;




            bool cell_matrix_counter;

            bool cell_residual_counter;

            unsigned int last_iter_cell;




  // METHODS //

  template<typename INFO>
  void make_assemblers_generic_constant_data(const INFO&                                InFo,
                                             FuelCellShop::Layer::BaseLayer<dim>* const layer);

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

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

  virtual void make_matrix_block_indices();

  virtual void make_residual_indices();

  // DATA 1 //

  unsigned int n_species;

  unsigned int indexO2;

  unsigned int indexH2;

  unsigned int indexH2O;

  // DATA 2 //

  double multiplierO2;

  double multiplierH2;

  double multiplierH2O;

  // DATA 3 //

  std::vector<double> molar_mass;

  // DATA 4 //

  std::vector< FEValuesExtractors::Scalar > density_extractors;

  FEValuesExtractors::Scalar electronic_electrical_potential_extractor;

  FEValuesExtractors::Scalar protonic_electrical_potential_extractor;

  // DATA 5 //

  std::vector<double> T_mixture;

  // DATA 7 //

  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;

  // DATA 8 //

  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;

  // DATA 9 //

  std::vector< std::vector<double> > density_old;

  std::vector<double> electronic_electrical_potential_old;

  std::vector<double> protonic_electrical_potential_old;

  // DATA 10 //

  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;

  // DATA 11 //

  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;


};

} // Equation

} // FuelCellShop

#endif