ChemicalSystem.hpp

// Reaktoro is a unified framework for modeling chemically reactive systems.
//
// Copyright © 2014-2024 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
 
// Reaktoro includes
#include <Reaktoro/Common/Matrix.hpp>
#include <Reaktoro/Common/Meta.hpp>
#include <Reaktoro/Common/TraitsUtils.hpp>
#include <Reaktoro/Common/Types.hpp>
#include <Reaktoro/Core/Database.hpp>
#include <Reaktoro/Core/Element.hpp>
#include <Reaktoro/Core/ElementList.hpp>
#include <Reaktoro/Core/Phase.hpp>
#include <Reaktoro/Core/PhaseList.hpp>
#include <Reaktoro/Core/Phases.hpp>
#include <Reaktoro/Core/Reaction.hpp>
#include <Reaktoro/Core/ReactionList.hpp>
#include <Reaktoro/Core/Reactions.hpp>
#include <Reaktoro/Core/Species.hpp>
#include <Reaktoro/Core/SpeciesList.hpp>
#include <Reaktoro/Core/Surface.hpp>
#include <Reaktoro/Core/SurfaceList.hpp>
#include <Reaktoro/Core/Surfaces.hpp>
 
namespace Reaktoro {
 
// Forward declarations
class ChemicalSystem;
 
template<typename T, typename... Ts>
constexpr auto _arePhaseReactionOrSurfaceConvertible()
{
    constexpr auto isPhaseConvertible = isBaseOf<GeneralPhase, T> || isBaseOf<GeneralPhasesGenerator, T>;
    constexpr auto isReactionConvertible = isConvertible<T, Reaction> || isConvertible<T, GeneralReaction> || isConvertible<T, ReactionGenerator>;
    constexpr auto isSurfaceConvertible = isConvertible<T, Surface> || isConvertible<T, GeneralSurface> || isConvertible<T, SurfaceGenerator>;
    constexpr auto aux = isPhaseConvertible || isReactionConvertible || isSurfaceConvertible;
 
    if constexpr (sizeof...(Ts) > 0)
        return aux && _arePhaseReactionOrSurfaceConvertible<Ts...>();
    else return aux;
}
 
template<typename T, typename... Ts>
constexpr auto arePhaseReactionOrSurfaceConvertible = _arePhaseReactionOrSurfaceConvertible<T, Ts...>();
 
template<typename... Args>
auto createChemicalSystem(Database const& db, Args const&... args) -> ChemicalSystem;
 
class ChemicalSystem
{
public:
    ChemicalSystem();
 
    explicit ChemicalSystem(Database const& database, PhaseList const& phases);
 
    explicit ChemicalSystem(Database const& database, PhaseList const& phases, SurfaceList const& surfaces);
 
    explicit ChemicalSystem(Database const& database, PhaseList const& phases, ReactionList const& reactions);
 
    explicit ChemicalSystem(Database const& database, PhaseList const& phases, ReactionList const& reactions, SurfaceList const& surfaces);
 
    explicit ChemicalSystem(Phases const& phases);
 
    explicit ChemicalSystem(Phases const& phases, Surfaces const& surfaces);
 
    explicit ChemicalSystem(Phases const& phases, Reactions const& reactions);
 
    explicit ChemicalSystem(Phases const& phases, Reactions const& reactions, Surfaces const& surfaces);
 
    template<typename... Args, Requires<arePhaseReactionOrSurfaceConvertible<Args...>> = true>
    explicit ChemicalSystem(Database const& db, Args const&... args)
    : ChemicalSystem(createChemicalSystem(db, args...)) {}
 
    auto id() const -> Index;
 
    auto database() const -> Database const&;
 
    auto element(Index index) const -> Element const&;
 
    auto elements() const -> ElementList const&;
 
    auto species(Index index) const -> Species const&;
 
    auto species() const -> SpeciesList const&;
 
    auto phase(Index index) const -> Phase const&;
 
    auto phases() const -> PhaseList const&;
 
    auto reaction(Index index) const -> Reaction const&;
 
    auto reactions() const -> ReactionList const&;
 
    auto surface(Index index) const -> Surface const&;
 
    auto surfaces() const -> SurfaceList const&;
 
    auto formulaMatrix() const -> MatrixXdConstRef;
 
    auto formulaMatrixElements() const -> MatrixXdConstRef;
 
    auto formulaMatrixCharge() const -> MatrixXdConstRef;
 
    auto stoichiometricMatrix() const -> MatrixXdConstRef;
 
private:
    struct Impl;
 
    SharedPtr<Impl> pimpl;
};
 
auto operator<<(std::ostream& out, ChemicalSystem const& system) -> std::ostream&;
 
template<typename... Args>
auto createChemicalSystem(Database const& db, Args const&... args) -> ChemicalSystem
{
    Phases phases(db);
    Reactions reactions;
    Surfaces surfaces;
 
    ForEach([&](auto arg) constexpr {
        using T = Decay<decltype(arg)>;
        constexpr auto isPhaseConvertible = isBaseOf<GeneralPhase, T> || isBaseOf<GeneralPhasesGenerator, T>;
        constexpr auto isReactionConvertible = isConvertible<T, Reaction> || isConvertible<T, GeneralReaction> || isConvertible<T, ReactionGenerator>;
        constexpr auto isSurfaceConvertible = isConvertible<T, Surface> || isConvertible<T, GeneralSurface> || isConvertible<T, SurfaceGenerator>;
 
        static_assert(isPhaseConvertible || isReactionConvertible || isSurfaceConvertible, "One of the arguments in your list of arguments for the construction of a ChemicalSystem object has a non-convertible type to either phase, reaction, or surface.");
 
        if constexpr(isPhaseConvertible) phases.add(arg);
        else if constexpr(isReactionConvertible) reactions.add(arg);
        else surfaces.add(arg);
    }, args...);
 
    return ChemicalSystem(phases, reactions, surfaces);
}
 
} // namespace Reaktoro