PureGas.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
//
// FCST: Fuel Cell Simulation Toolbox
//
// Copyright (C) 2006-2013 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: PureGas.h
// - Description: This class describes properties of pure gases
// - Developers: Valentin N. Zingan, University of Alberta
// - Id: $Id: PureGas.h 2605 2014-08-15 03:36:44Z secanell $
//
// ----------------------------------------------------------------------------

#ifndef _FCST_FUELCELLSHOP_MATERIAL_PUREGAS_H_
#define _FCST_FUELCELLSHOP_MATERIAL_PUREGAS_H_

#define _DUMMY_ 1.e300

#include "base_material.h"
#include "fcst_constants.h"

enum enMaterialID {matNone,
                   matOxygen,
                   matNitrogen,
                   matHydrogen,
                   matWaterVapor,
                   matAir,
                   matHelium};

namespace FuelCellShop
{
namespace Material
{

class PureGas : public BaseMaterial
{
public:



  virtual void declare_parameters(ParameterHandler& param) const;

  virtual void initialize(ParameterHandler& param);




  const double& get_molar_mass() const
  {
         return molar_mass;
  }

  const double& get_collision_diameter() const
  {
         return collision_diameter;
  }

  const double& get_eps_BY_k() const
  {
         return eps_BY_k;
  }

  const double& get_Prandtl() const
  {
         return Prandtl;
  }

  virtual enMaterialID get_ID() const = 0;

  const std::string& get_chemical_formula() const
  {
         return chemical_formula;
  }

  const std::string& get_dynamic_viscosity_mode() const
  {
         return dynamic_viscosity_mode;
  }

  const std::string& get_bulk_viscosity_mode() const
  {
         return bulk_viscosity_mode;
  }

  const std::string& get_thermal_conductivity_mode() const
  {
         return thermal_conductivity_mode;
  }




  const double get_pressure(const double& density,
                            const double& temperature) const;

  void get_pressure(const std::vector<double>& density,
                    const double&              temperature,
                    std::vector<double>&       pressure) const;

  void get_pressure(const std::vector<double>& density,
                    const std::vector<double>& temperature,
                    std::vector<double>&       pressure) const;

  const double get_Dpressure_Ddensity(const double& temperature) const;

  void get_Dpressure_Ddensity(const std::vector<double>& temperature,
                              std::vector<double>&       dst) const;

  const double get_Dpressure_Dtemperature(const double& density) const;

  void get_Dpressure_Dtemperature(const std::vector<double>& density,
                                  std::vector<double>&       dst) const;




  const double get_Sutherland_dynamic_viscosity(const double& temperature) const;

  void get_Sutherland_dynamic_viscosity(const std::vector<double>& temperature,
                                        std::vector<double>&       dynamic_viscosity) const;

  const double get_DSutherland_dynamic_viscosity_Dtemperature(const double& temperature) const;

  void get_DSutherland_dynamic_viscosity_Dtemperature(const std::vector<double>& temperature,
                                                      std::vector<double>&       dst) const;




  const double get_ChapmanEnskog_dynamic_viscosity(const double& temperature) const;

  void get_ChapmanEnskog_dynamic_viscosity(const std::vector<double>& temperature,
                                           std::vector<double>&       dynamic_viscosity) const;

  const double get_DChapmanEnskog_dynamic_viscosity_Dtemperature(const double& temperature) const;

  void get_DChapmanEnskog_dynamic_viscosity_Dtemperature(const std::vector<double>& temperature,
                                                         std::vector<double>&       dst) const;




  const double get_dynamic_viscosity(const double& temperature) const;

  void get_dynamic_viscosity(const std::vector<double>& temperature,
                             std::vector<double>&       dynamic_viscosity) const;

  const double get_Ddynamic_viscosity_Dtemperature(const double& temperature) const;

  void get_Ddynamic_viscosity_Dtemperature(const std::vector<double>& temperature,
                                           std::vector<double>&       dst) const;




  const double get_bulk_viscosity(const double& dynamic_viscosity) const;

  void get_bulk_viscosity(const std::vector<double>& dynamic_viscosity,
                          std::vector<double>&       bulk_viscosity) const;

  const double get_Dbulk_viscosity_Dtemperature(const double& src) const;

  void get_Dbulk_viscosity_Dtemperature(const std::vector<double>& src,
                                        std::vector<double>&       dst) const;




  const double get_Sutherland_thermal_conductivity(const double& temperature) const;

