def post_args():
args = request.json
args['hospitalized'] = RateLos(args['hospitalized_rate'],
args['hospitalized_los'])
args['icu'] = RateLos(args['icu_rate'], args['icu_los'])
args['ventilated'] = RateLos(args['ventilated_rate'],
args['ventilated_los'])
del args['hospitalized_rate']
del args['hospitalized_los']
del args['icu_rate']
del args['icu_los']
del args['ventilated_rate']
del args['ventilated_los']
p = Parameters(**args)
m = SimSirModel(p)
files = []
prefix = datetime.now().strftime("%Y.%m.%d.%H.%M.")
for df, name in (
(m.raw_df, "raw"),
(m.admits_df, "admits"),
(m.census_df, "census"),
):
filename = path.join(gettempdir(), prefix + name + ".csv")
df.to_csv(filename)
files.append(filename)
zipfilename = path.join(gettempdir(), prefix + 'result.zip')
with ZipFile(zipfilename, 'w') as zip:
for file in files:
zip.write(file, path.basename(file))
return send_file(zipfilename)
def main():
"""Main."""
a = parse_args()
p = Parameters(
current_hospitalized=a.current_hospitalized,
doubling_time=a.doubling_time,
known_infected=a.known_infected,
market_share=a.market_share,
n_days=a.n_days,
relative_contact_rate=a.relative_contact_rate,
susceptible=a.susceptible,
hospitalized=RateLos(a.hospitalized_rate, a.hospitalized_los),
icu=RateLos(a.icu_rate, a.icu_los),
ventilated=RateLos(a.ventilated_rate, a.ventilated_los),
)
m = SimSirModel(p)
prefix = a.prefix
for df, name in (
(m.raw_df, "raw"),
(m.admits_df, "admits"),
(m.census_df, "census"),
):
df.to_csv(prefix + name + ".csv")
def get_chime_model(parameters):
'''
instantiates and returns CHIME model using parameters
'''
if not isinstance(parameters, Parameters):
t = type(parameters)
raise TypeError(f'parameters must be a Parameters object not {t}')
return SimSirModel(parameters)
def test_model_first_hosp_fit(param):
param.date_first_hospitalized = param.current_date - timedelta(days=43)
param.doubling_time = None
my_model = SimSirModel(param)
assert abs(my_model.intrinsic_growth_rate - 0.123) / 0.123 < 0.01
assert abs(my_model.beta - 4.21501347256401e-07) < EPSILON
assert abs(my_model.r_t - 2.32) / 2.32 < 0.01
assert abs(my_model.r_naught - 2.72) / 2.72 < 0.01
assert abs(my_model.doubling_time_t - 7.71) / 7.71 < 0.01
def sim_chimes(scenarios: str, p: Parameters = None):
"""
Run many chime simulations.
If `params` is not None, then it is used to initialize all parameters. Any
parameter values set to something other than None in the following
optional args will update that parameter value. If `params` is None, then
all additional args must be other than None. These settings are just
for the base parameter values. We can run stuff over ranges as we see it.
:param scenarios:
:param params:
:return:
"""
base_input_params_dict = vars(p)
# Create a range of social distances
soc_dists = np.arange(0.05, 0.60, 0.05)
# array([0.05, 0.1 , 0.15, 0.2 , 0.25, 0.3 , 0.35, 0.4 , 0.45, 0.5 , 0.55, 0.6 ])
num_scenarios = len(soc_dists)
# We can store outputs any way we want. For this demo, just going to
# use a master list. # This will be a list of dicts of the
# result dataframes (+ 1 dict containing the scenario inputs)
results_list = []
for sd_pct in soc_dists:
sim_scenario = '{}{:.0f}'.format(scenarios, 100 * sd_pct)
# Update the parameters for this scenario
p.relative_contact_rate = sd_pct
input_params_dict = vars(p)
# Run the model
m = Model.SimSirModel(p)
# Gather results
results = gather_sim_results(m, sim_scenario, input_params_dict)
# Append results to results list
results_list.append(results.copy())
return results_list
def callback(self, *args, **kwargs):
"""
"""
kwargs = dict(zip(self.callback_inputs, args))
pars = self.components["sidebar"].parse_form_parameters(**kwargs)
kwargs["model"] = SimSirModel(pars)
kwargs["pars"] = pars
callback_returns = []
for component in self.components.values():
try:
callback_returns += component.callback(**kwargs)
except Exception as error:
raise HTMLComponentError(component, error)
return callback_returns
def handle_model_change(i, sidebar_data):
model = {}
pars = None
result = []
viz_kwargs = {}
if sidebar_data:
pars = parameters_deserializer(sidebar_data["parameters"])
model = SimSirModel(pars)
viz_kwargs = dict(
labels=pars.labels,
table_mod=7,
max_y_axis=pars.max_y_axis,
)
result.extend(i.components["intro"].build(model, pars))
for df_key in ["admits_df", "census_df", "sim_sir_w_date_df"]:
df = None
if model:
df = model.__dict__.get(df_key, None)
result.extend(prepare_visualization_group(df, **viz_kwargs))
return result
def handle_model_change_helper(pars_json):
model = None
pars = None
result = []
viz_kwargs = {}
if pars_json:
pars = parameters_deserializer(pars_json)
model = SimSirModel(pars)
viz_kwargs = dict(
labels=pars.labels,
table_mod=7,
max_y_axis=pars.max_y_axis,
# show_tables=kwargs["show_tables"],
)
result.extend(self.components["intro"].build(model, pars))
result.extend(self.components["tool_details"].build(model, pars))
for df_key in ["admits_df", "census_df", "sim_sir_w_date_df"]:
df = model.__dict__.get(df_key, None)
result.extend(prepare_visualization_group(df, **viz_kwargs))
return result
def sim_chime(scenario: str, p: Parameters
):
"""
Run one chime simulation.
If `params` is not None, then it is used to initialize all parameters. Any
parameter values set to something other than None in the following
optional args will update that parameter value. If `params` is None, then
all additional args must be other than None.
:param scenario:
:param p:
"""
input_params_dict = vars(p)
# Run the model
m = Model.SimSirModel(p)
# Gather results
results = gather_sim_results(m, sim_scenario, input_params_dict)
return results
from penn_chime.models import SimSirModel
from penn_chime.charts import (
additional_projections_chart,
admitted_patients_chart,
new_admissions_chart,
chart_descriptions
)
# This is somewhat dangerous:
# Hide the main menu with "Rerun", "run on Save", "clear cache", and "record a screencast"
# This should not be hidden in prod, but removed
# In dev, this should be shown
st.markdown(hide_menu_style, unsafe_allow_html=True)
p = display_sidebar(st, DEFAULTS)
m = SimSirModel(p)
display_header(st, m, p)
if st.checkbox("Show more info about this tool"):
notes = "The total size of the susceptible population will be the entire catchment area for Penn Medicine entities (HUP, PAH, PMC, CCH)"
show_more_info_about_this_tool(st=st, model=m, parameters=p, defaults=DEFAULTS, notes=notes)
st.subheader("New Admissions")
st.markdown("Projected number of **daily** COVID-19 admissions at Penn hospitals")
new_admit_chart = new_admissions_chart(alt, m.admits_df, parameters=p)
st.altair_chart(
new_admissions_chart(alt, m.admits_df, parameters=p),
use_container_width=True,
)
def sim_chimes(
scenarios: str,
params: Parameters = None,
current_hospitalized: int = None,
doubling_time: float = None,
known_infected: int = None,
relative_contact_rate: float = None,
susceptible: int = None,
hospitalized: RateLos = None,
icu: RateLos = None,
ventilated: RateLos = None,
market_share: float = None,
n_days: int = None,
recovery_days: float = None,
):
"""
Run many chime simulations.
If `params` is not None, then it is used to initialize all parameters. Any
parameter values set to something other than None in the following
optional args will update that parameter value. If `params` is None, then
all additional args must be other than None. These settings are just
for the base parameter values. We can run stuff over ranges as we see it.
:param scenarios:
:param params:
:param current_hospitalized:
:param doubling_time:
:param known_infected:
:param relative_contact_rate:
:param susceptible:
:param hospitalized:
:param icu:
:param ventilated:
:param market_share:
:param n_days:
:param recovery_days:
:return:
"""
if params is not None:
params_dict = vars(params)
else:
params_dict = {
"current_hospitalized": None,
"doubling_time": None,
"known_infected": None,
"relative_contact_rate": None,
"susceptible": None,
"hospitalized": None,
"icu": None,
"ventilated": None,
"market_share": None,
"n_days": None,
"recovery_days": None,
}
# Check for parameter updates passed
vals_passed = {
key: value
for (key, value) in vars().items()
if key not in ['scenario', 'params']
}
for key, value in vals_passed.items():
if value is not None:
params_dict[key] = value
# Create Parameters object
p = Parameters(
current_hospitalized=params_dict['current_hospitalized'],
doubling_time=params_dict['doubling_time'],
known_infected=params_dict['known_infected'],
market_share=params_dict['market_share'],
n_days=params_dict['n_days'],
relative_contact_rate=params_dict['relative_contact_rate'],
susceptible=params_dict['susceptible'],
hospitalized=params_dict['hospitalized'],
icu=params_dict['icu'],
ventilated=params_dict['ventilated'],
)
base_input_params_dict = vars(p)
# Create a range of social distances
soc_dists = np.arange(0.05, 0.60, 0.05)
# array([0.05, 0.1 , 0.15, 0.2 , 0.25, 0.3 , 0.35, 0.4 , 0.45, 0.5 , 0.55,
# 0.6 , 0.65, 0.7 , 0.75, 0.8 , 0.85])
num_scenarios = len(soc_dists)
# We can store outputs any way we want. For this demo, just going to
# use a master list. # This will be a list of dicts of the
# result dataframes (+ 1 dict containing the scenario inputs)
results_list = []
for sdpct in soc_dists:
sim_scenario = '{}{:.0f}'.format(scenarios, 100 * sdpct)
# Update the parameters for this scenario
p.relative_contact_rate = sdpct
input_params_dict = vars(p)
# Run the model
m = SimSirModel(p)
# Gather results
results = gather_sim_results(m, sim_scenario, input_params_dict)
# Append results to results list
results_list.append(results.copy())
return results_list
def sim_chime(
sim_scenario: str,
params: Parameters = None,
current_hospitalized: int = None,
doubling_time: float = None,
known_infected: int = None,
relative_contact_rate: float = None,
susceptible: int = None,
hospitalized: RateLos = None,
icu: RateLos = None,
ventilated: RateLos = None,
market_share: float = None,
n_days: int = None,
recovery_days: float = None,
):
"""
Run one chime simulation.
If `params` is not None, then it is used to initialize all parameters. Any
parameter values set to something other than None in the following
optional args will update that parameter value. If `params` is None, then
all additional args must be other than None.
:param sim_scenario:
:param params:
:param current_hospitalized:
:param doubling_time:
:param known_infected:
:param relative_contact_rate:
:param susceptible:
:param hospitalized:
:param icu:
:param ventilated:
:param market_share:
:param n_days:
:param recovery_days:
:return:
"""
if params is not None:
params_dict = vars(params)
else:
params_dict = {
"current_hospitalized": None,
"doubling_time": None,
"known_infected": None,
"relative_contact_rate": None,
"susceptible": None,
"hospitalized": None,
"icu": None,
"ventilated": None,
"market_share": None,
"n_days": None,
"recovery_days": None,
}
# Check for parameter updates passed
vals_passed = {
key: value
for (key, value) in vars().items()
if key not in ['scenario', 'params']
}
for key, value in vals_passed.items():
if value is not None:
params_dict[key] = value
# Create Parameters object
p = Parameters(
current_hospitalized=params_dict['current_hospitalized'],
doubling_time=params_dict['doubling_time'],
known_infected=params_dict['known_infected'],
market_share=params_dict['market_share'],
n_days=params_dict['n_days'],
relative_contact_rate=params_dict['relative_contact_rate'],
susceptible=params_dict['susceptible'],
hospitalized=params_dict['hospitalized'],
icu=params_dict['icu'],
ventilated=params_dict['ventilated'],
)
input_params_dict = vars(p)
# Run the model
m = SimSirModel(p)
# Gather results
results = gather_sim_results(m, sim_scenario, input_params_dict)
return results
