def gen_no_policy_simulation(): """ for 500 rounds, run the simulation and update each day ranges according to the global min and max values per state. """ consts = Consts.from_file(consts_file) range_per_day_dict = [ deepcopy(test_states) for _ in range(consts.total_steps) ] for i in range(500): print(i) sm = SimulationManager(supervisable_makers=test_states.keys(), consts=consts) sm.run() for supervisable in sm.supervisor.supervisables: name = supervisable.name() val_per_day = supervisable.y for test_state, val in zip(range_per_day_dict, val_per_day): test_state[name].update(val) # translate to dict for i in range(consts.total_steps): range_per_day_dict[i] = { state: val.to_dict() for state, val in range_per_day_dict[i].items() } # dump to json with open("simulation_test_ranges.json", "w") as f: json.dump(range_per_day_dict, f)
def test_no_policy_simulation(): """ run the simulation with no policy and fixed R0 Ranges for each state was generate from real sim runs, might be flaky. """ consts = Consts.from_file(consts_file) keys = range_per_day_dict[0].keys() sm = SimulationManager(supervisable_makers=keys, consts=consts) sm.run() for supervisable in sm.supervisor.supervisables: name = supervisable.name() val_per_day = supervisable.y # check for each day if value is in range for test_state, val in zip(range_per_day_dict, val_per_day): state = test_state[name] assert state["min"] <= val <= state["max"]
def run_simulation(args): matrix_data = MatrixData.import_matrix_data(args.matrix_data) population_data = PopulationData.import_population_data(args.population_data) initial_agent_constraints = InitialAgentsConstraints(args.agent_constraints_path) if args.simulation_parameters_path: consts = Consts.from_file(args.simulation_parameters_path) else: consts = Consts() set_seeds(args.seed) sm = SimulationManager( ( # "Latent", Supervisable.State.AddedPerDay("Asymptomatic"), Supervisable.State.Current("Asymptomatic"), Supervisable.State.TotalSoFar("Asymptomatic"), # "Silent", # "Asymptomatic", # "Symptomatic", # "Deceased", # "Hospitalized", # "ICU", # "Susceptible", # "Recovered", Supervisable.Sum( "Latent", "Latent-Asymp", "Latent-Presymp", "Asymptomatic", "Pre-Symptomatic", "Mild-Condition", "NeedOfCloseMedicalCare", "NeedICU", "ImprovingHealth", "PreRecovered", name="currently sick" ), # LambdaValueSupervisable("ever hospitalized", lambda manager: len(manager.medical_machine["Hospitalized"].ever_visited)), LambdaValueSupervisable( "was ever sick", lambda manager: len(manager.agents) - manager.medical_machine["Susceptible"].agent_count, ), Supervisable.NewCasesCounter(), Supervisable.Wrappers.Growth(Supervisable.NewCasesCounter(), 1), Supervisable.Wrappers.RunningAverage(Supervisable.Wrappers.Growth(Supervisable.NewCasesCounter()), 7), Supervisable.Wrappers.Growth(Supervisable.NewCasesCounter(), 7), # Supervisable.GrowthFactor( # Supervisable.Sum("Symptomatic", "Asymptomatic", "Latent", "Silent", "ICU", "Hospitalized"), # LambdaValueSupervisable("Detected Daily", lambda manager: manager.new_detected_daily), # LambdaValueSupervisable("Current Confirmed Cases", lambda manager: sum(manager.tested_positive_vector)), # Supervisable.R0(), # Supervisable.Delayed("Symptomatic", 3), ), population_data, matrix_data, initial_agent_constraints, run_args=args, consts=consts, ) print(sm) sm.run() df: pd.DataFrame = sm.dump(filename=args.output) df.plot() if args.figure_path: if not os.path.splitext(args.figure_path)[1]: args.figure_path = args.figure_path+'.png' plt.savefig(args.figure_path) else: plt.show()
def monte_carlo_state_machine_analysis(configuration: Dict) -> Dict: """ :param configuration: Dictionary with configuration for the mc run configuration must contain: * population_size for the mc configuration might contain: * consts_file - For loading Consts() * circle_consts file - for loading CircleConsts :return: Dictionary with statistics of the run: * population_size * days_passed - time it took to all the agents to recover/die * time_in_each_state - for each state, total number of days all agents were in it * visitors_in_each_state - Number of agents that visited each state * average_duration_in_state - Empirical mean time to stay at state conditioned that we enter it * state_duration_expected_time - Empirical mean to stay in state, not conditioned * average_time_to_terminal -Empirical mean time until death/recovery """ if 'consts_file' in configuration: consts = Consts.from_file(configuration['consts_file']) else: consts = Consts() if "circle_consts_file" in configuration: circle_const = CirclesConsts.from_file( configuration['circle_consts_file']) else: circle_const = CirclesConsts() population_size = configuration["monte_carlo_size"] medical_state_machine = consts.medical_state_machine() medical_machine_manager = MedicalStateManager( medical_state_machine=medical_state_machine) agents_list = _generate_agents_randomly(population_size=population_size, circle_consts=circle_const) _infect_all_agents(agents_list, medical_machine_manager, medical_state_machine) medical_states = medical_state_machine.states terminal_states = list(filter(_is_terminal_state, medical_states)) state_counter = Counter({m.name: m.agent_count for m in medical_states}) sum_days_to_terminal = 0 days_passed = 1 number_terminals_agents = 0 while number_terminals_agents != population_size: # No manager so we don't update it previous_terminal_agents = sum( [m.agent_count for m in terminal_states]) medical_machine_manager.step(list()) number_terminals_agents = sum([m.agent_count for m in terminal_states]) new_terminals = number_terminals_agents - previous_terminal_agents for m in medical_states: state_counter[m.name] += m.agent_count days_passed += 1 sum_days_to_terminal += days_passed * new_terminals average_state_time_duration, state_duration_expected_time = _get_empirical_state_times( medical_state_machine, population_size, state_counter) return dict(population_size=population_size, days_passed=days_passed, time_in_each_state=dict(state_counter), visitors_in_each_state={ m.name: len(m.ever_visited) for m in medical_state_machine.states }, average_duration_in_state=average_state_time_duration, state_duration_expected_time=state_duration_expected_time, average_time_to_terminal=sum_days_to_terminal / population_size)