Surfaces.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/Types.hpp>
#include <Reaktoro/Core/SurfaceAreaModel.hpp>
 
namespace Reaktoro {
 
// Forward declarations
class PhaseList;
class Surface;
 
using SurfaceGenerator = Fn<Vec<Surface>(PhaseList const& phases)>;
 
class GeneralSurface
{
public:
    GeneralSurface();
 
    GeneralSurface(String const& name);
 
    GeneralSurface(String const& name, SurfaceAreaModel const& area_model);
 
    auto setName(String const& name) -> GeneralSurface&;
 
    auto setAreaModel(SurfaceAreaModel const& model) -> GeneralSurface&;
 
    auto set(SurfaceAreaModel const& model) -> GeneralSurface&;
 
    auto name() const -> String const&;
 
    auto areaModel() const -> SurfaceAreaModel const&;
 
    auto operator()(PhaseList const& phases) const -> Surface;
 
private:
    String surface_name;
 
    SurfaceAreaModel area_model;
};
 
class Surfaces
{
public:
    Surfaces();
 
    template<typename... SurfaceConvertible>
    explicit Surfaces(SurfaceConvertible const&... surfaces)
    {
        static_assert(sizeof...(surfaces) > 0);
        addAux(surfaces...);
    }
 
    template<typename T>
    auto add(T const& item) -> void
    {
        static_assert(
            isConvertible<T, Surface> ||
            isConvertible<T, GeneralSurface> ||
            isConvertible<T, SurfaceGenerator>);
 
        if constexpr(isConvertible<T, Surface>)
        {
            surface_generators.push_back([=](PhaseList const& phases) -> Vec<Surface> { return { item }; }); // item is a Surface object
        }
        else if constexpr(isConvertible<T, GeneralSurface>)
        {
            surface_generators.push_back([=](PhaseList const& phases) -> Vec<Surface> { return { item(phases) }; }); // item is a GeneralSurface object; use operator()(PhaseList) to convert to Surface
        }
        else
        {
            surface_generators.push_back(item); // item is already a SurfaceGenerator
        }
    }
 
    auto convert(PhaseList const& phases) const -> Vec<Surface>;
 
private:
    Vec<SurfaceGenerator> surface_generators;
 
    template<typename Arg, typename... Args>
    auto addAux(const Arg& arg, const Args&... args) -> void
    {
        add(arg);
        if constexpr (sizeof...(Args) > 0)
            addAux(args...);
    }
};
 
} // namespace Reaktoro