index_metric.h

Go to the documentation of this file.

#pragma once

#include <string>
#include <map>
#include <vector>
#include "interop/util/exception.h"
#include "interop/util/assert.h"
#include "interop/model/metric_base/base_read_metric.h"
#include "interop/model/metric_base/metric_exceptions.h"
#include "interop/io/format/generic_layout.h"

namespace illumina { namespace interop { namespace model { namespace metrics
{

    class index_info
    {
    public:
        index_info() :
                m_index_seq(""),
                m_sample_id(""),
                m_sample_proj(""),
                m_cluster_count(0)
        {
        }

        index_info(const std::string &index_seq,
                   const std::string &sample_id,
                   const std::string &sample_proj,
                   const ::uint64_t cluster_count) :
                m_index_seq(index_seq),
                m_sample_id(sample_id),
                m_sample_proj(sample_proj),
                m_cluster_count(cluster_count)
        {
        }

    public:
        const std::string &index_seq() const
        { return m_index_seq; }

        const std::string &sample_id() const
        { return m_sample_id; }

        const std::string &sample_proj() const
        { return m_sample_proj; }

        ::uint64_t cluster_count() const
        { return m_cluster_count; }

        bool is_dual() const
        {
            return index_of_separator() != std::string::npos;
        }

        std::string index1() const
        {
            const std::string::size_type pos = index_of_separator();
            if (pos != std::string::npos) return m_index_seq.substr(0, pos);
            return m_index_seq;
        }

        std::string index2() const
        {
            const std::string::size_type pos = index_of_separator();
            if (pos != std::string::npos) return m_index_seq.substr(pos + 1);
            return "";
        }
        std::string unique_id()const
        {
            return m_index_seq+m_sample_id;
        }
    private:
        std::string::size_type index_of_separator() const
        {
            const std::string::size_type pos = m_index_seq.find('-');
            if (pos != std::string::npos) return pos;
            return m_index_seq.find('+');
        }

    private:
        std::string m_index_seq;
        std::string m_sample_id;
        std::string m_sample_proj;
        ::uint64_t m_cluster_count;
        template<class MetricType, int Version>
        friend
        struct io::generic_layout;
    };


    class index_metric_header : public metric_base::base_read_metric::header_type
    {
    public:
        typedef ::uint16_t ushort_t;
    public:
        index_metric_header(){}

        const std::vector<std::string>& index_order() const
        { return m_index_order; }
        void index_order(const std::vector<std::string>& order)
        {
            m_index_order = order;
        }

        static index_metric_header default_header()
        {
            return index_metric_header();
        }
        void clear()
        {
            m_index_order.clear();
            metric_base::base_read_metric::header_type::clear();
        }

    private:
        std::vector<std::string> m_index_order;
        template<class MetricType, int Version>
        friend
        struct io::generic_layout;
    };

    class index_metric : public metric_base::base_read_metric
    {
    public:
        enum
        {
            TYPE = constants::Index,
            LATEST_VERSION = 2
        };
        typedef index_metric_header header_type;
        typedef std::vector<index_info> index_array_t;
        typedef index_info index_info_t;
        typedef index_array_t::const_iterator const_iterator;
    public:
        index_metric() :
                metric_base::base_read_metric(0, 0, 0),
                m_cluster_count(std::numeric_limits<float>::quiet_NaN()),
                m_cluster_count_pf(std::numeric_limits<float>::quiet_NaN())
        {
        }
        index_metric(const header_type&) :
                metric_base::base_read_metric(0, 0, 0),
                m_cluster_count(std::numeric_limits<float>::quiet_NaN()),
                m_cluster_count_pf(std::numeric_limits<float>::quiet_NaN())
        {
        }

        index_metric(uint_t lane,
                     uint_t tile,
                     uint_t read,
                     const index_array_t &indices) :
                metric_base::base_read_metric(lane, tile, read),
                m_indices(indices),
                m_cluster_count(std::numeric_limits<float>::quiet_NaN()),
                m_cluster_count_pf(std::numeric_limits<float>::quiet_NaN())
        {
        }

    public:
        size_t size() const
        {
            return m_indices.size();
        }

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

        const index_array_t &indices() const
        {
            return m_indices;
        }
        const_iterator begin()const
        {
            return m_indices.begin();
        }
        const_iterator end()const
        {
            return m_indices.end();
        }
        float cluster_count() const
        { return m_cluster_count; }

        float cluster_count_pf() const
        { return m_cluster_count_pf; }

    public:
        void set_cluster_counts(const float cluster_count, const float cluster_count_pf)
        {
            m_cluster_count = cluster_count;
            m_cluster_count_pf = cluster_count_pf;
        }
        static const char *prefix()
        { return "Index"; }

        float percent_demultiplexed(const std::string& sample_id) const
        {
            uint64_t total_demultiplexed_clusters = 0;
            if (sample_id.empty())
            {
                for (size_t index_array_counter = 0; index_array_counter < m_indices.size(); ++index_array_counter)
                {
                    total_demultiplexed_clusters += m_indices[index_array_counter].cluster_count();
                }
            }
            else
            {
                for (size_t index_array_counter = 0; index_array_counter < m_indices.size(); ++index_array_counter)
                {
                    if(m_indices[index_array_counter].sample_id() == sample_id)
                    {
                        total_demultiplexed_clusters = m_indices[index_array_counter].cluster_count();
                        break;
                    }
                }
            }
            return static_cast<float>(total_demultiplexed_clusters)/m_cluster_count_pf * 100;
        }

    private:
        index_array_t m_indices;
        float m_cluster_count; // Derived from tile metric
        float m_cluster_count_pf; // Derived from tile metric
        template<class MetricType, int Version>
        friend
        struct io::generic_layout;
    };
}}}}