optimizer.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 NeoN authors
//
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include "NeoN/core/error.hpp"
#include "NeoN/dsl/expression.hpp"
#include "NeoN/dsl/spatialOperator.hpp"
 
#include "NeoN/finiteVolume/cellCentred/operators/gaussGreenDivLaplacian.hpp"
 
namespace NeoN::dsl
{
 
 
template<typename ExpressionType>
class Optimizer
{
public:
 
    virtual ~Optimizer() = default;
 
    virtual ExpressionType optimize(const ExpressionType& expr) const = 0;
};
 
 
template<typename ExpressionType>
class DivLapOptimizer : public Optimizer<ExpressionType>
{
public:
 
    ~DivLapOptimizer() {}
 
    ExpressionType optimize(const ExpressionType& expr) const override
    {
        ExpressionType out(expr);
 
        // early return if not both operators are present
        if (!(expr.template hasOperator<Operator::Type::Implicit>("DivOperator")
              && expr.template hasOperator<Operator::Type::Implicit>("LaplacianOperator")))
        {
            return out;
        }
 
        using ValueType = typename ExpressionType::ExpressionValueType;
        auto divOperator =
            out.template getOperator<SpatialOperator<ValueType>, Operator::Type::Implicit>(
                   "DivOperator"
            )
                .getConfig();
        auto lapOperator =
            out.template getOperator<SpatialOperator<ValueType>, Operator::Type::Implicit>(
                   "LaplacianOperator"
            )
                .getConfig();
 
        dsl::SpatialOperator<ValueType> divLapOperator =
            finiteVolume::cellCentred::GaussGreenDivLaplacian<ValueType>(
                expr.exec(), divOperator, lapOperator
            );
        out.addOperator(divLapOperator);
 
        out.template dropOperator<Operator::Type::Implicit>("DivOperator");
        out.template dropOperator<Operator::Type::Implicit>("LaplacianOperator");
 
        return out;
    }
};
 
 
template<typename ExpressionType>
ExpressionType optimize(const ExpressionType& in)
{
    auto optimizer = std::vector<std::shared_ptr<Optimizer<ExpressionType>>> {
        std::make_shared<DivLapOptimizer<ExpressionType>>()
    };
 
    return optimize(in, optimizer);
}
 
template<typename ExpressionType>
ExpressionType optimize(
    const ExpressionType& in, const std::vector<std::shared_ptr<Optimizer<ExpressionType>>>& opts
)
{
    ExpressionType out(in);
 
    for (const auto& opt : opts)
    {
        out = opt->optimize(out);
    }
 
    return out;
}
 
 
} // namespace dsl