Infections Estimation

Functions for estimating infection trajectories. More...

Collaboration diagram for Infections Estimation:

Subgroups
	Estimates Smoothing
	Functions for smoothing estimates using Gaussian processes.
	Observation Model
	Functions for modeling the observation process.

Functions
vector	deconvolve_infections (vector shifted_cases, vector noise, int fixed, int prior)
vector	generate_infections (vector R, int uot, vector gt_rev_pmf, array[] real initial_infections, int pop, int ht, int obs_scale, real frac_obs, int initial_as_scale)
	Generate infections using a renewal equation approach.
real	update_infectiousness (vector infections, vector gt_rev_pmf, int seeding_time, int index)

Description

Functions for estimating infection trajectories.

This group contains functions for estimating and modeling infection dynamics, including implementation of the renewal equation and backcalculation approaches. Core infection estimation functions from infections.stan and related generated quantities functions.

Function Documentation

deconvolve_infections()

vector deconvolve_infections	(	vector	shifted_cases,
		vector	noise,
		int	fixed,
		int	prior )

#include </github/workspace/inst/stan/functions/infections.stan>

Backcalculate infections from cases

This function estimates infections by working backwards from observed cases, applying noise to account for uncertainty in the process.

Parameters

shifted_cases	Vector of shifted case counts
noise	Vector of noise values
fixed	Whether to use fixed (1) or variable (0) noise
prior	Prior type to use (0: noise only, 1: cases * noise, 2: random walk)

Returns

A vector of infection counts

Definition at line 125 of file infections.stan.

                                        {
  int t = num_elements(shifted_cases);
  vector[t] infections = rep_vector(1e-5, t);
  if (!fixed) {
    vector[t] exp_noise = exp(noise);
    if (prior == 1) {
      infections = infections + shifted_cases .* exp_noise;
    } else if (prior == 0) {
     infections = infections + exp_noise;
    } else if (prior == 2) {
      infections[1] = infections[1] + shifted_cases[1] * exp_noise[1];
      for (i in 2:t) {
        infections[i] = infections[i - 1] * exp_noise[i];
      }
    }
  } else {
    infections = infections + shifted_cases;
  }
  return(infections);
}

generate_infections()

vector generate_infections	(	vector	R,
		int	uot,
		vector	gt_rev_pmf,
		array[]real	initial_infections,
		int	pop,
		int	ht,
		int	obs_scale,
		real	frac_obs,
		int	initial_as_scale )

#include </github/workspace/inst/stan/functions/infections.stan>

Generate infections using a renewal equation approach.

This function implements the renewal equation to generate a time series of infections based on reproduction numbers and the generation time distribution. It can also account for population depletion if a population size is specified.

Parameters

R	Vector of reproduction numbers
uot	Unobserved time (seeding time)
gt_rev_pmf	Vector of reversed generation time PMF
initial_infections	Array of initial infection values
pop	Initial susceptible population (0 for unlimited)
ht	Horizon time
obs_scale	Whether to scale by fraction observed (1) or not (0)
frac_obs	Fraction of infections that are observed
initial_as_scale	Whether initial infections are a scaling factor (1) or not (0)

Returns

A vector of infection counts

Definition at line 63 of file infections.stan.

                                                                               {
  // time indices and storage
  int ot = num_elements(R);
  int nht = ot - ht;
  int t = ot + uot;
  real exp_adj_Rt;
  vector[t] infections = rep_vector(0, t);
  vector[ot] cum_infections;
  vector[ot] infectiousness;
  real growth = R_to_r(R[1], gt_rev_pmf, 1e-3);
  // Initialise infections using daily growth
  if (initial_as_scale) {
    infections[1] = exp(initial_infections[1] - growth * uot);
    if (obs_scale) {
      infections[1] = infections[1] / frac_obs;
    }
  } else {
    infections[1] = exp(initial_infections[1]);
  }
  if (uot > 1) {
    real exp_growth = exp(growth);
    for (s in 2:uot) {
      infections[s] = infections[s - 1] * exp_growth;
    }
  }
  // calculate cumulative infections
  if (pop) {
    cum_infections[1] = sum(infections[1:uot]);
  }
  // iteratively update infections
  for (s in 1:ot) {
    infectiousness[s] = update_infectiousness(infections, gt_rev_pmf, uot, s);
    if (pop && s > nht) {
      exp_adj_Rt = exp(-R[s] * infectiousness[s] / (pop - cum_infections[nht]));
      exp_adj_Rt = exp_adj_Rt > 1 ? 1 : exp_adj_Rt;
      infections[s + uot] = (pop - cum_infections[s]) * (1 - exp_adj_Rt);
    } else {
      infections[s + uot] = R[s] * infectiousness[s];
    }
    if (pop && s < ot) {
      cum_infections[s + 1] = cum_infections[s] + infections[s + uot];
    }
  }
  return(infections);
}

References R_to_r(), and update_infectiousness().

Here is the call graph for this function:

update_infectiousness()

real update_infectiousness	(	vector	infections,
		vector	gt_rev_pmf,
		int	seeding_time,
		int	index )

#include </github/workspace/inst/stan/functions/infections.stan>

Infection Modeling Functions

This group of functions handles the generation, calculation, and backcalculation of infection time series in the model. These functions implement the core epidemiological dynamics, including the renewal equation approach. Calculate infectiousness for a single time point

This function computes the weighted sum of past infections with the generation time distribution to determine the current infectiousness.

Parameters

infections	Vector of infection counts
gt_rev_pmf	Vector of reversed generation time PMF
seeding_time	Number of time steps used for seeding
index	Current time index (relative to seeding_time)

Returns

The infectiousness at the specified time point

Definition at line 25 of file infections.stan.

                                                       {
  int gt_length = num_elements(gt_rev_pmf);
  // work out where to start the convolution of past infections with the
  // generation time distribution: (current_time - maximal generation time) if
  // that is >= 1, otherwise 1
  int inf_start = max(1, (index + seeding_time - gt_length + 1));
  // work out where to end the convolution: current_time
  int inf_end = (index + seeding_time);
  // number of indices of the generation time to sum over
  // (inf_end - inf_start + 1)
  int pmf_accessed = min(gt_length, index + seeding_time);
  // calculate the elements of the convolution
  real new_inf = dot_product(
    infections[inf_start:inf_end], tail(gt_rev_pmf, pmf_accessed)
  );
  return(new_inf);
}

Referenced by calculate_Rt(), and generate_infections().

Here is the caller graph for this function: