tile_metric.h

Go to the documentation of this file.

#pragma once

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

namespace illumina { namespace interop { namespace model { namespace metrics
{
    class tile_metric_header : public metric_base::base_metric::header_type
    {
    public:
        tile_metric_header(const float density) : m_density(density) {}
        float density()const{return m_density;}
        static tile_metric_header default_header()
        {
            return tile_metric_header(std::numeric_limits<float>::quiet_NaN());
        }
        void clear()
        {
            m_density=0;
            metric_base::base_metric::header_type::clear();
        }
    private:
        float m_density;
        template<class MetricType, int Version>
        friend struct io::generic_layout;
    };
    class read_metric
    {
    public:
        typedef ::uint32_t uint_t;
    public:
        read_metric(const uint_t read = 0,
                    const float percent_aligned = std::numeric_limits<float>::quiet_NaN(),
                    const float percent_phasing = std::numeric_limits<float>::quiet_NaN(),
                    const float percent_prephasing = std::numeric_limits<float>::quiet_NaN()) :
                m_read(read),
                m_percent_aligned(percent_aligned),
                m_percent_phasing(percent_phasing),
                m_percent_prephasing(percent_prephasing)
        {
        }

    public:
        uint_t read() const
        { return m_read; }

        float percent_aligned() const
        { return m_percent_aligned; }

        float percent_phasing() const
        { return (m_percent_phasing < 0) ? 0 : m_percent_phasing; /* Consistent with legacy */ }

        float percent_prephasing() const
        { return (m_percent_prephasing < 0) ? 0 : m_percent_prephasing; /* Consistent with legacy */ }
        void percent_aligned(const float val)
        { m_percent_aligned = val; }

        void percent_phasing(const float val)
        { m_percent_phasing = val; }

        void percent_prephasing(const float val)
        { m_percent_prephasing = val; }

    private:
        uint_t m_read;
        float m_percent_aligned;
        float m_percent_phasing;
        float m_percent_prephasing;
        template<class MetricType, int Version>
        friend struct io::generic_layout;
    };

    class tile_metric : public metric_base::base_metric
    {
    public:
        enum
        {
            TYPE = constants::Tile,
            LATEST_VERSION = 3
        };
        typedef std::vector<read_metric> read_metric_vector;
        typedef read_metric_vector::const_iterator const_iterator;
        typedef read_metric read_metric_type;
        typedef tile_metric_header header_type;
    private:
        typedef read_metric_vector::iterator read_iterator;
    public:
        tile_metric() : metric_base::base_metric(0, 0),
                        m_cluster_density(std::numeric_limits<float>::quiet_NaN()),
                        m_cluster_density_pf(std::numeric_limits<float>::quiet_NaN()),
                        m_cluster_count(std::numeric_limits<float>::quiet_NaN()),
                        m_cluster_count_pf(std::numeric_limits<float>::quiet_NaN())
        { }
        tile_metric(const header_type&) : metric_base::base_metric(0, 0),
                                          m_cluster_density(std::numeric_limits<float>::quiet_NaN()),
                                          m_cluster_density_pf(std::numeric_limits<float>::quiet_NaN()),
                                          m_cluster_count(std::numeric_limits<float>::quiet_NaN()),
                                          m_cluster_count_pf(std::numeric_limits<float>::quiet_NaN())
        { }

        tile_metric(const uint_t lane,
                    const uint_t tile,
                    const float cluster_density,
                    const float cluster_density_pf,
                    const float cluster_count,
                    const float cluster_count_pf,
                    const read_metric_vector &read_metrics = read_metric_vector()) :
                metric_base::base_metric(lane, tile),
                m_cluster_density(cluster_density),
                m_cluster_density_pf(cluster_density_pf),
                m_cluster_count(cluster_count),
                m_cluster_count_pf(cluster_count_pf),
                m_read_metrics(read_metrics)
        { }

        tile_metric(const uint_t lane,
                    const uint_t tile,
                    const read_metric_vector &read_metrics = read_metric_vector()) :
                metric_base::base_metric(lane, tile),
                m_cluster_density(std::numeric_limits<float>::quiet_NaN()),
                m_cluster_density_pf(std::numeric_limits<float>::quiet_NaN()),
                m_cluster_count(std::numeric_limits<float>::quiet_NaN()),
                m_cluster_count_pf(std::numeric_limits<float>::quiet_NaN()),
                m_read_metrics(read_metrics)
        { }

