base_metric.h

Go to the documentation of this file.

#pragma once

#include <limits>
#include "interop/util/assert.h"
#include "interop/io/layout/base_metric.h"
#include "interop/constants/enums.h"
#include "interop/constants/typedefs.h"

namespace illumina { namespace interop { namespace model { namespace metric_base
{
    class empty_header { };

    // Forward declaration
    class base_metric;
    class empty_metric;

    template<class Metric>
    struct metric_attributes : public Metric{};

    class base_metric_header : public empty_header
    {
    public:
        typedef constants::base_tile_t base_t;
    public:
        static base_metric_header default_header()
        {
            return base_metric_header();
        }

    protected:
        void clear(){}
        void update_max_cycle(const empty_metric &)
        { }
    };

    class empty_metric
    {
    public:
        typedef ::uint32_t id_t;
        typedef ::uint32_t uint_t;
        typedef constants::base_run_t base_t;

    public:
        template<class BaseMetric>
        void set_base(const BaseMetric &/*base*/)
        {
        }
        void set_base(const uint_t /*lane*/, const uint_t /*tile*/)
        {
        }
        static const char *suffix()
        {
            return "";
        }

        bool operator< (const empty_metric& /*metric2*/) const
        {
            return false;
        }
        static id_t create_id(const id_t, const id_t, const id_t= 0)// TODO: remove hack (const id_t=0)
        {
            return 1;// Cannot be zero
        }
    };

    class base_metric : public empty_metric
    {
    public:
        typedef ::uint64_t ulong_t;
        typedef ulong_t id_t;
        typedef ::uint16_t ushort_t;
        typedef ::uint32_t uint_t;
        typedef base_metric_header header_type;
        typedef ::uint8_t lane_t;
        typedef ::uint32_t tile_t;
        typedef constants::base_tile_t base_t;
        enum
        {
            //Compress Lane, Tile and cycle into a 64-bit Integer
            // Bit order: LTCR or Lane, Tile, Cycle/Read, Reserved
            // Reserved: Bits 0-16
            // Read/Cycle: Bits 16-32
            // Tile: Bits 32-58
            // Lane: Bits 58-64
            LANE_BIT_COUNT = 6, // Supports up to 63 lanes
            TILE_BIT_COUNT = 26, // Support 7 digit tile (up to 67108864)
            CYCLE_BIT_COUNT = 16, // Support up to 65535 cycles
            READ_BIT_COUNT = 16, // Support up to 65535 reads
            RESERVED_BIT_COUNT = 16, // Support up to 65535 values
            READ_BIT_SHIFT = RESERVED_BIT_COUNT,
            CYCLE_BIT_SHIFT = RESERVED_BIT_COUNT,
            TILE_BIT_SHIFT = CYCLE_BIT_SHIFT+CYCLE_BIT_COUNT,
            LANE_BIT_SHIFT = TILE_BIT_SHIFT+TILE_BIT_COUNT // Supports up to 63 lanes=
        };
    public:
        base_metric(const uint_t lane=0, const uint_t tile=0) :
                m_lane(static_cast<lane_t>(lane)), m_tile(static_cast<tile_t>(tile))
        { }

    public:
        void set_base(const uint_t lane, const uint_t tile)
        {
            m_lane = static_cast<lane_t>(lane);
            m_tile = static_cast<tile_t>(tile);
        }

        template<class BaseMetric>
        void set_base(const BaseMetric &base)
        {
            m_lane = static_cast<lane_t>(base.lane);
            m_tile = static_cast<tile_t>(base.tile);
        }

        id_t id() const
        {
            return create_id(m_lane, m_tile);
        }

        id_t tile_hash() const
        {
            return create_id(m_lane, m_tile);
        }

        static id_t create_id(const id_t lane, const id_t tile, const id_t= 0)// TODO: remove hack (const id_t=0)
        {
            return (lane << LANE_BIT_SHIFT) | (tile << TILE_BIT_SHIFT);
        }

        static id_t lane_from_id(const id_t id)
        {
            return id >> LANE_BIT_SHIFT;
        }
        static id_t tile_hash_from_id(const id_t id)
        {
            // 1. Remove cycle and reserved information
            return (id >> TILE_BIT_SHIFT) << TILE_BIT_SHIFT;
        }
        static id_t tile_from_id(const id_t id)
        {
            // 1. Shift off lane
            // 2. Shift tile id into proper position (removing cycle and reserved)
            return (id << (LANE_BIT_COUNT) >> (LANE_BIT_COUNT+CYCLE_BIT_COUNT+RESERVED_BIT_COUNT));
        }

        uint_t lane() const
        { return m_lane; }

