def main():
"""Main."""
my_args = parse_args()
my_args_dict = vars(my_args)
# Update sys.arg so we can call cli.parse_args()
sys.argv = [sys.argv[0], '--file', my_args_dict['file']]
a = cli.parse_args()
p = Parameters(
current_hospitalized=a.current_hospitalized,
date_first_hospitalized=a.date_first_hospitalized,
doubling_time=a.doubling_time,
infectious_days=a.infectious_days,
market_share=a.market_share,
n_days=a.n_days,
relative_contact_rate=a.relative_contact_rate,
population=a.population,
hospitalized=Disposition(a.hospitalized_rate, a.hospitalized_days),
icu=Disposition(a.icu_rate, a.icu_days),
ventilated=Disposition(a.ventilated_rate, a.ventilated_days),
)
m = Model(p)
for df, name in (
(m.sim_sir_w_date_df, "sim_sir_w_date"),
(m.admits_df, "projected_admits"),
(m.census_df, "projected_census"),
):
df.to_csv(f"{p.current_date}_{name}.csv")
def parameters_deserializer(p_json: str):
values = loads(p_json)
result = Parameters(
current_hospitalized=values["current_hospitalized"],
hospitalized=Disposition(*values["hospitalized"]),
icu=Disposition(*values["icu"]),
relative_contact_rate=values["relative_contact_rate"],
ventilated=Disposition(*values["ventilated"]),
current_date=parse_date(values["current_date"]),
date_first_hospitalized=values["date_first_hospitalized"],
doubling_time=values["doubling_time"],
infectious_days=values["infectious_days"],
market_share=values["market_share"],
max_y_axis=values["max_y_axis"],
n_days=values["n_days"],
population=values["population"],
recovered=values["recovered"],
region=values["region"],
)
for key, value in values.items():
if result.__dict__[key] != value and key not in ("dispositions",
"hospitalized", "icu",
"ventilated",
"current_date"):
result.__dict__[key] = value
return result
def get_model_params(parameters, region_results):
print("PARAMETERS PRINT", parameters)
p = { **parameters }
del p["param_set_id"]
days_back = p["end_date_days_back"]
del p["end_date_days_back"]
p["current_date"] = \
p["current_date"] - datetime.timedelta(days=days_back)
p["region"] = Regions(**{ p["region_name"]: p["population"] })
#print(p["hosp_census_lookback"])
derived_from = p.get("region_derived_from")
if derived_from:
_derived_region_setup(p, derived_from, region_results)
else:
_base_region_setup(p, days_back)
del p["hosp_census_lookback"]
for k in list(p): # convert keys to list so we don't modify p while iterating
if k.startswith("region_"):
del p[k] # delete region_name, etc.
del p["hosp_pop_share"]
if "exclude_pop_from_total" in p:
del p["exclude_pop_from_total"]
icu_rate = round(p["relative_icu_rate"] * p["hospitalized"].rate, 4)
vent_rate = round(p["relative_vent_rate"] * icu_rate, 4)
p["icu"] = Disposition(icu_rate, p["icu_days"])
p["ventilated"] = Disposition(vent_rate, p["icu_days"])
del p["relative_icu_rate"]
del p["relative_vent_rate"]
del p["icu_days"]
return p
def create_params_from_file(file):
"""
Create CHIME Parameters object from input config file
:param file:
:return:
"""
# Update sys.arg so we can call cli.parse_args()
sys.argv = [sys.argv[0], '--file', file]
a = cli.parse_args()
p = Parameters(
current_hospitalized=a.current_hospitalized,
infectious_days=a.infectious_days,
market_share=a.market_share,
n_days=a.n_days,
relative_contact_rate=a.relative_contact_rate,
population=a.population,
hospitalized=Disposition(a.hospitalized_rate, a.hospitalized_days),
icu=Disposition(a.icu_rate, a.icu_days),
ventilated=Disposition(a.ventilated_rate, a.ventilated_days),
)
if a.date_first_hospitalized is None:
p.doubling_time = a.doubling_time
else:
p.date_first_hospitalized = a.date_first_hospitalized
return p
def update_parameters(i, *input_values) -> List[dict]:
"""Reads html form outputs and converts them to a parameter instance
Returns Parameters
"""
inputs_dict = SidebarCallbacks.get_formated_values(i, input_values)
dt = inputs_dict["doubling_time"] if inputs_dict["doubling_time"] else None
dfh = inputs_dict["date_first_hospitalized"] if not dt else None
pars = Parameters(
current_hospitalized=inputs_dict["current_hospitalized"],
date_first_hospitalized=dfh,
doubling_time=dt,
hospitalized=Disposition.create(
days=inputs_dict["hospitalized_los"],
rate=inputs_dict["hospitalized_rate"] / 100,
),
icu=Disposition(
days=inputs_dict["icu_los"],
rate=inputs_dict["icu_rate"] / 100,
),
infectious_days=inputs_dict["infectious_days"],
market_share=inputs_dict["market_share"] / 100,
n_days=inputs_dict["n_days"],
population=inputs_dict["population"],
recovered=0, #FIXME input or pass through from defaults is required!
relative_contact_rate=inputs_dict["relative_contact_rate"] / 100,
ventilated=Disposition.create(
days=inputs_dict["ventilated_los"],
rate=inputs_dict["ventilated_rate"] / 100,
),
max_y_axis=inputs_dict.get("max_y_axis_value", None),
)
return [{"inputs_dict": inputs_dict, "parameters": parameters_serializer(pars)}]
def update_parameters(*input_values, **kwargs) -> List[str]:
"""Reads html form outputs and converts them to a parameter instance
Returns Parameters
"""
inputs_dict = Sidebar.get_formated_values(input_values)
dt = inputs_dict["doubling_time"] if inputs_dict["doubling_time"] else None
dfh = inputs_dict["date_first_hospitalized"] if not dt else None
pars = Parameters(
population=inputs_dict["population"],
current_hospitalized=inputs_dict["current_hospitalized"],
date_first_hospitalized=dfh,
doubling_time=dt,
hospitalized=Disposition(
inputs_dict["hospitalized_rate"] / 100, inputs_dict["hospitalized_los"]
),
icu=Disposition(inputs_dict["icu_rate"] / 100, inputs_dict["icu_los"]),
infectious_days=inputs_dict["infectious_days"],
market_share=inputs_dict["market_share"] / 100,
n_days=inputs_dict["n_days"],
relative_contact_rate=inputs_dict["relative_contact_rate"] / 100,
ventilated=Disposition(
inputs_dict["ventilated_rate"] / 100, inputs_dict["ventilated_los"]
),
max_y_axis=inputs_dict.get("max_y_axis_value", None),
)
return [parameters_serializer(pars)]
def parameters_deserializer(p_json: str):
values = loads(p_json)
dates = {
key: parse_date(values[key]).date() if values[key] else None
for key in (
"current_date",
"date_first_hospitalized",
"mitigation_date",
)
}
return Parameters(
current_date=dates["current_date"],
current_hospitalized=values["current_hospitalized"],
hospitalized=Disposition.create(
days=values["hospitalized"][0],
rate=values["hospitalized"][1],
),
icu=Disposition.create(
days=values["icu"][0],
rate=values["icu"][1],
),
infectious_days=values["infectious_days"],
date_first_hospitalized=dates["date_first_hospitalized"],
doubling_time=values["doubling_time"],
market_share=values["market_share"],
max_y_axis=values["max_y_axis"],
mitigation_date=dates["mitigation_date"],
n_days=values["n_days"],
population=values["population"],
recovered=values["recovered"],
region=values["region"],
relative_contact_rate=values["relative_contact_rate"],
ventilated=Disposition.create(
days=values["ventilated"][0],
rate=values["ventilated"][1],
),
)
output_path = my_args.output_path
# Read chime params from configuration file
a = cli.parse_args()
p = Parameters(
current_hospitalized=a.current_hospitalized,
date_first_hospitalized=a.date_first_hospitalized,
doubling_time=a.doubling_time,
infectious_days=a.infectious_days,
market_share=a.market_share,
n_days=a.n_days,
relative_contact_rate=a.relative_contact_rate,
population=a.population,
hospitalized=Disposition(a.hospitalized_rate, a.hospitalized_days),
icu=Disposition(a.icu_rate, a.icu_days),
ventilated=Disposition(a.ventilated_rate, a.ventilated_days),
)
if my_args.scenarios is None:
# Just running one scenario
results = sim_chime(scenario, p)
if not a.quiet:
print("Scenario: {}\n".format(results['scenario_str']))
print("\nInput parameters")
print("{}".format(50 * '-'))
print(json.dumps(results['input_params_dict'], indent=4, sort_keys=False))
print("\nIntermediate variables")
def get_varying_params(report_date, interpolated_days_count: int, use_future_divergence: bool):
fixed_dates = [
(datetime.date(2020, 4, 1), [.12]),
(datetime.date(2020, 4, 10), [.35]),
(datetime.date(2020, 4, 20), [.50]),
(datetime.date(2020, 4, 30), [.45]),
(datetime.date(2020, 5, 7), [.60]),
(datetime.date(2020, 5, 14), [.6]),
(datetime.date(2020, 6, 13), [.64]),
(datetime.date(2020, 7, 1), [.50, .60, .65, .70]),
(datetime.date(2020, 7, 7), [.50, .60, .65, .70]),
]
last_week = report_date - datetime.timedelta(days=7)
last_week_rates = _percent_range(55-3*3, 55+3*3, 3)
last_fixed_date = fixed_dates[-1][0]
interpolated_dates = \
interpolate_dates(last_fixed_date, last_week, interpolated_days_count)
past_stages = (
fixed_dates
+ list(zip(interpolated_dates, [_percent_range(25, 55, 5)] * len(interpolated_dates)))
+ [ (last_week, last_week_rates) ]
)
delta = 0.15
inc = 1.0 + delta
dec = 1.0 - delta
print (inc**2.0)
print (dec**2.0)
future_divergence_transforms = [
lambda last_week_rate: (.20,.20,.20 ),
lambda last_week_rate: (last_week_rate,last_week_rate,last_week_rate ),
lambda last_week_rate: (
last_week_rate * inc, last_week_rate * inc**2.0, last_week_rate * inc**3.0),
lambda last_week_rate: (
last_week_rate * dec, last_week_rate * dec**2.0, last_week_rate * dec**3.0),
lambda last_week_rate: (
last_week_rate * dec, last_week_rate * dec**2.0, last_week_rate * dec**3.0),
]
global _future_divergence_group_size
_future_divergence_group_size = len(future_divergence_transforms)
future_stages = {}
for last_week_rate in last_week_rates:
fs = []
fs.append((last_week_rate, ))
for fdt in future_divergence_transforms:
fs.append(fdt(last_week_rate))
fs = [ tuple( round(r, 4) for r in rs ) for rs in fs ]
future_stages[last_week_rate] = fs
past_combinations = list(itertools.product(*[ r for (d, r) in past_stages ]))
# It's useful to print these when debugging, but for real runs they get too
# large for us to want to print them.
#print(list( r for (d, r) in past_stages ))
#print(past_combinations)
#print(future_stages)
if not use_future_divergence:
combinations = list(past_combinations)
else:
combinations = []
for pc in past_combinations:
last_week_rate = pc[-1]
for fs in future_stages[last_week_rate]:
combined = pc + fs
combinations.append(combined)
dates = [ d for (d, r) in past_stages ]
if use_future_divergence:
dates = dates + [
report_date + datetime.timedelta(days=n) for n in [0,3,6,9]
]
for (d1, d2) in zip(dates[:-1], dates[1:]):
if not (d1 < d2):
raise AssertionError("Dates not in order:", d1, d2)
mitigation_stages = [
list(zip(dates, combo))
for combo in combinations
]
return {
"doubling_time":
list( dt/10.0 for dt in range(14, 26+1, 2) ),
"relative_contact_rate":
[.30],
#list( rcr/100.0 for rcr in range(50, 81, 10) ),
"mitigation_stages": mitigation_stages,
"mitigation_date": [ datetime.date(2020, 4, 10), ],
"hospitalized": list(
Disposition(pct/1000.0, days) for (pct, days)
in itertools.product(
#range(5, 15 + 1, 5),
[10],
[8] #range(5, 8, 1),
)
),
"relative_icu_rate": [
#pct/100.0 for pct in range(20, 50 + 1, 15)
pct/100.0 for pct in [10] # was: [24, 30]
],
"relative_vent_rate": [
#pct/100.0 for pct in range(70, 90 + 1, 10)
pct/100.0 for pct in [80]
],
"end_date_days_back": [ 0 ],
}