error_metric.h

Go to the documentation of this file.

#pragma once

#include <cstring>
#include "interop/util/exception.h"
#include "interop/model/metric_base/base_cycle_metric.h"
#include "interop/model/metric_base/metric_exceptions.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 error_metric_header : public metric_base::base_cycle_metric::header_type
    {
    public:
        error_metric_header(const std::vector<std::string>& adapters) :
            m_number_adapters(static_cast<uint16_t>(adapters.size())),
            m_adapter_length(0)
        {
            if(adapters.size()>0)
                m_adapter_length = static_cast<uint16_t>(adapters[0].size());
            for(size_t i = 0; i < adapters.size(); i++) {
                INTEROP_ASSERTMSG(adapters[i].size() == m_adapter_length,
                                  "Adapter Sequence (" << adapters[i] << ") length doesn't match expected adapter length");
                m_adapter_sequences.push_back(adapters[i]);
            }
        }

        error_metric_header() :
            m_number_adapters(0),
            m_adapter_length(0)
        {}

        uint16_t number_adapters() const
        {
            return m_number_adapters;
        }

        uint16_t adapter_length() const
        {
            return m_adapter_length;
        }

        const std::vector<std::string>& adapter_sequences() const
        {
            return m_adapter_sequences;
        }

        void clear()
        {
            m_number_adapters = 0;
            m_adapter_length = 0;
            m_adapter_sequences.clear();
            metric_base::base_cycle_metric::header_type::clear();
        }
        static error_metric_header default_header()
        {
            return error_metric_header(std::vector<std::string>());
        }

    private:
        uint16_t m_number_adapters;
        uint16_t m_adapter_length;
        std::vector<std::string> m_adapter_sequences;

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

    class error_metric : public metric_base::base_cycle_metric
    {
    public:
        enum
        {
            MAX_MISMATCH = 5,
            TYPE = constants::Error,
            LATEST_VERSION = 6
        };
        typedef std::vector<uint_t> uint_array_t;
        typedef std::vector<float> float_vector;
        typedef error_metric_header header_type;
    public:
        error_metric() :
            metric_base::base_cycle_metric(0, 0, 0),
            m_error_rate(std::numeric_limits<float>::quiet_NaN()),
            m_phix_adapter_rate(std::numeric_limits<float>::quiet_NaN()),
            m_mismatch_cluster_count(MAX_MISMATCH, 0)
        {
        }
        error_metric(const header_type& header) :
            metric_base::base_cycle_metric(0, 0, 0),
            m_error_rate(std::numeric_limits<float>::quiet_NaN()),
            m_phix_adapter_rate(std::numeric_limits<float>::quiet_NaN()),
            m_phix_adapter_rates(header.number_adapters(), 0),
            m_mismatch_cluster_count(MAX_MISMATCH, 0)
        {
        }

        error_metric(const uint_t lane,
                     const uint_t tile,
                     const uint_t cycle,
                     const float error,
                     const float phix_adapter_rate) :
            metric_base::base_cycle_metric(lane, tile, cycle),
            m_error_rate(error),
            m_phix_adapter_rate(phix_adapter_rate),
            m_mismatch_cluster_count(MAX_MISMATCH, 0)
        {
        }

        error_metric(const uint_t lane,
                     const uint_t tile,
                     const uint_t cycle,
                     const float error,
                     const float_vector &phix_adapter_rates) :
            metric_base::base_cycle_metric(lane, tile, cycle),
            m_error_rate(error),
            m_phix_adapter_rates(phix_adapter_rates),
            m_mismatch_cluster_count(MAX_MISMATCH, 0)
        {
            set_mean_adapter_rate();
        }

    public:
        float error_rate() const
        {
            return m_error_rate;
        }

        float phix_adapter_rate() const
        {
            return m_phix_adapter_rate;
        }
        /* Calculated adapter trim rate per adapter of PhiX clusters
         *
         * @note Supported by v6
         * @return vector of adapter rates per adapter
         */
        const float_vector& phix_adapter_rates() const
        {
            return m_phix_adapter_rates;
        }
        /* Calculated adapter trim rate per adapter of PhiX clusters
         *
         * @note Supported by v6
         * @return adapter rate for given adapter index
         */
        float phix_adapter_rate_at(const size_t n) const INTEROP_THROW_SPEC((model::index_out_of_bounds_exception))
        {
            INTEROP_BOUNDS_CHECK(n, m_phix_adapter_rates.size(), "Index out of bounds");
            return m_phix_adapter_rates[n];
        }
        /* Number of adapters on PhiX
         *
         * @note Supported by v6
         * @return number of adapters
         */
        size_t phix_adapter_count() const
        {
            return m_phix_adapter_rates.size();
        }

        uint_t mismatch_cluster_count(const size_t n) const INTEROP_THROW_SPEC((model::index_out_of_bounds_exception))
        {
            INTEROP_BOUNDS_CHECK(n, static_cast<size_t>(MAX_MISMATCH), "Index out of bounds");
            return m_mismatch_cluster_count[n];
        }

        uint_t mismatch_count() const
        {
            return MAX_MISMATCH;
        }

        const uint_array_t &mismatch_cluster_counts() const
        {
            return m_mismatch_cluster_count;
        }
        float errorRate() const
        {
            return m_error_rate;
        }

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

    private:

        void set_mean_adapter_rate() {
            const size_t size = m_phix_adapter_rates.size();
            if(size == 0) return;
            m_phix_adapter_rate = 0;
            for(size_t i = 0; i < size; i++)
                m_phix_adapter_rate += m_phix_adapter_rates[i];
            m_phix_adapter_rate /= size;
        }

        float m_error_rate;
        float m_phix_adapter_rate;
        float_vector m_phix_adapter_rates;
        uint_array_t m_mismatch_cluster_count;
        template<class MetricType, int Version>
        friend
        struct io::generic_layout;
    };
}}}}