Phases.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/Algorithms.hpp>
#include <Reaktoro/Common/StringList.hpp>
#include <Reaktoro/Common/StringUtils.hpp>
#include <Reaktoro/Common/Types.hpp>
#include <Reaktoro/Core/Database.hpp>
#include <Reaktoro/Core/Phase.hpp>
#include <Reaktoro/Models/ActivityModels/ActivityModelIdealAqueous.hpp>
#include <Reaktoro/Models/ActivityModels/ActivityModelIdealGas.hpp>
#include <Reaktoro/Models/ActivityModels/ActivityModelIdealSolution.hpp>
#include <Reaktoro/Models/ActivityModels/ActivityModelIdealIonExchange.hpp>
 
namespace Reaktoro {
 
struct Speciate
{
    Strings symbols;
 
    auto operator+=(Strings const& othersymbols) -> Speciate& { symbols = merge(symbols, othersymbols); return *this; }
};
 
auto speciate(StringList const& substances) -> Speciate;
 
struct Exclude
{
    Strings tags;
 
    auto operator+=(Strings const& othertags) -> Exclude& { tags = merge(tags, othertags); return *this; }
};
 
auto exclude(StringList const& tags) -> Exclude;
 
class GeneralPhase
{
public:
    GeneralPhase();
 
    explicit GeneralPhase(StringList const& species);
 
    explicit GeneralPhase(Speciate const& elements);
 
    explicit GeneralPhase(Speciate const& elements, Exclude const& withtags);
 
    explicit GeneralPhase(Exclude const& withtags);
 
    virtual ~GeneralPhase();
 
    auto setName(String name) -> GeneralPhase&;
 
    auto setStateOfMatter(StateOfMatter option) -> GeneralPhase&;
 
    auto setAggregateState(AggregateState option) -> GeneralPhase&;
 
    auto setAdditionalAggregateStates(Vec<AggregateState> const& options) -> GeneralPhase&;
 
    auto setActivityModel(ActivityModelGenerator const& model) -> GeneralPhase&;
 
    auto setIdealActivityModel(ActivityModelGenerator const& model) -> GeneralPhase&;
 
    auto named(String name) -> GeneralPhase&;
 
    auto set(StateOfMatter option) -> GeneralPhase&;
 
    auto set(AggregateState option) -> GeneralPhase&;
 
    auto set(ActivityModelGenerator const& model) -> GeneralPhase&;
 
    auto name() const -> String;
 
    auto stateOfMatter() const -> StateOfMatter;
 
    auto aggregateState() const -> AggregateState;
 
    auto additionalAggregateStates() const -> Vec<AggregateState> const&;
 
    auto species() const -> Strings const&;
 
    auto elements() const -> Strings const&;
 
    auto activityModel() const -> ActivityModelGenerator const&;
 
    auto idealActivityModel() const -> ActivityModelGenerator const&;
 
    auto convert(Database const& db, Strings const& elements) const -> Phase;
 
private:
    String phasename;
 
    StateOfMatter stateofmatter = StateOfMatter::Solid;
 
    AggregateState aggregatestate = AggregateState::Undefined;
 
    Vec<AggregateState> other_aggregate_states;
 
    Strings names;
 
    Strings symbols;
 
    Strings excludetags;
 
    ActivityModelGenerator activity_model;
 
    ActivityModelGenerator ideal_activity_model;
};
 
class GeneralPhasesGenerator
{
public:
    GeneralPhasesGenerator();
 
    explicit GeneralPhasesGenerator(StringList const& species);
 
    explicit GeneralPhasesGenerator(Speciate const& elements);
 
    explicit GeneralPhasesGenerator(Speciate const& elements, Exclude const& withtags);
 
    explicit GeneralPhasesGenerator(Exclude const& withtags);
 
    virtual ~GeneralPhasesGenerator();
 
    auto setStateOfMatter(StateOfMatter option) -> GeneralPhasesGenerator&;
 
