Struct MultilevelParams 

pub struct MultilevelParams {
    pub knn_pb_samples: usize,
    pub num_levels: usize,
    pub sort_dim: usize,
    pub num_opt_iter: usize,
    pub refine: RefineParams,
    pub output_calibration: CalibrateTarget,
    pub anchor_batches: Option<Vec<Box<str>>>,
    pub bulk_batches: Option<Vec<Box<str>>>,
    pub observe_panels: bool,
    pub keep_finest_stats: bool,
    pub pb_tree: Option<PbTreeParams>,
    pub strata: Option<Vec<usize>>,
}

Configuration for multi-level collapsing.

Fields

knn_pb_samples: usize

num_levels: usize

sort_dim: usize

num_opt_iter: usize

refine: RefineParams

BBKNN + Poisson DC-SBM refinement on top of the hash partition. Zero sweeps (num_gibbs == 0 && num_greedy == 0) keep the hash partition as is.

output_calibration: CalibrateTarget

Which posterior planes the output CollapsedOut should carry. MeanOnly skips the sd / log_mean / log_sd allocations entirely — a big memory win for consumers that only read posterior_mean() (e.g. bge). Use All when the caller exports log-scale dictionaries.

anchor_batches: Option<Vec<Box<str>>>

Batch labels whose columns are ALREADY batch-corrected pseudobulks — a prior run’s carried reference. Some switches the cross-batch counterfactual from pooled mutual adjustment to greedy batch correction: every pb-sample’s counterfactual is drawn from the anchor batches only, so new batches are corrected toward the anchor frame while an anchor pb-sample self-matches (its δ settles at the prior ≈ 1 and is never re-adjusted). Anchored columns also skip pb-sample re-merging — each stays its own matching unit, at the resolution the prior run already paid for. None = pooled behavior, bit-identical to before this field existed.

bulk_batches: Option<Vec<Box<str>>>

Batch labels whose columns are ALREADY summaries but are not a reference frame — bulk RNA-seq samples. Like anchors, each column bypasses the partition entirely (its own singleton pb-sample and its own singleton finest group — a bulk sample is never re-averaged), but unlike anchors it takes no part in cross-batch matching in EITHER direction: a bulk sample is a mixture over cell states, so matching it to a single-state pb-sample (as source or receiver) would let δ absorb composition rather than platform. Bulk therefore contributes observed sums only — the dictionary sees it, δ/γ never do, and δ for a bulk batch stays at its prior structurally. None = no bulk batches.

observe_panels: bool

Distinguish “unmeasured” from “measured as zero” when backends carry different feature panels (RowAlignment::Union): per-gene denominators count only the mass whose source measures the gene, and δ falls to its prior where a batch has no panel coverage. A no-op (bitwise) when every backend covers every row. Off for callers whose union is intentional structural disjointness — multiome stacks modalities on one axis, and re-weighting that is its own decision, not a side effect.

keep_finest_stats: bool

Retain the finest level’s Gamma sufficient statistics even under MeanOnly calibration. --emit-pb-reference serializes evidence_mean — data sum over data denominator — which reads a_stat/b_stat; MeanOnly normally drops them per block to bound memory. Costs two extra [D, S] planes per finest-level parameter.

pb_tree: Option<PbTreeParams>

Grow the finest partition as a tree from the marginal top nodes: reassign cells by likelihood, then bisect on residual components to one leaf target per level. None keeps the marginal hash, bit-identical to before this field existed.

strata: Option<Vec<usize>>

Per-cell CNV stratum (0 = mixable residual). Crossed into finest codes so no pb-group mixes strata; BBKNN matches only within stratum; unmatched clone mass is excluded from the δ update so private CN stays in mu_adjusted. None is bit-identical to the pre-strata path.

Implementations

impl MultilevelParams

pub fn new(proj_dim: usize) -> Self

pub fn with_strata(&self, strata: Vec<usize>) -> Self

Copy with Self::strata set (used by the thin with_strata wrapper).

Trait Implementations

impl Clone for MultilevelParams

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.