transport_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_TRANSPORT_SPECIES_H
#define ANTIOCH_TRANSPORT_SPECIES_H

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

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

namespace Antioch
{

  typedef unsigned int Species;


  template<typename CoeffType=double>
  class TransportSpecies
  {
  public:
    
    TransportSpecies(const Species   name, 
                     const CoeffType LJ_depth,
                     const CoeffType LJ_diameter,
                     const CoeffType dipole_moment,
                     const CoeffType polarizability,
                     const CoeffType rot_relax,
                     const CoeffType mass);


    TransportSpecies();

    ~TransportSpecies();

    Species species() const;

    CoeffType LJ_depth() const;

    CoeffType LJ_diameter() const;

    LennardJonesPotential<CoeffType> & LJ() const;

    CoeffType dipole_moment() const;

    CoeffType polarizability() const;

    CoeffType rotational_relaxation() const;

    CoeffType M() const;

    bool polar() const;
    

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


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

  protected:

    const Species _name;

    LennardJonesPotential<CoeffType> _LJ;

    CoeffType _dipole_moment;

    CoeffType _polarizability;

    CoeffType _rotational_relaxation;

    CoeffType _mass;

  }; // class TransportSpecies


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



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

  template<typename CoeffType>
  inline
  Species TransportSpecies<CoeffType>::species() const
  { return _name; }

  template<typename CoeffType>
  inline
  CoeffType TransportSpecies<CoeffType>::LJ_depth() const
  { return _LJ.depth(); }

  template<typename CoeffType>
  inline
  CoeffType TransportSpecies<CoeffType>::LJ_diameter() const 
  { return _LJ.diameter(); }

  template<typename CoeffType>
  inline
  LennardJonesPotential<CoeffType> & TransportSpecies<CoeffType>::LJ() const
  {
    return _LJ;
  }

  template<typename CoeffType>
  inline
  CoeffType TransportSpecies<CoeffType>::dipole_moment() const 
  { return _dipole_moment; }

  template<typename CoeffType>
  inline
  CoeffType TransportSpecies<CoeffType>::polarizability() const 
  { return _polarizability; }

  template<typename CoeffType>
  inline
  CoeffType TransportSpecies<CoeffType>::rotational_relaxation() const 
  { return _rotational_relaxation; }

  template<typename CoeffType>
  inline
  CoeffType TransportSpecies<CoeffType>::M() const 
  { return _mass; }

  template<typename CoeffType>
  inline
  bool TransportSpecies<CoeffType>::polar() const 
  {
     return (_dipole_moment > std::numeric_limits<CoeffType>::epsilon());
  }

  template<typename CoeffType>
  inline
  TransportSpecies<CoeffType>::TransportSpecies( const Species name,
                                                 const CoeffType LJ_depth,
                                                 const CoeffType LJ_diameter,
                                                 const CoeffType dipole_moment,
                                                 const CoeffType polarizability,
                                                 const CoeffType rotational_relaxation,
                                                 const CoeffType mass)
    : _name                  (name),
      _LJ                    (LJ_depth,LJ_diameter),
      _dipole_moment         (dipole_moment),
      _polarizability        (polarizability),
      _rotational_relaxation (rotational_relaxation),
      _mass                  (mass)
  {
    return;
  }


  template<typename CoeffType>
  inline
  TransportSpecies<CoeffType>::TransportSpecies()
    : _name(-1), 
      _LJ(0.,0.),
      _polarizability(0.),
      _rotational_relaxation(0.)
  {
    antioch_error();
    return;
  }


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


  template<typename CoeffType>
  inline
  void TransportSpecies<CoeffType>::print (std::ostream &os) const
  {
    os << " -----------------------------\n"
       << "| Species enum " << this->species() << '\n'
       << "| Transport data "             << '\n'
       << " -----------------------------\n"
       << std::scientific
       << "  LJ depth       = " << this->LJ_depth()              << '\n'
       << "  LJ diameter    = " << this->LJ_diameter()           << '\n'
       << "  polarizability = " << this->polarizability()        << '\n'
       << "  rot relax      = " << this->rotational_relaxation() << '\n';

    os << '\n';
    
    return;
  }


} // end namespace Antioch

#endif // ANTIOCH_CHEMICAL_SPECIES_H