QualityStats.hpp

#pragma once
 
#include <wmtk/utils/Logger.hpp>
 
#include "expression_parser/Expression.hpp"
 
#include <cmath>
#include <string>
#include <tuple>
#include <vector>
 
namespace wmtk::components::simwild {
 
struct QualityGroup
{
    std::string label;
    double target = 0.;
    double max_quality = -1.;
    double sum_quality = 0.;
    size_t count = 0;
 
    double avg_quality() const { return count > 0 ? sum_quality / count : 0.; }
    double max_relative() const { return count > 0 ? max_quality / target : -1.; }
};
 
struct QualityBreakdown
{
    std::vector<QualityGroup> groups;
    double max_relative = -1.;
    double avg_relative = 0.;
    size_t count = 0;
};
 
template <class ValidFn, class TagsFn, class QualityFn>
QualityBreakdown collect_quality_breakdown(
    const size_t capacity,
    const std::vector<std::tuple<expression_parser::ExpressionPtr, double>>& quality_field,
    const double base_target,
    ValidFn&& is_valid,
    TagsFn&& tags_of,
    QualityFn&& quality_of)
{
    QualityBreakdown out;
    out.groups.resize(quality_field.size() + 1);
    out.groups[0].label = "(default)";
    out.groups[0].target = base_target;
    for (size_t i = 0; i < quality_field.size(); ++i) {
        const auto& [expr, target] = quality_field[i];
        out.groups[i + 1].label = expr->to_string();
        out.groups[i + 1].target = target;
    }
 
    for (size_t cid = 0; cid < capacity; ++cid) {
        if (!is_valid(cid)) {
            continue;
        }
        const auto& tags = tags_of(cid);
 
        // Last match wins, mirroring target_quality. Scanning backwards finds it first, and the
        // common case -- a cell matching nothing -- still costs the whole field either way.
        size_t group = 0;
        for (size_t i = quality_field.size(); i-- > 0;) {
            if (std::get<0>(quality_field[i])->eval(tags)) {
                group = i + 1;
                break;
            }
        }
 
        const double quality = quality_of(cid);
        QualityGroup& g = out.groups[group];
        g.max_quality = std::max(g.max_quality, quality);
        g.sum_quality += quality;
        ++g.count;
 
        const double relative = quality / g.target;
        out.max_relative = std::max(out.max_relative, relative);
        out.avg_relative += relative;
        ++out.count;
    }
 
    if (out.count > 0) {
        out.avg_relative /= out.count;
    }
    return out;
}
 
inline void log_quality_breakdown(const QualityBreakdown& breakdown)
{
    std::vector<const QualityGroup*> order;
    order.reserve(breakdown.groups.size());
    for (const auto& g : breakdown.groups) {
        order.push_back(&g);
    }
    std::sort(order.begin(), order.end(), [](const QualityGroup* a, const QualityGroup* b) {
        return a->max_relative() > b->max_relative();
    });
 
    logger().info(
        "Quality by tag ({} cells, max rel = {:.4}, avg rel = {:.4}):",
        breakdown.count,
        breakdown.max_relative,
        breakdown.avg_relative);
    for (const QualityGroup* g : order) {
        if (g->count == 0) {
            logger().info("  {:<20} no cells", g->label);
            continue;
        }
        logger().info(
            "  {:<20} n = {:>8}, max = {:>8.6}, avg = {:>8.6}, target = {:>6.6}, max rel = {:6>.4}",
            g->label,
            g->count,
            g->max_quality,
            g->avg_quality(),
            g->target,
            g->max_relative());
    }
}
 
} // namespace wmtk::components::simwild