def run_the_app():
# Draw the UI elements to search for objects (pedestrians, cars, etc.)
gsize, s1, s2, s3, i1, i2, i3, r1, r2, r3, run = frame_selector_ui()
progress_flu_rule = DiscreteInvMarkovChain('flu-status',
{ 's': [s1, s2, s3], 'i': [i1, i2, i3], 'r': [r1, r2, r3] })
# s - susceptible
# i - infectious
# r - recovered
sites = { 'home': Site('h'), 'work': Site('w') }
probe_grp_size_flu = GroupSizeProbe.by_attr('flu', 'flu-status', progress_flu_rule.get_states(), msg_mode=ProbeMsgMode.DISP, memo='Mass distribution across flu status')
probe_grp_size_site = GroupSizeProbe.by_rel('site', Site.AT, sites.values(), msg_mode=ProbeMsgMode.DISP, memo='Mass distribution across sites')
data = ""
s = Simulation()
s.add_rule(progress_flu_rule)
s.add_probe(probe_grp_size_flu)
s.add_group(Group('g0', gsize, { 'flu-status': 's' }))
sys.stdout = open('out.dat', 'w')
s.run(int(run))
sys.stdout.close()
with open('out.dat') as file:
data = file.readlines()
for line in data:
st.write(line)
def simple(self):
progress_flu_rule = DiscreteInvMarkovChain('flu-status', { 's': [0.95, 0.05, 0.00], 'i': [0.00, 0.50, 0.50], 'r': [0.10, 0.00, 0.90] })
# s - susceptible
# i - infectious
# r - recovered
sites = { 'home': Site('h'), 'work': Site('w') }
probe_grp_size_flu = GroupSizeProbe.by_attr('flu', 'flu-status', progress_flu_rule.get_states(), msg_mode=ProbeMsgMode.DISP, memo='Mass distribution across flu status')
probe_grp_size_site = GroupSizeProbe.by_rel('site', Site.AT, sites.values(), msg_mode=ProbeMsgMode.DISP, memo='Mass distribution across sites')
# ----------------------------------------------------------------------------------------------------------------------
# (1) Simulations testing the basic operations on groups and rules:
# (1.1) A single-group, single-rule (1g.1r) simulation:
s = Simulation()
s.add_rule(progress_flu_rule)
s.add_probe(probe_grp_size_flu)
s.add_group(Group('g0', 1000, { 'flu-status': 's' }))
sys.stdout = open('out.dat', 'w')
s.run(24)
sys.stdout.close()
with open('out.dat') as file:
self.data = file.readlines()
self.data = str(self.data)
apple = self.data.replace('\\n', '<br>')
# print(apple)
return apple
def run_sim(p_lst):
for p in p_lst:
sim = (Simulation().
# add_rule(ResetSchoolDayRule(7)).
add_rule(GoToAndBackTimeAtRule()).
add_rule(flu_rule).
add_probes(probes_grp_size_flu_school)
)
for s in school_specs:
(sim.new_group(s.name, s.m).
set_attr('is-student', True).
set_attr('flu', 's').
set_rel(Site.AT, sites['home']).
set_rel('home', sites['home']).
set_rel('school', sites[f'school-{s.name}']).
done()
)
setattr(flu_rule, 'p_infection_min', p)
for p in probes_grp_size_flu_school:
p.set_consts([Const('p_inf_min', 'float', str(flu_rule.p_infection_min))])
p.set_persistence(probe_persistence)
sim.run(24 * sim_dur_days)
def sim_flu_ac_init(session, do_force=False):
if 'sim-flu-ac' in session and not do_force:
return
if 'sim-flu-ac' in session:
session.pop('sim-flu-ac')
gc.collect()
school_l = Site(450149323) # 88% low income students
school_m = Site(450067740) # 7% low income students
session['sim-flu-ac'] = (
Simulation().
set().
pragma_autocompact(True).
pragma_live_info(True).
pragma_live_info_ts(False).
pragma_rule_analysis_for_db_gen(False).
done().
add().
probe(sim_flu_ac_init_get_probe(school_l, 'low-income')).
probe(sim_flu_ac_init_get_probe(school_m, 'med-income')).
done()
)
session['stdout'] = []
def sim_flu_init(session, do_force=False):
if 'sim-flu' in session and not do_force:
return
if 'sim-flu' in session:
session.pop('sim-flu')
sites = { s:Site(s) for s in ['home', 'school-a', 'school-b']}
probe_grp_size_site = GroupSizeProbe.by_rel('site', Site.AT, sites.values(), msg_mode=ProbeMsgMode.CUMUL)
session['sim-flu'] = (
Simulation().
set().
pragma_live_info(False).
pragma_live_info_ts(False).
done().
add().
rule(ResetSchoolDayRule(TimePoint(7))).
rule(GoToAndBackTimeAtRule(t_at_attr='t@school')).
probe(probe_grp_size_site).
done().
new_group(500).
set_rel(Site.AT, sites['home']).
set_rel('home', sites['home']).
set_rel('school', sites['school-a']).
done().
new_group(500).
set_rel(Site.AT, sites['home']).
set_rel('home', sites['home']).
set_rel('school', sites['school-b']).
done()
)
def sim01(iter_cnt):
sim = (Simulation().add([
ProgressFluRule(),
GroupSizeProbe.by_attr('flu',
'flu', ['s', 'e', 'r'],
msg_mode=ProbeMsgMode.CUMUL),
Group(m=1000)
]).run(iter_cnt))
print(sim.probes[0].get_msg())
print()
def sim02(iter_cnt):
sim = (Simulation().add([
ProgressFluIncomeRule(),
GroupSizeProbe.by_attr('flu',
'flu', ['s', 'e', 'r'],
msg_mode=ProbeMsgMode.CUMUL),
Group(m=500, attr={'income': 'l'}),
Group(m=500, attr={'income': 'm'})
]).run(iter_cnt))
print(sim.probes[0].get_msg())
print()
def runSimulations(n):
for n in range(numberOfSimulations):
(Simulation().
set().
pragma_autocompact(True).
done().
add([
FluProgressRule(),
Group('Susceptible', initialSusceptible, attr={ 'flu': 's' }, rel={ Site.AT: site }),
Group('Exposed', initialExposed, attr={ 'flu': 'e' }, rel={ Site.AT: site }),
Group('Infectious', initialInfectious, attr={ 'flu': 'i' }, rel={ Site.AT: site }),
Group('Recovered', initialRecovered, attr={ 'flu': 'r' }, rel={ Site.AT: site }),
]).
run(numberOfDays)
)
print()
def run(iter):
(Simulation().set().rand_seed(1928).pragma_autocompact(
True).pragma_live_info(True).pragma_live_info_ts(False).fn_group_setup(
grp_setup).done().add().rule(
FluProgressRule()).rule(FluLocationRule()).probe(
probe_flu_at(school_l, 'low-income')
). # the simulation output we care about and want monitored
probe(probe_flu_at(school_m, 'med-income')). # ^
done().db(fpath_db).gen_groups(
tbl='students',
attr_db=[],
rel_db=[GroupDBRelSpec(name='school', col='school_id')],
attr_fix={},
rel_fix={
'home': site_home
},
rel_at='school').done().run(iter))
def graph(self):
if os.path.isfile(fpath_db): os.remove(fpath_db)
te = TrajectoryEnsemble(fpath_db)
if te.is_db_empty:
te.set_pragma_memoize_group_ids(True)
te.add_trajectories([
(Simulation().
add([
SARSQuarantineIntervention(
SEQIHRModel('sars', beta=0.80, alpha_n=0.75, alpha_q=0.40, delta_n=0.01, delta_h=0.03, mu=0.01, chi=0.01, phi=0.20, rho=0.75, solver=ODESolver()),
chi=0.99,
i=int(intervention_onset)
),
Group(m=95000, attr={ 'sars': 's' }),
Group(m= 5000, attr={ 'sars': 'e' })
])
) for intervention_onset in TN(30,120, 75,100, 5)
])
te.set_group_names(group_names)
sys.stdout = open('out.dat', 'w')
s.run(400)
sys.stdout.close()
with open('out.dat') as file:
self.data = file.readlines()
self.data = str(self.data)
apple = self.data.replace('\\n', '<br>')
# print(apple)
te.plot_mass_locus_line ((1200,300), os.path.join(os.path.dirname(__file__), 'out', 'plot-line.png'), col_scheme='tableau10', opacity_min=0.35)
te.plot_mass_locus_line_aggr((1200,300), os.path.join(os.path.dirname(__file__), 'out', 'plot-ci.png'), col_scheme='tableau10')
fpath_diag = os.path.join(os.path.dirname(__file__), 'out', 'sim-04.diag')
fpath_pdf = os.path.join(os.path.dirname(__file__), 'out', 'sim-04.pdf')
te.traj[2].sim.gen_diagram(fpath_diag, fpath_pdf)
def sim03(iter_cnt):
sim = (Simulation().add([
ProgressFluIncomeRule(),
GroupSizeProbe(
'flu-income',
[
GroupQry(attr={
'income': 'l',
'flu': 's'
}),
GroupQry(attr={
'income': 'l',
'flu': 'e'
}),
GroupQry(attr={
'income': 'l',
'flu': 'r'
}),
GroupQry(attr={
'income': 'm',
'flu': 's'
}),
GroupQry(attr={
'income': 'm',
'flu': 'e'
}),
GroupQry(attr={
'income': 'm',
'flu': 'r'
})
],
msg_mode=ProbeMsgMode.CUMUL,
),
Group(m=500, attr={'income': 'l'}),
Group(m=500, attr={'income': 'm'})
]).run(iter_cnt))
print(sim.probes[0].get_msg())
print()
def sim01():
from pram.data import GroupSizeProbe, ProbeMsgMode
from pram.entity import Site
from pram.rule import GoToAndBackTimeAtRule, ResetSchoolDayRule, TimePoint
from pram.sim import Simulation
sites = {s: Site(s) for s in ['home', 'school-a', 'school-b']}
probe_grp_size_site = GroupSizeProbe.by_rel('site',
Site.AT,
sites.values(),
msg_mode=ProbeMsgMode.CUMUL)
(Simulation().add().rule(ResetSchoolDayRule(TimePoint(7))).rule(
GoToAndBackTimeAtRule(t_at_attr='t@school')).probe(
probe_grp_size_site).commit().new_group(500).set_rel(
Site.AT, sites['home']).set_rel('home', sites['home']).set_rel(
'school',
sites['school-a']).commit().new_group(500).set_rel(
Site.AT,
sites['home']).set_rel('home', sites['home']).set_rel(
'school', sites['school-b']).commit().run(18))
return probe_grp_size_site.get_msg()
def run_simulation():
sim_info = json.loads(request.form['runInfo'])
initial_groups = sim_info['groups']
included_rules = sim_info['rules']
runs = sim_info['runs']
time_offset = sim_info['start_time']
add_initial_rules(time_offset)
s = Simulation(do_keep_mass_flow_specs=True)
#s.add_probe(probe_grp_size_site)
for rule_name in included_rules:
for r in rules[rule_name]:
s.add_rule(r)
g_index = 0
for group in initial_groups:
g_name = "g" + str(g_index)
g_index = g_index + 1
g_mass = group['n']
g_attributes = get_attribute_dictionary(group['attributeKeys'],
group['attributeValues'])
g_relations = get_attribute_dictionary(group['relationKeys'],
group['relationValues'])
g = Group(g_name, g_mass, g_attributes)
if not group['site'] == "":
g.set_rel(Site.AT, sites[group['site']])
for k, v in g_relations.items():
g.set_rel(k, sites[v])
s.add_group(g)
flows = run_and_get_mass_flow(s, runs)
return jsonify(flows)
queries=[GroupQry(attr={ 'flu': 's' }), GroupQry(attr={ 'flu': 'i' }), GroupQry(attr={ 'flu': 'r' })],
qry_tot=None,
var_names=['ps', 'pi', 'pr', 'ns', 'ni', 'nr'],
persistence=ProbePersistenceMem(),
msg_mode=ProbeMsgMode.NONE
)
# ----------------------------------------------------------------------------------------------------------------------
# (3) Simulation:
s = (Simulation().
set_pragma_autocompact(True).
add([
ODESystemMass(f_sir_model, [DotMap(attr={ 'flu': 's' }), DotMap(attr={ 'flu': 'i' }), DotMap(attr={ 'flu': 'r' })], dt=0.1),
Group(m=950, attr={ 'flu': 's' }),
Group(m= 50, attr={ 'flu': 'i' }),
probe
]).
run(1000)
)
# ----------------------------------------------------------------------------------------------------------------------
# (4) Results:
# Time series plot (group mass):
cmap = plt.get_cmap('tab20')
series = [
{ 'var': 'ps', 'lw': 2, 'linestyle': '--', 'marker': '+', 'color': cmap(0), 'markersize': 0, 'lbl': 'Susceptible' },
{ 'var': 'pi', 'lw': 2, 'linestyle': '-', 'marker': 'o', 'color': cmap(4), 'markersize': 0, 'lbl': 'Infectious' },
l = self.get_lambda(age)
p0 = poisson(l).pmf(0)
print(
f'n: {round(group.m,2):>12} age: {age:>3} l: {round(l,2):>3} p0: {round(p0,2):<4} p1: {round(1-p0,2):<4}'
)
return [
GroupSplitSpec(p=1.00,
attr_set={
'age': age + age_inc,
'ad': False
})
] # testing so don't move mass
def is_applicable(self, group, iter, t):
return super().is_applicable(group, iter, t) and group.ha(
['age', 'ad'])
def setup(self, pop, group):
if group.ha('age'):
return self.get_split_specs(group, 0)
else:
return None
# ----------------------------------------------------------------------------------------------------------------------
(Simulation().set().pragma_autocompact(True).pragma_live_info(
False).done().add().rule(DoubleIncidenceADRule()).group(
Group(m=100, attr={'age': 60})).done().run(40))
def __init__(self, t=TimeAlways()):
super().__init__(t=t, name='flu-spike-evt')
def apply(self, pop, group, iter, t):
return [
GroupSplitSpec(p=0.90, attr_set={ 'flu': 'i' }),
GroupSplitSpec(p=0.10)
]
def is_applicable(self, group, iter, t):
return super().is_applicable(group, iter, t) and iter == 30 and (group.ha({ 'flu': 's' }) or group.ha({ 'flu': 'r' }))
(Simulation().
add_probe(GroupSizeProbe.by_attr('flu', 'flu', ['s', 'i', 'r'], msg_mode=ProbeMsgMode.DISP)).
add_rule(SIRSModel('flu', beta=0.05, gamma=0.50, alpha=0.10)).
add_rule(FluSpikeEvent()).
add_group(Group(m=1000, attr={ 'flu': 's' })).
run(48)
)
# ----------------------------------------------------------------------------------------------------------------------
# dpath_cwd = os.path.dirname(__file__)
# fpath_db = os.path.join(dpath_cwd, f'sim.sqlite3')
#
# if os.path.isfile(fpath_db):
# os.remove(fpath_db)
#
# probe = GroupSizeProbe(
# name='flu',
# queries=[
if self.persistence:
self.persistence.persist(self, [
self.pop.m, self.pop.m_out, migrating_m, migrating_p,
migrating_time_mean, migrating_time_sd, settled_m, settled_p
], iter, t, traj_id)
# ----------------------------------------------------------------------------------------------------------------------
# persistence = None
persistence = ProbePersistenceMem()
# persistence = ProbePersistenceDB(os.path.join(os.path.dirname(__file__), f'sim-03.sqlite3'), mode=ProbePersistenceMode.OVERWRITE)
# ----------------------------------------------------------------------------------------------------------------------
# Simulation:
sim = (
Simulation().set_pragmas(analyze=False, autocompact=True).add([
ConflictRule(severity=0.05, scale=0.2, i=[0, 3 * 12]),
MigrationRule(env_harshness=0.05),
PopProbe(persistence),
Group(m=1 * 1000 * 1000,
attr={'is-migrating': False},
rel={Site.AT: site_conflict})
]).add(
sites_dst
) # this line is explicitly required for translation since no agents start outside Sudan
)
# ----------------------------------------------------------------------------------------------------------------------
pram2mesa(sim, 'Migration')
from pram.data import GroupSizeProbe, ProbeMsgMode
from pram.entity import Group, Site
from pram.rule import SEIRFluRule
from pram.sim import Simulation
rand_seed = 1928
probe_grp_size_flu = GroupSizeProbe.by_attr(
'flu',
SEIRFluRule.ATTR,
SEIRFluRule.State,
msg_mode=ProbeMsgMode.DISP,
memo='Mass distribution across flu states')
(Simulation().set().rand_seed(rand_seed).done().add().rule(
SEIRFluRule()).probe(probe_grp_size_flu).done().new_group(
1000).done().summary(True, 0, 0, 0, 0,
(0, 1)).run(16).compact().summary(
False, 8, 0, 0, 0, (1, 0)))
# (Simulation().
# set().
# rand_seed(rand_seed).
# pragma_analyze(False).
# pragma_autocompact(True).
# done().
# add().
# rule(SEIRFluRule()).
# probe(probe_grp_size_flu).
# done().
# new_group(1000).
# done().
'''
A test of the mass transfer graph.
'''
from pram.entity import Group
from pram.model.epi import SIRSModel
from pram.sim import Simulation
from pram.traj import Trajectory, TrajectoryEnsemble
# ----------------------------------------------------------------------------------------------------------------------
def get_out_dir(filename):
return os.path.join(os.path.dirname(__file__), 'out', filename)
te = (TrajectoryEnsemble().add_trajectories([
Trajectory(sim=(Simulation().add(
[SIRSModel('flu', beta, 0.50, 0.10),
Group(m=1000, attr={'flu': 's'})])),
name=f'SIR: b={round(beta,2)}') for beta in [0.05, 0.10]
]).set_group_names([(0, 'S', Group.gen_hash(attr={'flu': 's'})),
(1, 'I', Group.gen_hash(attr={'flu': 'i'})),
(2, 'R', Group.gen_hash(attr={'flu': 'r'}))]).run(100))
# te.plot_mass_locus_line ((1200,300), get_out_dir('_plot-line.png'), iter_range=(-1, -1))
# te.plot_mass_locus_line_aggr((1200,300), get_out_dir('_plot-aggr.png'), iter_range=(-1, -1))
# te.traj[1].plot_mass_locus_streamgraph((900,600), get_out_dir('_plot.png'), do_sort=True)
# te.traj[1].plot_heatmap((800,800), get_out_dir('_plot-heatmap.png'), (-1,20))
(Simulation(6,1,24, rand_seed=rand_seed).
new_group('g0', 1000).
set_rel(Site.AT, sites['home']).
set_rel('home', sites['home']).
set_rel('work', sites['work-a']).
set_rel('store', sites['store-a']).
commit().
new_group('g1', 1000).
set_rel(Site.AT, sites['home']).
set_rel('home', sites['home']).
set_rel('work', sites['work-b']).
set_rel('store', sites['store-b']).
commit().
new_group('g2', 100).
set_rel(Site.AT, sites['home']).
set_rel('home', sites['home']).
set_rel('work', sites['work-c']).
commit().
add_rule(GotoRule(TimeInt( 8,12), 0.4, 'home', 'work', 'Some agents leave home to go to work')).
add_rule(GotoRule(TimeInt(16,20), 0.4, 'work', 'home', 'Some agents return home from work')).
add_rule(GotoRule(TimeInt(16,21), 0.2, 'home', 'store', 'Some agents go to a store after getting back home')).
add_rule(GotoRule(TimeInt(17,23), 0.3, 'store', 'home', 'Some shopping agents return home from a store')).
add_rule(GotoRule(TimePoint(24), 1.0, 'store', 'home', 'All shopping agents return home after stores close')).
add_rule(GotoRule(TimePoint( 2), 1.0, None, 'home', 'All still-working agents return home')).
add_probe(probe_grp_size_site).
summary((True, True, True, True, True), (0,1)).
run().
summary((False, True, False, False, False), (1,1)).
run(4)
)
'flu-status',
progress_flu_rule.get_states(),
msg_mode=ProbeMsgMode.DISP,
memo='Mass distribution across flu status')
probe_grp_size_site = GroupSizeProbe.by_rel(
'site',
Site.AT,
sites.values(),
msg_mode=ProbeMsgMode.DISP,
memo='Mass distribution across sites')
# ----------------------------------------------------------------------------------------------------------------------
# (1) Simulations testing the basic operations on groups and rules:
# (1.1) A single-group, single-rule (1g.1r) simulation:
s = Simulation()
s.add_rule(progress_flu_rule)
s.add_probe(probe_grp_size_flu)
s.add_group(Group('g0', 1000, {'flu-status': 's'}))
s.run(24)
# (1.2) A single-group, two-rule (1g.2r) simulation:
# s = Simulation()
# s.add_rule(progress_flu_rule)
# s.add_rule(GoToRule(TimeInt(10,16), 0.4, 'home', 'work'))
# s.add_probe(probe_grp_size_flu)
# s.add_group(Group('g0', 1000, { 'flu-status': 's' }, { Site.AT: sites['home'], 'home': sites['home'], 'work': sites['work'] }))
# s.run(24)
# (1.3) As above (1g.2r), but with reversed rule order (which should not, and does not, change the results):
# s = Simulation()
# ----------------------------------------------------------------------------------------------------------------------
sites = {'home': Site('h'), 'work': Site('w')}
probe_grp_size_flu = GroupSizeProbe.by_attr(
'flu',
'flu-stage',
AttrFluStage,
msg_mode=ProbeMsgMode.DISP,
memo='Mass distribution across flu stages')
# ----------------------------------------------------------------------------------------------------------------------
# (1) A proper simulation:
print('(1)')
s = (Simulation(TimeHour(6), 16).add_rule(ProgressFluRule()).add_rule(
GoToAndBackTimeAtRule()).add_probe(probe_grp_size_flu).new_group(
'0', 1000).set_attr('flu-stage', AttrFluStage.NO).commit())
print(f'Attributes : {s.last_run.attr_used}')
print(f'Relations : {s.last_run.rel_used}')
print()
# ----------------------------------------------------------------------------------------------------------------------
# (2) Improper simulations (rendered proper automatically):
# (2.1) A group has superfluous attributes and relations, but automatic group pruning saved the day:
print('(2.1)')
(Simulation(TimeHour(6), 16).set_pragma_autoprune_groups(True).add_rule(
ProgressFluRule()).add_probe(probe_grp_size_flu).new_group(
'0',
probe_grp_size_flu = GroupSizeProbe.by_attr(
'flu',
'flu', ['S', 'I', 'R'],
msg_mode=ProbeMsgMode.DISP,
persistance=ProbePersistanceDB(),
memo='Mass distribution across flu status')
p = GroupSizeProbe.by_attr('flu',
'flu', ['S', 'I', 'R'],
persistance=ProbePersistanceDB())
(Simulation().add_probe(
GroupSizeProbe.by_attr('flu',
'flu', ['S', 'I', 'R'],
msg_mode=ProbeMsgMode.DISP)).add_probe(p).add_rule(
SIRRule()).add_group(
Group(m=1000, attr={'flu': 'S'})).run(26))
series = [{
'var': 'p0',
'lw': 0.75,
'linestyle': '-',
'marker': 'o',
'color': 'red',
'markersize': 0,
'lbl': 'S'
}, {
'var': 'p1',
'lw': 0.75,
'linestyle': '--',
# (0) Init:
rand_seed = 1928
pragma_live_info = True
pragma_live_info_ts = False
fpath_db_in = os.path.join(os.path.dirname(__file__), '..', '..', '..', 'data',
'allegheny-county', 'allegheny-students.sqlite3')
# ----------------------------------------------------------------------------------------------------------------------
# (1) Sites:
sites = Simulation.gen_sites_from_db(
fpath_db_in,
lambda fpath_db:
{'school': Site.gen_from_db(fpath_db, 'schools', 'sp_id', 'school', [])},
pragma_live_info=pragma_live_info,
pragma_live_info_ts=pragma_live_info_ts)
site_home = Site('home')
# ----------------------------------------------------------------------------------------------------------------------
# (2) Probes:
# n_schools = 8
# few_schools = [sites['school'][k] for k in list(sites['school'].keys())[:n_schools]]
#
# probe_grp_size_few_schools = GroupSizeProbe('school', [GroupQry(rel={ Site.AT: s }) for s in few_schools], msg_mode=ProbeMsgMode.DISP)
fpath_db = os.path.join(os.path.dirname(__file__), 'out-test-03c.sqlite3')
# ----------------------------------------------------------------------------------------------------------------------
if os.path.isfile(fpath_db): os.remove(fpath_db)
te = TrajectoryEnsemble(fpath_db)
# te = TrajectoryEnsemble(fpath_db, cluster_inf=ClusterInf(address='auto'))
# te = TrajectoryEnsemble(fpath_db, cluster_inf=ClusterInf(num_cpus=6, memory=500*1024*1024, object_store_memory=500*1024*1024, include_webui=True))
if te.is_db_empty:
te.set_pragma_memoize_group_ids(True)
te.add_trajectories([
Trajectory(
(Simulation().
add([
SIRModel('flu', beta=0.10, gamma=0.05, solver=MCSolver()),
SIRModel('flu', beta=0.50, gamma=U(0.01, 0.15), i=[int(5 + TN(0,50, 5,10)), 50], solver=MCSolver()),
FluProcess(i=[50,0], p_max=None, a=3.0, scale=flu_proc_scale),
Group(m=950, attr={ 'flu': 's' }),
Group(m= 50, attr={ 'flu': 'i' })
])
)
) for flu_proc_scale in U(1,5, 1)
])
te.set_group_names(group_names)
te.run(120)
# Visualize:
te.plot_mass_locus_line ((1200,300), os.path.join(os.path.dirname(__file__), 'out', '_plot-line.png'), opacity_min=0.2)
te.plot_mass_locus_line_aggr((1200,300), os.path.join(os.path.dirname(__file__), 'out', '_plot-iqr.png'))
var_names=['ps', 'pi', 'pr', 'ns', 'ni', 'nr'],
persistence=ProbePersistenceMem(),
msg_mode=ProbeMsgMode.NONE)
# ----------------------------------------------------------------------------------------------------------------------
# (3) Simulation:
s = (
Simulation().set_pragma_autocompact(True).add([
ODESystemMass(f_sir_model, [
DotMap(attr={'flu': 's'}),
DotMap(attr={'flu': 'i'}),
DotMap(attr={'flu': 'r'})
],
dt=0.1),
# FluEvent(),
# FluLinProcess(),
# FluExpProcess(),
FluGammaProcess(),
# ODESystemMass(f_decay, [DotMap(attr={ 'flu': 'r' }), DotMap(attr={ 'flu': 's' })], dt=0.1),
Group(m=950, attr={'flu': 's'}),
Group(m=50, attr={'flu': 'i'}),
probe
]).run(3000))
# ----------------------------------------------------------------------------------------------------------------------
# (4) Results:
# Time series plot (group mass):
cmap = plt.get_cmap('tab20')
series = [{
'var': 'ps',
Simulation(pop_hist_len=0).set().pragma_analyze(
False).pragma_autocompact(True).pragma_comp_summary(
False).pragma_fractional_mass(False).
pragma_live_info(False).fn_group_setup(grp_setup).done().add([
DailyBehaviorRule('school', p_home_IS=0.90),
DailyBehaviorRule('work', p_home_IS=0.90),
# DiseaseRule('school', r0=1.8, p_E_IA=0.40, p_IA_IS=0.40, p_IS_R=0.40, p_home_E=0.025, p_social_E=0.05, soc_dist_comp_young=sdc, soc_dist_comp_old=sdc, p_fat_by_age_group=p_covid19_fat_by_age_group_comb),
# DiseaseRule('work', r0=1.8, p_E_IA=0.40, p_IA_IS=0.40, p_IS_R=0.40, p_home_E=0.025, p_social_E=0.05, soc_dist_comp_young=sdc, soc_dist_comp_old=sdc, p_fat_by_age_group=p_covid19_fat_by_age_group_comb),
DiseaseRule2(
'school',
SEI2RModelParams.by_clinical_obs(s0=2,
r0=1.8,
incub_period=5.1 * 2,
asympt_period=2.5 * 2,
inf_dur=5.0 * 2),
p_home_E=0.0,
p_social_E=0.95,
soc_dist_comp_young=0.66,
soc_dist_comp_old=0.45,
p_fat_by_age_group=p_covid19_fat_by_age_group_comb),
DiseaseRule2(
'work',
SEI2RModelParams.by_clinical_obs(s0=2,
r0=1.8,
incub_period=5.1 * 2,
asympt_period=2.5 * 2,
inf_dur=5.0 * 2),
p_home_E=0.0,
p_social_E=0.95,
soc_dist_comp_young=0.66,
soc_dist_comp_old=0.45,
p_fat_by_age_group=p_covid19_fat_by_age_group_comb),
ClosedownIntervention(prop_pop_IS_threshold=0.01),
ReopenIntervention(prop_pop_IS_threshold=0.02),
PopProbe(persistence, do_print=False),
]))
if os.path.isfile(fpath_db): os.remove(fpath_db)
te = TrajectoryEnsemble(fpath_db)
if te.is_db_empty:
te.set_pragma_memoize_group_ids(True)
te.add_trajectories([(Simulation().add([
SARSQuarantineIntervention(SEQIHRModel('sars',
beta=0.80,
alpha_n=0.75,
alpha_q=0.40,
delta_n=0.01,
delta_h=0.03,
mu=0.01,
chi=0.01,
phi=0.20,
rho=0.75,
solver=ODESolver()),
chi=0.99,
i=int(intervention_onset)),
Group(m=95000, attr={'sars': 's'}),
Group(m=5000, attr={'sars': 'e'})
])) for intervention_onset in TN(30, 120, 75, 100, 5)])
te.set_group_names(group_names)
te.run(400)
# te.plot_mass_locus_line ((1200,300), os.path.join(os.path.dirname(__file__), 'out', 'plot-line.png'), col_scheme='tableau10', opacity_min=0.35)
# te.plot_mass_locus_line_aggr((1200,300), os.path.join(os.path.dirname(__file__), 'out', 'plot-ci.png'), col_scheme='tableau10')
# fpath_diag = os.path.join(os.path.dirname(__file__), 'out', 'sim-04.diag')
def setup(self, pop, group):
return [GroupSplitSpec(p=1.0, attr_set={"value": 1000})]
old_p = GroupSizeProbe.by_attr('stage',
'stage', ['c', 'success', 'failure'],
persistance=ProbePersistanceMem(),
msg_mode=ProbeMsgMode.CUMUL)
probe2 = GroupSizeProbe.by_attr("value",
"value", ['c', 'success', 'failure'],
persistance=ProbePersistanceMem(),
msg_mode=ProbeMsgMode.DISP)
# c_group = Group(name="c", m = 100, attr = {"stage" : "c", "value": 1000})
# success_group = Group(name="success", m = 100, attr ={"stage":"success", "value" : 1000})
# failure_group = Group(name="failure", m = 100, attr = {"stage": "failure", "value" : 1000})
c_group = Group(name="c", m=100, attr={"stage": "c"})
success_group = Group(name="success", m=100, attr={"stage": "success"})
failure_group = Group(name="failure", m=100, attr={"stage": "failure"})
sim = (Simulation().add([
SimpleMultiplyCombined(), old_p, probe2, c_group, success_group,
failure_group
]).run(10))
print(sim.probes[0].get_msg())
print(sim.probes[1].get_msg())
print()
import random
from scipy.stats import poisson
from pram.entity import Group, Site
from pram.rule import SegregationModel
from pram.sim import Simulation
from pram.traj import Trajectory, TrajectoryEnsemble
# ----------------------------------------------------------------------------------------------------------------------
loc = [Site('a'), Site('b')]
s = (Simulation().set().pragma_autocompact(True).pragma_live_info(
False).done().add([
SegregationModel('team', len(loc)),
Group(m=200, attr={'team': 'blue'}, rel={Site.AT: loc[0]}),
Group(m=300, attr={'team': 'blue'}, rel={Site.AT: loc[1]}),
Group(m=100, attr={'team': 'red'}, rel={Site.AT: loc[0]}),
Group(m=400, attr={'team': 'red'}, rel={Site.AT: loc[1]})
]))
# ----------------------------------------------------------------------------------------------------------------------
te = (TrajectoryEnsemble().add_trajectory(Trajectory(
'segregation', None, s)).set_group_names([
(0, 'Blue A',
Group.gen_hash(attr={'team': 'blue'}, rel={Site.AT: loc[0]})),
(1, 'Blue B',
Group.gen_hash(attr={'team': 'blue'}, rel={Site.AT: loc[1]})),
(2, 'Red A', Group.gen_hash(attr={'team': 'red'},
rel={Site.AT: loc[0]})),
(3, 'Red B', Group.gen_hash(attr={'team': 'red'},
rel={Site.AT: loc[1]}))
