GeneralMixture.hpp

// Reaktoro is a unified framework for modeling chemically reactive systems.
//
// Copyright (C) 2014-2018 Allan Leal
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// 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, see <http://www.gnu.org/licenses/>.
 
#pragma once
 
// C++ includes
#include <string>
#include <vector>
 
// Reaktoro includes
#include <Reaktoro/Common/Index.hpp>
#include <Reaktoro/Common/ChemicalScalar.hpp>
#include <Reaktoro/Common/ChemicalVector.hpp>
#include <Reaktoro/Common/ScalarTypes.hpp>
#include <Reaktoro/Common/SetUtils.hpp>
#include <Reaktoro/Common/ThermoScalar.hpp>
#include <Reaktoro/Core/Utils.hpp>
 
namespace Reaktoro {
 
struct MixtureState
{
    Temperature T;
 
    Pressure P;
 
    ChemicalVector x;
};
 
inline auto operator==(const MixtureState& l, const MixtureState& r) -> bool
{
    return l.T == r.T && r.P == r.P && l.x == r.x;
}
 
template<class SpeciesType>
class GeneralMixture
{
public:
    GeneralMixture();
 
    explicit GeneralMixture(const std::vector<SpeciesType>& species);
 
    virtual ~GeneralMixture();
 
    auto setName(std::string name) -> void;
 
    auto numSpecies() const -> unsigned;
 
    auto name() const -> std::string;
 
    auto species() const -> const std::vector<SpeciesType>&;
 
    auto species(const Index& index) const -> const SpeciesType&;
 
    auto indexSpecies(const std::string& name) const -> Index;
 
    auto indexSpeciesAny(const std::vector<std::string>& names) const -> Index;
 
    auto namesSpecies() const -> std::vector<std::string>;
 
    auto chargesSpecies() const -> Vector;
 
    auto moleFractions(VectorConstRef n) const -> ChemicalVector;
 
    auto state(Temperature T, Pressure P, VectorConstRef n) const -> MixtureState;
 
private:
    std::string _name;
 
    std::vector<SpeciesType> _species;
};
 
template<class SpeciesType>
GeneralMixture<SpeciesType>::GeneralMixture()
{}
 
template<class SpeciesType>
GeneralMixture<SpeciesType>::GeneralMixture(const std::vector<SpeciesType>& species)
: _species(species)
{}
 
template<class SpeciesType>
GeneralMixture<SpeciesType>::~GeneralMixture()
{}
 
template<class SpeciesType>
auto GeneralMixture<SpeciesType>::setName(std::string name) -> void
{
    _name = name;
}
 
template<class SpeciesType>
auto GeneralMixture<SpeciesType>::numSpecies() const -> unsigned
{
    return _species.size();
}
 
template<class SpeciesType>
auto GeneralMixture<SpeciesType>::name() const -> std::string
{
    return _name;
}
 
template<class SpeciesType>
auto GeneralMixture<SpeciesType>::species() const -> const std::vector<SpeciesType>&
{
    return _species;
}
 
template<class SpeciesType>
auto GeneralMixture<SpeciesType>::species(const Index& index) const -> const SpeciesType&
{
    return _species[index];
}
 
template<class SpeciesType>
auto GeneralMixture<SpeciesType>::indexSpecies(const std::string& name) const -> Index
{
    return index(name, _species);
}
 
template<class SpeciesType>
auto GeneralMixture<SpeciesType>::indexSpeciesAny(const std::vector<std::string>& names) const -> Index
{
    return indexAny(names, _species);
}
 
template<class SpeciesType>
auto GeneralMixture<SpeciesType>::namesSpecies() const -> std::vector<std::string>
{
    std::vector<std::string> names(_species.size());
    for(unsigned i = 0; i < names.size(); ++i)
        names[i] = _species[i].name();
    return names;
}
 
template<class SpeciesType>
auto GeneralMixture<SpeciesType>::chargesSpecies() const -> Vector
{
    const unsigned nspecies = numSpecies();
    Vector charges(nspecies);
    for(unsigned i = 0; i < nspecies; ++i)
        charges[i] = _species[i].charge();
    return charges;
}
 
template<class SpeciesType>
auto GeneralMixture<SpeciesType>::moleFractions(VectorConstRef n) const -> ChemicalVector
{
    const unsigned nspecies = numSpecies();
    if(nspecies == 1)
    {
        ChemicalVector x(1);
        x.val[0] = 1.0;
        return x;
    }
    ChemicalVector x(nspecies);
    const double nt = n.sum();
    if(nt == 0.0) return x;
    x.val = n/nt;
    for(unsigned i = 0; i < nspecies; ++i)
    {
        x.ddn.row(i).fill(-x.val[i]/nt);
        x.ddn(i, i) += 1.0/nt;
    }
    return x;
}
 
template<class SpeciesType>
auto GeneralMixture<SpeciesType>::state(Temperature T, Pressure P, VectorConstRef n) const -> MixtureState
{
    MixtureState res;
    res.T = T;
    res.P = P;
    res.x = moleFractions(n);
    return res;
}
 
} // namespace Reaktoro