corrected_intensity_metric.h

Go to the documentation of this file.

#pragma once

#include <limits>
#include <numeric>
#include <cstring>
#include <fstream>
#include "interop/util/math.h"
#include "interop/util/exception.h"
#include "interop/constants/enums.h"
#include "interop/io/format/generic_layout.h"
#include "interop/model/metric_base/metric_set.h"
#include "interop/io/layout/base_metric.h"
#include "interop/model/metric_base/metric_exceptions.h"
#include "interop/model/metric_base/base_cycle_metric.h"

namespace illumina { namespace interop { namespace model { namespace metrics
{
    class corrected_intensity_metric : public metric_base::base_cycle_metric
    {
    public:
        enum
        {
            TYPE = constants::CorrectedInt,
            LATEST_VERSION = 4
        };
        typedef ::intptr_t difference_type;
        typedef std::vector<ushort_t> ushort_array_t;
        typedef std::vector<uint_t> uint_array_t;
        typedef std::vector<float> float_array_t;
        typedef ::uint16_t *ushort_pointer_t;
        typedef ::uint32_t *uint_pointer_t;
        typedef float* float_pointer_t;
    public:
        corrected_intensity_metric() :
                metric_base::base_cycle_metric(0, 0, 0),
                m_average_cycle_intensity(0),
                m_corrected_int_all(constants::NUM_OF_BASES, std::numeric_limits<ushort_t>::max()),
                m_corrected_int_called(constants::NUM_OF_BASES, std::numeric_limits<float>::quiet_NaN()),
                m_called_counts(constants::NUM_OF_BASES_AND_NC, 0),
                m_signal_to_noise(std::numeric_limits<float>::quiet_NaN())
        { }
        corrected_intensity_metric(const header_type&) :
                metric_base::base_cycle_metric(0, 0, 0),
                m_average_cycle_intensity(0),
                m_corrected_int_all(constants::NUM_OF_BASES, std::numeric_limits<ushort_t>::max()),
                m_corrected_int_called(constants::NUM_OF_BASES, std::numeric_limits<float>::quiet_NaN()),
                m_called_counts(constants::NUM_OF_BASES_AND_NC, 0),
                m_signal_to_noise(std::numeric_limits<float>::quiet_NaN())
        { }

        corrected_intensity_metric(const uint_t lane,
                                   const uint_t tile,
                                   const uint_t cycle,
                                   const ushort_t average_cycle_intensity,
                                   const float signal_to_noise,
                                   const float_array_t &corrected_int_called,
                                   const ushort_array_t &corrected_int_all,
                                   const uint_array_t &called_counts) :
                metric_base::base_cycle_metric(lane, tile, cycle),
                m_average_cycle_intensity(average_cycle_intensity),
                m_corrected_int_all(corrected_int_all),
                m_corrected_int_called(corrected_int_called),
                m_called_counts(called_counts),
                m_signal_to_noise(signal_to_noise)
        {
            INTEROP_ASSERT(m_corrected_int_all.size() == constants::NUM_OF_BASES);
            INTEROP_ASSERT(m_corrected_int_called.size() == constants::NUM_OF_BASES);
            INTEROP_ASSERT(m_called_counts.size() == constants::NUM_OF_BASES_AND_NC);
        }

        corrected_intensity_metric(const uint_t lane,
                                   const uint_t tile,
                                   const uint_t cycle,
                                   const ushort_t average_cycle_intensity,
                                   const float signal_to_noise,
                                   const float_pointer_t corrected_int_called,
                                   const ushort_pointer_t corrected_int_all,
                                   const uint_pointer_t called_counts) :
                metric_base::base_cycle_metric(lane, tile, cycle),
                m_average_cycle_intensity(average_cycle_intensity),
                m_corrected_int_all(corrected_int_all, corrected_int_all + constants::NUM_OF_BASES),
                m_corrected_int_called(corrected_int_called, corrected_int_called + constants::NUM_OF_BASES),
                m_called_counts(called_counts, called_counts + constants::NUM_OF_BASES_AND_NC),
                m_signal_to_noise(signal_to_noise)
        {
            INTEROP_ASSERT(m_corrected_int_all.size() == constants::NUM_OF_BASES);
            INTEROP_ASSERT(m_corrected_int_called.size() == constants::NUM_OF_BASES);
            INTEROP_ASSERT(m_called_counts.size() == constants::NUM_OF_BASES_AND_NC);
        }

        corrected_intensity_metric(const uint_t lane,
                                   const uint_t tile,
                                   const uint_t cycle,
                                   const float_array_t &corrected_int_called,
                                   const uint_array_t &called_counts) :
                metric_base::base_cycle_metric(lane, tile, cycle),
                m_average_cycle_intensity(std::numeric_limits<ushort_t>::max()),
                m_corrected_int_all(constants::NUM_OF_BASES, std::numeric_limits<ushort_t>::max()),
                m_corrected_int_called(corrected_int_called),
                m_called_counts(called_counts),
                m_signal_to_noise(std::numeric_limits<float>::quiet_NaN())
        {
            INTEROP_ASSERT(m_corrected_int_all.size() == constants::NUM_OF_BASES);
            INTEROP_ASSERT(m_called_counts.size() == constants::NUM_OF_BASES_AND_NC);
        }