  void get_Sutherland_thermal_conductivity(const std::vector<double>& temperature,
                                           std::vector<double>&       thermal_conductivity) const;

  const double get_DSutherland_thermal_conductivity_Dtemperature(const double& temperature) const;

  void get_DSutherland_thermal_conductivity_Dtemperature(const std::vector<double>& temperature,
                                                         std::vector<double>&       dst) const;




  const double get_ChapmanEnskog_thermal_conductivity(const double& temperature) const;

  void get_ChapmanEnskog_thermal_conductivity(const std::vector<double>& temperature,
                                              std::vector<double>&       thermal_conductivity) const;

  const double get_DChapmanEnskog_thermal_conductivity_Dtemperature(const double& temperature) const;

  void get_DChapmanEnskog_thermal_conductivity_Dtemperature(const std::vector<double>& temperature,
                                                            std::vector<double>&       dst) const;




  const double get_thermal_conductivity(const double& temperature) const;

  void get_thermal_conductivity(const std::vector<double>& temperature,
                                std::vector<double>&       thermal_conductivity) const;

  const double get_Dthermal_conductivity_Dtemperature(const double& temperature) const;

  void get_Dthermal_conductivity_Dtemperature(const std::vector<double>& temperature,
                                              std::vector<double>&       dst) const;




  const double get_molar_enthalpy(const double& temperature) const;

  void get_molar_enthalpy(const std::vector<double>& temperature,
                          std::vector<double>&       molar_enthalpy) const;

  const double get_Dmolar_enthalpy_Dtemperature(const double& temperature) const;

  void get_Dmolar_enthalpy_Dtemperature(const std::vector<double>& temperature,
                                        std::vector<double>&       dst) const;

  const double get_D2molar_enthalpy_Dtemperature2(const double& temperature) const;

  void get_D2molar_enthalpy_Dtemperature2(const std::vector<double>& temperature,
                                          std::vector<double>&       dst) const;




  const double get_water_vapor_saturation_pressure(const double& temperature) const;

  void get_water_vapor_saturation_pressure(const std::vector<double>& temperature,
                                           std::vector<double>&       water_vapor_saturation_pressure) const;

  const double get_Dwater_vapor_saturation_pressure_Dtemperature(const double& temperature) const;

  void get_Dwater_vapor_saturation_pressure_Dtemperature(const std::vector<double>& temperature,
                                                         std::vector<double>&       dst) const;




  const double get_collision_integral(const double& temperature) const;

  void get_collision_integral(const std::vector<double>& temperature,
                              std::vector<double>&       collision_integral) const;

  const double get_Dcollision_integral_Dtemperature(const double& temperature) const;

  void get_Dcollision_integral_Dtemperature(const std::vector<double>& temperature,
                                            std::vector<double>&       dst) const;




  const double get_specific_heat_capacity(const double& temperature) const;

  void get_specific_heat_capacity(const std::vector<double>& temperature,
                                  std::vector<double>&       specific_heat_capacity) const;

  const double get_Dspecific_heat_capacity_Dtemperature(const double& temperature) const;

  void get_Dspecific_heat_capacity_Dtemperature(const std::vector<double>& temperature,
                                                std::vector<double>&       dst) const;

  const double get_D2specific_heat_capacity_Dtemperature2(const double& temperature) const;

  void get_D2specific_heat_capacity_Dtemperature2(const std::vector<double>& temperature,
                                                  std::vector<double>&       dst) const;


protected:



  PureGas(const std::string& name);

  virtual ~PureGas();


  // DATA //



  double molar_mass;

  double collision_diameter;

  double eps_BY_k;

  double Prandtl;




  double A_Sutherland;

  double B_Sutherland;

  double c_0;

  double c_1;

  double c_2;

  double c_3;

  double H_ref;

  double T_ref;




  std::string chemical_formula;

  std::string dynamic_viscosity_mode;

  std::string bulk_viscosity_mode;

  std::string thermal_conductivity_mode;


};

class Oxygen : public PureGas
{
public:



  Oxygen()
  :
  PureGas("oxygen")
  {
         this->molar_mass         = 31.999e-3;
         this->collision_diameter = 3.4330000;
         this->eps_BY_k           = 113.00000;
         this->Prandtl            = 0.7130000;

         this->A_Sutherland = 1.693411300e-6;
         this->B_Sutherland = 127.0000000000;

         this->c_0 =   0.8800e3;
         this->c_1 = - 0.0001e3;
         this->c_2 =   0.5400e3;
         this->c_3 = - 0.3300e3;

         this->H_ref = 0.000;
         this->T_ref = 298.0;

         this->chemical_formula = "O2";
  }

