run_metrics.h

Go to the documentation of this file.

#pragma once

#include "interop/util/exception.h"
#include "interop/util/object_list.h"
#include "interop/model/metric_base/metric_set.h"
#include "interop/model/model_exceptions.h"
#include "interop/io/stream_exceptions.h"
#include "interop/io/metric_file_stream.h"
#include "interop/model/run/info.h"
#include "interop/model/run/parameters.h"

//Metrics
#include "interop/model/metrics/corrected_intensity_metric.h"
#include "interop/model/metrics/dynamic_phasing_metric.h"
#include "interop/model/metrics/error_metric.h"
#include "interop/model/metrics/extended_tile_metric.h"
#include "interop/model/metrics/extraction_metric.h"
#include "interop/model/metrics/image_metric.h"
#include "interop/model/metrics/index_metric.h"
#include "interop/model/metrics/phasing_metric.h"
#include "interop/model/metrics/q_metric.h"
#include "interop/model/metrics/q_by_lane_metric.h"
#include "interop/model/metrics/q_collapsed_metric.h"
#include "interop/model/metrics/tile_metric.h"
#include "interop/model/metrics/summary_run_metric.h"

namespace illumina { namespace interop { namespace model { namespace metrics
{

    class run_metrics
    {
    public:
        typedef make_type_list<
                corrected_intensity_metric,
                dynamic_phasing_metric,
                error_metric,
                extended_tile_metric,
                extraction_metric,
                image_metric,
                index_metric,
                phasing_metric,
                q_metric,
                q_by_lane_metric,
                q_collapsed_metric,
                tile_metric,
                summary_run_metric
        >::result_t metric_type_list_t;

    private:
        template<class T>
        struct create_metric_set
        {
            typedef typename model::metric_base::metric_set_helper<T>::metric_set_t result_t;
        };
        typedef transform_type_list<metric_type_list_t, create_metric_set>::result_t metric_set_list_t;
        typedef object_list<metric_set_list_t> metric_list_t;

    public:
        typedef metric_base::base_metric::id_t id_t;
        typedef std::map<id_t, metric_base::base_metric> tile_metric_map_t;
        typedef std::map<id_t, metric_base::base_cycle_metric> cycle_metric_map_t;

    public:
        typedef metric_base::metric_set<error_metric>::id_set_t id_set_t;

    public:
        run_metrics()
        {
        }

        run_metrics(const run::info &run_info, const run::parameters &run_param = run::parameters()) :
                m_run_info(run_info),
                m_run_parameters(run_param)
        {
        }

    public:
        void read(const std::string &run_folder, const size_t thread_count=1) INTEROP_THROW_SPEC((xml::xml_file_not_found_exception,
        xml::bad_xml_format_exception,
        xml::empty_xml_format_exception,
        xml::missing_xml_element_exception,
        xml::xml_parse_exception,
        io::file_not_found_exception,
        io::bad_format_exception,
        io::incomplete_file_exception,
        model::invalid_channel_exception,
        model::index_out_of_bounds_exception,
        model::invalid_tile_naming_method,
        model::invalid_tile_list_exception,
        model::invalid_run_info_exception,
        model::invalid_run_info_cycle_exception,
        model::invalid_parameter));
        void read(const std::string &run_folder,
                  const std::vector<unsigned char>& valid_to_load,
                  const size_t thread_count=1,
                  const bool skip_loaded=false)
        INTEROP_THROW_SPEC((xml::xml_file_not_found_exception,
        xml::bad_xml_format_exception,
        xml::empty_xml_format_exception,
        xml::missing_xml_element_exception,
        xml::xml_parse_exception,
        io::file_not_found_exception,
        io::bad_format_exception,
        io::incomplete_file_exception,
        model::invalid_channel_exception,
        model::index_out_of_bounds_exception,
        model::invalid_tile_naming_method,
        model::invalid_tile_list_exception,
        model::invalid_run_info_exception,
        model::invalid_run_info_cycle_exception,
        model::invalid_parameter));

        size_t read_xml(const std::string &run_folder) INTEROP_THROW_SPEC((io::file_not_found_exception,
        xml::xml_file_not_found_exception,
        xml::bad_xml_format_exception,
        xml::empty_xml_format_exception,
        xml::missing_xml_element_exception,
        xml::xml_parse_exception));

        void read_run_info(const std::string &run_folder) INTEROP_THROW_SPEC((xml::xml_file_not_found_exception,
        xml::bad_xml_format_exception,
        xml::empty_xml_format_exception,
        xml::missing_xml_element_exception,
        xml::xml_parse_exception));

        size_t read_run_parameters(const std::string &run_folder, const bool force_load=false) INTEROP_THROW_SPEC((
        io::file_not_found_exception,
        xml::xml_file_not_found_exception,
        xml::bad_xml_format_exception,
        xml::empty_xml_format_exception,
        xml::missing_xml_element_exception,
        xml::xml_parse_exception));

