def compute_acquisition_rates_time_invariant_part(n_types, states, k_matrix): """ Compute the time invariant part of the acquisition rate :param n_types: number of types :param states: a list of infection states :param k_matrix: np.array of the pairwise interaction parameters in acquisition :return: output: list of length n_types. Each item in the list is a n_state**2 np.array. [j,k]-element of i-th matrix: acquisition interaction parameter from state j to state k. """ n_states = len(states) output = [] for t in range(1, n_types + 1): output_i = np.zeros((n_states, n_states)) for end_state in states: if t not in end_state.types: continue start_state = getState([x for x in end_state.types if x != t], states) d = 1 if len(start_state.types) > 0: d = np.prod([ k_matrix[start_t - 1, t - 1] for start_t in start_state.types ]) output_i[start_state.state_id, end_state.state_id] = d output.append(output_i) return output
def compute_clearance_rates_group(n_types, states, h_matrix, mu, partition): """ Compute the clearance rate :param n_types: number of types :param states: a list of state objects :param h_matrix: np.array of the pairwise interaction parameters in clearance :param mu: the baseline type-specific clearance rate :param partition: partition of groups (clusters) of types :return: output: a n_state**2 np.array. The [j,k]-element the clearance rate from state j to state k including the interaction parameters. """ num_states = len(states) output = np.zeros((num_states, num_states)) for t in range(1, n_types + 1): type_cluster = np.where([t in part for part in partition])[0][0] + 1 for startState in states: if t not in startState.types: continue end_state = getState([x for x in startState.types if x != t], states) d = mu[t - 1] if len(end_state.types) > 0: d *= np.prod([ h_matrix[end_clus - 1, type_cluster - 1] for end_clus in end_state.clusters ]) output[startState.state_id, end_state.state_id] = d return output
def compute_clearance_rates(n_types, states, h_matrix, mu): """ Compute the clearance rate :param n_types: number of types :param states: a list of state objects :param h_matrix: np.array of the pairwise interaction parameters in clearance :param mu: the baseline type-specific clearance rate :return: output: a n_state**2 np.array. The [j,k]-element the clearance rate from state j to state k including the interaction parameters. """ num_states = len(states) output = np.zeros((num_states, num_states)) for t in range(1, n_types + 1): for start_state in states: if t not in start_state.types: continue end_state = getState([x for x in start_state.types if x != t], states) d = mu[t - 1] if len(end_state.types) > 0: d = np.prod( [h_matrix[end_t - 1, t - 1] for end_t in end_state.types]) * mu[t - 1] output[start_state.state_id, end_state.state_id] = d return output
def compute_acquisition_rates_time_invariant_part_group( n_types, states, k_matrix, partition): """ Compute the time invariant part of the acquisition rate of the all or nothing model :param n_types: number of types :param states: a list of state objects :param k_matrix: np.array of the pairwise interaction parameters in acquisition between clusters :param partition: list of lists of types belonging to the same cluster :return: output: list of length n_types. Each item in the list is a n_state**2 np.array. [j,k]-element of i-th matrix: acquisition interaction parameter from state j to state k. """ n_states = len(states) output = [] for t in range(1, n_types + 1): type_cluster = np.where([t in part for part in partition])[0][0] + 1 output_i = np.zeros((n_states, n_states)) for end_state in states: if t not in end_state.types: continue # if type is in endState state_state = getState([x for x in end_state.types if x != t], states) d = 1 if len(state_state.types) > 0: d = np.prod([ k_matrix[startCluster - 1, type_cluster - 1] for startCluster in state_state.clusters ]) output_i[state_state.state_id, end_state.state_id] = d output.append(output_i) return output
def compute_hazard_based_predictor(steady_state, trans_matrix, states, vt, nvt_): """ computing type-specific hazard-based predictors :param steady_state: a list of prevalence of infection states :param trans_matrix: transition matrix (hazards) :param states: a list of state objects :param vt: a list of vaccine types :param nvt_: a integer giving the non-vaccine type at interest :return: type-specific hazard-based- predictor for type replacement by the non-vaccine type at interest """ entries = np.zeros((2, 4)) for state in states: if len(set(state.types) & set(vt)) > 0 and len(set(state.types) & set([nvt_])) == 0: state_nvt = getState(state.types + [nvt_], states) # hazards of acquiring the non-vaccine type at interest from states: # - containing at least a vaccine type # - not containing the non-vaccine type at interest entries[0, 0] += steady_state[state.state_id] * trans_matrix[state.state_id, state_nvt.state_id] entries[1, 0] += steady_state[state.state_id] # hazards of clearing the non-vaccine type at interest from states: # - containing at least a vaccine type # - containing the non-vaccine type at interest entries[0, 1] += steady_state[state_nvt.state_id] * trans_matrix[state_nvt.state_id, state.state_id] entries[1, 1] += steady_state[state_nvt.state_id] elif len(set(state.types) & set(vt)) == 0 and len(set(state.types) & set([nvt_])) == 0: state_nvt = getState(state.types + [nvt_], states) # hazards of acquiring the non-vaccine type at interest from states: # - not containing any vaccine type # - not containing the non-vaccine type at interest entries[0, 2] += steady_state[state.state_id] * trans_matrix[state.state_id, state_nvt.state_id] entries[1, 2] += steady_state[state.state_id] # hazards of clearing the non-vaccine type at interest from states: # - not containing any vaccine type # - containing the non-vaccine type at interest entries[0, 3] += steady_state[state_nvt.state_id] * trans_matrix[state_nvt.state_id, state.state_id] entries[1, 3] += steady_state[state_nvt.state_id] # compute all weighted averages combined_entries = entries[0]/entries[1] predictor = (combined_entries[0]/combined_entries[2]) / (combined_entries[1]/combined_entries[3]) return predictor
def simulate_post_vaccination(n, n_vt, m): # """ # :param n: number of types # :param n_vt: number of vaccine types # :param m: interaction structure # """ # param parameter_sets: np.array of parameter sets (transmissibilities and interaction parameters) # part_sets: np.array of partition (clusters/groups of types) sets # sign_sets: np.array of sign parameters # num_simulations: number parameter sets to simulate from # states: list of infection states # mu: the baseline per capita type-specific clearance rate # marginal operator: matrix for left-multiplying with the state variable to get the marginal prevalence # steady_states: np.array for saving the simulated steady state prevalence per infection state parameter_sets = read_parameters(n) num_simulations = parameter_sets.shape[0] part_sets = np.zeros((num_simulations, n)) sign_sets = np.zeros((num_simulations, 2 * n**2)) if m[1] == 'groupwise': part_sets = read_partitions(n) if m[3] != 0: sign_sets = read_sign(n) n_nvt = n - n_vt full_states = computeStates(n) reduced_states = computeStates(n_nvt) n_full_states = len(full_states) n_reduced_states = len(reduced_states) # matrix to translate a state in the reduced system to the full system state_translater = np.zeros((n_full_states, n_reduced_states)) for i in range(n_reduced_states): reduced_state = reduced_states[i] state_id = getState(list(np.array(reduced_state.types) + n_vt), full_states).state_id state_translater[state_id, i] = 1 mu = np.ones(n - n_vt) marginal_operator = np.array( [[1 if (t + 1) in s.types else 0 for s in reduced_states] for t in range(n - n_vt)]) steady_states = np.ones((num_simulations, 2**n)) # Simulate pre-vaccination steady states for each parameter set previous_run_times = [] for j in range(num_simulations): start_time = time() # Get the type-specific transmissibilities beta = parameter_sets[j, n_vt:n] # Derive the required parameters k_matrix, h_matrix, states, partition = derive_param( parameter_sets[j], sign_sets[j], part_sets[j], n, n_vt, m) # Simulate the equilibrium corresponding to the j-th parameter set ss = get_steady_state(n - n_vt, states, k_matrix, h_matrix, beta, mu, marginal_operator, False, m[1], partition) steady_states[j, :] = state_translater.dot(ss) end_time = time() # Save the time used to simulate the first 100 parameter sets and estimate the remaining simulation time if j < 100: # save the time used to simulate the j-th parameter set previous_run_times.append(end_time - start_time) if j % int(num_simulations / 10) == 0: # print each time 10% of all parameter sets are simulated print(j, end_time - start_time) if j == 100: # print the estimated time until all parameter sets are simulated print([int(x) for x in strftime("%Y,%m,%d,%H,%M,%S").split(',')][3:5]) print( sum(previous_run_times) / 100 * num_simulations / 3600, ' hours to go.') # write the simulated steady states in a csv file filename = '_'.join(m) + '_{}types_{}vts_VE1_prevalence.csv'.format( n, n_vt) df = pd.DataFrame(steady_states) df.to_csv(filename)