extraction_metric.h

Go to the documentation of this file.

#pragma once

#include <ctime>
#include <cstring>
#include <algorithm>
#include "interop/util/exception.h"
#include "interop/util/time.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 extraction_metric_header : public metric_base::base_cycle_metric::header_type
    {
    public:
        enum{
            MAX_CHANNELS=4
        };
        typedef ::uint16_t ushort_t;
    public:
        extraction_metric_header(ushort_t channel_count) : m_channel_count(channel_count) {}
        ushort_t channel_count()const{return m_channel_count;}
        void channel_count(const size_t channel_count)
        {
            m_channel_count = static_cast<ushort_t>(channel_count);
        }
        static extraction_metric_header default_header()
        {
            return extraction_metric_header(MAX_CHANNELS);
        }
        void clear()
        {
            m_channel_count=MAX_CHANNELS;
            metric_base::base_cycle_metric::header_type::clear();
        }
    private:
        ushort_t m_channel_count;
        template<class MetricType, int Version>
        friend struct io::generic_layout;
    };
    class extraction_metric : public metric_base::base_cycle_metric
    {
    public:
        enum
        {
            MAX_CHANNELS = 4,
            TYPE = constants::Extraction,
            LATEST_VERSION = 3
        };
        typedef extraction_metric_header header_type;
        typedef std::vector<ushort_t> ushort_array_t;
        typedef std::vector<float> float_array_t;
        typedef ::uint16_t *ushort_pointer_t;
        typedef float *float_pointer_t;

    public:
        extraction_metric() :
                metric_base::base_cycle_metric(0, 0, 0),
                m_date_time_csharp(0),
                m_date_time(0),
                m_max_intensity_values(MAX_CHANNELS, 0),
                m_focus_scores(MAX_CHANNELS, 0)
        {
        }
        extraction_metric(const header_type& header) :
                metric_base::base_cycle_metric(0, 0, 0),
                m_date_time_csharp(0),
                m_date_time(0),
                m_max_intensity_values(header.channel_count(), 0),
                m_focus_scores(header.channel_count(), 0)
        {
        }

        extraction_metric(const uint_t lane,
                          const uint_t tile,
                          const uint_t cycle,
                          const ulong_t date_time,
                          const ushort_array_t &intensities_p90,
                          const float_array_t &focus_scores) :
                metric_base::base_cycle_metric(lane, tile, cycle),
                m_date_time_csharp(util::csharp_date_time::to_csharp(date_time)),
                m_date_time(date_time),
                m_max_intensity_values(intensities_p90),
                m_focus_scores(focus_scores)
        {
            INTEROP_ASSERT(intensities_p90.size() <= MAX_CHANNELS);
            INTEROP_ASSERT(m_focus_scores.size() <= MAX_CHANNELS);
            m_max_intensity_values.resize(MAX_CHANNELS, 0);
            m_focus_scores.resize(MAX_CHANNELS, 0);
        }

        extraction_metric(const uint_t lane,
                          const uint_t tile,
                          const uint_t cycle,
                          const ulong_t date_time,
                          const ushort_pointer_t intensities_p90,
                          const float_pointer_t focus_scores,
                          const uint_t channel_count = MAX_CHANNELS) :
                metric_base::base_cycle_metric(lane, tile, cycle),
                m_date_time_csharp(util::csharp_date_time::to_csharp(date_time)),
                m_date_time(date_time),
                m_max_intensity_values(intensities_p90, intensities_p90 + channel_count),
                m_focus_scores(focus_scores, focus_scores + channel_count)
        {
        }

        extraction_metric(const uint_t lane,
                          const uint_t tile,
                          const uint_t cycle,
                          const util::csharp_date_time date_time,
                          const ushort_array_t &intensities_p90,
                          const float_array_t &focus_scores) :
                metric_base::base_cycle_metric(lane, tile, cycle),
                m_date_time_csharp(date_time),
                m_date_time(date_time.to_unix()),
                m_max_intensity_values(intensities_p90),
                m_focus_scores(focus_scores)
        {
            INTEROP_ASSERT(intensities_p90.size() <= MAX_CHANNELS);
            INTEROP_ASSERT(m_focus_scores.size() <= MAX_CHANNELS);
            m_max_intensity_values.resize(MAX_CHANNELS, 0);
            m_focus_scores.resize(MAX_CHANNELS, 0);
        }

        extraction_metric(const uint_t lane,
                          const uint_t tile,
                          const uint_t cycle,
                          const util::csharp_date_time date_time,
                          const ushort_pointer_t intensities_p90,
                          const float_pointer_t focus_scores,
                          const uint_t channel_count = MAX_CHANNELS) :
                metric_base::base_cycle_metric(lane, tile, cycle),
                m_date_time_csharp(date_time),
                m_date_time(date_time.to_unix()),
                m_max_intensity_values(intensities_p90, intensities_p90 + channel_count),
                m_focus_scores(focus_scores, focus_scores + channel_count)
        {
        }
        extraction_metric(const uint_t lane,
                          const uint_t tile,
                          const uint_t cycle,
                          const ushort_array_t& max_intensity_values,
                          const float_array_t& focus_scores) :
                metric_base::base_cycle_metric(lane, tile, cycle),
                m_date_time_csharp(0),
                m_date_time(0),
                m_max_intensity_values(max_intensity_values),
                m_focus_scores(focus_scores)
        {
        }

        extraction_metric(const uint_t lane,
                          const uint_t tile,
                          const uint_t cycle,
                          const ::uint16_t* intensity_values,
                          const size_t intensity_count,
                          const float* focus_scores,
                          const size_t focus_count,
                          const size_t /*dummy*/) :
                metric_base::base_cycle_metric(lane, tile, cycle),
                m_date_time_csharp(0),
                m_date_time(0),
                m_max_intensity_values(intensity_values, intensity_values+intensity_count),
                m_focus_scores(focus_scores, focus_scores+focus_count)
        {
        }

    public:
        void set(const uint_t lane,
                 const uint_t tile,
                 const uint_t cycle,
                 const ulong_t date_time,
                 const ushort_array_t& max_intensity_values,
                 const float_array_t& focus_scores)
        {
            metric_base::base_cycle_metric::set_base(lane, tile, cycle);
            m_date_time_csharp = util::csharp_date_time::to_csharp(date_time);
            m_date_time = date_time;
            m_max_intensity_values.assign(max_intensity_values.begin(), max_intensity_values.end());
            m_focus_scores.assign(focus_scores.begin(), focus_scores.end());
        }
        void set(const uint_t lane,
                 const uint_t tile,
                 const uint_t cycle,
                 const ushort_array_t& max_intensity_values,
                 const float_array_t& focus_scores)
        {
            metric_base::base_cycle_metric::set_base(lane, tile, cycle);
            m_max_intensity_values.assign(max_intensity_values.begin(), max_intensity_values.end());
            m_focus_scores.assign(focus_scores.begin(), focus_scores.end());
        }

    public:
        ulong_t date_time() const
        {
            return m_date_time;
        }

        const util::csharp_date_time &date_time_csharp() const
        {
            return m_date_time_csharp;
        }
        ulong_t date_time_csharp_raw() const
        {
            return m_date_time_csharp.value;
        }

        ushort_t max_intensity(const size_t channel) const INTEROP_THROW_SPEC((model::index_out_of_bounds_exception))
        {
            INTEROP_BOUNDS_CHECK(channel, m_max_intensity_values.size(), "Channel out of bounds");
            return m_max_intensity_values[channel];
        }

        float focus_score(const size_t channel) const INTEROP_THROW_SPEC((model::index_out_of_bounds_exception))
        {
            INTEROP_BOUNDS_CHECK(channel, m_focus_scores.size(), "Channel out of bounds");
            return m_focus_scores[channel];
        }

        const ushort_array_t &max_intensity_values() const
        { return m_max_intensity_values; }

        const float_array_t &focus_scores() const
        { return m_focus_scores; }

        size_t channel_count()const
        {
            return m_focus_scores.size();
        }
        void trim(const size_t channel_count)
        {
            m_focus_scores.resize(channel_count);
            m_max_intensity_values.resize(channel_count);
        }
        float focusScore(size_t channel) const
        {
            INTEROP_ASSERT(channel < MAX_CHANNELS);
            INTEROP_ASSERT(m_focus_scores.size() == MAX_CHANNELS);
            return m_focus_scores[channel];
        }

        ulong_t dateTime() const
        {
            return m_date_time;
        }

        const float_array_t &focusScores() const
        { return m_focus_scores; }
        void date_time(const ulong_t time)
        {
            m_date_time=time;
            m_date_time_csharp = util::csharp_date_time::to_csharp(time);
        }

        bool is_any_p90_zero() const
        {
            for(size_t channel = 0; channel < channel_count(); ++channel)
            {
                if(max_intensity(channel) == 0)
                    return true;
            }
            return false;
        }

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

    private:
        util::csharp_date_time m_date_time_csharp;
        ulong_t m_date_time;
        ushort_array_t m_max_intensity_values;
        float_array_t m_focus_scores;
        template<class MetricType, int Version>
        friend
        struct io::generic_layout;
    };
}}}}