operating_conditions.h

Go to the documentation of this file.

//---------------------------------------------------------------------------
//    $Id: operating_conditions.h 2605 2014-08-15 03:36:44Z secanell $
//
//    Copyright (C) 2009 by Marc Secanell
//
//    This file is subject to QPL and may not be  distributed
//    without copyright and license information. Please refer
//    to the file deal.II/doc/license.html for the  text  and
//    further information on this license.
//
//---------------------------------------------------------------------------

#ifndef _FUELCELL_OPERATING_CONDITIONS__H
#define _FUELCELL_OPERATING_CONDITIONS__H

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


#include <boost/lexical_cast.hpp>

#include <utils/logging.h>
#include <utils/fcst_constants.h>
#include <application_core/initial_and_boundary_data.h>
#include <grid/geometry.h>
#include <materials/PureGas.h>
#include <materials/GasMixture.h>
#include <utils/fcst_units.h>

using namespace dealii;

namespace FuelCell
{
    
    class OperatingConditions
    {
    public:
        OperatingConditions();
        
        ~OperatingConditions();
        
        void declare_parameters (ParameterHandler &param) const;

        void initialize (ParameterHandler& param);
        
        void set_gas_mixtures(FuelCellShop::Material::GasMixture& c_mix, FuelCellShop::Material::GasMixture& a_mix)
        {
            c_mix.set_total_pressure(get_pc_Pa());
            c_mix.set_temperature(get_T());
            
            cathode_mix = &c_mix;
            
            a_mix.set_total_pressure(get_pa_Pa());
            a_mix.set_temperature(get_T());
            
            anode_mix = &a_mix;
        }
            
        std::vector<double> get_rho_anode() const;
        
        std::vector<double> get_rho_cathode() const;
        
        
        double saturation_pressure() const;
        
        double get_x_wv(int) const;
        
        double get_x_wv() const;

        double get_x_wv_anode() const;        
        
        double get_x_o2() const;
        
        double get_x_h2() const;
        
        double get_x_n2(int) const;        
        
        double get_rho_wv(int) const;
        
        double get_rho_wv() const;

        double get_rho_wv_anode() const;        
        
        double get_rho_o2() const;
        double get_rho_h2() const;        
        double get_rho_n2(int) const;
        double get_rho_n2() const;
        double get_rho_n2_anode() const;        
        
        void set_gas_map(std::map<unsigned int, std::string> tmp);
        
        std::map<unsigned int, std::string> get_gas_map() const;
        
        double get_density_from_map(std::string species) const;
        
        double voltage_cell_th();
        
        void print_operating_conditions() const;
        
        void adjust_initial_solution(std::vector< component_materialID_value_map >& maps,
                                     const boost::shared_ptr< FuelCellShop::Geometry::GridBase<dim> > grid) const;
        void adjust_boundary_conditions(std::vector< component_boundaryID_value_map >& maps,
                                        const boost::shared_ptr< FuelCellShop::Geometry::GridBase<dim> > grid) const;
        inline double get_c_c() const
        {       return c_c; }
        inline double get_T() const
        { return T_cell; }
        inline double get_V() const
        { return V_cell; }
        inline double get_dV_a() const
        { return dV_a; }
        inline double get_pc_Pa() const
        { return p_c; }
        inline double get_pc_atm() const
        { return p_c/Units::convert(1.,Units::ATM_to_PA); }
        inline double get_c_a() const
        {       return c_a; }
        inline double get_pa_Pa() const
        { return p_a; }
        inline double get_pa_atm() const
        { return p_a/Units::convert(1.,Units::ATM_to_PA); }
        inline double get_RH_a() const
        {return RH_a;}
        inline double get_RH_c() const
        {return RH_c;}
        inline double get_OCV() const
        {return OCV;}
        
