q_metric.h

Go to the documentation of this file.

#pragma once
#include <vector>
#include "interop/model/metrics/q_metric.h"
#include "interop/model/metrics/q_collapsed_metric.h"
#include "interop/model/metrics/q_by_lane_metric.h"
#include "interop/model/model_exceptions.h"
#include "interop/model/metric_base/metric_set.h"


namespace illumina { namespace interop { namespace logic { namespace metric
{

    template<typename I>
    size_t count_q_metric_bins(I beg, I end)
    {
        return (beg==end) ? 0 : beg->size();
    }
    inline size_t count_q_metric_bins(const model::metric_base::metric_set<model::metrics::q_metric>& metric_set)
    {
        return count_q_metric_bins(metric_set.begin(), metric_set.end());
    }
    inline size_t count_q_metric_bins(const model::metric_base::metric_set<model::metrics::q_by_lane_metric>& metric_set)
    {
        return count_q_metric_bins(metric_set.begin(), metric_set.end());
    }
    inline size_t count_q_metric_bins(const model::metric_base::metric_set<model::metrics::q_collapsed_metric>&)
    {
        return 0;
    }
    void populate_cumulative_distribution(model::metric_base::metric_set<model::metrics::q_by_lane_metric>& q_metric_set)
                                                                                INTEROP_THROW_SPEC(( model::index_out_of_bounds_exception ));
    void populate_cumulative_distribution(model::metric_base::metric_set<model::metrics::q_metric>& q_metric_set)
                    INTEROP_THROW_SPEC(( model::index_out_of_bounds_exception ));
    void populate_cumulative_distribution(model::metric_base::metric_set<model::metrics::q_collapsed_metric>& q_metric_set)
                    INTEROP_THROW_SPEC(( model::index_out_of_bounds_exception ));
    template<class QMetric>
    size_t count_legacy_q_score_bins(const model::metric_base::metric_set<QMetric>& q_metric_set)
    {
        // 0 is a sentinel that indicates legacy binning is not required
        if (q_metric_set.version() > 4) return 0;     // Version 5 and later do not require legacy binning
        if (!q_metric_set.get_bins().empty()) return 0;   // If the metrics already have a header they do not require binning

        const size_t max_bin_count = 7;
        typename model::metric_base::metric_set<QMetric>::const_iterator beg = q_metric_set.begin(),
                end = q_metric_set.end();
        if (beg == end) return 0;
        typedef model::metrics::q_metric::uint_t uint_t;
        std::set<uint_t> bins_found;
        for (; beg != end; ++beg) {
            for (uint_t i = 0; i < static_cast<uint_t>(beg->qscore_hist().size()); ++i)
                if (beg->qscore_hist()[i] > 0) bins_found.insert(i);
            if (bins_found.size() > max_bin_count) break; // Number of bins greater than 7 indicates this is unbinned
        }
        return bins_found.size();
    }
    inline bool requires_legacy_bins(const size_t count)
    {
        return count <= 7 && count > 0;
    }
    void populate_legacy_q_score_bins(std::vector<model::metrics::q_score_bin>& q_score_bins,
                                             const constants::instrument_type instrument,
                                             const size_t count);
    void compress_q_metrics(model::metric_base::metric_set<model::metrics::q_metric>& q_metric_set);
    void compress_q_metrics(model::metric_base::metric_set<model::metrics::q_by_lane_metric>& q_metric_set);
    inline void populate_legacy_q_score_bins(model::metric_base::metric_set<model::metrics::q_metric>& q_metric_set,
                                             std::vector<model::metrics::q_score_bin>& q_score_bins,
                                             const constants::instrument_type instrument)
    {
        const size_t count = count_legacy_q_score_bins(q_metric_set);
        populate_legacy_q_score_bins(q_score_bins, instrument, count);
    }
    inline void populate_legacy_q_score_bins(model::metric_base::metric_set<model::metrics::q_by_lane_metric>& q_metric_set,
                                             std::vector<model::metrics::q_score_bin>& q_score_bins,
                                             const constants::instrument_type instrument)
    {
        const size_t count = count_legacy_q_score_bins(q_metric_set);
        populate_legacy_q_score_bins(q_score_bins, instrument, count);
    }
    inline size_t count_qvals(const model::metric_base::metric_set<model::metrics::q_metric>& q_metric_set)
    {
        return q_metric_set.size() > 0 ? q_metric_set[0].size() : 0;
    }
    inline size_t count_qvals( const model::metric_base::metric_set<model::metrics::q_by_lane_metric>& q_metric_set)
    {
        return q_metric_set.size() > 0 ? q_metric_set[0].size() : 0;
    }
    inline size_t count_qvals( const model::metric_base::metric_set<model::metrics::q_collapsed_metric>&)
    {
        return 0;
    }
    inline bool is_compressed(const model::metric_base::metric_set<model::metrics::q_metric>& q_metric_set)
    {
        const size_t q_val_count = count_qvals(q_metric_set);
        return q_val_count > 0 && q_val_count != model::metrics::q_metric::MAX_Q_BINS;
    }
    inline bool is_compressed(const model::metric_base::metric_set<model::metrics::q_collapsed_metric>& q_metric_set)
    {
        const size_t q_val_count = count_qvals(q_metric_set);
        return q_val_count > 0 && q_val_count != model::metrics::q_metric::MAX_Q_BINS;
    }
    inline bool is_compressed(const model::metric_base::metric_set<model::metrics::q_by_lane_metric>& q_metric_set)
    {
        const size_t q_val_count = count_qvals(q_metric_set);
        return q_val_count > 0 && q_val_count != model::metrics::q_metric::MAX_Q_BINS;
    }
    inline size_t max_qval(
            const model::metric_base::metric_set<model::metrics::q_metric>& q_metric_set)
    {
        return is_compressed(q_metric_set) ? q_metric_set.get_bins().back().upper() : count_qvals(q_metric_set);
    }
    inline size_t max_qval(const model::metric_base::metric_set<model::metrics::q_by_lane_metric>& q_metric_set)
    {
        return is_compressed(q_metric_set) ? q_metric_set.get_bins().back().upper() : count_qvals(q_metric_set);
    }
    inline size_t max_qval(const model::metric_base::metric_set<model::metrics::q_collapsed_metric>& q_metric_set)
    {
        return is_compressed(q_metric_set) ?
               static_cast<size_t>(q_metric_set.get_bins().back().upper()) : count_qvals(q_metric_set);
    }
    inline size_t index_for_q_value(
            const model::metric_base::metric_set<model::metrics::q_metric>& q_metric_set,
            const size_t qval)
    {
        if(!is_compressed(q_metric_set)) return qval-1;
        return q_metric_set.index_for_q_value(qval);
    }
    inline size_t index_for_q_value(
            const model::metric_base::metric_set<model::metrics::q_by_lane_metric>& q_metric_set,
            const size_t qval)
    {
        if(!is_compressed(q_metric_set)) return qval-1;
        return q_metric_set.index_for_q_value(qval);
    }
    void create_collapse_q_metrics(const model::metric_base::metric_set<model::metrics::q_metric>& metric_set,
                                          model::metric_base::metric_set<model::metrics::q_collapsed_metric>& collapsed);
    void create_q_metrics_by_lane(const model::metric_base::metric_set<model::metrics::q_metric>& metric_set,
                                  model::metric_base::metric_set<model::metrics::q_by_lane_metric>& bylane,
                                  const constants::instrument_type instrument)
                                        INTEROP_THROW_SPEC((model::index_out_of_bounds_exception));
}}}}