q_metric.h

Go to the documentation of this file.

#pragma once

#include <cstring>
#include <numeric>
#include "interop/util/exception.h"
#include "interop/model/metric_base/base_cycle_metric.h"
#include "interop/model/metric_base/metric_set.h"
#include "interop/io/layout/base_metric.h"
#include "interop/io/format/generic_layout.h"

namespace illumina { namespace interop { namespace model { namespace metrics
{
    class q_score_bin
    {
    public:
        typedef ::uint16_t bin_type;
    public:
        q_score_bin(const bin_type lower = 0, const bin_type upper = 0, const bin_type value = 0) :
                m_lower(lower),
                m_upper(upper),
                m_value(value)
        { }

    public:
        template<class T>
        q_score_bin &operator=(const T &val)
        {
            m_lower = val.m_lower;
            m_upper = val.m_upper;
            m_value = val.m_value;
            return *this;
        }

    public:
        bin_type lower() const
        { return m_lower; }

        bin_type upper() const
        { return m_upper; }

        bin_type value() const
        { return m_value; }
    private:
        bin_type m_lower;
        bin_type m_upper;
        bin_type m_value;
        template<class MetricType, int Version>
        friend
        struct io::generic_layout;
    };

    class q_score_header : public metric_base::base_cycle_metric::header_type
    {
    public:
        enum
        {
            MAX_Q_BINS = 50
        };
        typedef std::vector<q_score_bin> qscore_bin_vector_type;
        typedef q_score_bin bin_t;
    public:
        q_score_header()
        { }

        q_score_header(const qscore_bin_vector_type &bins) :
                m_qscore_bins(bins)
        { }

        const q_score_bin &bin_at(const size_t n) const INTEROP_THROW_SPEC((model::index_out_of_bounds_exception))
        {
            INTEROP_BOUNDS_CHECK(n, m_qscore_bins.size(), "Index out of bounds");
            return m_qscore_bins[n];
        }

        const qscore_bin_vector_type &get_bins() const
        {
            return m_qscore_bins;
        }

        qscore_bin_vector_type &bins()
        {
            return m_qscore_bins;
        }

        size_t bin_count() const
        { return m_qscore_bins.size(); }
        size_t q_val_count() const
        { return m_qscore_bins.empty() ? static_cast<size_t>(MAX_Q_BINS) : m_qscore_bins.size(); }

        size_t index_for_q_value(const size_t qval) const
        {
            if (m_qscore_bins.size() == 0) return qval - 1;
            size_t index = 0;
            while (index < m_qscore_bins.size() && binAt(index).value() < qval) index++;
            return index;
        }
        size_t binCount() const
        { return m_qscore_bins.size(); }

        static q_score_header default_header()
        {
            return q_score_header();
        }

        const q_score_bin &binAt(const size_t n) const
        {
            INTEROP_ASSERT(n < binCount());
            return m_qscore_bins[n];
        }
        void clear()
        {
            m_qscore_bins.clear();
            metric_base::base_cycle_metric::header_type::clear();
        }

    protected:
        qscore_bin_vector_type m_qscore_bins;
    private:
        template<class MetricType, int Version>
        friend
        struct io::generic_layout;
    };

    class q_metric : public metric_base::base_cycle_metric
    {
    public:
        enum
        {
            TYPE = constants::Q,
            LATEST_VERSION = 7
        };
    public:
        enum
        {
            MAX_Q_BINS = q_score_header::MAX_Q_BINS
        };
        typedef q_score_header header_type;
        typedef header_type::qscore_bin_vector_type qscore_bin_vector_type;
        typedef std::vector< ::uint32_t > uint32_vector;
        typedef std::vector< ::uint32_t > uint_vector;
        typedef std::vector< ::uint64_t > uint64_vector;
        typedef ::uint32_t *uint_pointer_t;
    public:
        q_metric() :
                metric_base::base_cycle_metric(0, 0, 0)
        { }
        q_metric(const header_type& header) :
                metric_base::base_cycle_metric(0, 0, 0),
                m_qscore_hist(header.bin_count()==0?static_cast<size_t>(MAX_Q_BINS):header.bin_count())
        { }

