center_spike_in_factors.hpp

Go to the documentation of this file.

#ifndef SCRAN_NORM_CENTER_SPIKE_IN_FACTORS_HPP
#define SCRAN_NORM_CENTER_SPIKE_IN_FACTORS_HPP
 
#include "center_size_factors.hpp"
#include "utils.hpp"
 
namespace scran_norm {
 
struct CenterSpikeInFactorsOptions {
    bool ignore_invalid = true;
 
    SizeFactorDiagnostics* endogenous_diagnostics = NULL;
 
    std::vector<SizeFactorDiagnostics*> spike_in_diagnostics; 
};
 
template<typename SizeFactor_>
void center_spike_in_factors(
    const std::size_t num_cells,
    SizeFactor_* const endogenous,
    const std::vector<SizeFactor_*>& spike_ins,
    const CenterSpikeInFactorsOptions& options
) {
    CenterSizeFactorsOptions cent_opt;
    cent_opt.ignore_invalid = options.ignore_invalid;
    cent_opt.diagnostics = options.endogenous_diagnostics;
    center_size_factors(num_cells, endogenous, cent_opt);
 
    const auto num_spikes = spike_ins.size();
    const bool use_diagnostics = (num_spikes == options.spike_in_diagnostics.size());
    for (I<decltype(num_spikes)> i = 0; i < num_spikes; ++i) {
        if (use_diagnostics) {
            cent_opt.diagnostics = options.spike_in_diagnostics[i];
        }
        center_size_factors(num_cells, spike_ins[i], cent_opt);
    }
}
 
struct CenterSpikeInFactorsBlockedOptions {
    bool ignore_invalid = true;
 
    SizeFactorDiagnostics* endogenous_diagnostics = NULL;
 
    std::vector<SizeFactorDiagnostics*> spike_in_diagnostics; 
 
    CenterBlockMode block_mode = CenterBlockMode::LOWEST;
};
 
template<typename SizeFactor_, typename Block_>
std::vector<SizeFactor_> center_spike_in_factors_blocked(
    const std::size_t num_cells,
    SizeFactor_* const endogenous,
    const std::vector<SizeFactor_*>& spike_ins,
    const Block_* const block,
    const std::size_t num_blocks,
    const CenterSpikeInFactorsBlockedOptions& options
) {
    CenterSizeFactorsBlockedOptions cent_opt;
    cent_opt.ignore_invalid = options.ignore_invalid;
    cent_opt.block_mode = options.block_mode;
    cent_opt.diagnostics = options.endogenous_diagnostics;
    cent_opt.report_final = true;
    auto output = center_size_factors_blocked(num_cells, endogenous, block, num_blocks, cent_opt);
 
    cent_opt.block_mode = CenterBlockMode::CUSTOM;
    cent_opt.custom_centers = std::move(output);
    const auto num_spikes = spike_ins.size();
    const bool use_diagnostics = (num_spikes == options.spike_in_diagnostics.size());
 
    for (I<decltype(num_spikes)> i = 0; i < num_spikes; ++i) {
        if (use_diagnostics) {
            cent_opt.diagnostics = options.spike_in_diagnostics[i];
        }
        center_size_factors_blocked(num_cells, spike_ins[i], block, num_blocks, cent_opt);
    }
 
    output.swap(*(cent_opt.custom_centers));
    return output;
}
 
}
 
#endif