        corrected_intensity_metric(const uint_t lane,
                                   const uint_t tile,
                                   const uint_t cycle,
                                   const ushort_pointer_t corrected_int_called,
                                   const uint_pointer_t called_counts) :
                metric_base::base_cycle_metric(lane, tile, cycle),
                m_average_cycle_intensity(std::numeric_limits<ushort_t>::max()),
                m_corrected_int_all(constants::NUM_OF_BASES, std::numeric_limits<ushort_t>::max()),
                m_corrected_int_called(corrected_int_called, corrected_int_called + constants::NUM_OF_BASES),
                m_called_counts(called_counts, called_counts + constants::NUM_OF_BASES_AND_NC),
                m_signal_to_noise(std::numeric_limits<float>::quiet_NaN())
        {// TODO: Add array safety to this constructor
            INTEROP_ASSERT(m_corrected_int_called.size() == constants::NUM_OF_BASES);
            INTEROP_ASSERT(m_called_counts.size() == constants::NUM_OF_BASES_AND_NC);
        }

        corrected_intensity_metric(const uint_t lane,
                                   const uint_t tile,
                                   const uint_t cycle,
                                   const uint_array_t& called_count) :
                metric_base::base_cycle_metric(lane, tile, cycle),
                m_average_cycle_intensity(std::numeric_limits<ushort_t>::max()),
                m_corrected_int_all(constants::NUM_OF_BASES, std::numeric_limits<ushort_t>::max()),
                m_corrected_int_called(constants::NUM_OF_BASES, std::numeric_limits<float>::quiet_NaN()),
                m_called_counts(called_count),
                m_signal_to_noise(std::numeric_limits<float>::quiet_NaN())
        {
            INTEROP_ASSERT(called_count.size() == static_cast<size_t>(constants::NUM_OF_BASES_AND_NC));
        }
        corrected_intensity_metric(const uint_t lane,
                                   const uint_t tile,
                                   const uint_t cycle,
                                   const ::uint32_t* called_counts,
                                   const size_t num_of_counts,
                                   const size_t /*dummy*/, /* dummy parameters work around swig bug */
                                   const size_t /*dummy*/) :
                metric_base::base_cycle_metric(lane, tile, cycle),
                m_average_cycle_intensity(std::numeric_limits<ushort_t>::max()),
                m_corrected_int_all(constants::NUM_OF_BASES, std::numeric_limits<ushort_t>::max()),
                m_corrected_int_called(constants::NUM_OF_BASES, std::numeric_limits<float>::quiet_NaN()),
                m_called_counts(called_counts, called_counts + std::min(num_of_counts, static_cast<size_t>(constants::NUM_OF_BASES_AND_NC))),
                m_signal_to_noise(std::numeric_limits<float>::quiet_NaN())
        {
            INTEROP_ASSERT(num_of_counts== static_cast<size_t>(constants::NUM_OF_BASES_AND_NC));
        }

    public:
        void set(const uint_t lane,
                 const uint_t tile,
                 const uint_t cycle,
                 const uint_array_t& called_counts)
        {
            metric_base::base_cycle_metric::set_base(lane, tile, cycle);
            m_called_counts = called_counts;
        }

    public:
        ushort_t average_cycle_intensity() const
        {
            return m_average_cycle_intensity;
        }

        ushort_t corrected_int_all(const constants::dna_bases index) const INTEROP_THROW_SPEC((model::index_out_of_bounds_exception))
        {
            INTEROP_BOUNDS_CHECK(static_cast<size_t>(index), m_corrected_int_all.size(), "Base out of bounds");
            return m_corrected_int_all[index];
        }

        float corrected_int_all_float(const constants::dna_bases index) const INTEROP_THROW_SPEC((model::index_out_of_bounds_exception))
        {
            INTEROP_BOUNDS_CHECK(static_cast<size_t>(index), m_corrected_int_all.size(), "Base out of bounds");
            return util::float_cast(m_corrected_int_all[index]);
        }

        float corrected_int_called(const constants::dna_bases index) const INTEROP_THROW_SPEC((model::index_out_of_bounds_exception))
        {
            INTEROP_BOUNDS_CHECK(static_cast<size_t>(index), m_corrected_int_all.size(), "Base out of bounds");
            return m_corrected_int_called[index];
        }

        const uint_array_t &called_counts_array() const
        { return m_called_counts; }

        const float_array_t &corrected_int_called_array() const
        { return m_corrected_int_called; }

        const ushort_array_t &corrected_int_all_array() const
        { return m_corrected_int_all; }

        uint_t called_counts(const constants::dna_bases index) const INTEROP_THROW_SPEC((model::index_out_of_bounds_exception))
        {
            INTEROP_BOUNDS_CHECK(static_cast<size_t>(index + 1), m_called_counts.size(), "Base out of bounds");
            return m_called_counts[static_cast<uint_t>(index + 1)];
        }