  virtual ~Oxygen() { }




  virtual enMaterialID get_ID() const
  {
         return matOxygen;
  }


};

class Nitrogen : public PureGas
{
public:



  Nitrogen()
  :
  PureGas("nitrogen")
  {
         this->molar_mass         = 28.0134e-3;
         this->collision_diameter = 3.66700000;
         this->eps_BY_k           = 99.8000000;
         this->Prandtl            = 0.70700000;

         this->A_Sutherland = 1.406732195e-6;
         this->B_Sutherland = 111.0000000000;

         this->c_0 =   1.11e3;
         this->c_1 = - 0.48e3;
         this->c_2 =   0.96e3;
         this->c_3 = - 0.42e3;

         this->H_ref = 0.000;
         this->T_ref = 298.0;

         this->chemical_formula = "N2";
  }

  virtual ~Nitrogen() { }




  virtual enMaterialID get_ID() const
  {
         return matNitrogen;
  }


};

class Hydrogen : public PureGas
{
public:



  Hydrogen()
  :
  PureGas("hydrogen")
  {
         this->molar_mass         = 2.016e-3;
         this->collision_diameter = 2.915000;
         this->eps_BY_k           = 38.00000;
         this->Prandtl            = 0.685000;

         this->A_Sutherland = 6.362365620e-7;
         this->B_Sutherland = 72.00000000000;

         this->c_0 =   13.46e3;
         this->c_1 =   4.600e3;
         this->c_2 = - 6.850e3;
         this->c_3 =   3.790e3;

         this->H_ref = 0.000;
         this->T_ref = 298.0;

         this->chemical_formula = "H2";
  }

  virtual ~Hydrogen() { }




  virtual enMaterialID get_ID() const
  {
         return matHydrogen;
  }


};

class WaterVapor : public PureGas
{
public:



  WaterVapor()
  :
  PureGas("water")
  {
         this->molar_mass         = 18.015e-3;
         this->collision_diameter = 2.6410000;
         this->eps_BY_k           = 809.10000;
         this->Prandtl            = 0.9500000;

         this->A_Sutherland = _DUMMY_;
         this->B_Sutherland = _DUMMY_;

         this->c_0 =   1.790e3;
         this->c_1 =   0.107e3;
         this->c_2 =   0.586e3;
         this->c_3 = - 0.200e3;

         this->H_ref = - 2.41826e5;
         this->T_ref =   298.00000;

         this->chemical_formula = "H2O Vapor";
  }

  virtual ~WaterVapor() { }




  virtual enMaterialID get_ID() const
  {
         return matWaterVapor;
  }


};

class Air : public PureGas
{
public:



  Air()
  :
  PureGas("air")
  {
         this->molar_mass         = 28.964e-3;
         this->collision_diameter = 3.6170000;
         this->eps_BY_k           = 97.000000;
         this->Prandtl            = 0.7020000;

         this->A_Sutherland = 1.512041288e-6;
         this->B_Sutherland = 120.0000000000;

         this->c_0 =   1.050e3;
         this->c_1 = - 0.365e3;
         this->c_2 =   0.850e3;
         this->c_3 = - 0.390e3;

         this->H_ref = _DUMMY_;
         this->T_ref = _DUMMY_;

         this->chemical_formula = "78.1_N2__20.9_O2__0.9_Ar__0.03_CO2__0.002_Ne__0.0005_He__0.0002_CH4__0.0001_Kr__0.00005_H2__0.000009_He";
  }

  virtual ~Air() { }




  virtual enMaterialID get_ID() const
  {
         return matAir;
  }


};

class Helium : public PureGas
{
public:



  Helium()
  :
  PureGas("helium")
  {
         this->molar_mass         = 4.002602e-3;
         this->collision_diameter = 2.576000000;
         this->eps_BY_k           = 10.20000000;
         this->Prandtl            = 0.710000000;

         this->A_Sutherland = 1.484381490e-6;
         this->B_Sutherland = 79.40000000000;

         this->c_0 = 5.193e3;
         this->c_1 = 0.00000;
         this->c_2 = 0.00000;
         this->c_3 = 0.00000;

         this->H_ref = _DUMMY_;
         this->T_ref = _DUMMY_;

         this->chemical_formula = "He";
  }

  virtual ~Helium() { }




  virtual enMaterialID get_ID() const
  {
         return matHelium;
  }


};

} // Material

} // FuelCellShop

#endif