hibf_statistics.hpp

Go to the documentation of this file.

// ---------------------------------------------------------------------------------------------------
// Copyright (c) 2006-2023, Knut Reinert & Freie Universität Berlin
// Copyright (c) 2016-2023, Knut Reinert & MPI für molekulare Genetik
// This file may be used, modified and/or redistributed under the terms of the 3-clause BSD-License
// shipped with this file and also available at: https://github.com/seqan/chopper/blob/main/LICENSE.md
// ---------------------------------------------------------------------------------------------------
 
#pragma once
 
#include <algorithm>
#include <cassert>
#include <cstddef>
#include <iosfwd>
#include <map>
#include <numeric>
#include <string>
#include <typeindex>
#include <vector>
 
#include <chopper/configuration.hpp>
 
#include <hibf/layout/layout.hpp>
#include <hibf/sketch/hyperloglog.hpp>
 
namespace std
{
 
template <>
struct hash<std::vector<size_t>>
{
    size_t operator()(std::vector<size_t> const & vec) const
    {
        return std::accumulate(vec.begin(),
                               vec.end(),
                               vec.size(),
                               [](std::size_t hash, size_t value)
                               {
                                   return hash ^= value + 0x9e3779b9ULL + (hash << 6) + (hash >> 2);
                               });
    }
};
 
} // namespace std
 
namespace chopper::layout
{
 
class hibf_statistics
{
public:
    hibf_statistics() = delete;                                    
    hibf_statistics(hibf_statistics const & b) = delete;           
    hibf_statistics & operator=(hibf_statistics const &) = delete; 
    hibf_statistics(hibf_statistics && b) = delete;                
    hibf_statistics & operator=(hibf_statistics &&) = delete;      
    ~hibf_statistics() = default;                                  
 
    hibf_statistics(configuration const & config_,
                    std::vector<seqan::hibf::sketch::hyperloglog> const & sketches_,
                    std::vector<size_t> const & kmer_counts);
 
    class bin;
 
    struct level
    {
        std::vector<bin> bins;
 
        double current_query_cost{0.0};
    };
 
    enum class bin_kind
    {
        split, 
        merged 
    };
 
    void finalize();
 
    static void print_header_to(std::ostream & stream, bool const verbose = true);
 
    void print_summary_to(size_t & t_max_64_memory, std::ostream & stream, bool const verbose = true);
 
    size_t total_hibf_size_in_byte();
 
    [[nodiscard]] static std::string byte_size_to_formatted_str(size_t const bytes);
 
    level top_level_ibf;
 
    double total_query_cost{0.0};
 
    double expected_HIBF_query_cost{0.0};
 
    seqan::hibf::layout::layout hibf_layout;
 
private:
    configuration const config{};
 
    std::vector<double> const fp_correction{};
 
    double const merged_fpr_correction_factor{};
 
    std::vector<seqan::hibf::sketch::hyperloglog> const & sketches;
 
    std::vector<size_t> const & counts;
 
    size_t const total_kmer_count{};
 
    struct level_summary;
 
    std::map<size_t, level_summary> summaries;
 
    std::string to_formatted_BF_size(size_t const number_of_kmers_to_be_stored) const;
 
    void collect_bins();
 
    void compute_cardinalities(level & curr_level);
 
    void compute_total_query_cost(level & curr_level);
 
    void gather_statistics(level const & curr_level, size_t const level_summary_index);
};
 
class hibf_statistics::bin
{
public:
    bin_kind kind;            
    size_t cardinality;       
    size_t num_contained_ubs; 
    size_t num_spanning_tbs;  
    std::vector<size_t> user_bin_indices; 
    size_t tb_index;                      // The (first) technical bin idx this bin is stored in.
    level child_level;                    
    size_t child_level_idx;               
 
    bin() = default;                        
    bin(bin const & b) = default;           
    bin & operator=(bin const &) = default; 
    bin(bin && b) = default;                
    bin & operator=(bin &&) = default;      
    ~bin() = default;                       
 
    bin(bin_kind const kind_, size_t const spanning_tbs, std::vector<size_t> const & user_bin_indices_) :
        kind{kind_},
        num_contained_ubs{user_bin_indices_.size()},
        num_spanning_tbs{spanning_tbs},
        user_bin_indices{user_bin_indices_}
    {
        assert((kind == bin_kind::split && num_contained_ubs == 1u)
               || (kind == bin_kind::merged && num_spanning_tbs == 1u));
    }
};
 
struct hibf_statistics::level_summary
{
    size_t num_ibfs{};
 
    std::vector<size_t> num_tbs{};
    std::vector<size_t> num_ubs{};
 
    std::vector<size_t> num_split_tbs{};
    std::vector<size_t> num_merged_tbs{};
 
    std::vector<size_t> num_split_ubs{};
    std::vector<size_t> num_merged_ubs{};
 
    std::vector<size_t> max_split_tb_span{};
    std::vector<size_t> split_tb_corr_kmers{};
    std::vector<size_t> split_tb_kmers{};
 
    std::vector<size_t> max_ubs_in_merged{};
 
    std::vector<size_t> ibf_mem_size{};
    std::vector<size_t> ibf_mem_size_no_corr{};
};
 
} // namespace chopper::layout