        uint_t tile() const
        { return m_tile; }

        uint_t number(const illumina::interop::constants::tile_naming_method) const
        {
            return m_tile % 100;
        }

        uint_t section(const illumina::interop::constants::tile_naming_method method) const
        {
            if (method == constants::FiveDigit)
                return (m_tile / 100) % 10;
            return std::numeric_limits<uint_t>::min();
        }

        uint_t surface(const illumina::interop::constants::tile_naming_method method) const
        {
            if (method == constants::FiveDigit)
                return (m_tile / 10000);
            if (method == constants::FourDigit)
                return m_tile / 1000;
            return 1;
        }

        uint_t swath(const illumina::interop::constants::tile_naming_method method) const
        {
            if (method == constants::FiveDigit)
                return (m_tile / 1000) % 10;
            if (method == constants::FourDigit)
                return (m_tile / 100) % 10;
            return 1;
        }

        uint_t phyiscalLocationIndex(const illumina::interop::constants::tile_naming_method method,
                                     const uint_t section_per_lane,
                                     const uint_t tile_count,
                                     const uint_t swath_count,
                                     const bool all_surfaces) const
        {
            const uint_t column = phyiscalLocationColumn(method, swath_count, all_surfaces);
            const uint_t row = phyiscalLocationRow(method, section_per_lane, tile_count);
            const uint_t row_count = section_per_lane * tile_count;
            return column * row_count + row;
        }

        uint_t phyiscalLocationColumn(const illumina::interop::constants::tile_naming_method method,
                                      const uint_t swath_count,
                                      const bool all_surfaces) const
        {
            if (!(method == constants::FiveDigit || method == constants::FourDigit)) return 0;
            uint_t col = swath(method);
            if (all_surfaces && surface(method) == 2) col += swath_count;
            return col;
        }

        uint_t phyiscalLocationRow(const illumina::interop::constants::tile_naming_method method,
                                   const uint_t section_per_lane,
                                   const uint_t tile_count) const
        {
            uint_t section;
            switch (method)
            {
                case constants::FiveDigit:
                    section = ((m_tile % 1000) - (m_tile % 100)) / 100;
                    if (section == 4) section = 6;
                    else if (section == 6) section = 4;
                    section = (section - 1) * section_per_lane;
                    return (section * tile_count) + (m_tile % 100);
                case constants::FourDigit:
                    return m_tile % 100;
                default:
                    return m_tile;
            }
        }

        size_t physical_location_index(const illumina::interop::constants::tile_naming_method method,
                                       const uint_t section_per_lane,
                                       const uint_t tile_count,
                                       const uint_t swath_count,
                                       const bool all_surfaces) const
        {

            INTEROP_ASSERTMSG(swath(method) <= swath_count, swath(method) << " <= " << swath_count);
            INTEROP_ASSERTMSG(number(method) <= tile_count, number(method) << " <= " << tile_count);
            const uint_t column = physical_location_column(method, swath_count, all_surfaces);
            const uint_t row = physical_location_row(method, section_per_lane, tile_count);
            const uint_t row_count = section_per_lane * tile_count;
            return static_cast<size_t>(column * row_count + row);
        }

        uint_t physical_location_column(const illumina::interop::constants::tile_naming_method method,
                                        const uint_t swath_count,
                                        const bool all_surfaces) const
        {
            if (!(method == constants::FiveDigit || method == constants::FourDigit)) return 0;
            uint_t col = swath(method);
            if (all_surfaces && surface(method) == 2) col += swath_count;
            return col - 1;
        }

        uint_t physical_location_row(const illumina::interop::constants::tile_naming_method method,
                                     const uint_t section_per_lane,
                                     const uint_t tile_count) const
        {
            uint_t section;
            switch (method)
            {
                case constants::FiveDigit:
                    section = ((m_tile % 1000) - (m_tile % 100)) / 100;
                    if (section == 4) section = 6;
                    else if (section == 6) section = 4;
                    section = (section - 1) % section_per_lane;
                    return (section * tile_count) + (m_tile % 100) - 1;
                case constants::FourDigit:
                    return m_tile % 100 - 1;
                default:
                    return m_tile - 1;
            }
        }
        static const char *suffix()
        {
            return "";
        }
        bool operator< (const base_metric& metric2) const
        {
            return id() < metric2.id();
        }

    private:
        lane_t m_lane;
        tile_t m_tile;
    };


    template<>
    struct metric_attributes<base_metric>
    {
        enum
        {
            TYPE = constants::UnknownMetricType,
            LATEST_VERSION=0
        };

        static const char *prefix()
        {
            return "";
        }
        static const char *suffix()
        {
            return "";
        }
    };


}}}}