    auto setAggregateState(AggregateState option) -> GeneralPhasesGenerator&;
 
    auto setAdditionalAggregateStates(Vec<AggregateState> const& options) -> GeneralPhasesGenerator&;
 
    auto setActivityModel(ActivityModelGenerator const& model) -> GeneralPhasesGenerator&;
 
    auto setIdealActivityModel(ActivityModelGenerator const& model) -> GeneralPhasesGenerator&;
 
    auto set(StateOfMatter option) -> GeneralPhasesGenerator&;
 
    auto set(AggregateState option) -> GeneralPhasesGenerator&;
 
    auto set(ActivityModelGenerator const& model) -> GeneralPhasesGenerator&;
 
    auto stateOfMatter() const -> StateOfMatter;
 
    auto aggregateState() const -> AggregateState;
 
    auto additionalAggregateStates() const -> Vec<AggregateState> const&;
 
    auto species() const -> Strings const&;
 
    auto elements() const -> Strings const&;
 
    auto activityModel() const -> ActivityModelGenerator const&;
 
    auto idealActivityModel() const -> ActivityModelGenerator const&;
 
    auto convert(Database const& db, Strings const& elements) const -> Vec<GeneralPhase>;
 
private:
    StateOfMatter stateofmatter = StateOfMatter::Solid;
 
    AggregateState aggregatestate = AggregateState::Undefined;
 
    Vec<AggregateState> other_aggregate_states;
 
    Strings names;
 
    Strings symbols;
 
    Strings excludetags;
 
    ActivityModelGenerator activity_model;
 
    ActivityModelGenerator ideal_activity_model;
};
 
template <typename T, typename... Ts>
constexpr auto _areGeneralPhasesImpl()
{
    constexpr auto aux = isBaseOf<GeneralPhase, T> || isBaseOf<GeneralPhasesGenerator, T>;
    if constexpr (sizeof...(Ts) > 0)
        return aux && _areGeneralPhasesImpl<Ts...>();
    else return aux;
}
 
template<typename T, typename... Ts>
constexpr auto areGeneralPhases = _areGeneralPhasesImpl<T, Ts...>();
 
class Phases
{
public:
    Phases(Database const& db);
 
    template<typename... GeneralPhases, Requires<areGeneralPhases<GeneralPhases...>> = true>
    explicit Phases(Database const& db, GeneralPhases const&... gphases)
    : Phases(db)
    {
        static_assert(sizeof...(gphases) > 0);
        addAux(gphases...);
    }
 
    // TODO: Implement `auto add(Phase const& phase) -> void` as well, in case the user provides a
    // Phase object. This will need a new data member `phases` of type `Vec<Phase>`.
 
    auto add(GeneralPhase const& phase) -> void;
 
    auto add(GeneralPhasesGenerator const& generator) -> void;
 
    auto database() const -> Database const&;
 
    auto generalPhases() const -> Vec<GeneralPhase> const&;
 
    auto generalPhasesGenerators() const -> Vec<GeneralPhasesGenerator> const&;
 
    auto convert() const -> Vec<Phase>;
 
    operator Vec<Phase>() const;
 
private:
    Database db;
 
    Vec<GeneralPhase> generalphases;
 
    Vec<GeneralPhasesGenerator> generators;
 
    template<typename Arg, typename... Args>
    auto addAux(Arg const& arg, Args const&... args) -> void
    {
        add(arg);
        if constexpr (sizeof...(Args) > 0)
            addAux(args...);
    }
};
 
class AqueousPhase : public GeneralPhase
{
public:
    AqueousPhase() : GeneralPhase() { initialize(); }
 
    explicit AqueousPhase(StringList const& species) : GeneralPhase(species) { initialize(); }
 
    explicit AqueousPhase(Speciate elements) : GeneralPhase(elements += {"H", "O"}) { initialize(); }
 