        q_metric(const uint_t lane,
                 const uint_t tile,
                 const uint_t cycle,
                 const uint32_vector &qscore_hist) :
                metric_base::base_cycle_metric(lane, tile, cycle),
                m_qscore_hist(qscore_hist)
        {
        }

        q_metric(const uint_t lane,
                 const uint_t tile,
                 const uint_t cycle,
                 const uint_pointer_t qscore_hist,
                 const uint_t count) :
                metric_base::base_cycle_metric(lane, tile, cycle),
                m_qscore_hist(qscore_hist, qscore_hist + count)
        {
        }

    public:
        void set(const uint_t lane,
                 const uint_t tile,
                 const uint_t cycle,
                 const uint32_vector& qscore_hist)
        {
            metric_base::base_cycle_metric::set_base(lane, tile, cycle);
            m_qscore_hist = qscore_hist;
            m_qscore_hist_cumulative.resize(qscore_hist.size(), 0);
        }

    public:
        uint_t qscore_hist(const size_t n) const INTEROP_THROW_SPEC((model::index_out_of_bounds_exception))
        {
            INTEROP_BOUNDS_CHECK(n, m_qscore_hist.size(), "Index out of bounds");
            return m_qscore_hist[n];
        }

        const uint32_vector &qscore_hist() const
        {
            return m_qscore_hist;
        }

        size_t size() const
        {
            return m_qscore_hist.size();
        }

        uint_t sum_qscore() const
        {
            return std::accumulate(m_qscore_hist.begin(), m_qscore_hist.end(), 0);
        }

        ::uint64_t sum_qscore_cumulative() const
        {
            return std::accumulate(m_qscore_hist_cumulative.begin(),
                                   m_qscore_hist_cumulative.end(),
                                   static_cast< ::uint64_t >(0));
        }

        uint_t total_over_qscore(const uint_t qscore,
                                 const qscore_bin_vector_type &bins) const
        {
            uint_t total_count = 0;
            for (size_t i = 0; i < bins.size(); i++)
            {
                if (bins[i].value() >= qscore)
                    total_count += m_qscore_hist[i];
            }
            return total_count;
        }

        uint_t total_over_qscore(const size_t qscore_index) const
        {
            uint_t total_count = 0;
            if(qscore_index <= m_qscore_hist.size())
                total_count = std::accumulate(m_qscore_hist.begin() + qscore_index, m_qscore_hist.end(), 0);
            return total_count;
        }

        ::uint64_t total_over_qscore_cumulative(const size_t qscore_index) const
        {
            INTEROP_ASSERT(m_qscore_hist_cumulative.size() > 0);
            ::uint64_t total_count = 0;
            if(qscore_index <= m_qscore_hist_cumulative.size())
                total_count = std::accumulate(m_qscore_hist_cumulative.begin() + qscore_index,
                                              m_qscore_hist_cumulative.end(),
                                              static_cast< ::uint64_t >(0));
            return total_count;
        }

        float percent_over_qscore(const size_t qscore_index) const
        {
            const float total = static_cast<float>(sum_qscore());
            if (total == 0.0f) return std::numeric_limits<float>::quiet_NaN();
            const uint_t total_count = total_over_qscore(qscore_index);
            return 100 * total_count / total;
        }

        float percent_over_qscore_cumulative(const size_t qscore_index) const
        {
            INTEROP_ASSERT(m_qscore_hist_cumulative.size() > 0);
            const ::uint64_t total = sum_qscore_cumulative();
            if (total == 0) return std::numeric_limits<float>::quiet_NaN();
            const ::uint64_t total_count = total_over_qscore_cumulative(qscore_index);
            return 100.0f * total_count / total;
        }