        tile_metric(const tile_metric &metric,
                    const read_metric_vector &read_metrics = read_metric_vector()) :
                metric_base::base_metric(metric),
                m_cluster_density(metric.m_cluster_density),
                m_cluster_density_pf(metric.m_cluster_density_pf),
                m_cluster_count(metric.m_cluster_count),
                m_cluster_count_pf(metric.m_cluster_count_pf),
                m_read_metrics(read_metrics.size() > 0 ? read_metrics : metric.read_metrics())
        { }
        tile_metric(const uint_t lane,
                    const uint_t tile,
                    const float cluster_count,
                    const float cluster_count_pf,
                    const read_metric_vector & read_metrics=read_metric_vector()) :
                metric_base::base_metric(lane,tile),
                m_cluster_density(std::numeric_limits<float>::quiet_NaN()),
                m_cluster_density_pf(std::numeric_limits<float>::quiet_NaN()),
                m_cluster_count(cluster_count),
                m_cluster_count_pf(cluster_count_pf),
                m_read_metrics(read_metrics)
        {}

    public:
        float cluster_density() const
        { return m_cluster_density; }

        float cluster_density_k() const
        { return m_cluster_density/1000.0f; }

        float cluster_density_pf() const
        { return m_cluster_density_pf; }

        float cluster_density_pf_k() const
        { return m_cluster_density_pf/1000.0f; }

        float cluster_count() const
        { return m_cluster_count; }

        float cluster_count_k() const
        { return m_cluster_count/1000.0f; }

        float cluster_count_m() const
        { return m_cluster_count/1000000.0f; }

        float cluster_count_pf() const
        { return m_cluster_count_pf; }

        float cluster_count_pf_k() const
        { return m_cluster_count_pf/1000.0f; }

        float cluster_count_pf_m() const
        { return m_cluster_count_pf/1000000.0f; }

        float percent_pf() const
        {
            return 100 * m_cluster_count_pf / m_cluster_count;
        }

        const read_metric_vector &read_metrics() const
        { return m_read_metrics; }

        float percent_aligned(const size_t n) const
        {
            if (n >= m_read_metrics.size())
                return std::numeric_limits<float>::quiet_NaN();
            return m_read_metrics[n].percent_aligned();
        }

        float percent_phasing(const size_t n) const
        {
            if (n >= m_read_metrics.size())
                return std::numeric_limits<float>::quiet_NaN();
            return m_read_metrics[n].percent_phasing();
        }

        float percent_prephasing(const size_t n) const
        {
            if (n >= m_read_metrics.size())
                return std::numeric_limits<float>::quiet_NaN();
            return m_read_metrics[n].percent_prephasing();
        }

        float percent_aligned_at(const size_t number) const
        {
            for (const_iterator b = m_read_metrics.begin(), e = m_read_metrics.end(); b != e; ++b)
                if (b->read() == number) return b->percent_aligned();
            return std::numeric_limits<float>::quiet_NaN();
        }

        float percent_phasing_at(const size_t number) const
        {
            for (const_iterator b = m_read_metrics.begin(), e = m_read_metrics.end(); b != e; ++b)
                if (b->read() == number) return b->percent_phasing();
            return std::numeric_limits<float>::quiet_NaN();
        }

        float percent_prephasing_at(const size_t number) const
        {
            for (const_iterator b = m_read_metrics.begin(), e = m_read_metrics.end(); b != e; ++b)
                if (b->read() == number) return b->percent_prephasing();
            return std::numeric_limits<float>::quiet_NaN();
        }

        size_t read_count() const
        {
            return m_read_metrics.size();
        }

        bool is_dead_tile() const
        {
            return (cluster_count() == 0) || (cluster_count_pf() == 0);
        }

        /* @} */
        void update_phasing_if_missing(const size_t number, const float phasing, const float prephasing)
        {
            for (read_iterator b = m_read_metrics.begin(); b != m_read_metrics.end(); ++b)
            {
                if (b->read() == static_cast<uint_t>(number))
                {
                    if(std::isnan(b->percent_phasing()))
                    {
                        b->percent_phasing(phasing);
                    }
                    if(std::isnan(b->percent_prephasing()))
                    {
                        b->percent_prephasing(prephasing);
                    }
                    return;
                }
            }
            m_read_metrics.push_back(read_metric(static_cast<uint_t>(number),
                                                 std::numeric_limits<float>::quiet_NaN(),
                                                 phasing,
                                                 prephasing));
        }
        float clusterDensity() const
        { return m_cluster_density; }

        float clusterDensityPf() const
        { return m_cluster_density_pf; }

        float clusterCount() const
        { return m_cluster_count; }

        float clusterCountPf() const
        { return m_cluster_count_pf; }

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

    private:
        float m_cluster_density;
        float m_cluster_density_pf;
        float m_cluster_count;
        float m_cluster_count_pf;
        read_metric_vector m_read_metrics;

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