    explicit AqueousPhase(Speciate elements, Exclude const& withtags) : GeneralPhase(elements += {"H", "O"}, withtags) { initialize(); }
 
    explicit AqueousPhase(Exclude const& withtags) : GeneralPhase(speciate("H O"), withtags) { initialize(); }
 
    auto initialize() -> void
    {
        setName("AqueousPhase");
        setStateOfMatter(StateOfMatter::Liquid);
        setAggregateState(AggregateState::Aqueous);
        setActivityModel(ActivityModelIdealAqueous());
        setIdealActivityModel(ActivityModelIdealAqueous());
    }
};
 
class GaseousPhase : public GeneralPhase
{
public:
    GaseousPhase() : GeneralPhase() { initialize(); }
 
    explicit GaseousPhase(StringList const& species) : GeneralPhase(species) { initialize(); }
 
    explicit GaseousPhase(Speciate const& elements) : GeneralPhase(elements) { initialize(); }
 
    explicit GaseousPhase(Speciate const& elements, Exclude const& withtags) : GeneralPhase(elements, withtags) { initialize(); }
 
    explicit GaseousPhase(Exclude const& withtags) : GeneralPhase(withtags) { initialize(); }
 
    auto initialize() -> void
    {
        setName("GaseousPhase");
        setStateOfMatter(StateOfMatter::Gas);
        setAggregateState(AggregateState::Gas);
        setActivityModel(ActivityModelIdealGas());
        setIdealActivityModel(ActivityModelIdealGas());
    }
};
 
class LiquidPhase : public GeneralPhase
{
public:
    LiquidPhase() : GeneralPhase() { initialize(); }
 
    explicit LiquidPhase(StringList const& species) : GeneralPhase(species) { initialize(); }
 
    explicit LiquidPhase(Speciate const& elements) : GeneralPhase(elements) { initialize(); }
 
    explicit LiquidPhase(Speciate const& elements, Exclude const& withtags) : GeneralPhase(elements, withtags) { initialize(); };
 
    explicit LiquidPhase(Exclude const& withtags) : GeneralPhase(withtags) { initialize(); };
 
    auto initialize() -> void
    {
        setName("LiquidPhase");
        setStateOfMatter(StateOfMatter::Liquid);
        setAggregateState(AggregateState::Liquid);
        setActivityModel(ActivityModelIdealSolution(StateOfMatter::Liquid));
        setIdealActivityModel(ActivityModelIdealSolution(StateOfMatter::Liquid));
    }
};
 
class SolidPhase : public GeneralPhase
{
public:
    explicit SolidPhase(StringList const& species) : GeneralPhase(species) { initialize(); }
 
    auto initialize() -> void
    {
        String phasename;
        auto i = 0;
        for(auto&& name : species())
            phasename += (i++ == 0) ? name : "-" + name;
 
        setName("SolidPhase");
        setStateOfMatter(StateOfMatter::Solid);
        setAggregateState(AggregateState::Solid);
        setAdditionalAggregateStates({AggregateState::CrystallineSolid});
        setActivityModel(ActivityModelIdealSolution(StateOfMatter::Solid));
        setIdealActivityModel(ActivityModelIdealSolution(StateOfMatter::Solid));
    }
};
 
class MineralPhase : public GeneralPhase
{
public:
    explicit MineralPhase(String mineral) : GeneralPhase(mineral) { initialize(); }
 
    auto initialize() -> void
    {
        setName(species().front());
        setStateOfMatter(StateOfMatter::Solid);
        setAggregateState(AggregateState::Solid);
        setAdditionalAggregateStates({
            AggregateState::CrystallineSolid,
            AggregateState::AmorphousSolid
        });
        setActivityModel(ActivityModelIdealSolution(StateOfMatter::Solid));
        setIdealActivityModel(ActivityModelIdealSolution(StateOfMatter::Solid));
    }
};
 
class MineralPhases : public GeneralPhasesGenerator
{
public:
    MineralPhases() : GeneralPhasesGenerator() { initialize(); }
 
