PerCellRnaQcMetrics.hpp

Go to the documentation of this file.

#ifndef SCRAN_PER_CELL_RNA_QC_METRICS_HPP
#define SCRAN_PER_CELL_RNA_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 PerCellRnaQcMetrics {
public:
    struct Defaults {
        static constexpr int num_threads = 1;
    };
 
    PerCellRnaQcMetrics& 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;
 
        std::vector<Float*> subset_proportions;
    };
 
public:
    template<class Matrix, typename Subset = const uint8_t*, typename Float, typename Integer>
    void run(const Matrix* mat, const std::vector<Subset>& subsets, 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.subset_total = output.subset_proportions;
 
        // 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, subsets, tmp); 
 
        // Computing the proportions safely.
        for (auto s : output.subset_proportions) {
            if (s) {
                quality_control::safe_divide(NC, s, tmp.total);
            }
        }
 
        return;
    }
 
public:
    struct Results {
        Results() {}
 
        Results(size_t ncells, size_t nsubsets) : sums(ncells), detected(ncells), subset_proportions(nsubsets, std::vector<double>(ncells)) {}
        std::vector<double> sums;
 
        std::vector<int> detected;
 
        std::vector<std::vector<double> > subset_proportions;
 
    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();
 
            size_t nsubsets = y.subset_proportions.size();
            x.subset_proportions.resize(nsubsets);
            for (size_t s = 0; s < nsubsets; ++s) {
                x.subset_proportions[s] = y.subset_proportions[s].data();
            }
        }
   };
 
public:
    template<class Matrix, typename Subset = const uint8_t*>
    Results run(const Matrix* mat, const std::vector<Subset>& subsets) const {
        size_t nsubsets = subsets.size();
        Results output(mat->ncol(), nsubsets);
        auto buffers = output.buffers();
        run(mat, subsets, buffers);
        return output;
    }
};
 
}
 
#endif