        void finalize_after_load(size_t count = std::numeric_limits<size_t>::max()) INTEROP_THROW_SPEC((
        model::invalid_channel_exception,
        model::invalid_tile_naming_method,
        model::index_out_of_bounds_exception,
        model::invalid_tile_list_exception,
        model::invalid_run_info_exception,
        model::invalid_run_info_cycle_exception,
        model::invalid_parameter));

        bool empty() const;

        void legacy_channel_update(const constants::instrument_type type);

        void set_naming_method(const constants::tile_naming_method naming_method);
        size_t count_legacy_bins(const size_t legacy_bin_count=std::numeric_limits<size_t>::max())const;
         bool is_run_parameters_required(const size_t legacy_bin_count=std::numeric_limits<size_t>::max())const;

    public:
        const run::info &run_info() const
        {
            return m_run_info;
        }

        void run_info(const run::info &info)
        {
            m_run_info = info;
        }
        const run::parameters &run_parameters() const
        {
            return m_run_parameters;
        }

        void run_parameters(const run::parameters &param)
        {
            m_run_parameters = param;
        }

        void list_filenames(const constants::metric_group group,
                            std::vector<std::string>& files,
                            const std::string& run_folder,
                            const bool use_out=true)
        INTEROP_THROW_SPEC((invalid_run_info_exception));

        void list_filenames(std::vector<std::string>& files,
                            const std::string& run_folder,
                            const bool bycycle=false,
                            const bool use_out=true)
        INTEROP_THROW_SPEC((invalid_run_info_exception));

    public:
        template<class T>
        void set(const T& metrics)
        {
            //static_assert( )
            m_metrics.get< T >() = metrics;
        }
        template<class T>
        typename metric_base::metric_set_helper<T>::metric_set_t &get()
        {
            typedef typename metric_base::metric_set_helper<T>::metric_set_t metric_set_t;
            return m_metrics.get< metric_set_t >();
        }

        template<class T>
        const typename metric_base::metric_set_helper<T>::metric_set_t &get() const
        {
            typedef typename metric_base::metric_set_helper<T>::metric_set_t metric_set_t;
            return m_metrics.get< metric_set_t >();
        }

        template<class T>
        metric_base::metric_set<T> &get_metric_set()
        {
            return m_metrics.get<metric_base::metric_set<T> >();
        }

    public:
        void copy_tile(const run_metrics& metrics, const metric_base::base_metric& tile_id);
        void append_tiles(const run_metrics& metrics, const metric_base::base_metric& tile_id);
        void check_for_data_sources(const std::string &run_folder, const size_t last_cycle);
        void read_metrics(const std::string &run_folder, const size_t last_cycle, const size_t thread_count) INTEROP_THROW_SPEC((
        io::file_not_found_exception,
        io::bad_format_exception,
        io::incomplete_file_exception));
        void read_metrics(const std::string &run_folder,
                          const size_t last_cycle,
                          const std::vector<unsigned char>& valid_to_load,
                          const size_t thread_count,
                          const bool skip_loaded=false) INTEROP_THROW_SPEC((
        io::file_not_found_exception,
        io::bad_format_exception,
        io::incomplete_file_exception,
        model::invalid_parameter));
        void write_metrics(const std::string &run_folder, const bool use_out=true)const INTEROP_THROW_SPEC((
        io::file_not_found_exception,
        io::bad_format_exception));


        void read_metrics_from_buffer(const constants::metric_group group,
                                     ::uint8_t* buffer,
                                     const size_t buffer_size) INTEROP_THROW_SPEC((
        io::file_not_found_exception,
        io::bad_format_exception,
        io::incomplete_file_exception,
        model::index_out_of_bounds_exception));
        void write_metrics_to_buffer(const constants::metric_group group,
                                     ::uint8_t* buffer,
                                     const size_t buffer_size)const INTEROP_THROW_SPEC((
        io::invalid_argument,
        io::bad_format_exception,
        io::incomplete_file_exception));
        size_t calculate_buffer_size(const constants::metric_group group)const INTEROP_THROW_SPEC((
        io::invalid_argument, io::bad_format_exception));

        void validate() INTEROP_THROW_SPEC((invalid_run_info_exception, invalid_run_info_cycle_exception));

        template<class ReadFunc>
        void read_callback(ReadFunc &func)
        {
            metrics_callback(func);
            func(m_run_info);
            finalize_after_load();
        }

        template<class Func>
        void metrics_callback(Func &func)
        {
            m_metrics.apply(func);
        }
        template<class Func>
        void metrics_callback(Func &func)const
        {
            m_metrics.apply(func);
        }
        bool is_group_empty(const std::string& group_name) const;
        bool is_group_empty(const constants::metric_group group_id) const;

        void populate_id_map(tile_metric_map_t &map) const;

        void populate_id_map(cycle_metric_map_t &map) const;
        void sort();

         void clear();

    private:
        metric_list_t m_metrics;
        run::info m_run_info;
        run::parameters m_run_parameters;

    };


}}}}