ChemicalState.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 <memory>
#include <string>
 
// Reaktoro includes
#include <Reaktoro/Math/Matrix.hpp>
#include <Reaktoro/Common/ScalarTypes.hpp>
 
namespace Reaktoro {
 
// Forward declarations
class ChemicalProperties;
class ChemicalSystem;
 
class ChemicalState
{
public:
    ChemicalState() = delete;
 
    explicit ChemicalState(const ChemicalSystem& system);
 
    ChemicalState(const ChemicalState& other);
 
    virtual ~ChemicalState();
 
    auto operator=(ChemicalState other) -> ChemicalState&;
 
    auto setTemperature(double val) -> void;
 
    auto setTemperature(double val, std::string units) -> void;
 
    auto setPressure(double val) -> void;
 
    auto setPressure(double val, std::string units) -> void;
 
    auto setSpeciesAmounts(double val) -> void;
 
    auto setSpeciesAmounts(VectorConstRef n) -> void;
 
    auto setSpeciesAmounts(VectorConstRef n, const Indices& indices) -> void;
 
    auto setSpeciesAmount(Index index, double amount) -> void;
 
    auto setSpeciesAmount(std::string name, double amount) -> void;
 
    auto setSpeciesAmount(Index index, double amount, std::string units) -> void;
 
    auto setSpeciesAmount(std::string name, double amount, std::string units) -> void;
 
    auto setSpeciesMass(Index index, double mass) -> void;
 
    auto setSpeciesMass(std::string name, double mass) -> void;
 
    auto setSpeciesMass(Index index, double mass, std::string units) -> void;
 
    auto setSpeciesMass(std::string name, double mass, std::string units) -> void;
 
    auto setSpeciesDualPotentials(VectorConstRef z) -> void;
 
    auto setElementDualPotentials(VectorConstRef y) -> void;
 
    auto scaleSpeciesAmounts(double scalar) -> void;
 
    auto scaleSpeciesAmountsInPhase(Index index, double scalar) -> void;
 
    auto scalePhaseVolume(Index index, double volume) -> void;
 
    auto scalePhaseVolume(Index index, double volume, std::string units) -> void;
 
    auto scalePhaseVolume(std::string name, double volume) -> void;
 
    auto scalePhaseVolume(std::string name, double volume, std::string units) -> void;
 
    auto scaleFluidVolume(double volume) -> void;
 
    auto scaleFluidVolume(double volume, std::string units) -> void;
 
    auto scaleSolidVolume(double volume) -> void;
 
    auto scaleSolidVolume(double volume, std::string units) -> void;
 
    auto scaleVolume(double volume) -> void;
 
    auto scaleVolume(double volume, std::string units) -> void;
 
    auto system() const -> const ChemicalSystem&;
 
    auto temperature() const -> double;
 
    auto pressure() const -> double;
 
    auto speciesAmounts() const -> VectorConstRef;
 
    auto speciesAmounts(const Indices& indices) const -> Vector;
 
    auto speciesAmount(Index index) const -> double;
 
    auto speciesAmount(std::string name) const -> double;
 
    auto speciesAmount(Index index, std::string units) const -> double;
 
    auto speciesAmount(std::string name, std::string units) const -> double;
 
    auto speciesDualPotentials() const -> VectorConstRef;
 
    auto elementAmounts() const -> Vector;
 
    auto elementAmountsInPhase(Index index) const -> Vector;
 
    auto elementAmountsInSpecies(const Indices& indices) const -> Vector;
 
    auto elementAmount(Index index) const -> double;
 
    auto elementAmount(std::string name) const -> double;
 
    auto elementAmount(Index index, std::string units) const -> double;
 
    auto elementAmount(std::string name, std::string units) const -> double;
 
    auto elementAmountInPhase(Index ielement, Index iphase) const -> double;
 
    auto elementAmountInPhase(std::string element, std::string phase) const -> double;
 
    auto elementAmountInPhase(Index ielement, Index iphase, std::string units) const -> double;
 
    auto elementAmountInPhase(std::string element, std::string phase, std::string units) const -> double;
 
    auto elementAmountInSpecies(Index ielement, const Indices& ispecies) const -> double;
 
    auto elementAmountInSpecies(Index ielement, const Indices& ispecies, std::string units) const -> double;
 
    auto elementDualPotentials() const -> VectorConstRef;
 
    auto phaseAmount(Index index) const -> double;
 
    auto phaseAmount(std::string name) const -> double;
 
    auto phaseAmount(Index index, std::string units) const -> double;
 
    auto phaseAmount(std::string name, std::string units) const -> double;
 
    auto phaseStabilityIndices() const -> Vector;
 
    auto properties() const -> ChemicalProperties;
 
    auto output(std::ostream& out, int precision = 6) const -> void;
        
    auto output(std::string const& filename, int precision = 6) const -> void;
 
private:
    struct Impl;
 
    std::unique_ptr<Impl> pimpl;
};
 
auto operator<<(std::ostream& out, const ChemicalState& state) -> std::ostream&;
 
auto operator+(const ChemicalState& l, const ChemicalState& r) -> ChemicalState;
 
auto operator*(double scalar, const ChemicalState& state) -> ChemicalState;
 
auto operator*(const ChemicalState& state, double scalar) -> ChemicalState;
 
} // namespace Reaktoro