    private:
        unsigned int get_species_index(std::string name) const
        {
            AssertThrow(name.compare(0,16,"density_species_") == 0, ExcMessage("This function is only meant to be used to get species number from density_species_*, please use another function."));
            
            std::string speciesStr     = name.substr(16); //get substring from position 16 to end which should be the full species number 
            unsigned int species_index = atoi(speciesStr.c_str()) - 1; //convert species string number to int to use in map
            
            return species_index;
        }
        double get_anode_gas_density(unsigned int species_index) const
        {                    
            double density(0.0);
            double p_sat_Pa = Units::convert(saturation_pressure(),Units::ATM_to_PA);
            
            unsigned int anode_gas_index = species_index - cathode_mix->n_gases();
            
            const std::string gas_name = anode_mix->get_gas(anode_gas_index)->name_material ();
            double M = 1e3*anode_mix->get_gas(anode_gas_index)->get_molar_mass();  // g/cm3     
            
            //-- Get pV if water is solved for only:
            double pv_a = 0.0;
            for (unsigned int ind_g = 0; ind_g<anode_mix->n_gases(); ind_g++) {
                std::string name = anode_mix->get_gas(ind_g)->name_material ();
                if (name.compare("water") == 0)
                    pv_a = p_sat_Pa*RH_a;
            }
            double p_H2 = channel_dry_hydrogen_mole_fraction*(p_a-pv_a);
            double p_N2 = p_a - p_H2 - pv_a;
            
            if (gas_name.compare("water") == 0)
                density = 1E-6*M*pv_a/(R*T_cell);         // g/cm^3
            else if (gas_name.compare("hydrogen") == 0)
                density = 1E-6*M*p_H2/(R*T_cell);         // g/cm^3
            else if (gas_name.compare("nitrogen") == 0)
                density = 1E-6*M*p_N2/(R*T_cell);         // g/cm^3
            else
                AssertThrow(false, ExcMessage("Gas not implemented"));
            
            return density;
                        
        }
        double get_cathode_gas_density(unsigned int species_index) const
        {
            double density(0.0);
            double p_sat_Pa = Units::convert(saturation_pressure(),Units::ATM_to_PA);
            
            const std::string gas_name = cathode_mix->get_gas(species_index)->name_material ();
            double M = 1e3*cathode_mix->get_gas(species_index)->get_molar_mass();  // g/cm3  
            
            double pv_c = 0.0;
            for (unsigned int ind_g = 0; ind_g<cathode_mix->n_gases(); ind_g++) 
            {
                std::string name = cathode_mix->get_gas(ind_g)->name_material ();
                if (name.compare("water") == 0)
                    pv_c = p_sat_Pa*RH_c;
            }   
            double p_O2 = channel_oxygen_mole_fraction*(p_c-pv_c);
            double p_N2 = p_a - p_O2 - pv_c;
            
            if (gas_name.compare("water") == 0)
                density = 1E-6*M*pv_c/(R*T_cell);         // g/cm^3
            else if (gas_name.compare("oxygen") == 0)
                density = 1E-6*M*p_O2/(R*T_cell);         // g/cm^3
            else if (gas_name.compare("nitrogen") == 0)
                density = 1E-6*M*p_N2/(R*T_cell);         // g/cm^3
            else
                AssertThrow(false, ExcMessage("Gas not implemented"));
            
            return density;
        }
        
        //------------ BOUNDARY CONDITIONS -------------------------------
        bool adjust_BC;
        //------------ CONSTANTS -----------------------------------------
        double R; //Gas constant 8.3144 J / (mol K)
        
        double channel_oxygen_mole_fraction;
        
        double channel_dry_hydrogen_mole_fraction;
        
        //------------ CELL DATA -----------------------------------------
        double T_cell;
        double V_cell;
        double dV_a;
        double OCV;
        double E_th;
        
        //------------- ANODE DATA -------------------------------------
        double p_a; 
        double c_a;
        double RH_a;
        
        //------------- CATHODE DATA -------------------------------------
        double p_c;
        double c_c;
        double RH_c;
        
        //------------- GAS DATA -------------------------------------
        FuelCellShop::Material::WaterVapor water;
        const double M_water = water.get_molar_mass() * 1000; // [g/mol]
        FuelCellShop::Material::Oxygen oxygen;
        const double M_oxygen = oxygen.get_molar_mass() * 1000; // [g/mol]
        FuelCellShop::Material::Nitrogen nitrogen;
        const double M_nitrogen = nitrogen.get_molar_mass() * 1000; // [g/mol]
        FuelCellShop::Material::Hydrogen hydrogen;
        const double M_hydrogen = hydrogen.get_molar_mass() * 1000; // [g/mol]
        FuelCellShop::Material::GasMixture* anode_mix;
        FuelCellShop::Material::GasMixture* cathode_mix;

        std::map<unsigned int, std::string> gasSpeciesMap;
        
        bool anode = false;
        
        enum Electrode {noElectrode, ANODE, CATHODE, MEMBRANE};
        Electrode compartment;
    };
    
}

#endif // _FUELCELL_OPERATING_CONDITIONS__H