PerCellCrisprQcMetrics.hpp

Go to the documentation of this file.

#ifndef SCRAN_PER_CELL_CRISPR_QC_METRICS_HPP
#define SCRAN_PER_CELL_CRISPR_QC_METRICS_HPP
 
#include "../utils/macros.hpp"
 
#include <vector>
#include <limits>
 
#include "tatami/base/Matrix.hpp"
#include "PerCellQcMetrics.hpp"
#include "utils.hpp"
 
namespace scran {
 
class PerCellCrisprQcMetrics {
public:
    struct Defaults {
        static constexpr int num_threads = 1;
    };
 
    PerCellCrisprQcMetrics& set_num_threads(int n = Defaults::num_threads) {
        num_threads = n;
        return *this;
    }
 
private:
    int num_threads = Defaults::num_threads;
 
 
public:
    template<typename Float = double, typename Integer = int>
    struct Buffers {
        Float* sums = NULL;
 
        Integer* detected = NULL;
 
        Float* max_proportion = NULL;
 
        Integer* max_index = NULL;
    };
 
public:
    template<class Matrix, typename Float, typename Integer>
    void run(const Matrix* mat, Buffers<Float, Integer>& output) const {
        size_t NC = mat->ncol();
 
        // Calling the general-purpose PerCellQcMetrics function.
        PerCellQcMetrics general;
        general.set_num_threads(num_threads);
 
        PerCellQcMetrics::Buffers<Float, Integer> tmp;
        tmp.total = output.sums;
        tmp.detected = output.detected;
        tmp.max_count = output.max_proportion;
        tmp.max_index = output.max_index;
 
        // Make sure that sums are computed one way or another.
        std::vector<Float> placeholder;
        if (!tmp.total && tmp.subset_total.size()) {
            placeholder.resize(NC);
            tmp.total = placeholder.data();            
        }
 
        general.run(mat, {}, tmp); 
 
        // Computing the proportion safely.
        quality_control::safe_divide(NC, output.max_proportion, tmp.total);
        return;
    }
 
public:
    struct Results {
        Results() {}
 
        Results(size_t ncells) : sums(ncells), detected(ncells), max_proportion(ncells), max_index(ncells) {}
        std::vector<double> sums;
 
        std::vector<int> detected;
 
        std::vector<double> max_proportion;
 
        std::vector<int> max_index;
    public:
        Buffers<> buffers() {
            Buffers<> output;
            populate_buffers(output, *this);
            return output;
        }
 
        Buffers<const double, const int> buffers() const {
            Buffers<const double, const int> output;
            populate_buffers(output, *this);
            return output;
        }
 
    private:
        template<class SomeBuffer, class Results>
        static void populate_buffers(SomeBuffer& x, Results& y) {
            x.sums = y.sums.data();
            x.detected = y.detected.data();
            x.max_proportion = y.max_proportion.data();
            x.max_index = y.max_index.data();
            return;
        }
    };
 
public:
    template<class Matrix>
    Results run(const Matrix* mat) const {
        Results output(mat->ncol());
        auto buffers = output.buffers();
        run(mat, buffers);
        return output;
    }
};
 
}
 
#endif