    explicit MineralPhases(StringList const& species) : GeneralPhasesGenerator(species) { initialize(); }
 
    explicit MineralPhases(Speciate const& elements) : GeneralPhasesGenerator(elements) { initialize(); }
 
    explicit MineralPhases(Speciate const& elements, Exclude const& withtags) : GeneralPhasesGenerator(elements, withtags) { initialize(); };
 
    explicit MineralPhases(Exclude const& withtags) : GeneralPhasesGenerator(withtags) { initialize(); };
 
    auto initialize() -> void
    {
        setStateOfMatter(StateOfMatter::Solid);
        setAggregateState(AggregateState::Solid);
        setAdditionalAggregateStates({
            AggregateState::CrystallineSolid,
            AggregateState::AmorphousSolid
        });
        setActivityModel(ActivityModelIdealSolution(StateOfMatter::Solid));
        setIdealActivityModel(ActivityModelIdealSolution(StateOfMatter::Solid));
    }
};
 
class CondensedPhase : public GeneralPhase
{
public:
    explicit CondensedPhase(String species) : GeneralPhase(species) { initialize(); }
 
    auto initialize() -> void
    {
        setName(species().front());
        setStateOfMatter(StateOfMatter::Condensed);
        setAggregateState(AggregateState::CondensedPhase);
        setAdditionalAggregateStates({
            AggregateState::Liquid,
            AggregateState::LiquidCrystal,
            AggregateState::Solid,
            AggregateState::CrystallineSolid,
            AggregateState::AmorphousSolid
        });
        setActivityModel(ActivityModelIdealSolution(StateOfMatter::Solid)); // TODO: Create ActivityModelIdealCondensedPhase(melting_temperature) or rely on a MeltingTemperature attribute in the species block of the database
        setIdealActivityModel(ActivityModelIdealSolution(StateOfMatter::Solid));
    }
};
 
class CondensedPhases : public GeneralPhasesGenerator
{
public:
    CondensedPhases() : GeneralPhasesGenerator() { initialize(); }
 
    explicit CondensedPhases(StringList const& species) : GeneralPhasesGenerator(species) { initialize(); }
 
    explicit CondensedPhases(Speciate const& elements) : GeneralPhasesGenerator(elements) { initialize(); }
 
    explicit CondensedPhases(Speciate const& elements, Exclude const& withtags) : GeneralPhasesGenerator(elements, withtags) { initialize(); };
 
    explicit CondensedPhases(Exclude const& withtags) : GeneralPhasesGenerator(withtags) { initialize(); };
 
    auto initialize() -> void
    {
        setStateOfMatter(StateOfMatter::Condensed);
        setAggregateState(AggregateState::CondensedPhase);
        setAdditionalAggregateStates({
            AggregateState::Liquid,
            AggregateState::LiquidCrystal,
            AggregateState::Solid,
            AggregateState::CrystallineSolid,
            AggregateState::AmorphousSolid
        });
        setActivityModel(ActivityModelIdealSolution(StateOfMatter::Solid)); // TODO: Create ActivityModelIdealCondensedPhase(melting_temperature)
        setIdealActivityModel(ActivityModelIdealSolution(StateOfMatter::Solid));
    }
};
 
class IonExchangePhase : public GeneralPhase
{
public:
 
    explicit IonExchangePhase(StringList const& species) : GeneralPhase(species) { initialize(); }
 
    auto initialize() -> void
    {
        setName("IonExchangePhase");
        setStateOfMatter(StateOfMatter::Solid);
        setAggregateState(AggregateState::IonExchange);
        setActivityModel(ActivityModelIdealIonExchange());
        setIdealActivityModel(ActivityModelIdealIonExchange());
 
    }
};
 
} // namespace Reaktoro