SmartEquilibriumResult.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/Equilibrium/EquilibriumResult.hpp>
 
namespace Reaktoro {
 
struct SmartEquilibriumTiming
{
    double solve = 0.0;
 
    double learning = 0.0;
 
    double learning_solve = 0.0;
 
    double learning_chemical_properties = 0.0;
 
    double learning_sensitivity_matrix = 0.0;
 
    double learning_error_control_matrices = 0.0;
 
    double learning_storage = 0.0;
 
    double prediction = 0.0;
 
    double prediction_search = 0.0;
 
    double prediction_error_control = 0.0;
 
    double prediction_taylor = 0.0;
 
    double prediction_priority_update = 0.0;
 
    auto operator+=(const SmartEquilibriumTiming& other) -> SmartEquilibriumTiming&;
};
 
struct SmartEquilibriumResultDuringPrediction
{
    bool accepted = false;
 
    String failed_with_species;
 
    double failed_with_amount;
 
    double failed_with_chemical_potential;
 
    // Self addition assignment to accumulate results.
    auto operator+=(const SmartEquilibriumResultDuringPrediction& other) -> SmartEquilibriumResultDuringPrediction&;
};
 
struct SmartEquilibriumResultDuringLearning
{
    EquilibriumResult solve;
 
    auto operator+=(const SmartEquilibriumResultDuringLearning& other) -> SmartEquilibriumResultDuringLearning&;
};
 
struct SmartEquilibriumResult
{
    auto succeeded() { return prediction.accepted ? true : learning.solve.succeeded(); };
 
    auto failed() { return !succeeded(); };
 
    auto predicted() { return prediction.accepted; };
 
    auto learned() { return !prediction.accepted; };
 
    auto iterations() { return prediction.accepted ? 0 : learning.solve.iterations(); };
 
    SmartEquilibriumResultDuringPrediction prediction;
 
    SmartEquilibriumResultDuringLearning learning;
 
    SmartEquilibriumTiming timing;
 
    auto operator+=(const SmartEquilibriumResult& other) -> SmartEquilibriumResult&;
};
 
} // namespace Reaktoro