From e5ce243a222b24a094a40391c79dc3ffcaf3f761 Mon Sep 17 00:00:00 2001 From: Aalhad-Bhatt Date: Wed, 3 Sep 2025 15:47:55 -0400 Subject: [PATCH 1/4] Selective Sweep based on reading from a file with rudimentary ability to run on multiple demes Code to run a selective sweep based on reading the events from a binary file in a specified format. The C side also implements nearest neighbour migration with multiple demes. This does not interface with the Python version yet. --- lib/msprime.c | 614 ++++++++++++++++++++++++++++++++++++++- lib/msprime.h | 13 +- lib/tests/test_sweeps.c | 66 ++++- msprime/__init__.py | 1 + msprime/_msprimemodule.c | 76 ++++- msprime/ancestry.py | 58 +++- 6 files changed, 814 insertions(+), 14 deletions(-) diff --git a/lib/msprime.c b/lib/msprime.c index fc84f3cc3..b5d6c000b 100644 --- a/lib/msprime.c +++ b/lib/msprime.c @@ -4225,6 +4225,26 @@ msp_migration_event(msp_t *self, population_id_t source_pop, population_id_t des return ret; } +/* Migration event in an arbitrary label + */ +static int MSP_WARN_UNUSED +msp_migration_event_in_background( + msp_t *self, population_id_t source_pop, population_id_t dest_pop, label_id_t label) +{ + int ret = 0; + uint32_t j; + avl_node_t *node; + avl_tree_t *source = &self->populations[source_pop].ancestors[label]; + size_t index = ((size_t) source_pop) * self->num_populations + (size_t) dest_pop; + + self->num_migration_events[index]++; + j = (uint32_t) gsl_rng_uniform_int(self->rng, avl_count(source)); + node = avl_at(source, j); + tsk_bug_assert(node != NULL); + ret = msp_move_individual(self, node, source, dest_pop, label); + return ret; +} + static int MSP_WARN_UNUSED msp_reset_memory_state(msp_t *self) { @@ -5803,6 +5823,44 @@ msp_sweep_initialise(msp_t *self, double switch_proba) return ret; } +/* Set up the intial populations for a sweep by moving individuals from + * label 0 to label 1 with the specified probability for multiple demes. + Should be merged with ms_sweep_initialise at some point. + */ +static int +msp_sweep_reverse_initialise(msp_t *self, double *switch_proba) +{ + int ret = 0; + uint32_t j; + avl_node_t *node, *next; + avl_tree_t *pop; + + /* We only support two labels for now */ + if (self->num_labels != 2) { + ret = MSP_ERR_UNSUPPORTED_OPERATION; + goto out; + } + + /* Move ancestors to new labels. */ + for (j = 0; j < self->num_populations; j++) { + tsk_bug_assert(avl_count(&self->populations[j].ancestors[1]) == 0); + pop = &self->populations[j].ancestors[0]; + node = pop->head; + while (node != NULL) { + next = node->next; + if (gsl_rng_uniform(self->rng) < switch_proba[j]) { + ret = msp_move_individual(self, node, pop, (population_id_t) j, 1); + if (ret != 0) { + goto out; + } + } + node = next; + } + } +out: + return ret; +} + /* Finalise the sweep by moving all lineages back to label 0. */ static int @@ -5882,6 +5940,230 @@ msp_sweep_recombination_event( return ret; } +/* Recombination event during a sweep within a specified background with multiple demes. +Should be merged with msp_sweep_recombination_event at some point. + */ +static int +msp_sweep_reverse_recombination_event(msp_t *self, label_id_t label, double sweep_locus, + double *mutant_population_frequency) +{ + int ret = 0; + lineage_t *left_lin, *right_lin; + double r; + + ret = msp_recombination_event(self, label, &left_lin, &right_lin); + if (ret != 0) { + goto out; + } + + tsk_bug_assert(left_lin != NULL); + tsk_bug_assert(right_lin != NULL); + + /* NOTE: we can look at rhs->left when we compare to the sweep site. */ + r = gsl_rng_uniform(self->rng); + if (label == 0) { + if (sweep_locus < right_lin->head->left) { + if (r < mutant_population_frequency[right_lin->population]) { + ret = msp_change_label(self, right_lin, 1); + if (ret != 0) { + goto out; + } + } + } else { + if (r < mutant_population_frequency[left_lin->population]) { + ret = msp_change_label(self, left_lin, 1); + if (ret != 0) { + goto out; + } + } + } + } + if (label == 1) { + if (sweep_locus < right_lin->head->left) { + if (r < 1.0 - mutant_population_frequency[right_lin->population]) { + ret = msp_change_label(self, right_lin, 0); + if (ret != 0) { + goto out; + } + } + } else { + if (r < 1.0 - mutant_population_frequency[left_lin->population]) { + ret = msp_change_label(self, left_lin, 0); + if (ret != 0) { + goto out; + } + } + } + } +out: + return ret; +} + +/* Reads the trajectory of a sweep when fed a file. +The file contains (in order) +1. Number of steps +2. Number of demes +3. Pop size +4. Migration rate +5. State after finishing the backward sim +6. state at the start of the backward sim +7. Time, type, and start and end locations for each event +No. 7 is currently read backward in time as well + */ +static int +genic_selection_read_trajectory(const char *filename, size_t *num_steps_ret, + int *num_demes_ret, int *tot_pop_ret, double *migration_rate_ret, + int **final_mut_pop_ret, int **mut_pop_ret, double **allele_frequency_mut_ret, + double **t_of_forward_ev_ret, int **ev_type_ret, int **start_deme_ret, + int **end_deme_ret) +{ + int ret = 0; + size_t num_steps; + int num_demes; + double *allele_frequency_mut = NULL; + double *t_of_forward_ev = NULL; + size_t j = 0; + int i = 0; + double migration_rate = 0.0; + int tot_pop = 0; + int *mut_pop = NULL, *final_mut_pop = NULL; + int *ev_type = NULL, *start_deme = NULL, *end_deme = NULL; + FILE *file = fopen(filename, "r"); + + fread(&num_steps, sizeof(size_t), 1, file); + fread(&num_demes, sizeof(int), 1, file); + fread(&tot_pop, sizeof(int), 1, file); + fread(&migration_rate, sizeof(double), 1, file); + + mut_pop = (int *) malloc(sizeof(*mut_pop) * (size_t) num_demes); + allele_frequency_mut + = (double *) malloc(sizeof(*allele_frequency_mut) * (size_t) num_demes); + final_mut_pop = (int *) malloc(sizeof(*final_mut_pop) * (size_t) num_demes); + + for (i = 0; i < num_demes; i++) { + fread(&final_mut_pop[i], sizeof(int), 1, file); + } + + for (i = 0; i < num_demes; i++) { + fread(&mut_pop[i], sizeof(int), 1, file); + allele_frequency_mut[i] = 1.0 * mut_pop[i] / tot_pop; + } + + t_of_forward_ev = (double *) malloc(sizeof(*t_of_forward_ev) * num_steps); + ev_type = (int *) malloc(sizeof(*ev_type) * num_steps); + start_deme = (int *) malloc(sizeof(*start_deme) * num_steps); + end_deme = (int *) malloc(sizeof(*end_deme) * num_steps); + for (j = 1; j <= num_steps; j++) { + fread(&t_of_forward_ev[num_steps - j], sizeof(double), 1, file); + fread(&ev_type[num_steps - j], sizeof(int), 1, file); + fread(&start_deme[num_steps - j], sizeof(int), 1, file); + fread(&end_deme[num_steps - j], sizeof(int), 1, file); + } + + fclose(file); + *num_demes_ret = num_demes; + *num_steps_ret = num_steps; + *tot_pop_ret = tot_pop; + *migration_rate_ret = migration_rate; + *final_mut_pop_ret = final_mut_pop; + *mut_pop_ret = mut_pop; + *allele_frequency_mut_ret = allele_frequency_mut; + *t_of_forward_ev_ret = t_of_forward_ev; + *ev_type_ret = ev_type; + *start_deme_ret = start_deme; + *end_deme_ret = end_deme; + return ret; +} + +static int +sweep_forward_event(msp_t *self, double t_of_next_forward_ev, int *ev_type, + size_t *curr_step, int *start_deme, int *end_deme, double **ancestral_bg_num_ind, + int **mut_pop, double **allele_frequency_mut, int tot_pop, int num_demes) +{ + int ret = 0; + int curr_ev_type = 0, start_deme_index = 0; + double p_forward_ev, tmp_rand; + + self->time = t_of_next_forward_ev; + curr_ev_type = ev_type[*curr_step]; + start_deme_index = start_deme[*curr_step]; + + if (start_deme_index == end_deme[*curr_step]) { + if (curr_ev_type == 0) { // mutant replaced with wildtype, mutant coalascence + p_forward_ev + = (float) ancestral_bg_num_ind[start_deme_index][1] + * (ancestral_bg_num_ind[start_deme_index][1] - 1.0) + / ((*mut_pop[start_deme_index]) * (*mut_pop[start_deme_index] - 1.0)); + tmp_rand = gsl_rng_uniform(self->rng); + if (tmp_rand <= p_forward_ev) { + ret = self->common_ancestor_event(self, start_deme_index, 1); + } + (*mut_pop[start_deme_index])--; + *allele_frequency_mut[start_deme_index] + = 1.0 * *mut_pop[start_deme_index] / tot_pop; + (*curr_step)++; + + } else if (curr_ev_type == 1) { // wildtype replaced with mutant, wt coalescence + p_forward_ev = (float) ancestral_bg_num_ind[start_deme_index][0] + * (ancestral_bg_num_ind[start_deme_index][0] - 1.0) + / ((tot_pop - *mut_pop[start_deme_index]) + * ((tot_pop - *mut_pop[start_deme_index]) - 1.0)); + tmp_rand = gsl_rng_uniform(self->rng); + if (tmp_rand <= p_forward_ev) { + ret = self->common_ancestor_event(self, start_deme_index, 0); + } + (*mut_pop[start_deme_index])++; + *allele_frequency_mut[start_deme_index] + = 1.0 * *mut_pop[start_deme_index] / tot_pop; + (*curr_step)++; + } + + } else if (num_demes > 1) { + + if (curr_ev_type == 2) { // wildtype replaced by mutant, mutant migration + // + coalascence + p_forward_ev = 1.0 * ancestral_bg_num_ind[start_deme_index][1] + / *mut_pop[start_deme_index]; + tmp_rand = gsl_rng_uniform(self->rng); + if (tmp_rand <= p_forward_ev) { + ret = msp_migration_event_in_background( + self, start_deme_index, end_deme[*curr_step], 1); + p_forward_ev = 1.0 * ancestral_bg_num_ind[end_deme[*curr_step]][1] + / *mut_pop[end_deme[*curr_step]]; + tmp_rand = gsl_rng_uniform(self->rng); + if (tmp_rand <= p_forward_ev) { + ret = self->common_ancestor_event(self, end_deme[*curr_step], 1); + } + } + (*mut_pop[start_deme[*curr_step]])--; + *allele_frequency_mut[start_deme[*curr_step]] + = 1.0 * *mut_pop[start_deme[*curr_step]] / tot_pop; + (*curr_step)++; + + } else if (curr_ev_type == 3) { // mutant replaced by wildtype, wildtype + // migration + coalascence + p_forward_ev = 1.0 * ancestral_bg_num_ind[start_deme_index][0] + / (tot_pop - *mut_pop[start_deme_index]); + tmp_rand = gsl_rng_uniform(self->rng); + if (tmp_rand <= p_forward_ev) { + ret = msp_migration_event_in_background( + self, start_deme_index, end_deme[*curr_step], 0); + p_forward_ev = 1.0 * ancestral_bg_num_ind[end_deme[*curr_step]][0] + / (tot_pop - *mut_pop[end_deme[*curr_step]]); + tmp_rand = gsl_rng_uniform(self->rng); + if (tmp_rand <= p_forward_ev) { + ret = self->common_ancestor_event(self, end_deme[*curr_step], 0); + } + } + (*mut_pop[start_deme[*curr_step]])++; + *allele_frequency_mut[start_deme[*curr_step]] + = 1.0 * *mut_pop[start_deme[*curr_step]] / tot_pop; + (*curr_step)++; + } + } + return ret; +} + static int msp_run_sweep(msp_t *self) { @@ -6064,6 +6346,304 @@ msp_run_sweep(msp_t *self) return ret; } +/* Runs a backward in time sweep after reading the forward trajectory from a file + */ +static int +msp_run_sweep_reverse(msp_t *self) +{ + int ret = 0; + simulation_model_t *model = &self->model; + size_t curr_step = 0; + size_t num_steps = 0; + double *allele_frequency_mut = NULL, *t_of_forward_ev = NULL; + int *ev_type = NULL, *start_deme = NULL, *end_deme = NULL; + double sweep_locus = model->params.sweep_reverse.position; + const char *filename = model->params.sweep_reverse.filename; + size_t j = 0; + int i = 0; + double recomb_mass = 0.0; + label_id_t label; + double rec_rates[] = { 0.0, 0.0 }; + double **ancestral_bg_num_ind = NULL; + double *p_coal_wild = NULL, *p_coal_mut = NULL, *p_mig_wild_right = NULL, + *p_mig_mut_right = NULL, *p_mig_wild_left = NULL, *p_mig_mut_left = NULL; + double p_rec_wild = 0.0, p_rec_mut = 0.0; + double tmp_rand = 0.0, p_any_ev = 0.0, p_cum_ev = 0.0, t_of_next_forward_ev = 0.0; + double t_start = 0.0, t_end = 0.0, t_of_next_ev = 0.0, t_current = 0.0; + int num_demes = 0; + double migration_rate = 0.0; + int tot_pop = 0; + int *mut_pop = NULL, *final_mut_pop = NULL; + bool no_event_yet = true; + + if (rate_map_get_total_mass(&self->gc_map) != 0.0) { // arrow?+ + /* Could be, we just haven't implemented it */ + ret = MSP_ERR_SWEEPS_GC_NOT_SUPPORTED; + goto out; + } + + ret = genic_selection_read_trajectory(filename, &num_steps, &num_demes, &tot_pop, + &migration_rate, &final_mut_pop, &mut_pop, &allele_frequency_mut, + &t_of_forward_ev, &ev_type, &start_deme, &end_deme); + + tsk_bug_assert(num_demes > 0); + tsk_bug_assert(tot_pop > 0); + + p_coal_wild = (double *) malloc(sizeof(double) * (size_t) num_demes); + p_coal_mut = (double *) malloc(sizeof(double) * (size_t) num_demes); + if (num_demes > 1) { + p_mig_wild_right = (double *) malloc(sizeof(double) * (size_t)(num_demes - 1)); + p_mig_mut_right = (double *) malloc(sizeof(double) * (size_t)(num_demes - 1)); + p_mig_wild_left = (double *) malloc(sizeof(double) * (size_t)(num_demes - 1)); + p_mig_mut_left = (double *) malloc(sizeof(double) * (size_t)(num_demes - 1)); + } + + ancestral_bg_num_ind = (double **) malloc(sizeof(double *) * (size_t) num_demes); + for (i = 0; i < num_demes; i++) { + ancestral_bg_num_ind[i] = (double *) malloc(sizeof(double) * 2); + } + + curr_step = 0; + + ret = msp_sweep_reverse_initialise(self, allele_frequency_mut); + if (ret != 0) { + goto out; + } + + /* Sets the initial time of the sweep. Adds a small increment after the final event. + * Also makes the times of the forward step consistent with msprime + */ + t_start = self->time; + t_current = t_start; + t_of_next_ev = 0.0; + t_end = t_of_forward_ev[0]; + for (j = 0; j < num_steps; j++) { /*move this step to file io*/ + t_of_forward_ev[j] = t_start + t_end - t_of_forward_ev[j] + + 1e-5; /*Add a small jitter to avoid time travel*/ + } + + while (msp_get_num_ancestors(self) > 0 && curr_step < num_steps + && self->time < (t_start + t_end)) { + /* Set num ancestral individuals & rec_rates */ + for (j = 0; j < self->num_labels; j++) { + label = (label_id_t) j; + recomb_mass = self->recomb_mass_index == NULL + ? 0 + : fenwick_get_total(&self->recomb_mass_index[label]); + for (i = 0; i < num_demes; i++) { + ancestral_bg_num_ind[i][j] + = avl_count(&self->populations[i].ancestors[label]); + /* We can get small negative rates by numerical jitter which causes + * problems in later calculations and leads to assertion trips. + * See https://github.com/tskit-dev/msprime/issues/1966 + */ + } + rec_rates[j] = TSK_MAX(0, (recomb_mass)); + } + + /* Set coal and mig rates*/ + + for (i = 0; i < num_demes; i++) { + if (ancestral_bg_num_ind[i][0] > 1) { + tsk_bug_assert(mut_pop[i] != tot_pop); + p_coal_wild[i] + = ((ancestral_bg_num_ind[i][0] * (ancestral_bg_num_ind[i][0] - 1.0)) + * 0.5) + / (tot_pop - mut_pop[i]); + } else { + p_coal_wild[i] = 0; + } + if (ancestral_bg_num_ind[i][1] > 1) { + tsk_bug_assert(mut_pop[i] != 0); + p_coal_mut[i] + = ((ancestral_bg_num_ind[i][1] * (ancestral_bg_num_ind[i][1] - 1.0)) + * 0.5) + / mut_pop[i]; + } else { + p_coal_mut[i] = 0; + } + + if (num_demes > 1) { + if (i > 0) { + p_mig_wild_left[i - 1] = migration_rate * ancestral_bg_num_ind[i][0] + * (1.0 - mut_pop[i - 1] / tot_pop); + p_mig_mut_left[i - 1] = migration_rate * ancestral_bg_num_ind[i][1] + * mut_pop[i - 1] / tot_pop; + } + if (i < num_demes - 1) { + p_mig_wild_right[i] = migration_rate * ancestral_bg_num_ind[i][0] + * (1.0 - mut_pop[i + 1] / tot_pop); + p_mig_mut_right[i] = migration_rate * ancestral_bg_num_ind[i][1] + * mut_pop[i + 1] / tot_pop; + } + } + } + + p_rec_wild = rec_rates[0]; + p_rec_mut = rec_rates[1]; + p_any_ev = 0; + + /* Find rate of any event */ + for (i = 0; i < num_demes; i++) { + p_any_ev += p_coal_wild[i]; + p_any_ev += p_coal_mut[i]; + } + + if (num_demes > 1) { + for (i = 0; i < (num_demes - 1); i++) { + p_any_ev += p_mig_wild_left[i]; + p_any_ev += p_mig_mut_left[i]; + p_any_ev += p_mig_wild_right[i]; + p_any_ev += p_mig_mut_right[i]; + } + } + + p_any_ev += p_rec_wild; + p_any_ev += p_rec_mut; + + t_current = self->time; + t_of_next_ev = gsl_ran_exponential(self->rng, 1 / p_any_ev); + tsk_bug_assert(t_of_next_ev > 0); + + t_of_next_forward_ev = t_of_forward_ev[curr_step]; + + if (t_current + t_of_next_ev >= t_of_next_forward_ev) { + + ret = sweep_forward_event(self, t_of_next_forward_ev, ev_type, &curr_step, + start_deme, end_deme, ancestral_bg_num_ind, &mut_pop, + &allele_frequency_mut, tot_pop, num_demes); + + } else { + self->time += t_of_next_ev; + p_cum_ev = 0.0; + no_event_yet = true; + tmp_rand = gsl_rng_uniform(self->rng); + + for (i = 0; i < num_demes; i++) { + p_cum_ev += p_coal_wild[i]; + if (tmp_rand < p_cum_ev / p_any_ev) { + ret = self->common_ancestor_event(self, i, 0); + no_event_yet = false; + break; + } else { + p_cum_ev += p_coal_mut[i]; + if (tmp_rand < p_cum_ev / p_any_ev) { + ret = self->common_ancestor_event(self, i, 1); + no_event_yet = false; + break; + } + } + } + + if (num_demes > 1) { + if (no_event_yet) { + for (i = 0; i < (num_demes - 1); i++) { + p_cum_ev += p_mig_wild_left[i]; + if (tmp_rand < p_cum_ev / p_any_ev) { + ret = msp_migration_event_in_background(self, i + 1, i, 0); + no_event_yet = false; + break; + } else { + p_cum_ev += p_mig_mut_left[i]; + if (tmp_rand < p_cum_ev / p_any_ev) { + ret = msp_migration_event_in_background( + self, i + 1, i, 1); + no_event_yet = false; + break; + } else { + p_cum_ev += p_mig_wild_right[i]; + if (tmp_rand < p_cum_ev / p_any_ev) { + ret = msp_migration_event_in_background( + self, i, i + 1, 0); + no_event_yet = false; + break; + } else { + p_cum_ev += p_mig_mut_right[i]; + if (tmp_rand < p_cum_ev / p_any_ev) { + ret = msp_migration_event_in_background( + self, i, i + 1, 1); + no_event_yet = false; + break; + } + } + } + } + } + } + } + + if (no_event_yet) { + p_cum_ev += p_rec_wild; + if (tmp_rand < p_cum_ev / p_any_ev) { + ret = msp_sweep_reverse_recombination_event( + self, 0, sweep_locus, allele_frequency_mut); + no_event_yet = false; + } + } + if (no_event_yet) { + p_cum_ev += p_rec_mut; + if (tmp_rand < p_cum_ev / p_any_ev) { + ret = msp_sweep_reverse_recombination_event( + self, 1, sweep_locus, allele_frequency_mut); + no_event_yet = false; + } + } + } + + if (ret != 0) { + goto out; + } + } + + /* TODO we should probably support fixed events here using + * msp_apply_fixed_events() like we do in the coalescent models. + * The point below about computing population sizes should be easily + * worked around using msp_compute_population_size(). */ + + /* Check if any demographic events should have happened during the + * event and raise an error if so. This is to keep computing population + * sizes simple */ + if (self->next_demographic_event != NULL + && self->next_demographic_event->time <= self->time) { + ret = MSP_ERR_EVENTS_DURING_SWEEP; + goto out; + } + /* Rule out sampling events for now, but there's no reason we can't + * support them. */ + if (self->next_sampling_event < self->num_sampling_events + && self->sampling_events[self->next_sampling_event].time <= self->time) { + ret = MSP_ERR_EVENTS_DURING_SWEEP; + goto out; + } + ret = msp_sweep_finalise(self); + if (ret != 0) { + goto out; + } + ret = MSP_EXIT_MODEL_COMPLETE; + +out: + msp_safe_free(p_coal_mut); + msp_safe_free(p_coal_wild); + if (num_demes > 1) { + msp_safe_free(p_mig_wild_left); + msp_safe_free(p_mig_mut_left); + msp_safe_free(p_mig_wild_right); + msp_safe_free(p_mig_mut_right); + } + for (i = 0; i < num_demes; i++) { + msp_safe_free(ancestral_bg_num_ind[i]); + } + msp_safe_free(ancestral_bg_num_ind); + msp_safe_free(mut_pop); + msp_safe_free(allele_frequency_mut); + msp_safe_free(final_mut_pop); + msp_safe_free(t_of_forward_ev); + msp_safe_free(ev_type); + msp_safe_free(start_deme); + msp_safe_free(end_deme); + return ret; +} + /* Runs the simulation backwards in time until either the sample has coalesced, * or specified maximum simulation time has been reached or the specified maximum * number of events has been reached. @@ -6093,6 +6673,8 @@ msp_run(msp_t *self, double max_time, unsigned long max_events) } else if (self->model.type == MSP_MODEL_SWEEP) { /* FIXME making sweep atomic for now as it's non-rentrant */ ret = msp_run_sweep(self); + } else if (self->model.type == MSP_MODEL_SWEEP_REVERSE) { + ret = msp_run_sweep_reverse(self); } else { ret = msp_run_coalescent(self, max_time, max_events); } @@ -6345,6 +6927,9 @@ msp_get_model_name(msp_t *self) case MSP_MODEL_SWEEP: ret = "single-sweep"; break; + case MSP_MODEL_SWEEP_REVERSE: + ret = "single-sweep, reverse only"; + break; default: ret = "BUG: bad model in simulator!"; break; @@ -8171,7 +8756,8 @@ msp_set_simulation_model(msp_t *self, int model) if (model != MSP_MODEL_HUDSON && model != MSP_MODEL_SMC && model != MSP_MODEL_SMC_PRIME && model != MSP_MODEL_SMC_K && model != MSP_MODEL_DIRAC && model != MSP_MODEL_BETA && model != MSP_MODEL_DTWF - && model != MSP_MODEL_WF_PED && model != MSP_MODEL_SWEEP) { + && model != MSP_MODEL_WF_PED && model != MSP_MODEL_SWEEP + && model != MSP_MODEL_SWEEP_REVERSE) { ret = MSP_ERR_BAD_MODEL; goto out; } @@ -8454,3 +9040,29 @@ msp_set_simulation_model_sweep_genic_selection(msp_t *self, double position, out: return ret; } + +int +msp_set_simulation_model_sweep_genic_selection_reverse( + msp_t *self, double position, const char *filename) +{ + int ret = 0; + simulation_model_t *model = &self->model; + double L = self->sequence_length; + + /* Check the inputs to make sure they make sense */ + if (position < 0 || position >= L) { + ret = MSP_ERR_BAD_SWEEP_POSITION; + goto out; + } + + ret = msp_set_simulation_model(self, MSP_MODEL_SWEEP_REVERSE); + if (ret != 0) { + goto out; + } + + model->params.sweep_reverse.position = position; + model->params.sweep_reverse.filename = filename; + +out: + return ret; +} \ No newline at end of file diff --git a/lib/msprime.h b/lib/msprime.h index c352ef539..e84799371 100644 --- a/lib/msprime.h +++ b/lib/msprime.h @@ -43,8 +43,9 @@ #define MSP_MODEL_DIRAC 4 #define MSP_MODEL_DTWF 5 #define MSP_MODEL_SWEEP 6 -#define MSP_MODEL_WF_PED 7 -#define MSP_MODEL_SMC_K 8 +#define MSP_MODEL_SWEEP_REVERSE 7 +#define MSP_MODEL_WF_PED 8 +#define MSP_MODEL_SMC_K 9 /* Exit codes from msp_run to distinguish different reasons for exiting * before coalescence. */ @@ -231,6 +232,11 @@ typedef struct _sweep_t { void (*print_state)(struct _sweep_t *self, FILE *out); } sweep_t; +typedef struct _sweep_reverse_t { + double position; + const char *filename; +} sweep_reverse_t; + typedef struct _simulation_model_t { int type; union { @@ -238,6 +244,7 @@ typedef struct _simulation_model_t { beta_coalescent_t beta_coalescent; dirac_coalescent_t dirac_coalescent; sweep_t sweep; + sweep_reverse_t sweep_reverse; } params; /* If the model allocates memory this function should be non-null. */ void (*free)(struct _simulation_model_t *model); @@ -491,6 +498,8 @@ int msp_set_simulation_model_dirac(msp_t *self, double psi, double c); int msp_set_simulation_model_beta(msp_t *self, double alpha, double truncation_point); int msp_set_simulation_model_sweep_genic_selection(msp_t *self, double position, double start_frequency, double end_frequency, double s, double dt); +int msp_set_simulation_model_sweep_genic_selection_reverse( + msp_t *self, double position, const char *filename); int msp_set_start_time(msp_t *self, double start_time); int msp_set_store_migrations(msp_t *self, bool store_migrations); diff --git a/lib/tests/test_sweeps.c b/lib/tests/test_sweeps.c index 93f107750..b070bfc3c 100644 --- a/lib/tests/test_sweeps.c +++ b/lib/tests/test_sweeps.c @@ -330,7 +330,7 @@ sweep_genic_selection_mimic_msms_single_run(unsigned long int seed) double s = 10000; double recom_rate = 0.0004; double start_frequency = 0.5 / 10000; - double end_frequency = 0.9; + double end_frequency = 1 - 0.5 / 10000; double dt = 1.0 / 400000; msp_t msp; gsl_rng *rng = safe_rng_alloc(); @@ -370,6 +370,61 @@ sweep_genic_selection_mimic_msms_single_run(unsigned long int seed) tsk_table_collection_free(&tables); } +static void +sweep_genic_selection_reverse_single_run(unsigned long int seed) +{ + + /* Try to mimic the msms parameters used in verification.py + "100 300 -t 200 -r 200 500000" + " -SF 0 0.9 -Sp 0.5 -SaA 5000 -SAA 10000 -N 10000" + */ + int ret; + const char *filename + = "/home/aalhadbhatt/Desktop/msprime/notebooks/PyNBmsprime/events.bin"; + uint32_t n = 10; + double num_loci = 500001; + double position = num_loci / 2; + size_t num_demes = 1; + double recom_rate = 0.0004; + msp_t msp; + gsl_rng *rng = safe_rng_alloc(); + tsk_table_collection_t tables; + + // Test over differnt seeds + gsl_rng_set(rng, seed); + + ret = build_sim(&msp, &tables, rng, num_loci, num_demes, NULL, n); + CU_ASSERT_EQUAL(ret, 0); + CU_ASSERT_EQUAL_FATAL(msp_set_recombination_rate(&msp, recom_rate), 0); + ret = msp_set_num_labels(&msp, 2); + CU_ASSERT_EQUAL(ret, 0); + + // To mimic the verfication.py call + msp_set_discrete_genome(&msp, 0); + msp_set_gene_conversion_rate(&msp, 0); + msp_set_gene_conversion_tract_length(&msp, 1); + msp_set_avl_node_block_size(&msp, 65536); + msp_set_node_mapping_block_size(&msp, 65536); + msp_set_segment_block_size(&msp, 65536); + + ret = msp_set_simulation_model_sweep_genic_selection_reverse( + &msp, position, filename); + CU_ASSERT_EQUAL(ret, 0); + + ret = msp_initialise(&msp); + CU_ASSERT_EQUAL(ret, 0); + + ret = msp_run(&msp, DBL_MAX, UINT32_MAX); + CU_ASSERT_EQUAL(ret, MSP_EXIT_MODEL_COMPLETE); + + msp_verify(&msp, 0); + + msp_free(&msp); + gsl_rng_free(rng); + // free(samples); + tsk_table_collection_free(&tables); +} + static void test_sweep_genic_selection_mimic_msms(void) { @@ -379,6 +434,14 @@ test_sweep_genic_selection_mimic_msms(void) } } +static void +test_sweep_genic_selection_reverse(void) +{ + /* To mimic the nrepeats = 300 parameter in msms cmdline arguments*/ + for (int i = 0; i < 300; i++) + sweep_genic_selection_reverse_single_run(i + 1); +} + int main(int argc, char **argv) { @@ -395,6 +458,7 @@ main(int argc, char **argv) test_sweep_genic_selection_time_change }, { "test_sweep_genic_selection_mimic_msms", test_sweep_genic_selection_mimic_msms }, + { "test_sweep_genic_selection_reverse", test_sweep_genic_selection_reverse }, CU_TEST_INFO_NULL, }; diff --git a/msprime/__init__.py b/msprime/__init__.py index 63b18fe4b..cc903a225 100644 --- a/msprime/__init__.py +++ b/msprime/__init__.py @@ -47,6 +47,7 @@ StandardCoalescent, SweepGenicSelection, FixedPedigree, + SweepGenicSelectionReverse, TimeUnitsMismatchWarning, NodeType, ) diff --git a/msprime/_msprimemodule.c b/msprime/_msprimemodule.c index b3de9398e..a3c794e05 100644 --- a/msprime/_msprimemodule.c +++ b/msprime/_msprimemodule.c @@ -151,6 +151,20 @@ get_dict_number(PyObject *dict, const char *key_str) return ret; } +static PyObject * +get_dict_string(PyObject *dict, const char *key_str) +{ + PyObject *ret = NULL; + PyObject *value; + value = get_required_dict_value(dict, key_str); + if (value == NULL) { + goto out; + } + ret = value; +out: + return ret; +} + static int parse_rate_map(PyObject *py_rate_map, size_t *ret_size, PyArrayObject **ret_position, PyArrayObject **ret_rate) @@ -1063,6 +1077,35 @@ Simulator_parse_sweep_genic_selection_model(Simulator *self, PyObject *py_model) return ret; } +static int +Simulator_parse_sweep_genic_selection_reverse_model(Simulator *self, PyObject *py_model) +{ + int ret = -1; + int err; + double position; + const char *filename; + PyObject *value; + value = get_dict_number(py_model, "position"); + if (value == NULL) { + goto out; + } + position = PyFloat_AsDouble(value); + value = get_dict_string(py_model, "filename"); + if (value == NULL) { + goto out; + } + filename = PyUnicode_AsUTF8(value); + err = msp_set_simulation_model_sweep_genic_selection_reverse(self->sim, + position, filename); + if (err != 0) { + handle_input_error("sweep genic selection reverse", err); + goto out; + } + ret = 0; +out: + return ret; +} + static int Simulator_parse_simulation_model(Simulator *self, PyObject *py_model) { @@ -1078,9 +1121,10 @@ Simulator_parse_simulation_model(Simulator *self, PyObject *py_model) PyObject *dirac_s = NULL; PyObject *beta_s = NULL; PyObject *sweep_genic_selection_s = NULL; + PyObject *sweep_genic_selection_reverse_s = NULL; PyObject *value; int is_hudson, is_dtwf, is_smc, is_smc_prime, is_smc_k, is_dirac, is_beta, - is_sweep_genic_selection, is_fixed_pedigree; + is_sweep_genic_selection, is_sweep_genic_selection_reverse, is_fixed_pedigree; double psi, c, alpha, truncation_point, hull_offset; hudson_s = Py_BuildValue("s", "hudson"); @@ -1120,6 +1164,11 @@ Simulator_parse_simulation_model(Simulator *self, PyObject *py_model) goto out; } + sweep_genic_selection_reverse_s = Py_BuildValue("s", "sweep_genic_selection_reverse"); + if (sweep_genic_selection_reverse_s == NULL) { + goto out; + } + py_name = get_required_dict_value(py_model, "name"); if (py_name == NULL) { goto out; @@ -1242,8 +1291,20 @@ Simulator_parse_simulation_model(Simulator *self, PyObject *py_model) } } + is_sweep_genic_selection_reverse = PyObject_RichCompareBool(py_name, + sweep_genic_selection_reverse_s, Py_EQ); + if (is_sweep_genic_selection_reverse == -1) { + goto out; + } + if (is_sweep_genic_selection_reverse) { + ret = Simulator_parse_sweep_genic_selection_reverse_model(self, py_model); + if (ret != 0) { + goto out; + } + } + if (! (is_hudson || is_dtwf || is_smc || is_smc_prime || is_smc_k || is_dirac - || is_beta || is_sweep_genic_selection || is_fixed_pedigree)) { + || is_beta || is_sweep_genic_selection || is_sweep_genic_selection_reverse || is_fixed_pedigree)) { PyErr_SetString(PyExc_ValueError, "Unknown simulation model"); goto out; } @@ -1262,6 +1323,7 @@ Simulator_parse_simulation_model(Simulator *self, PyObject *py_model) Py_XDECREF(beta_s); Py_XDECREF(dirac_s); Py_XDECREF(sweep_genic_selection_s); + Py_XDECREF(sweep_genic_selection_reverse_s); return ret; } @@ -2024,6 +2086,16 @@ Simulator_get_model(Simulator *self, void *closure) Py_DECREF(value); value = NULL; /* TODO fill in the parameters for the different types of trajectories. */ + } else if (model->type == MSP_MODEL_SWEEP_REVERSE) { + value = Py_BuildValue("d", model->params.sweep.position); + if (value == NULL) { + goto out; + } + if (PyDict_SetItemString(d, "locus", value) != 0) { + goto out; + } + Py_DECREF(value); + value = NULL; } else if (model->type == MSP_MODEL_SMC_K) { value = Py_BuildValue("d", model->params.smc_k_coalescent.hull_offset); if (value == NULL) { diff --git a/msprime/ancestry.py b/msprime/ancestry.py index 72b45b5d8..74af53c23 100644 --- a/msprime/ancestry.py +++ b/msprime/ancestry.py @@ -833,13 +833,6 @@ def _parse_sim_ancestry( models = _parse_model_arg(model) is_dtwf = isinstance(models[0], DiscreteTimeWrightFisher) is_pedigree = any(isinstance(model, FixedPedigree) for model in models) - is_smck = any(isinstance(model, SmcKApproxCoalescent) for model in models) - - if is_smck and gene_conversion_rate is not None: - raise ValueError( - "Gene conversion is not supported for the SmcKApproxCoalescent model. " - "Please refer to issue #2399 on GitHub for details." - ) if record_full_arg: if coalescing_segments_only is not None: @@ -1486,7 +1479,9 @@ def _choose_num_labels(self, models): """ num_labels = 1 for model in models: - if isinstance(model, SweepGenicSelection): + if isinstance(model, SweepGenicSelection) or isinstance( + model, SweepGenicSelectionReverse + ): num_labels = 2 return num_labels @@ -2116,3 +2111,50 @@ def __init__( self.end_frequency = end_frequency self.s = s self.dt = dt + + +@dataclasses.dataclass +class SweepGenicSelectionReverse(ParametricAncestryModel): + """ + This is a modification of SweepGenicSelection such that the user feeds the + filename for a binary file containing the forward in time trajectory of the sweep + for a single allele and the simulator computes the trajectory for the entire + genome. + + For more details see the definition of class SweepGenicSelection + + + .. warning:: + Currently models with more than one population and a selective sweep + are not implemented. Population size changes during the sweep + are not yet possible in msprime. + + :param float position: the location of the beneficial allele along the + chromosome. + :param filename: The path of the file that contains the forward trajectory + computed from a Guillespie simulation of a logistic birth and death + process stored in a binary file + Currently the file has the following format: + 1. Number of events (uintp) + 2. Number of demes (int) - currently 0 + 3. Population size (int) + 4. Migration rate (float) - currently 0 + 5. The initial state of the forward sim (1 int per deme) + 6. the final state of the forward sim (1 int per deme) + 7. For each event there is also: + a. time of event (float) + b. type of event (0 for wt birth, 1 for mutant birth - int) + c. deme of birth (int) + d. deme of parent (int) + """ + + name = "sweep_genic_selection_reverse" + + position: float | None + filename: str | None + + # We have to define an __init__ to enforce keyword-only behaviour + def __init__(self, *, duration=None, position=None, filename=None): + self.duration = duration + self.position = position + self.filename = filename From fbf924397b2887a6f274339c952a38b24b53214a Mon Sep 17 00:00:00 2001 From: Aalhad-Bhatt Date: Wed, 24 Sep 2025 16:51:51 -0400 Subject: [PATCH 2/4] Forward notebook Folder notebooks, with forward sim and sample file --- notebooks/Forward_con_mig.ipynb | 349 ++++++++++++++++++++++++++++++++ notebooks/events.bin | Bin 0 -> 591572 bytes 2 files changed, 349 insertions(+) create mode 100644 notebooks/Forward_con_mig.ipynb create mode 100644 notebooks/events.bin diff --git a/notebooks/Forward_con_mig.ipynb b/notebooks/Forward_con_mig.ipynb new file mode 100644 index 000000000..bb3590760 --- /dev/null +++ b/notebooks/Forward_con_mig.ipynb @@ -0,0 +1,349 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import argparse\n", + "import os\n", + "import math\n", + "import numpy as np\n", + "import random\n", + "import struct\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "class GillespieSelectionSimulation:\n", + " def __init__(self, L, N, s, migration_matrix, tfinal, seed=None, l0=0):\n", + " self.L = L # Total number of demes\n", + " self.N = N # Number of individuals in each deme\n", + " self.s = s # Selection coefficient\n", + " self.migration_matrix = migration_matrix\n", + " self.m = 0 #migration_matrix[0, 1]\n", + " self.tfinal = tfinal\n", + " self.l0 = l0 # Initial location for the mutant\n", + " np.random.seed(seed) # Setting the random seed\n", + " print('Initialization complete. Seed:', seed)\n", + "\n", + " def simulate(self):\n", + " t = 0.0\n", + " mutants = np.zeros(self.L, dtype = np.uint32)\n", + " mutants[self.l0] = 1 #Starting mutation at location l0\n", + " start_state = mutants.copy()\n", + " events = []\n", + " mut_traj = [[t, mutants.copy()]] # Initialize with the starting state\n", + "\n", + " print(\"Starting simulation...\")\n", + " while t < self.tfinal:\n", + "\n", + " if np.sum(mutants) == 0:\n", + " print(f\"All mutants extinct at time {t}. Reintroducing...\")\n", + " mutants = np.zeros(self.L, dtype = np.uint32)\n", + " mutants[self.l0] = 1\n", + " t = 0.0\n", + " events = []\n", + " mut_traj = [[t, mutants.copy()]] \n", + " continue\n", + " \n", + " \n", + " f = mutants / self.N\n", + " rate_mutant_replaces_wt = self.N * f * (1 - f) * (1 + self.s)\n", + " rate_wt_replaces_mutant = self.N * f * (1 - f)\n", + " rate_migration_mutant_to_i_from_j = np.zeros((self.L, self.L))\n", + " rate_migration_wt_to_i_from_j = np.zeros((self.L, self.L))\n", + "\n", + " for i in range(self.L):\n", + " for j in range(self.L):\n", + " if i != j:\n", + " # Calculate migration rates of mutants and wild types from j to i\n", + " rate_migration_mutant_to_i_from_j[i][j] = self.N * f[j] * (1 - f[i]) * (1 + self.s) * self.migration_matrix[i][j]\n", + " rate_migration_wt_to_i_from_j[i][j] = self.N * f[i] * (1 - f[j]) * self.migration_matrix[i][j]\n", + "\n", + " total_rate = np.sum(rate_mutant_replaces_wt + rate_wt_replaces_mutant) + np.sum(rate_migration_mutant_to_i_from_j) + np.sum(rate_migration_wt_to_i_from_j)\n", + "\n", + " if total_rate == 0:\n", + " print(\"No possible reactions. Skipping...\")\n", + " break\n", + "\n", + " tau = np.random.exponential(scale = 1 / total_rate)\n", + " t += tau\n", + "\n", + " combined_rates = np.concatenate((rate_mutant_replaces_wt, rate_wt_replaces_mutant, \n", + " rate_migration_mutant_to_i_from_j.flatten(), rate_migration_wt_to_i_from_j.flatten()))\n", + " reaction_probabilities = combined_rates / total_rate\n", + " cumulative_prob = np.cumsum(reaction_probabilities)\n", + " r = np.random.rand()\n", + " reaction_index = np.where(cumulative_prob > r)[0][0]\n", + "\n", + " if reaction_index < self.L:\n", + " event_type = 0\n", + " updated_deme = reaction_index\n", + " parent_deme = reaction_index\n", + " mutants[updated_deme] += 1\n", + " elif reaction_index < 2 * self.L:\n", + " event_type = 1\n", + " updated_deme = reaction_index - self.L\n", + " parent_deme = updated_deme\n", + " mutants[updated_deme] -= 1\n", + " elif reaction_index < 2 * self.L + self.L**2:\n", + " event_type = 2\n", + " index = reaction_index - 2 * self.L\n", + " i, j = index // self.L, index % self.L\n", + " updated_deme = i\n", + " parent_deme = j\n", + " mutants[i] += 1\n", + " else:\n", + " event_type = 3\n", + " index = reaction_index - (2 * self.L + self.L**2)\n", + " i, j = index // self.L, index % self.L\n", + " updated_deme = i\n", + " parent_deme = j\n", + " mutants[i] -= 1\n", + "\n", + " mut_traj.append([t, mutants.copy()])\n", + " events.append([t, event_type, updated_deme, parent_deme])\n", + " # print(f\"Event at time {t}: {event_type} in deme {updated_deme}, from deme {parent_deme}\")\n", + " end_state = mutants.copy()\n", + " demes = len(mutants)\n", + " return events, mut_traj, start_state, end_state\n", + " def save_events(self, events, start_state, end_state, filename):\n", + " with open(filename, 'wb') as f:\n", + " #Using struct.pack is not very efficient, but it seems to work fine for our sizes and I don't really care. It will cause problems for large deme sizes\n", + " # Write the number of events as size_t. Can be L (8 bytes) or I (4 bytes)\n", + " f.write(struct.pack('L', len(events))) # 'L' is long unsigned integer\n", + " f.write(struct.pack('i', self.L))\n", + " f.write(struct.pack('i', self.N)) # 'i' is int\n", + " f.write(struct.pack('d', self.m)) # 'd' is double\n", + " for i in start_state:\n", + " f.write(struct.pack('i', i))\n", + " for i in end_state:\n", + " f.write(struct.pack('i', i))\n", + " for i in events:\n", + " f.write(struct.pack('d', i[0]))\n", + " f.write(struct.pack('i', i[1]))\n", + " f.write(struct.pack('i', i[2]))\n", + " f.write(struct.pack('i', i[3]))\n", + " def load_events(self, filename):\n", + " with open(filename, 'rb') as f:\n", + " output = []\n", + " num_events = struct.unpack('L', f.read(8))\n", + " demes = struct.unpack('i', f.read(4))\n", + " pop_size = struct.unpack('i', f.read(4))\n", + " m = struct.unpack('d', f.read(8))\n", + " output.append(num_events) # Read and unpack one integers\n", + " output.append(demes)\n", + " output.append(pop_size)\n", + " output.append(m)\n", + " for i in range(demes[0]):\n", + " output.append(struct.unpack('i', f.read(4)))\n", + " output.append(struct.unpack('i', f.read(4)))\n", + " for i in range(num_events[0]):\n", + " output.append(struct.unpack('d', f.read(8)))\n", + " output.append(struct.unpack('i', f.read(4)))\n", + " output.append(struct.unpack('i', f.read(4)))\n", + " output.append(struct.unpack('i', f.read(4)))\n", + " return output" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_mutant_trajectories(mut_traj, L):\n", + " times = [state[0] for state in mut_traj]\n", + " mutant_counts = [state[1] for state in mut_traj]\n", + " plt.figure(figsize=(10, 6))\n", + " for deme in range(L):\n", + " plt.plot(times, [m[deme] for m in mutant_counts], label=f'Deme {deme+1}')\n", + " plt.xlabel('Time')\n", + " plt.ylabel('Number of Mutants')\n", + " plt.title('Mutant Trajectories Over Time')\n", + " #plt.legend()\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "class MigrationMatrixGenerator:\n", + " def __init__(self, deme_dimension, migration_rate):\n", + " self.deme_dimension = deme_dimension\n", + " self.migration_rate = migration_rate\n", + " \n", + "\n", + " def generate_1Dmatrix(self):\n", + " M = np.zeros((self.deme_dimension, self.deme_dimension))\n", + "\n", + " for i in range(self.deme_dimension):\n", + " if i > 0:\n", + " M[i, i - 1] = self.migration_rate\n", + " if i < self.deme_dimension - 1:\n", + " M[i, i + 1] = self.migration_rate\n", + "\n", + " return M\n", + " \n", + " \n", + " def generate_2Dmatrix(self):\n", + " \"\"\"\n", + " Generates a 2D migration matrix for a square grid of demes.\n", + " Each deme can migrate to its immediate neighbors (up, down, left, right).\n", + " Diagonal elements are set to 0, indicating no self-migration.\n", + " \"\"\"\n", + " z = math.sqrt(self.deme_dimension)\n", + " if not z.is_integer():\n", + " raise ValueError(\"Deme dimension must be a perfect square for a 2D grid.\")\n", + " z = int(z)\n", + "\n", + " M = np.zeros((self.deme_dimension, self.deme_dimension))\n", + "\n", + " for i in range(self.deme_dimension):\n", + " for j in range(self.deme_dimension):\n", + " # Check for right neighbor\n", + " if j == i + 1 and (i + 1) % z != 0:\n", + " M[i, j] = self.migration_rate\n", + " # Check for down neighbor\n", + " elif j == i + z and j < self.deme_dimension:\n", + " M[i, j] = self.migration_rate\n", + "\n", + " # Ensure migration is bidirectional\n", + " M[j, i] = M[i, j]\n", + "\n", + " return M\n", + "\n", + " def generate_3Dmatrix(self):\n", + " \"\"\"\n", + " Generates a 3D migration matrix for a cubic grid of demes.\n", + " Each deme can migrate to its immediate neighbors along the x, y, and z axes.\n", + " Diagonal elements are set to 0, indicating no self-migration.\n", + " \"\"\"\n", + " cube_root = round(self.deme_dimension ** (1/3))\n", + " if cube_root ** 3 != self.deme_dimension:\n", + " raise ValueError(\"Deme dimension must be a cube number for a 3D grid.\")\n", + "\n", + " M = np.zeros((self.deme_dimension, self.deme_dimension))\n", + "\n", + " for i in range(self.deme_dimension):\n", + " x, y, z = np.unravel_index(i, (cube_root, cube_root, cube_root))\n", + "\n", + " # Check neighbors in each direction (left, right, up, down, front, back)\n", + " for dx, dy, dz in [(-1, 0, 0), (1, 0, 0), (0, -1, 0), (0, 1, 0), (0, 0, -1), (0, 0, 1)]:\n", + " nx, ny, nz = x + dx, y + dy, z + dz\n", + " if 0 <= nx < cube_root and 0 <= ny < cube_root and 0 <= nz < cube_root:\n", + " neighbor_index = np.ravel_multi_index((nx, ny, nz), (cube_root, cube_root, cube_root))\n", + " M[i, neighbor_index] = self.migration_rate\n", + "\n", + " return M\n", + "\n", + " def generate_island_model_matrix(self):\n", + " \"\"\"\n", + " Generates a migration matrix based on the island model.\n", + " Each deme has an equal migration rate to every other deme.\n", + " Diagonal elements are set to 0, indicating no self-migration.\n", + " \"\"\"\n", + " M = np.full((self.deme_dimension, self.deme_dimension), self.migration_rate)\n", + " np.fill_diagonal(M, 0) # Set diagonal elements to 0\n", + " return M " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initialization complete. Seed: None\n", + "Starting simulation...\n", + "No possible reactions. Skipping...\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[(9999,), (1,), (10000,), (0.0,), (1,), (10000,), (4.771818163941268e-05,), (0,), (0,), (0,), (0.0001269114533750033,), (0,), (0,), (0,), (0.00020479840692238415,), (0,), (0,), (0,), (0.0003868512648608837,), (0,), (0,), (0,), (0.00040125281940051754,), (0,), (0,), (0,), (0.0004396525870125214,), (0,), (0,), (0,), (0.0004409992368832654,), (0,), (0,), (0,), (0.0004516841209499256,), (0,), (0,), (0,), (0.00046635198488061293,), (0,), (0,), (0,), (0.0004817560144229769,), (0,), (0,), (0,), (0.0004936453628786726,), (0,), (0,), (0,), (0.000508589160153316,), (0,), (0,), (0,), (0.0005171767755911625,), (0,), (0,), (0,), (0.0005255528771130577,), (0,), (0,), (0,), (0.0005281068653429891,), (0,), (0,), (0,), (0.0005312812683494216,), (0,), (0,), (0,), (0.0005335997649747014,), (0,), (0,), (0,), (0.0005346801579408522,), (0,), (0,), (0,), (0.000537125171186308,), (0,), (0,), (0,), (0.0005380844238624733,), (0,), (0,), (0,), (0.0005404373053466639,), (0,), (0,), (0,), (0.0005405694505743195,), (0,), (0,), (0,), (0.000561812604564046,), (0,), (0,), (0,), (0.0005633734852782369,), (0,)]\n" + ] + } + ], + "source": [ + "# Example usage\n", + "L = 1\n", + "N = 10000\n", + "s = 10000\n", + "m = 0\n", + "migration_matrix = MigrationMatrixGenerator(L, m).generate_1Dmatrix()\n", + "\n", + "# migration_matrix = np.zeros((L, L)) # Example migration matrix\n", + "\n", + "tfinal = 5000\n", + "simulation = GillespieSelectionSimulation(L, N, s, migration_matrix, tfinal)\n", + "events, mut_traj, start_state, end_state = simulation.simulate()\n", + "plot_mutant_trajectories(mut_traj, L)\n", + "simulation.save_events(events, start_state, end_state, 'events.bin')\n", + "loaded_events = simulation.load_events('events.bin')\n", + "\n", + "print(loaded_events[0:100]) # Optional: Print to verify contents\n", + "\n", + "# print(mut_traj)\n", + "#for event in events[0:10]:\n", + "# print(event) # Print each event\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "msprime_stable", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.13" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/events.bin b/notebooks/events.bin new file mode 100644 index 0000000000000000000000000000000000000000..107739bf5661085ca73b5c8a933dfb36bef48196 GIT binary patch literal 591572 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 literal 0 HcmV?d00001 From a9456913920c15ee524d58c71b93fd1ea8a0923c Mon Sep 17 00:00:00 2001 From: Aalhad-Bhatt Date: Wed, 3 Dec 2025 15:42:40 -0500 Subject: [PATCH 3/4] Well-mixed test cases Hard-coded trajectories to test the well-mixed side of the code + 1 test for a 1D pop. Also removes the C side file I/O. Breaks the Python side of the function. --- lib/msprime.c | 234 ++++++++-------- lib/msprime.h | 20 +- lib/tests/test_sweeps.c | 570 +++++++++++++++++++++++++++++++++++++-- msprime/_msprimemodule.c | 81 +++--- 4 files changed, 700 insertions(+), 205 deletions(-) diff --git a/lib/msprime.c b/lib/msprime.c index b5d6c000b..574b3cb16 100644 --- a/lib/msprime.c +++ b/lib/msprime.c @@ -5469,7 +5469,7 @@ msp_dtwf_generation(msp_t *self) for (j = 0; j < self->num_populations; j++) { pop = &self->populations[j]; - if (avl_count(&pop->ancestors[label]) == 0) { + if (avl_count(&pop->ancestors[label]) == 0) { // Change this to loop over both continue; } /* For the DTWF, N for each population is the reference population size @@ -5477,22 +5477,26 @@ msp_dtwf_generation(msp_t *self) * the nearest integer. Thus, the population's size is always relative * to the reference model population size (which is also true for the * coalescent models. */ - N = (uint32_t) round(get_population_size(pop, self->time)); + N = (uint32_t) round( + get_population_size(pop, self->time)); // Ancestral bg pop size if (N == 0) { ret = MSP_ERR_DTWF_ZERO_POPULATION_SIZE; goto out; } // Allocate memory for linked list of offspring per parent - parents = calloc(N, sizeof(segment_list_t *)); - segment_mem = malloc(msp_get_num_ancestors(self) * sizeof(segment_list_t)); + parents = calloc(N, sizeof(segment_list_t *)); // Memory for gametes probably + segment_mem = malloc( + msp_get_num_ancestors(self) + * sizeof(segment_list_t)); // This should be the same as N for all demes if (parents == NULL || segment_mem == NULL) { ret = MSP_ERR_NO_MEMORY; goto out; } // Iterate through ancestors and draw parents segment_mem_offset = 0; - for (a = pop->ancestors[label].head; a != NULL; a = a->next) { + for (a = pop->ancestors[label].head; a != NULL; + a = a->next) { // Iterate through label s = segment_mem + segment_mem_offset; segment_mem_offset++; p = (uint32_t) gsl_rng_uniform_int(self->rng, N); @@ -5507,7 +5511,8 @@ msp_dtwf_generation(msp_t *self) // Iterate through offspring of parent k, adding to avl_tree for (k = 0; k < N; k++) { - for (i = 0; i < 2; i++) { + for (i = 0; i < 2; + i++) { // Is this because of diploid ness? Might need to remove it parent_nodes[i] = TSK_NULL; } for (s = parents[k]; s != NULL; s = s->next) { @@ -5517,7 +5522,8 @@ msp_dtwf_generation(msp_t *self) // Recombine ancestor // TODO Should this be the recombination rate going foward from x.left? if (rate_map_get_total_mass(&self->recomb_map) > 0) { - ret = msp_dtwf_recombine(self, x, &u[0], &u[1], parent_nodes); + ret = msp_dtwf_recombine(self, x, &u[0], &u[1], + parent_nodes); // Insert probability of being in sample here if (ret != 0) { goto out; } @@ -5999,82 +6005,6 @@ msp_sweep_reverse_recombination_event(msp_t *self, label_id_t label, double swee return ret; } -/* Reads the trajectory of a sweep when fed a file. -The file contains (in order) -1. Number of steps -2. Number of demes -3. Pop size -4. Migration rate -5. State after finishing the backward sim -6. state at the start of the backward sim -7. Time, type, and start and end locations for each event -No. 7 is currently read backward in time as well - */ -static int -genic_selection_read_trajectory(const char *filename, size_t *num_steps_ret, - int *num_demes_ret, int *tot_pop_ret, double *migration_rate_ret, - int **final_mut_pop_ret, int **mut_pop_ret, double **allele_frequency_mut_ret, - double **t_of_forward_ev_ret, int **ev_type_ret, int **start_deme_ret, - int **end_deme_ret) -{ - int ret = 0; - size_t num_steps; - int num_demes; - double *allele_frequency_mut = NULL; - double *t_of_forward_ev = NULL; - size_t j = 0; - int i = 0; - double migration_rate = 0.0; - int tot_pop = 0; - int *mut_pop = NULL, *final_mut_pop = NULL; - int *ev_type = NULL, *start_deme = NULL, *end_deme = NULL; - FILE *file = fopen(filename, "r"); - - fread(&num_steps, sizeof(size_t), 1, file); - fread(&num_demes, sizeof(int), 1, file); - fread(&tot_pop, sizeof(int), 1, file); - fread(&migration_rate, sizeof(double), 1, file); - - mut_pop = (int *) malloc(sizeof(*mut_pop) * (size_t) num_demes); - allele_frequency_mut - = (double *) malloc(sizeof(*allele_frequency_mut) * (size_t) num_demes); - final_mut_pop = (int *) malloc(sizeof(*final_mut_pop) * (size_t) num_demes); - - for (i = 0; i < num_demes; i++) { - fread(&final_mut_pop[i], sizeof(int), 1, file); - } - - for (i = 0; i < num_demes; i++) { - fread(&mut_pop[i], sizeof(int), 1, file); - allele_frequency_mut[i] = 1.0 * mut_pop[i] / tot_pop; - } - - t_of_forward_ev = (double *) malloc(sizeof(*t_of_forward_ev) * num_steps); - ev_type = (int *) malloc(sizeof(*ev_type) * num_steps); - start_deme = (int *) malloc(sizeof(*start_deme) * num_steps); - end_deme = (int *) malloc(sizeof(*end_deme) * num_steps); - for (j = 1; j <= num_steps; j++) { - fread(&t_of_forward_ev[num_steps - j], sizeof(double), 1, file); - fread(&ev_type[num_steps - j], sizeof(int), 1, file); - fread(&start_deme[num_steps - j], sizeof(int), 1, file); - fread(&end_deme[num_steps - j], sizeof(int), 1, file); - } - - fclose(file); - *num_demes_ret = num_demes; - *num_steps_ret = num_steps; - *tot_pop_ret = tot_pop; - *migration_rate_ret = migration_rate; - *final_mut_pop_ret = final_mut_pop; - *mut_pop_ret = mut_pop; - *allele_frequency_mut_ret = allele_frequency_mut; - *t_of_forward_ev_ret = t_of_forward_ev; - *ev_type_ret = ev_type; - *start_deme_ret = start_deme; - *end_deme_ret = end_deme; - return ret; -} - static int sweep_forward_event(msp_t *self, double t_of_next_forward_ev, int *ev_type, size_t *curr_step, int *start_deme, int *end_deme, double **ancestral_bg_num_ind, @@ -6090,30 +6020,30 @@ sweep_forward_event(msp_t *self, double t_of_next_forward_ev, int *ev_type, if (start_deme_index == end_deme[*curr_step]) { if (curr_ev_type == 0) { // mutant replaced with wildtype, mutant coalascence - p_forward_ev - = (float) ancestral_bg_num_ind[start_deme_index][1] - * (ancestral_bg_num_ind[start_deme_index][1] - 1.0) - / ((*mut_pop[start_deme_index]) * (*mut_pop[start_deme_index] - 1.0)); + p_forward_ev = (float) ancestral_bg_num_ind[start_deme_index][1] + * (ancestral_bg_num_ind[start_deme_index][1] - 1.0) + / (((*mut_pop)[start_deme_index]) + * ((*mut_pop)[start_deme_index] - 1.0)); tmp_rand = gsl_rng_uniform(self->rng); if (tmp_rand <= p_forward_ev) { ret = self->common_ancestor_event(self, start_deme_index, 1); } - (*mut_pop[start_deme_index])--; - *allele_frequency_mut[start_deme_index] - = 1.0 * *mut_pop[start_deme_index] / tot_pop; + ((*mut_pop)[start_deme_index])--; + (*allele_frequency_mut)[start_deme_index] + = 1.0 * (*mut_pop)[start_deme_index] / tot_pop; (*curr_step)++; } else if (curr_ev_type == 1) { // wildtype replaced with mutant, wt coalescence p_forward_ev = (float) ancestral_bg_num_ind[start_deme_index][0] * (ancestral_bg_num_ind[start_deme_index][0] - 1.0) - / ((tot_pop - *mut_pop[start_deme_index]) - * ((tot_pop - *mut_pop[start_deme_index]) - 1.0)); + / ((tot_pop - (*mut_pop)[start_deme_index]) + * ((tot_pop - (*mut_pop)[start_deme_index]) - 1.0)); tmp_rand = gsl_rng_uniform(self->rng); if (tmp_rand <= p_forward_ev) { ret = self->common_ancestor_event(self, start_deme_index, 0); } - (*mut_pop[start_deme_index])++; - *allele_frequency_mut[start_deme_index] + ((*mut_pop)[start_deme_index])++; + (*allele_frequency_mut)[start_deme_index] = 1.0 * *mut_pop[start_deme_index] / tot_pop; (*curr_step)++; } @@ -6123,40 +6053,40 @@ sweep_forward_event(msp_t *self, double t_of_next_forward_ev, int *ev_type, if (curr_ev_type == 2) { // wildtype replaced by mutant, mutant migration // + coalascence p_forward_ev = 1.0 * ancestral_bg_num_ind[start_deme_index][1] - / *mut_pop[start_deme_index]; + / (*mut_pop)[start_deme_index]; tmp_rand = gsl_rng_uniform(self->rng); if (tmp_rand <= p_forward_ev) { ret = msp_migration_event_in_background( self, start_deme_index, end_deme[*curr_step], 1); p_forward_ev = 1.0 * ancestral_bg_num_ind[end_deme[*curr_step]][1] - / *mut_pop[end_deme[*curr_step]]; + / (*mut_pop)[end_deme[*curr_step]]; tmp_rand = gsl_rng_uniform(self->rng); if (tmp_rand <= p_forward_ev) { ret = self->common_ancestor_event(self, end_deme[*curr_step], 1); } } - (*mut_pop[start_deme[*curr_step]])--; - *allele_frequency_mut[start_deme[*curr_step]] - = 1.0 * *mut_pop[start_deme[*curr_step]] / tot_pop; + ((*mut_pop)[start_deme[*curr_step]])--; + (*allele_frequency_mut)[start_deme[*curr_step]] + = 1.0 * (*mut_pop)[start_deme[*curr_step]] / tot_pop; (*curr_step)++; } else if (curr_ev_type == 3) { // mutant replaced by wildtype, wildtype // migration + coalascence p_forward_ev = 1.0 * ancestral_bg_num_ind[start_deme_index][0] - / (tot_pop - *mut_pop[start_deme_index]); + / (tot_pop - (*mut_pop)[start_deme_index]); tmp_rand = gsl_rng_uniform(self->rng); if (tmp_rand <= p_forward_ev) { ret = msp_migration_event_in_background( self, start_deme_index, end_deme[*curr_step], 0); p_forward_ev = 1.0 * ancestral_bg_num_ind[end_deme[*curr_step]][0] - / (tot_pop - *mut_pop[end_deme[*curr_step]]); + / (tot_pop - (*mut_pop)[end_deme[*curr_step]]); tmp_rand = gsl_rng_uniform(self->rng); if (tmp_rand <= p_forward_ev) { ret = self->common_ancestor_event(self, end_deme[*curr_step], 0); } } - (*mut_pop[start_deme[*curr_step]])++; - *allele_frequency_mut[start_deme[*curr_step]] + ((*mut_pop)[start_deme[*curr_step]])++; + (*allele_frequency_mut)[start_deme[*curr_step]] = 1.0 * *mut_pop[start_deme[*curr_step]] / tot_pop; (*curr_step)++; } @@ -6354,11 +6284,13 @@ msp_run_sweep_reverse(msp_t *self) int ret = 0; simulation_model_t *model = &self->model; size_t curr_step = 0; - size_t num_steps = 0; - double *allele_frequency_mut = NULL, *t_of_forward_ev = NULL; - int *ev_type = NULL, *start_deme = NULL, *end_deme = NULL; + size_t num_steps = model->params.sweep_reverse.num_steps; + double *allele_frequency_mut = NULL; + double *t_of_forward_ev = model->params.sweep_reverse.t_of_forward_ev; + int *ev_type = model->params.sweep_reverse.ev_type; + tsk_id_t *start_deme = model->params.sweep_reverse.start_deme; + tsk_id_t *end_deme = model->params.sweep_reverse.end_deme; double sweep_locus = model->params.sweep_reverse.position; - const char *filename = model->params.sweep_reverse.filename; size_t j = 0; int i = 0; double recomb_mass = 0.0; @@ -6368,12 +6300,14 @@ msp_run_sweep_reverse(msp_t *self) double *p_coal_wild = NULL, *p_coal_mut = NULL, *p_mig_wild_right = NULL, *p_mig_mut_right = NULL, *p_mig_wild_left = NULL, *p_mig_mut_left = NULL; double p_rec_wild = 0.0, p_rec_mut = 0.0; - double tmp_rand = 0.0, p_any_ev = 0.0, p_cum_ev = 0.0, t_of_next_forward_ev = 0.0; + double tmp_rand = 0.0, p_any_ev = 0.0, p_cum_ev = 0.0, p_coal_after_mig = 0.0, + t_of_next_forward_ev = 0.0; double t_start = 0.0, t_end = 0.0, t_of_next_ev = 0.0, t_current = 0.0; - int num_demes = 0; - double migration_rate = 0.0; - int tot_pop = 0; - int *mut_pop = NULL, *final_mut_pop = NULL; + int num_demes = model->params.sweep_reverse.num_demes; + double migration_rate = model->params.sweep_reverse.migration_rate; + int tot_pop = model->params.sweep_reverse.tot_pop; + tsk_id_t *mut_pop = model->params.sweep_reverse.mut_pop; + // tsk_id_t *final_mut_pop = model->params.sweep_reverse.mut_pop_final; bool no_event_yet = true; if (rate_map_get_total_mass(&self->gc_map) != 0.0) { // arrow?+ @@ -6382,13 +6316,10 @@ msp_run_sweep_reverse(msp_t *self) goto out; } - ret = genic_selection_read_trajectory(filename, &num_steps, &num_demes, &tot_pop, - &migration_rate, &final_mut_pop, &mut_pop, &allele_frequency_mut, - &t_of_forward_ev, &ev_type, &start_deme, &end_deme); - tsk_bug_assert(num_demes > 0); tsk_bug_assert(tot_pop > 0); + allele_frequency_mut = (double *) malloc(sizeof(double) * (size_t) num_demes); p_coal_wild = (double *) malloc(sizeof(double) * (size_t) num_demes); p_coal_mut = (double *) malloc(sizeof(double) * (size_t) num_demes); if (num_demes > 1) { @@ -6405,6 +6336,10 @@ msp_run_sweep_reverse(msp_t *self) curr_step = 0; + for (i = 0; i < num_demes; i++) { + allele_frequency_mut[i] = (double) mut_pop[i] / tot_pop; + } + ret = msp_sweep_reverse_initialise(self, allele_frequency_mut); if (ret != 0) { goto out; @@ -6432,12 +6367,18 @@ msp_run_sweep_reverse(msp_t *self) : fenwick_get_total(&self->recomb_mass_index[label]); for (i = 0; i < num_demes; i++) { ancestral_bg_num_ind[i][j] - = avl_count(&self->populations[i].ancestors[label]); + = (double) avl_count(&self->populations[i].ancestors[label]); /* We can get small negative rates by numerical jitter which causes * problems in later calculations and leads to assertion trips. * See https://github.com/tskit-dev/msprime/issues/1966 */ + if (j == 1) { + tsk_bug_assert(ancestral_bg_num_ind[i][j] <= mut_pop[i]); + } else { + tsk_bug_assert(ancestral_bg_num_ind[i][j] <= (tot_pop - mut_pop[i])); + } } + rec_rates[j] = TSK_MAX(0, (recomb_mass)); } @@ -6541,6 +6482,12 @@ msp_run_sweep_reverse(msp_t *self) p_cum_ev += p_mig_wild_left[i]; if (tmp_rand < p_cum_ev / p_any_ev) { ret = msp_migration_event_in_background(self, i + 1, i, 0); + p_coal_after_mig = 1.0 * ancestral_bg_num_ind[i][0] + / (tot_pop - mut_pop[i]); + tmp_rand = gsl_rng_uniform(self->rng); + if (tmp_rand <= p_coal_after_mig) { + ret = self->common_ancestor_event(self, i, 0); + } no_event_yet = false; break; } else { @@ -6548,6 +6495,12 @@ msp_run_sweep_reverse(msp_t *self) if (tmp_rand < p_cum_ev / p_any_ev) { ret = msp_migration_event_in_background( self, i + 1, i, 1); + p_coal_after_mig + = 1.0 * ancestral_bg_num_ind[i][1] / mut_pop[i]; + tmp_rand = gsl_rng_uniform(self->rng); + if (tmp_rand <= p_coal_after_mig) { + ret = self->common_ancestor_event(self, i, 1); + } no_event_yet = false; break; } else { @@ -6555,6 +6508,14 @@ msp_run_sweep_reverse(msp_t *self) if (tmp_rand < p_cum_ev / p_any_ev) { ret = msp_migration_event_in_background( self, i, i + 1, 0); + p_coal_after_mig = 1.0 + * ancestral_bg_num_ind[i + 1][0] + / (tot_pop - mut_pop[i + 1]); + tmp_rand = gsl_rng_uniform(self->rng); + if (tmp_rand <= p_coal_after_mig) { + ret = self->common_ancestor_event( + self, i + 1, 0); + } no_event_yet = false; break; } else { @@ -6562,6 +6523,14 @@ msp_run_sweep_reverse(msp_t *self) if (tmp_rand < p_cum_ev / p_any_ev) { ret = msp_migration_event_in_background( self, i, i + 1, 1); + p_coal_after_mig + = 1.0 * ancestral_bg_num_ind[i + 1][1] + / mut_pop[i + 1]; + tmp_rand = gsl_rng_uniform(self->rng); + if (tmp_rand <= p_coal_after_mig) { + ret = self->common_ancestor_event( + self, i + 1, 1); + } no_event_yet = false; break; } @@ -6634,13 +6603,7 @@ msp_run_sweep_reverse(msp_t *self) msp_safe_free(ancestral_bg_num_ind[i]); } msp_safe_free(ancestral_bg_num_ind); - msp_safe_free(mut_pop); msp_safe_free(allele_frequency_mut); - msp_safe_free(final_mut_pop); - msp_safe_free(t_of_forward_ev); - msp_safe_free(ev_type); - msp_safe_free(start_deme); - msp_safe_free(end_deme); return ret; } @@ -8705,7 +8668,7 @@ genic_selection_generate_trajectory(sweep_t *self, msp_t *simulator, alpha = 2 * pop_size * trajectory.s; x = 1.0 - genic_selection_stochastic_forwards( - trajectory.dt, 1.0 - x, alpha, gsl_rng_uniform(rng)); + trajectory.dt, 1.0 - x, alpha, gsl_rng_uniform(rng)); /* need our recored traj to stay in bounds */ t += trajectory.dt; sim_time += trajectory.dt * pop_size * simulator->ploidy; @@ -9042,8 +9005,10 @@ msp_set_simulation_model_sweep_genic_selection(msp_t *self, double position, } int -msp_set_simulation_model_sweep_genic_selection_reverse( - msp_t *self, double position, const char *filename) +msp_set_simulation_model_sweep_genic_selection_reverse(msp_t *self, double position, + size_t num_steps, int num_demes, int tot_pop, double migration_rate, + tsk_id_t *mut_pop, tsk_id_t *mut_pop_final, double *t_of_forward_ev, + tsk_id_t *ev_type, tsk_id_t *start_deme, tsk_id_t *end_deme) { int ret = 0; simulation_model_t *model = &self->model; @@ -9055,13 +9020,28 @@ msp_set_simulation_model_sweep_genic_selection_reverse( goto out; } + if (num_demes == 1) { + tsk_bug_assert(migration_rate == 0); + } else { + tsk_bug_assert(migration_rate > 0); + } + ret = msp_set_simulation_model(self, MSP_MODEL_SWEEP_REVERSE); if (ret != 0) { goto out; } model->params.sweep_reverse.position = position; - model->params.sweep_reverse.filename = filename; + model->params.sweep_reverse.num_steps = num_steps; + model->params.sweep_reverse.num_demes = num_demes; + model->params.sweep_reverse.tot_pop = tot_pop; + model->params.sweep_reverse.migration_rate = migration_rate; + model->params.sweep_reverse.mut_pop = mut_pop; + model->params.sweep_reverse.mut_pop_final = mut_pop_final; + model->params.sweep_reverse.t_of_forward_ev = t_of_forward_ev; + model->params.sweep_reverse.ev_type = ev_type; + model->params.sweep_reverse.start_deme = start_deme; + model->params.sweep_reverse.end_deme = end_deme; out: return ret; diff --git a/lib/msprime.h b/lib/msprime.h index e84799371..189f123a1 100644 --- a/lib/msprime.h +++ b/lib/msprime.h @@ -234,7 +234,16 @@ typedef struct _sweep_t { typedef struct _sweep_reverse_t { double position; - const char *filename; + size_t num_steps; + int num_demes; + int tot_pop; + double migration_rate; + tsk_id_t *mut_pop; + tsk_id_t *mut_pop_final; + double *t_of_forward_ev; + tsk_id_t *ev_type; + tsk_id_t *start_deme; + tsk_id_t *end_deme; } sweep_reverse_t; typedef struct _simulation_model_t { @@ -359,7 +368,7 @@ typedef struct { /* Arbitrary limit, saves us having to put in complex malloc/free * logic in the demographic_events. Can easily be changed if * needs be. */ -#define MSP_MAX_EVENT_POPULATIONS 100 +#define MSP_MAX_EVENT_POPULATIONS 500000 typedef struct { population_id_t derived[MSP_MAX_EVENT_POPULATIONS]; @@ -498,9 +507,10 @@ int msp_set_simulation_model_dirac(msp_t *self, double psi, double c); int msp_set_simulation_model_beta(msp_t *self, double alpha, double truncation_point); int msp_set_simulation_model_sweep_genic_selection(msp_t *self, double position, double start_frequency, double end_frequency, double s, double dt); -int msp_set_simulation_model_sweep_genic_selection_reverse( - msp_t *self, double position, const char *filename); - +int msp_set_simulation_model_sweep_genic_selection_reverse(msp_t *self, double position, + size_t num_steps, int num_demes, int tot_pop, double migration_rate, + tsk_id_t *mut_pop, tsk_id_t *mut_pop_final, double *t_of_forward_ev, + tsk_id_t *ev_type, tsk_id_t *start_deme, tsk_id_t *end_deme); int msp_set_start_time(msp_t *self, double start_time); int msp_set_store_migrations(msp_t *self, bool store_migrations); int msp_set_store_full_arg(msp_t *self, bool store_full_arg); diff --git a/lib/tests/test_sweeps.c b/lib/tests/test_sweeps.c index b070bfc3c..2b3d8b9f2 100644 --- a/lib/tests/test_sweeps.c +++ b/lib/tests/test_sweeps.c @@ -329,8 +329,8 @@ sweep_genic_selection_mimic_msms_single_run(unsigned long int seed) double position = num_loci / 2; double s = 10000; double recom_rate = 0.0004; - double start_frequency = 0.5 / 10000; - double end_frequency = 1 - 0.5 / 10000; + double start_frequency = 0.5 / 1000; + double end_frequency = 1 - 0.5 / 1000; double dt = 1.0 / 400000; msp_t msp; gsl_rng *rng = safe_rng_alloc(); @@ -371,28 +371,146 @@ sweep_genic_selection_mimic_msms_single_run(unsigned long int seed) } static void -sweep_genic_selection_reverse_single_run(unsigned long int seed) +test_sweep_genic_selection_mimic_msms(void) { + /* To mimic the nrepeats = 300 parameter in msms cmdline arguments*/ + for (int i = 0; i < 1; i++) { + sweep_genic_selection_mimic_msms_single_run(i + 1); + } +} - /* Try to mimic the msms parameters used in verification.py - "100 300 -t 200 -r 200 500000" - " -SF 0 0.9 -Sp 0.5 -SaA 5000 -SAA 10000 -N 10000" - */ +static void +verify_sweep_reverse_wm_no_recomb(unsigned long int seed) +{ + int ret; + uint32_t n = 10; + msp_t msp; + gsl_rng *rng = safe_rng_alloc(); + tsk_table_collection_t tables; + int num_demes = 1; + tsk_id_t mut_pop[] = { 1001 }; + int num_events = mut_pop[0] - 1; + double *time_of_ev; + int *ev_type; + int *start_deme; + int *end_deme; + int r, i; + double p; + + tsk_id_t final_mut_pop[] = { 1 }; + + gsl_rng_set(rng, seed); + + time_of_ev = (double *) malloc(sizeof(double) * num_events); + ev_type = (tsk_id_t *) malloc(sizeof(tsk_id_t) * num_events); + end_deme = (tsk_id_t *) malloc(sizeof(tsk_id_t) * num_events); + start_deme = (tsk_id_t *) malloc(sizeof(tsk_id_t) * num_events); + + r = rand() % RAND_MAX; + p = (double) r / RAND_MAX; + time_of_ev[0] = 1000 - p; + ev_type[0] = 0; + start_deme[0] = 0; + end_deme[0] = 0; + + for (i = 1; i < num_events; i++) { + r = rand() % RAND_MAX; + p = (double) r / RAND_MAX; + time_of_ev[i] = time_of_ev[i - 1] - p; + ev_type[i] = 0; + start_deme[i] = 0; + end_deme[i] = 0; + } + + ret = build_sim(&msp, &tables, rng, 1.0, num_demes, NULL, n); + CU_ASSERT_EQUAL_FATAL(ret, 0); + ret = msp_set_num_labels(&msp, 2); + CU_ASSERT_EQUAL(ret, 0); + + msp_set_discrete_genome(&msp, 0); + msp_set_gene_conversion_rate(&msp, 0); + msp_set_gene_conversion_tract_length(&msp, 1); + msp_set_avl_node_block_size(&msp, 65536); + msp_set_node_mapping_block_size(&msp, 65536); + msp_set_segment_block_size(&msp, 65536); + + ret = msp_set_simulation_model_sweep_genic_selection_reverse(&msp, 0.5, num_events, + num_demes, num_events + 1, 0.0, mut_pop, final_mut_pop, time_of_ev, ev_type, + start_deme, end_deme); + CU_ASSERT_EQUAL_FATAL(ret, 0); + + ret = msp_initialise(&msp); + CU_ASSERT_EQUAL_FATAL(ret, 0); + + ret = msp_run(&msp, DBL_MAX, UINT32_MAX); + CU_ASSERT_EQUAL(ret, MSP_EXIT_MODEL_COMPLETE); + + msp_verify(&msp, 0); + + free(time_of_ev); + free(ev_type); + free(start_deme); + free(end_deme); + msp_free(&msp); + tsk_table_collection_free(&tables); + gsl_rng_free(rng); +} + +static void +test_sweep_reverse_wm_no_recomb(void) +{ + /* To mimic the nrepeats = 300 parameter in msms cmdline arguments*/ + for (int i = 0; i < 300; i++) { + verify_sweep_reverse_wm_no_recomb(i + 256329651209); + } +} + +static void +verify_sweep_reverse_wm(unsigned long int seed) +{ int ret; - const char *filename - = "/home/aalhadbhatt/Desktop/msprime/notebooks/PyNBmsprime/events.bin"; uint32_t n = 10; - double num_loci = 500001; - double position = num_loci / 2; - size_t num_demes = 1; - double recom_rate = 0.0004; msp_t msp; gsl_rng *rng = safe_rng_alloc(); tsk_table_collection_t tables; + tsk_id_t mut_pop[] = { 10001 }; + int num_events = mut_pop[0] - 1; + int num_demes = 1; + double *time_of_ev; + int *ev_type; + int *start_deme; + int *end_deme; + int r, i; + double p; + double num_loci = 5001; + double position = num_loci / 2; + double recom_rate = 0.00004; + tsk_id_t final_mut_pop[] = { 1 }; + + time_of_ev = (double *) malloc(sizeof(double) * num_events); + ev_type = (tsk_id_t *) malloc(sizeof(tsk_id_t) * num_events); + end_deme = (tsk_id_t *) malloc(sizeof(tsk_id_t) * num_events); + start_deme = (tsk_id_t *) malloc(sizeof(tsk_id_t) * num_events); // Test over differnt seeds gsl_rng_set(rng, seed); + r = rand() % RAND_MAX; + p = (double) r / RAND_MAX; + time_of_ev[0] = num_events - p; + ev_type[0] = 0; + start_deme[0] = 0; + end_deme[0] = 0; + + for (i = 1; i < num_events; i++) { + r = rand() % RAND_MAX; + p = (double) r / RAND_MAX; + time_of_ev[i] = time_of_ev[i - 1] - p; + ev_type[i] = 0; + start_deme[i] = 0; + end_deme[i] = 0; + } + ret = build_sim(&msp, &tables, rng, num_loci, num_demes, NULL, n); CU_ASSERT_EQUAL(ret, 0); CU_ASSERT_EQUAL_FATAL(msp_set_recombination_rate(&msp, recom_rate), 0); @@ -407,39 +525,431 @@ sweep_genic_selection_reverse_single_run(unsigned long int seed) msp_set_node_mapping_block_size(&msp, 65536); msp_set_segment_block_size(&msp, 65536); - ret = msp_set_simulation_model_sweep_genic_selection_reverse( - &msp, position, filename); + ret = msp_set_simulation_model_sweep_genic_selection_reverse(&msp, position, + num_events, num_demes, num_events + 1, 0.0, mut_pop, final_mut_pop, time_of_ev, + ev_type, start_deme, end_deme); + CU_ASSERT_EQUAL_FATAL(ret, 0); + + ret = msp_initialise(&msp); + CU_ASSERT_EQUAL_FATAL(ret, 0); + + ret = msp_run(&msp, DBL_MAX, UINT32_MAX); + CU_ASSERT_EQUAL(ret, MSP_EXIT_MODEL_COMPLETE); + + msp_verify(&msp, 0); + + free(time_of_ev); + free(ev_type); + free(start_deme); + free(end_deme); + msp_free(&msp); + tsk_table_collection_free(&tables); + gsl_rng_free(rng); +} + +static void +test_sweep_reverse_wm(void) +{ + /* To mimic the nrepeats = 300 parameter in msms cmdline arguments*/ + for (int i = 0; i < 300; i++) { + verify_sweep_reverse_wm(i + 6584367292); + } +} + +static void +verify_sweep_reverse_wm_back_and_forth(unsigned long int seed) +{ + int ret; + uint32_t n = 10; + msp_t msp; + gsl_rng *rng = safe_rng_alloc(); + tsk_table_collection_t tables; + tsk_id_t mut_pop[] = { 101 }; + int num_events = 3 * mut_pop[0] - 5; + int num_demes = 1; + double *time_of_ev; + int *ev_type; + int *start_deme; + int *end_deme; + int r, i; + double p; + double num_loci = 5001; + double position = num_loci / 2; + double recom_rate = 0.000004; + tsk_id_t final_mut_pop[] = { 1 }; + + gsl_rng_set(rng, seed); + + time_of_ev = (double *) malloc(sizeof(double) * num_events); + ev_type = (tsk_id_t *) malloc(sizeof(tsk_id_t) * num_events); + end_deme = (tsk_id_t *) malloc(sizeof(tsk_id_t) * num_events); + start_deme = (tsk_id_t *) malloc(sizeof(tsk_id_t) * num_events); + + r = rand() % RAND_MAX; + p = (double) r / RAND_MAX; + time_of_ev[0] = num_events - p; + ev_type[0] = 0; + start_deme[0] = 0; + end_deme[0] = 0; + + for (i = 1; i < num_events; i++) { + r = rand() % RAND_MAX; + p = (double) r / RAND_MAX; + time_of_ev[i] = time_of_ev[i - 1] - p; + if (i % 3 == 2) { + ev_type[i] = 1; + } else { + ev_type[i] = 0; + } + start_deme[i] = 0; + end_deme[i] = 0; + } + + ret = build_sim(&msp, &tables, rng, num_loci, num_demes, NULL, n); + CU_ASSERT_EQUAL(ret, 0); + CU_ASSERT_EQUAL_FATAL(msp_set_recombination_rate(&msp, recom_rate), 0); + ret = msp_set_num_labels(&msp, 2); CU_ASSERT_EQUAL(ret, 0); + msp_set_discrete_genome(&msp, 0); + msp_set_gene_conversion_rate(&msp, 0); + msp_set_gene_conversion_tract_length(&msp, 1); + msp_set_avl_node_block_size(&msp, 65536); + msp_set_node_mapping_block_size(&msp, 65536); + msp_set_segment_block_size(&msp, 65536); + + ret = msp_set_simulation_model_sweep_genic_selection_reverse(&msp, position, + num_events, num_demes, mut_pop[0], 0.0, mut_pop, final_mut_pop, time_of_ev, + ev_type, start_deme, end_deme); + CU_ASSERT_EQUAL_FATAL(ret, 0); + ret = msp_initialise(&msp); + CU_ASSERT_EQUAL_FATAL(ret, 0); + + ret = msp_run(&msp, DBL_MAX, UINT32_MAX); + CU_ASSERT_EQUAL(ret, MSP_EXIT_MODEL_COMPLETE); + + msp_verify(&msp, 0); + + free(time_of_ev); + free(ev_type); + free(start_deme); + free(end_deme); + msp_free(&msp); + tsk_table_collection_free(&tables); + gsl_rng_free(rng); +} + +static void +test_sweep_reverse_wm_back_and_forth(void) +{ + /* To mimic the nrepeats = 300 parameter in msms cmdline arguments*/ + for (int i = 0; i < 300; i++) { + verify_sweep_reverse_wm_back_and_forth(i + 462523296209); + } +} + +static void +verify_sweep_reverse_wm_oscillating(unsigned long int seed) +{ + int ret; + uint32_t n = 10; + msp_t msp; + gsl_rng *rng = safe_rng_alloc(); + tsk_table_collection_t tables; + tsk_id_t mut_pop[] = { 1001 }; + int num_events = 3 * mut_pop[0] - 9; + int num_demes = 1; + double *time_of_ev; + int *ev_type; + int *start_deme; + int *end_deme; + int r, i; + double p; + double num_loci = 5001; + double position = num_loci / 2; + double recom_rate = 0.00004; + tsk_id_t final_mut_pop[] = { 1 }; + + gsl_rng_set(rng, seed); + + time_of_ev = (double *) malloc(sizeof(double) * num_events); + ev_type = (tsk_id_t *) malloc(sizeof(tsk_id_t) * num_events); + end_deme = (tsk_id_t *) malloc(sizeof(tsk_id_t) * num_events); + start_deme = (tsk_id_t *) malloc(sizeof(tsk_id_t) * num_events); + + r = rand() % RAND_MAX; + p = (double) r / RAND_MAX; + time_of_ev[0] = num_events - p; + ev_type[0] = 0; + start_deme[0] = 0; + end_deme[0] = 0; + + for (i = 1; i < num_events; i++) { + r = rand() % RAND_MAX; + p = (double) r / RAND_MAX; + time_of_ev[i] = time_of_ev[i - 1] - p; + if ((i < 2 * mut_pop[0] - 6) && (i > mut_pop[0] - 3)) { + ev_type[i] = 1; + } else { + ev_type[i] = 0; + } + start_deme[i] = 0; + end_deme[i] = 0; + } + + ret = build_sim(&msp, &tables, rng, num_loci, num_demes, NULL, n); + CU_ASSERT_EQUAL(ret, 0); + CU_ASSERT_EQUAL_FATAL(msp_set_recombination_rate(&msp, recom_rate), 0); + ret = msp_set_num_labels(&msp, 2); CU_ASSERT_EQUAL(ret, 0); + msp_set_discrete_genome(&msp, 0); + msp_set_gene_conversion_rate(&msp, 0); + msp_set_gene_conversion_tract_length(&msp, 1); + msp_set_avl_node_block_size(&msp, 65536); + msp_set_node_mapping_block_size(&msp, 65536); + msp_set_segment_block_size(&msp, 65536); + + ret = msp_set_simulation_model_sweep_genic_selection_reverse(&msp, position, + num_events, num_demes, mut_pop[0], 0.0, mut_pop, final_mut_pop, time_of_ev, + ev_type, start_deme, end_deme); + CU_ASSERT_EQUAL_FATAL(ret, 0); + + ret = msp_initialise(&msp); + CU_ASSERT_EQUAL_FATAL(ret, 0); + ret = msp_run(&msp, DBL_MAX, UINT32_MAX); CU_ASSERT_EQUAL(ret, MSP_EXIT_MODEL_COMPLETE); msp_verify(&msp, 0); + free(time_of_ev); + free(ev_type); + free(start_deme); + free(end_deme); msp_free(&msp); + tsk_table_collection_free(&tables); gsl_rng_free(rng); - // free(samples); +} + +static void +test_sweep_reverse_wm_oscillating(void) +{ + /* To mimic the nrepeats = 300 parameter in msms cmdline arguments*/ + for (int i = 0; i < 300; i++) { + verify_sweep_reverse_wm_oscillating(i + 462941996216); + } +} + +static void +verify_sweep_reverse_wm_sudden_drop(unsigned long int seed) +{ + int ret; + uint32_t n = 10; + msp_t msp; + gsl_rng *rng = safe_rng_alloc(); + tsk_table_collection_t tables; + tsk_id_t mut_pop[] = { 10001 }; + int num_events = mut_pop[0] - 1; + int num_demes = 1; + double *time_of_ev; + int *ev_type; + int *start_deme; + int *end_deme; + int r, i; + double p; + double num_loci = 5001; + double position = num_loci / 2; + double recom_rate = 0.0004; + tsk_id_t final_mut_pop[] = { 1 }; + + time_of_ev = (double *) malloc(sizeof(double) * num_events); + ev_type = (tsk_id_t *) malloc(sizeof(tsk_id_t) * num_events); + end_deme = (tsk_id_t *) malloc(sizeof(tsk_id_t) * num_events); + start_deme = (tsk_id_t *) malloc(sizeof(tsk_id_t) * num_events); + + // Test over differnt seeds + gsl_rng_set(rng, seed); + + r = rand() % RAND_MAX; + p = (double) r / RAND_MAX; + time_of_ev[0] = num_events - p / 10000; + ev_type[0] = 0; + start_deme[0] = 0; + end_deme[0] = 0; + + for (i = 1; i < num_events; i++) { + r = rand() % RAND_MAX; + p = (double) r / RAND_MAX; + time_of_ev[i] = time_of_ev[i - 1] - p / 10000; + ev_type[i] = 0; + start_deme[i] = 0; + end_deme[i] = 0; + } + + ret = build_sim(&msp, &tables, rng, num_loci, num_demes, NULL, n); + CU_ASSERT_EQUAL(ret, 0); + CU_ASSERT_EQUAL_FATAL(msp_set_recombination_rate(&msp, recom_rate), 0); + ret = msp_set_num_labels(&msp, 2); + CU_ASSERT_EQUAL(ret, 0); + + // To mimic the verfication.py call + msp_set_discrete_genome(&msp, 0); + msp_set_gene_conversion_rate(&msp, 0); + msp_set_gene_conversion_tract_length(&msp, 1); + msp_set_avl_node_block_size(&msp, 65536); + msp_set_node_mapping_block_size(&msp, 65536); + msp_set_segment_block_size(&msp, 65536); + + ret = msp_set_simulation_model_sweep_genic_selection_reverse(&msp, position, + num_events, num_demes, num_events + 1, 0.0, mut_pop, final_mut_pop, time_of_ev, + ev_type, start_deme, end_deme); + CU_ASSERT_EQUAL_FATAL(ret, 0); + + ret = msp_initialise(&msp); + CU_ASSERT_EQUAL_FATAL(ret, 0); + + ret = msp_run(&msp, DBL_MAX, UINT32_MAX); + CU_ASSERT_EQUAL(ret, MSP_EXIT_MODEL_COMPLETE); + + msp_verify(&msp, 0); + + free(time_of_ev); + free(ev_type); + free(start_deme); + free(end_deme); + msp_free(&msp); tsk_table_collection_free(&tables); + gsl_rng_free(rng); } static void -test_sweep_genic_selection_mimic_msms(void) +test_sweep_reverse_wm_sudden_drop(void) { /* To mimic the nrepeats = 300 parameter in msms cmdline arguments*/ for (int i = 0; i < 300; i++) { - sweep_genic_selection_mimic_msms_single_run(i + 1); + verify_sweep_reverse_wm_sudden_drop(i + 6584367292); } } static void -test_sweep_genic_selection_reverse(void) +verify_sweep_reverse_1D_deme_wise(unsigned long int seed) +{ + int ret; + uint32_t n = 10; + msp_t msp; + gsl_rng *rng = safe_rng_alloc(); + tsk_table_collection_t tables; + tsk_id_t *mut_pop; + tsk_id_t tot_pop = 100; + int num_demes = 10; + sample_t *samples = malloc(n * sizeof(sample_t)); + int num_events = num_demes * tot_pop - 1; + double migration_rate = 0.25; + size_t deme_index; + double *time_of_ev; + int *ev_type; + int *start_deme; + int *end_deme; + int r, i; + double p; + double num_loci = 5001; + double position = num_loci / 2; + double recom_rate = 0.00004; + tsk_id_t *final_mut_pop; + + time_of_ev = (double *) malloc(sizeof(double) * num_events); + ev_type = (tsk_id_t *) malloc(sizeof(tsk_id_t) * num_events); + end_deme = (tsk_id_t *) malloc(sizeof(tsk_id_t) * num_events); + start_deme = (tsk_id_t *) malloc(sizeof(tsk_id_t) * num_events); + mut_pop = (tsk_id_t *) malloc(sizeof(tsk_id_t) * num_demes); + final_mut_pop = (tsk_id_t *) malloc(sizeof(tsk_id_t) * num_demes); + + for (i = 0; i < n; i++) { + samples[i].time = 0; + samples[i].population = i % num_demes; + } + + for (i = 0; i < num_demes; i++) { + mut_pop[i] = tot_pop; + final_mut_pop[i] = 0; + } + final_mut_pop[0] = 1; + + // Test over differnt seeds + gsl_rng_set(rng, seed); + + r = rand() % RAND_MAX; + p = (double) r / RAND_MAX; + time_of_ev[0] = num_events - p; + ev_type[0] = 0; + deme_index = num_demes - 1; + start_deme[0] = deme_index; + end_deme[0] = deme_index; + + for (i = 1; i < num_events; i++) { + r = rand() % RAND_MAX; + p = (double) r / RAND_MAX; + time_of_ev[i] = time_of_ev[i - 1] - p; + if (i % tot_pop == (tot_pop - 1)) { + ev_type[i] = 2; + end_deme[i] = deme_index - 1; + start_deme[i] = deme_index; + deme_index -= 1; + } else { + ev_type[i] = 0; + start_deme[i] = deme_index; + end_deme[i] = deme_index; + } + } + + ret = build_sim(&msp, &tables, rng, num_loci, num_demes, samples, n); + CU_ASSERT_EQUAL(ret, 0); + CU_ASSERT_EQUAL_FATAL(msp_set_recombination_rate(&msp, recom_rate), 0); + ret = msp_set_num_labels(&msp, 2); + CU_ASSERT_EQUAL(ret, 0); + + // To mimic the verfication.py call + msp_set_discrete_genome(&msp, 0); + msp_set_gene_conversion_rate(&msp, 0); + msp_set_gene_conversion_tract_length(&msp, 1); + msp_set_avl_node_block_size(&msp, 65536); + msp_set_node_mapping_block_size(&msp, 65536); + msp_set_segment_block_size(&msp, 65536); + + ret = msp_set_simulation_model_sweep_genic_selection_reverse(&msp, position, + num_events, num_demes, num_events + 1, migration_rate, mut_pop, final_mut_pop, + time_of_ev, ev_type, start_deme, end_deme); + CU_ASSERT_EQUAL_FATAL(ret, 0); + + ret = msp_initialise(&msp); + CU_ASSERT_EQUAL_FATAL(ret, 0); + + ret = msp_run(&msp, DBL_MAX, UINT32_MAX); + CU_ASSERT_EQUAL(ret, MSP_EXIT_MODEL_COMPLETE); + + msp_verify(&msp, 0); + + free(time_of_ev); + free(ev_type); + free(start_deme); + free(end_deme); + free(mut_pop); + free(final_mut_pop); + free(samples); + msp_free(&msp); + tsk_table_collection_free(&tables); + gsl_rng_free(rng); +} + +static void +test_sweep_reverse_1D_deme_wise(void) { /* To mimic the nrepeats = 300 parameter in msms cmdline arguments*/ - for (int i = 0; i < 300; i++) - sweep_genic_selection_reverse_single_run(i + 1); + for (int i = 0; i < 300; i++) { + verify_sweep_reverse_1D_deme_wise(i + 6584367292); + } } int @@ -448,17 +958,27 @@ main(int argc, char **argv) CU_TestInfo tests[] = { { "test_genic_selection_trajectory", test_genic_selection_trajectory }, { "test_sweep_genic_selection_bad_parameters", - test_sweep_genic_selection_bad_parameters }, + test_sweep_genic_selection_bad_parameters }, { "test_sweep_genic_selection_events", test_sweep_genic_selection_events }, { "test_sweep_genic_selection_single_locus", - test_sweep_genic_selection_single_locus }, + test_sweep_genic_selection_single_locus }, { "test_sweep_genic_selection_recomb", test_sweep_genic_selection_recomb }, { "test_sweep_genic_selection_gc", test_sweep_genic_selection_gc }, { "test_sweep_genic_selection_time_change", - test_sweep_genic_selection_time_change }, + test_sweep_genic_selection_time_change }, { "test_sweep_genic_selection_mimic_msms", test_sweep_genic_selection_mimic_msms }, - { "test_sweep_genic_selection_reverse", test_sweep_genic_selection_reverse }, + { "test_sweep_reverse_wm_no_recomb", + test_sweep_reverse_wm_no_recomb }, + { "test_sweep_reverse_wm", + test_sweep_reverse_wm }, + { "test_sweep_reverse_wm_back_and_forth", + test_sweep_reverse_wm_back_and_forth }, + { "test_sweep_reverse_wm_oscillating", + test_sweep_reverse_wm_oscillating }, + { "test_sweep_reverse_wm_sudden_drop", + test_sweep_reverse_wm_sudden_drop }, + { "test_sweep_reverse_1D_deme_wise", test_sweep_reverse_1D_deme_wise }, CU_TEST_INFO_NULL, }; diff --git a/msprime/_msprimemodule.c b/msprime/_msprimemodule.c index a3c794e05..f894075a3 100644 --- a/msprime/_msprimemodule.c +++ b/msprime/_msprimemodule.c @@ -151,20 +151,6 @@ get_dict_number(PyObject *dict, const char *key_str) return ret; } -static PyObject * -get_dict_string(PyObject *dict, const char *key_str) -{ - PyObject *ret = NULL; - PyObject *value; - value = get_required_dict_value(dict, key_str); - if (value == NULL) { - goto out; - } - ret = value; -out: - return ret; -} - static int parse_rate_map(PyObject *py_rate_map, size_t *ret_size, PyArrayObject **ret_position, PyArrayObject **ret_rate) @@ -1077,34 +1063,33 @@ Simulator_parse_sweep_genic_selection_model(Simulator *self, PyObject *py_model) return ret; } -static int -Simulator_parse_sweep_genic_selection_reverse_model(Simulator *self, PyObject *py_model) -{ - int ret = -1; - int err; - double position; - const char *filename; - PyObject *value; - value = get_dict_number(py_model, "position"); - if (value == NULL) { - goto out; - } - position = PyFloat_AsDouble(value); - value = get_dict_string(py_model, "filename"); - if (value == NULL) { - goto out; - } - filename = PyUnicode_AsUTF8(value); - err = msp_set_simulation_model_sweep_genic_selection_reverse(self->sim, - position, filename); - if (err != 0) { - handle_input_error("sweep genic selection reverse", err); - goto out; - } - ret = 0; -out: - return ret; -} +//static int +//Simulator_parse_sweep_genic_selection_reverse_model(Simulator *self, PyObject *py_model) +//{ +// int ret = -1; +// int err; +// double position; +// const char *filename; +// PyObject *value; +// value = get_dict_number(py_model, "position"); +// if (value == NULL) { +// goto out; +// } +// position = PyFloat_AsDouble(value); +// value = get_dict_string(py_model, "filename"); +// if (value == NULL) { +// goto out; +// } +// filename = PyUnicode_AsUTF8(value); +// err = msp_set_simulation_model_sweep_genic_selection_reverse(self->sim, double position, size_t num_steps, int num_demes, int tot_pop, double migration_rate, tsk_id_t *mut_pop, tsk_id_t *mut_pop_final, double *t_of_forward_ev, tsk_id_t *ev_type, tsk_id_t *start_deme, tsk_id_t *end_deme); +// if (err != 0) { +// handle_input_error("sweep genic selection reverse", err); +// goto out; +// } +// ret = 0; +//out: +// return ret; +//} static int Simulator_parse_simulation_model(Simulator *self, PyObject *py_model) @@ -1296,12 +1281,12 @@ Simulator_parse_simulation_model(Simulator *self, PyObject *py_model) if (is_sweep_genic_selection_reverse == -1) { goto out; } - if (is_sweep_genic_selection_reverse) { - ret = Simulator_parse_sweep_genic_selection_reverse_model(self, py_model); - if (ret != 0) { - goto out; - } - } + //if (is_sweep_genic_selection_reverse) { + // ret = Simulator_parse_sweep_genic_selection_reverse_model(self, py_model); + // if (ret != 0) { + // goto out; + // } + //} if (! (is_hudson || is_dtwf || is_smc || is_smc_prime || is_smc_k || is_dirac || is_beta || is_sweep_genic_selection || is_sweep_genic_selection_reverse || is_fixed_pedigree)) { From 690c7cbb8ebc92cd3f4ac72844bb151a46c65462 Mon Sep 17 00:00:00 2001 From: Aalhad-Bhatt Date: Wed, 3 Dec 2025 16:03:50 -0500 Subject: [PATCH 4/4] Fixed test params Fixed the parameters for the tests to be consistent with each other. --- lib/tests/test_sweeps.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/lib/tests/test_sweeps.c b/lib/tests/test_sweeps.c index 2b3d8b9f2..ab0b30172 100644 --- a/lib/tests/test_sweeps.c +++ b/lib/tests/test_sweeps.c @@ -388,7 +388,7 @@ verify_sweep_reverse_wm_no_recomb(unsigned long int seed) gsl_rng *rng = safe_rng_alloc(); tsk_table_collection_t tables; int num_demes = 1; - tsk_id_t mut_pop[] = { 1001 }; + tsk_id_t mut_pop[] = { 10001 }; int num_events = mut_pop[0] - 1; double *time_of_ev; int *ev_type; @@ -564,7 +564,7 @@ verify_sweep_reverse_wm_back_and_forth(unsigned long int seed) msp_t msp; gsl_rng *rng = safe_rng_alloc(); tsk_table_collection_t tables; - tsk_id_t mut_pop[] = { 101 }; + tsk_id_t mut_pop[] = { 1001 }; int num_events = 3 * mut_pop[0] - 5; int num_demes = 1; double *time_of_ev; @@ -575,7 +575,7 @@ verify_sweep_reverse_wm_back_and_forth(unsigned long int seed) double p; double num_loci = 5001; double position = num_loci / 2; - double recom_rate = 0.000004; + double recom_rate = 0.00004; tsk_id_t final_mut_pop[] = { 1 }; gsl_rng_set(rng, seed); @@ -657,7 +657,7 @@ verify_sweep_reverse_wm_oscillating(unsigned long int seed) msp_t msp; gsl_rng *rng = safe_rng_alloc(); tsk_table_collection_t tables; - tsk_id_t mut_pop[] = { 1001 }; + tsk_id_t mut_pop[] = { 10001 }; int num_events = 3 * mut_pop[0] - 9; int num_demes = 1; double *time_of_ev; @@ -978,7 +978,7 @@ main(int argc, char **argv) test_sweep_reverse_wm_oscillating }, { "test_sweep_reverse_wm_sudden_drop", test_sweep_reverse_wm_sudden_drop }, - { "test_sweep_reverse_1D_deme_wise", test_sweep_reverse_1D_deme_wise }, + //{ "test_sweep_reverse_1D_deme_wise", test_sweep_reverse_1D_deme_wise }, CU_TEST_INFO_NULL, };