chemical_species.h

Go to the documentation of this file.

//-----------------------------------------------------------------------bl-
//--------------------------------------------------------------------------
//
// Antioch - A Gas Dynamics Thermochemistry Library
//
// Copyright (C) 2014-2016 Paul T. Bauman, Benjamin S. Kirk,
//                         Sylvain Plessis, Roy H. Stonger
//
// Copyright (C) 2013 The PECOS Development Team
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the Version 2.1 GNU Lesser General
// Public License as published by the Free Software Foundation.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc. 51 Franklin Street, Fifth Floor,
// Boston, MA  02110-1301  USA
//
//-----------------------------------------------------------------------el-
//
// $Id$
//
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------

#ifndef ANTIOCH_CHEMICAL_SPECIES_H
#define ANTIOCH_CHEMICAL_SPECIES_H

// Antioch
#include "antioch/antioch_asserts.h"
#include "antioch/physical_constants.h"

// C++
#include <string>
#include <vector>
#include <iostream>

namespace Antioch
{

  template<typename CoeffType=double>
  class ChemicalSpecies
  {
  public:
    
    ChemicalSpecies( const std::string &name, 
                     const CoeffType    mol_wght,
                     const CoeffType    h_form,
                     const CoeffType    n_tr_dofs,
                     const int         charge );


    ChemicalSpecies();

    ~ChemicalSpecies();

    const std::string& species() const;

    CoeffType molar_mass() const;


    CoeffType gas_constant() const;

    CoeffType formation_enthalpy() const;
    
    CoeffType n_tr_dofs() const;
    
    int charge() const;

    bool has_vibrational_modes() const;

    unsigned int n_vibrational_modes() const;

    const std::vector<CoeffType>& theta_v() const;

    const std::vector<unsigned int>& ndg_v() const;

    const std::vector<CoeffType>& theta_e() const;

    const std::vector<unsigned int>& ndg_e() const;

    void add_vibrational_data(const CoeffType theta_v,
                              const CoeffType ndg_v);

    void add_electronic_data(const CoeffType theta_e,
                             const CoeffType ndg_e);


    void print(std::ostream &os = std::cout) const;


    friend std::ostream& operator<<( std::ostream& os,
                                     const ChemicalSpecies<CoeffType>& species )
    {
      species.print(os);
      return os;
    }

  protected:

    const std::string _name;

    const CoeffType _mol_wght;

    const CoeffType _R;

    const CoeffType _h_form;

    const CoeffType _n_tr_dofs;

    const int _charge;

    std::vector<CoeffType> _theta_v;

    std::vector<unsigned int> _ndg_v;

    std::vector<CoeffType> _theta_e;

    std::vector<unsigned int> _ndg_e;
    
  }; // class ChemicalSpecies


  /* ------------------------- Friend Functions ------------------------- */

  

  /* ------------------------- Inline Functions ------------------------- */

  template<typename CoeffType>
  inline
  const std::string& ChemicalSpecies<CoeffType>::species() const 
  { return _name; }

  template<typename CoeffType>
  inline
  CoeffType ChemicalSpecies<CoeffType>::molar_mass() const
  { return _mol_wght; }

  template<typename CoeffType>
  inline
  CoeffType ChemicalSpecies<CoeffType>::gas_constant() const 
  { return _R; }

  template<typename CoeffType>
  inline
  CoeffType ChemicalSpecies<CoeffType>::formation_enthalpy() const 
  { return _h_form; }

  template<typename CoeffType>
  inline
  CoeffType ChemicalSpecies<CoeffType>::n_tr_dofs() const 
  { return _n_tr_dofs; }

  template<typename CoeffType>
  inline
  int ChemicalSpecies<CoeffType>::charge() const 
  { return _charge; }

  template<typename CoeffType>
  inline
  bool ChemicalSpecies<CoeffType>::has_vibrational_modes() const 
  { return !_theta_v.empty(); }

  template<typename CoeffType>
  inline
  unsigned int ChemicalSpecies<CoeffType>::n_vibrational_modes() const
  {
    antioch_assert_equal_to(_theta_v.size(), _ndg_v.size());
    return _theta_v.size();
  }

  template<typename CoeffType>
  inline
  const std::vector<CoeffType>& ChemicalSpecies<CoeffType>::theta_v() const
  { return _theta_v; }

  template<typename CoeffType>
  inline
  const std::vector<unsigned int>& ChemicalSpecies<CoeffType>::ndg_v() const 
  { return _ndg_v; }

  template<typename CoeffType>
  inline
  const std::vector<CoeffType>& ChemicalSpecies<CoeffType>::theta_e() const 
  { return _theta_e; }

  template<typename CoeffType>
  inline
  const std::vector<unsigned int>& ChemicalSpecies<CoeffType>::ndg_e() const
  { return _ndg_e; }


  template<typename CoeffType>
  inline
  void ChemicalSpecies<CoeffType>::add_vibrational_data(const CoeffType theta_v,
                                                        const CoeffType ndg_v)
  {
    _theta_v.push_back(theta_v);
    _ndg_v.push_back(ndg_v);
  }

  template<typename CoeffType>
  inline
  void ChemicalSpecies<CoeffType>::add_electronic_data(const CoeffType theta_e,
                                                       const CoeffType ndg_e)
  {
    _theta_e.push_back(theta_e);
    _ndg_e.push_back(ndg_e);
  }

  template<typename CoeffType>
  inline
  ChemicalSpecies<CoeffType>::ChemicalSpecies( const std::string &name,
                                               const CoeffType mol_wght,
                                               const CoeffType h_form,
                                               const CoeffType n_tr_dofs,
                                               const int charge )
    : _name      (name),
      _mol_wght  (mol_wght),
      _R         (Constants::R_universal<CoeffType>()/mol_wght),
      _h_form    (h_form),
      _n_tr_dofs (n_tr_dofs),
      _charge    (charge)
  {
    return;
  }


  template<typename CoeffType>
  inline
  ChemicalSpecies<CoeffType>::ChemicalSpecies()
    : _name("Err"), 
      _mol_wght(0), 
      _R(0),
      _h_form(0), 
      _n_tr_dofs(0), 
      _charge(0)
  {
    antioch_error();
    return;
  }


  template<typename CoeffType>
  inline
  ChemicalSpecies<CoeffType>::~ChemicalSpecies()
  {
    return;
  }


  template<typename CoeffType>
  inline
  void ChemicalSpecies<CoeffType>::print (std::ostream &os) const
  {
    os << " -----------------------------\n"
       << "| Species " << this->species() << '\n'
       << " -----------------------------\n"
       << std::scientific
       << "  Mol Wgt = " << this->molar_mass() << '\n'
       << "  R       = " << this->gas_constant()     << '\n'
       << "  h0      = " << this->formation_enthalpy() << '\n'
       << "  n_tr    = " << this->n_tr_dofs() << '\n'
       << "  charge  = " << this->charge() << '\n';

    for (unsigned int l=0; l<this->theta_v().size(); l++)
      os << "  theta_v_" << l << " = " << this->theta_v()[l]
         << ", ndg = " << this->ndg_v()[l] << "\n";
    
    for (unsigned int l=0; l<this->theta_e().size(); l++)
      os << "  theta_e_" << l << " = " << this->theta_e()[l]
         << ", ndg = " << this->ndg_e()[l] << "\n";
    
    os << '\n';
    
    return;
  }


} // end namespace Antioch

#endif // ANTIOCH_CHEMICAL_SPECIES_H