        uint_t no_calls() const
        {
            if(m_called_counts.empty()) return 0;
            return m_called_counts[0];
        }

        float signal_to_noise() const
        {
            return m_signal_to_noise;
        }

        uint_t total_calls(const bool nocalls = false) const
        {
            if (nocalls)
                return std::accumulate(m_called_counts.begin(), m_called_counts.end(), 0);
            return std::accumulate(m_called_counts.begin() + 1, m_called_counts.end(), 0);
        }

        uint_t total_intensity() const
        {
            return std::accumulate(m_corrected_int_all.begin(), m_corrected_int_all.end(), 0);
        }

        float total_called_intensity() const
        {
            return std::accumulate(m_corrected_int_called.begin(), m_corrected_int_called.end(), 0.0f);
        }

        float percent_base(const constants::dna_bases index) const INTEROP_THROW_SPEC((model::index_out_of_bounds_exception))
        {
            const uint_t total = total_calls(index == constants::NC );
            if (total == 0)
                return std::numeric_limits<float>::quiet_NaN();
            return called_counts(index) / static_cast<float>(total) * 100.0f;
        }

        float_array_t percent_bases() const
        {
            if(m_called_counts.empty())
            {
                return float_array_t();
            }
            const uint_t total = total_calls();
            float_array_t percent_bases(constants::NUM_OF_BASES);
            for (size_t i = 0; i < percent_bases.size(); ++i)
                percent_bases[i] = static_cast<float>(m_called_counts[i + 1]) / static_cast<float>(total) * 100.0f;
            return percent_bases;
        }

        float percent_nocall() const INTEROP_THROW_SPEC((model::index_out_of_bounds_exception))
        {
            return percent_base(constants::NC);
        }
        void corrected_int_called_array(const float_array_t & vals)
        {
            m_corrected_int_called.assign(vals.begin(), vals.end());
        }

        //--------------------------------------------------------------------------------------------------------------
        bool any_valid_called_int()const
        {
            for(size_t i=0;i<m_corrected_int_called.size();++i)
                if(!std::isnan(static_cast<float>(m_corrected_int_called[i]))) return true;
            return false;
        }
        ushort_t averageCycleIntensity() const
        {
            return m_average_cycle_intensity;
        }

        ushort_t correctedIntAll(size_t index) const
        {
            INTEROP_ASSERT(index < static_cast<size_t>(constants::NUM_OF_BASES));
            return m_corrected_int_all[index];
        }

        float correctedIntCalled(size_t index) const
        {
            INTEROP_ASSERT(index < static_cast<size_t>(constants::NUM_OF_BASES));
            return m_corrected_int_called[index];
        }

        const float_array_t &correctedIntCalled() const
        { return m_corrected_int_called; }

        const ushort_array_t &correctedIntAll() const
        { return m_corrected_int_all; }

        const uint_array_t &calledCounts() const
        { return m_called_counts; }

        uint_t noCalls() const
        {
            return m_called_counts[0];
        }

        float percentBase(difference_type index) const
        {
            uint_t total = totalCalls(static_cast<constants::dna_bases>(index) == constants::NC);
            if (total == 0) return std::numeric_limits<float>::quiet_NaN();
            return calledCounts(index) / static_cast<float>(total) * 100;
        }

        uint_t calledCounts(difference_type index) const
        {
            INTEROP_ASSERT((index + 1) < static_cast<difference_type>(constants::NUM_OF_BASES_AND_NC));
            return m_called_counts[static_cast<uint_t>(index + 1)];
        }

        float signalToNoise() const
        {
            return m_signal_to_noise;
        }

        uint_t totalCalls(const bool nocalls = false) const
        {
            if (nocalls)
                return std::accumulate(m_called_counts.begin(), m_called_counts.end(), 0);
            return std::accumulate(m_called_counts.begin() + 1, m_called_counts.end(), 0);
        }

        uint_t totalIntensity() const
        {
            return std::accumulate(m_corrected_int_all.begin(), m_corrected_int_all.end(), 0u);
        }

        float totalCalledIntensity() const
        {
            return std::accumulate(m_corrected_int_called.begin(), m_corrected_int_called.end(), 0.0f);
        }

        float percentIntensity(size_t index) const
        {
            uint_t total = totalIntensity();
            if (total == 0) return std::numeric_limits<float>::quiet_NaN();
            return correctedIntAll(index) / static_cast<float>(total) * 100;
        }

        float percentCalledIntensity(const size_t index) const
        {
            float total = totalCalledIntensity();
            if (total == 0) return std::numeric_limits<float>::quiet_NaN();
            return correctedIntCalled(index) / total * 100;
        }

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

    private:
        ushort_t m_average_cycle_intensity; // Version 1 & 2
        ushort_array_t m_corrected_int_all; // Version 1 & 2
        float_array_t m_corrected_int_called;
        // All
        uint_array_t m_called_counts; // All
        float m_signal_to_noise; // Version 2

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