metric_summary.h

Go to the documentation of this file.

#pragma once
#include "interop/io/format/generic_layout.h"

namespace illumina { namespace interop { namespace model { namespace summary {

    class metric_summary
    {
    public:
        metric_summary(const size_t /*channel_count*/) :
                m_error_rate(std::numeric_limits<float>::quiet_NaN()),
                m_percent_aligned(std::numeric_limits<float>::quiet_NaN()),
                m_first_cycle_intensity(std::numeric_limits<float>::quiet_NaN()),
                m_percent_gt_q30(std::numeric_limits<float>::quiet_NaN()),
                m_yield_g(std::numeric_limits<float>::quiet_NaN()),
                m_projected_yield_g(0),
                m_percent_occupied(std::numeric_limits<float>::quiet_NaN()),
                m_percent_occupancy_proxy(std::numeric_limits<float>::quiet_NaN()),
                m_reads_raw(0),
                m_reads_pf(0),
                m_cluster_count_raw(std::numeric_limits<float>::quiet_NaN()),
                m_cluster_count_pf(std::numeric_limits<float>::quiet_NaN())

        {}
    public:
        float error_rate()const
        {
            return m_error_rate;
        }
        float percent_aligned()const
        {
            return m_percent_aligned;
        }
        float first_cycle_intensity()const
        {
            return m_first_cycle_intensity;
        }
        float percent_gt_q30()const
        {
            return m_percent_gt_q30;
        }
        float yield_g()const
        {
            return m_yield_g;
        }

        float projected_yield_g()const
        {
            return m_projected_yield_g;
        }
        float percent_occupied()const
        {
            return m_percent_occupied;
        }
        float percent_occupancy_proxy()const
        {
            return m_percent_occupancy_proxy;
        }
        double cluster_count()const
        {
            return m_cluster_count_raw;
        }

        double cluster_count_pf()const
        {
            return m_cluster_count_pf;
        }
        uint64_t reads()const
        {
            return m_reads_raw;
        }
        uint64_t reads_pf()const
        {
            return m_reads_pf;
        }
        void first_cycle_intensity(const float val)
        {
            m_first_cycle_intensity = val;
        }
        void error_rate(const float val)
        {
            m_error_rate = val;
        }
        void percent_aligned(const float val)
        {
            m_percent_aligned = val;
        }
        void percent_gt_q30(const float val)
        {
            m_percent_gt_q30 = val;
        }

        void yield_g(const float val)
        {
            m_yield_g = val;
        }
        void projected_yield_g(const float val)
        {
            m_projected_yield_g = val;
        }
        void percent_occupied(const float val)
        {
            m_percent_occupied = val;
        }
        void percent_occupancy_proxy(const float val)
        {
            m_percent_occupancy_proxy = val;
        }

        void resize(const size_t)
        {
        }

        void cluster_count(const double val)
        {
            m_cluster_count_raw = val;
        }

        void cluster_count_pf(const double val)
        {
            m_cluster_count_pf = val;
        }

        void reads(const uint64_t val)
        {
            m_reads_raw = val;
        }

        void reads_pf(const uint64_t val)
        {
            m_reads_pf = val;
        }

    private:
        float m_error_rate;
        float m_percent_aligned;
        float m_first_cycle_intensity;
        float m_percent_gt_q30;
        float m_yield_g;
        float m_projected_yield_g;
        float m_percent_occupied;
        float m_percent_occupancy_proxy;
        uint64_t m_reads_raw;
        uint64_t m_reads_pf;
        double m_cluster_count_raw;
        double m_cluster_count_pf;
        template<class MetricType, int Version>
        friend struct io::generic_layout;
    };



}}}}