        ::uint64_t total_over_qscore_cumulative(const uint_t qscore,
                                                const qscore_bin_vector_type &bins) const
        {
            INTEROP_ASSERT(m_qscore_hist_cumulative.size() > 0);
            ::uint64_t total_count = 0;
            for (size_t i = 0; i < bins.size(); i++)
            {
                if (bins[i].value() >= qscore)
                    total_count += m_qscore_hist_cumulative[i];
            }
            return total_count;
        }

        float percent_over_qscore(const uint_t qscore_index,
                                  const qscore_bin_vector_type &bins) const
        {
            const float total = static_cast<float>(sum_qscore());
            if (total == 0.0f) return std::numeric_limits<float>::quiet_NaN();
            const uint_t total_count = total_over_qscore(qscore_index, bins);
            return 100.0f * total_count / total;
        }

        float percent_over_qscore_cumulative(const uint_t qscore,
                                             const qscore_bin_vector_type &bins) const
        {
            INTEROP_ASSERT(m_qscore_hist_cumulative.size() > 0);
            const ::uint64_t total = sum_qscore_cumulative();
            if (total == 0) return std::numeric_limits<float>::quiet_NaN();
            const ::uint64_t total_count = total_over_qscore_cumulative(qscore, bins);
            return 100.0f * total_count / total;
        }

        uint_t median(const qscore_bin_vector_type &bins = qscore_bin_vector_type()) const
        {
            const uint_t total = sum_qscore();
            const uint_t position = total % 2 == 0 ? total / 2 + 1 : (total + 1) / 2;
            uint_t i = 0;
            uint_t sum = 0;
            for (; i < m_qscore_hist.size(); i++)
            {
                sum += m_qscore_hist[i];
                if (sum >= position)
                {
                    if (bins.size() == 0 || m_qscore_hist.size() == MAX_Q_BINS) return i + 1;
                    if (i < bins.size()) return bins[i].value();
                    break;
                }
            }
            return std::numeric_limits<uint_t>::max();
        }

        bool is_cumulative_empty() const
        {
            return m_qscore_hist_cumulative.empty();
        }
        void accumulate(const q_metric &metric)
        {
            uint64_vector::const_iterator beg = metric.m_qscore_hist_cumulative.begin(),
                    end = metric.m_qscore_hist_cumulative.end();
            m_qscore_hist_cumulative.assign(m_qscore_hist.begin(), m_qscore_hist.end());
            if (&metric != this)
            {
                for (uint64_vector::iterator cur = m_qscore_hist_cumulative.begin(); beg != end; ++beg, ++cur)
                    *cur += *beg;
            }
        }

        template<typename T>
        void accumulate_into(std::vector<T> &distribution) const
        {
            INTEROP_ASSERT(distribution.size() == m_qscore_hist.size());
            if (distribution.size() != m_qscore_hist.size()) return;
            typename std::vector<T>::iterator it = distribution.begin();
            for (typename uint32_vector::const_iterator cur = m_qscore_hist.begin(), end = m_qscore_hist.end();
                 cur != end; ++it, ++cur)
            {
                (*it) += (*cur);
            }
        }
        void compress(const header_type& header)
        {
            if(size() == header.bin_count() || header.bin_count() == 0) return;
            for(size_t i=0;i<header.bin_count();++i)
            {
                m_qscore_hist[i] = m_qscore_hist[static_cast<size_t>(header.bin_at(i).value()-1)];
            }
            m_qscore_hist.resize(header.bin_count());
        }

        uint_t qscoreHist(const size_t n) const
        {
            INTEROP_ASSERT(n < m_qscore_hist.size());
            return m_qscore_hist[n];
        }

        const uint32_vector &qscoreHist() const
        {
            return m_qscore_hist;
        }

    public:
        static const char *prefix()
        { return "Q"; }

    protected:
        uint32_vector m_qscore_hist;
    private:
        uint64_vector m_qscore_hist_cumulative;

        template<class MetricType, int Version>
        friend
        struct io::generic_layout;
    };
}}}}