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_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 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 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 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 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)
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=[ # GroupQry(attr={ 'flu': 's' }),
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'},
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')
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() # s.add_rule(GoToRule(TimeInt(10,16), 0.4, 'home', 'work')) # s.add_rule(progress_flu_rule) # s.add_probe(probe_grp_size_flu)
from pram.model.epi import SEQIHRModel from pram.rule import ODESystemMass, Intervention from pram.sim import Simulation from pram.traj import Trajectory, TrajectoryEnsemble from pram.util import Err # ---------------------------------------------------------------------------------------------------------------------- fpath_db = os.path.join(os.path.dirname(__file__), 'data', 'seqihr.sqlite3') # ---------------------------------------------------------------------------------------------------------------------- def TN(a, b, mu, sigma, n=None): return truncnorm((a - mu) / sigma, (b - mu) / sigma, mu, sigma).rvs(n) group_names = [(0, 'S', Group.gen_hash(attr={'sars': 's'})), (1, 'E', Group.gen_hash(attr={'sars': 'e'})), (2, 'Q', Group.gen_hash(attr={'sars': 'q'})), (3, 'I', Group.gen_hash(attr={'sars': 'i'})), (4, 'H', Group.gen_hash(attr={'sars': 'h'})), (5, 'R', Group.gen_hash(attr={'sars': 'r'}))] # ---------------------------------------------------------------------------------------------------------------------- # A quarantine intervention rule: class SARSQuarantineIntervention(Intervention): def __init__(self, seqihr_model, chi, i): Err.type(seqihr_model, 'seqihr_model', SEQIHRModel) super().__init__(i=i)
''' 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))
from pram.sim import Simulation # ---------------------------------------------------------------------------------------------------------------------- # (1) Simulation (test population): (Simulation().set().pragma_autocompact(True).pragma_live_info( False).done().add().rule( PoissonIncidenceProcess( 'ad', 65, 0.01, 2, 5, rate_delta_mode=PoissonIncidenceProcess.RateDeltaMode.EXP)).group( Group(m=100, attr={'age': 60 })).done().run(20).summary(False, 1024, 0, 0, 0, (1, 0))) # ---------------------------------------------------------------------------------------------------------------------- # (2) Simulation (synthetic Allegheny County population): # fpath_db = os.path.join(os.path.dirname(__file__), '..', '..', '..', 'data', 'allegheny-county', 'allegheny.sqlite3') # # (Simulation(). # set(). # pragma_autocompact(True). # pragma_live_info(False). # done(). # add(). # rule(PoissonIncidenceProcess('ad', 65, 0.01, 2, 5, rate_delta_mode=PoissonIncidenceProcess.RateDeltaMode.EXP)).
probe plotting. ''' from pram.data import ProbePersistenceMem, GroupSizeProbe from pram.entity import Group from pram.model.epi import SIRSModel from pram.sim import Simulation # ---------------------------------------------------------------------------------------------------------------------- p = GroupSizeProbe.by_attr('flu', 'flu', ['s', 'i', 'r'], persistence=ProbePersistenceMem()) (Simulation().add_probe(p).add_rule( SIRSModel('flu', beta=0.05, gamma=0.50, alpha=0.10)).add_group(Group(m=1000, attr={'flu': 's'})).run(100)) series = [{ 'var': 'p0', 'lw': 0.75, 'ls': 'solid', 'marker': 'o', 'color': 'red', 'ms': 0, 'lbl': 'S' }, { 'var': 'p1', 'lw': 0.75, 'ls': 'dashed', 'marker': '+', 'color': 'blue',
def analysis_simple(tx_dict=None, population=10000, iteration=16): if tx_dict is None: tx_dict = dict( round_seed_a=0.3, round_seed_failure=0.67, round_a_b=0.2, round_a_failure=0.6, round_b_c=0.3, round_b_failure=0.4, round_c_success=0.5, round_c_failure=0.5, round_success_success=1, round_success_failure=0, round_failure_success=0, round_failure_failure=1, # round_a_a=0.2, # round_b_b=0.2, # round_c_c=0.2, ) old_p = GroupSizeProbe.by_attr( 'stage', 'stage', ['seed', 'a', 'b', 'c', 'success', 'failure'], persistance=ProbePersistanceMem(), msg_mode=ProbeMsgMode.CUMUL) p = GroupSizeProbe.by_attr('stage', 'stage', ['seed', 'a', 'b', 'c', 'success', 'failure'], persistance=ProbePersistanceDB()) sim = (Simulation().add( [UserStartupGrowthRule(tx_dict), p, Group(m=population)]).run(iteration)) series = [ { 'var': 'n0' }, { 'var': 'n1' }, { 'var': 'n2' }, { 'var': 'n3' }, { 'var': 'n4' }, { 'var': 'n5' }, ] col_names = { 'n0': 'seed', 'n1': 'a', 'n2': 'b', 'n3': 'c', 'n4': 'success', 'n5': 'failure' } probe_data = p.probe_data(series) probe_frame: pd.DataFrame probe_frame = pd.DataFrame.from_dict(probe_data) probe_frame.rename(columns=col_names, inplace=True) probe_frame["i"] = probe_frame["i"] + 1 initial_condition = { 'seed': population, 'a': 0, 'b': 0, 'c': 0, 'success': 0, 'failure': 0, 'i': 0 } probe_frame = pd.concat( [pd.DataFrame(initial_condition, index=[0]), probe_frame[:]]).reset_index(drop=True) probe_frame.drop(columns=['i'], inplace=True) print(probe_frame) d = probe_frame.iloc[0] print(d) # for chart plot_data = probe_frame.iloc[0] # probe_names = probe_frame print(plot_data.values) print(list(plot_data.index)) # data_source = ColumnDataSource(probe_frame) return probe_frame
# ---------------------------------------------------------------------------------------------------------------------- # ---------------------------------------------------------------------------------------------------------------------- if __name__ == "__main__": i = 1 eq = 50 print(eq * "=", "starting sim {}".format(i), eq * "=") sim = (Simulation().add([ StartupGrowthRule(), GroupSizeProbe.by_attr('stage', 'stage', ['s', 'a', 'b', 'c', 'success', 'failure'], msg_mode=ProbeMsgMode.CUMUL), Group(m=10000) ]).run(10)) print(sim.probes[0].get_msg()) print() i += 1 print(eq * "=", "starting sim {}".format(i), eq * "=") sim = (Simulation().add([ StartupLocationRule(), GroupSizeProbe( 'startup-location', [ GroupQry(attr={ 'location': 'usa', 'stage': 'success' }),
from pram.rule import GammaDistributionProcess, IterAlways, IterInt, TimeAlways from pram.sim import Simulation from pram.traj import Trajectory, TrajectoryEnsemble, ClusterInf # ---------------------------------------------------------------------------------------------------------------------- fpath_db = os.path.join(os.path.dirname(__file__), 'data', 'sir-comp.sqlite3') def U(a,b, n=None): return uniform(a,a+b).rvs(n) def TN(a,b, mu, sigma, n=None): return truncnorm((a - mu) / sigma, (b - mu) / sigma, mu, sigma).rvs(n) 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' })) ] # ---------------------------------------------------------------------------------------------------------------------- # A gamma distribution process rule: class FluProcess(GammaDistributionProcess): def apply(self, pop, group, iter, t): p = self.get_p(iter) return [ GroupSplitSpec(p=p, attr_set={ 'flu': 's' }), GroupSplitSpec(p=1-p) ]
from pram.entity import Group, GroupQry, GroupSplitSpec from pram.model.model import MCSolver from pram.model.epi import SIRSModel from pram.sim import Simulation # ---------------------------------------------------------------------------------------------------------------------- (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, solver=MCSolver())).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=[ # GroupQry(attr={ 'flu': 's' }), # GroupQry(attr={ 'flu': 'i' }), # GroupQry(attr={ 'flu': 'r' }) # ],
TrajectoryEnsemble(fpath_db).set_pragma_memoize_group_ids(True). add_trajectories([ Trajectory(sim=( Simulation().add([ sir_a1, # sir_b1, # make_sir_b1_fixed_delay(iter0), # make_sir_b1_random_delay(iter0), # make_sir_b1_random_delay(), # make_sir_b1_random_delay(iter0_dist=gamma(a=5.0, loc=50.0, scale=25.0)), make_sir_b1_random_delay_gamma(), RecurrentFluProcess(i=IterInt(2000, 0), p_max=gamma_proc_p_max, a=5.0, scale=50.0), Group(m=950, attr={'flu': 's'}), Group(m=50, attr={'flu': 'i'}) ])) # ) for _ in range(5) # ) for iter0 in [900, 950, 1000, 1050, 1100] # ) for gamma_proc_p_max in uniform(loc=0.75, scale=0.20).rvs(1) ) for gamma_proc_p_max in [1.00] ]).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(4000)) # ---------------------------------------------------------------------------------------------------------------------- # Load data: # te = TrajectoryEnsemble(fpath_db).stats()
def test_attributes_and_relations(self): f = self.assertFalse t = self.assertTrue g0 = Group('g.0', 100) g1 = Group('g.1', 200, { 'sex': 'f', 'income': 'l' }, {'location': 'home'}) # Attributes: f(g0.has_attr('sex')) # query is a string f(g0.has_attr(['sex'])) # query is an iterable (one string) f(g0.has_attr(['sex', 'income'])) # query is an iterable (multiple strings) f(g0.has_attr({'sex': 'f'})) # query is a dict (one element) f(g0.has_attr({ 'sex': 'f', 'income': 'l' })) # query is a dict (multiple elements) f(g0.has_rel({'location': 'home'})) t(g1.has_attr('sex')) # query is a string t(g1.has_attr(['sex'])) # query is an iterable (one string) t(g1.has_attr(['sex', 'income'])) # query is an iterable (multiple strings) t(g1.has_attr({'sex': 'f'})) # query is a dict (one element) t(g1.has_attr({ 'sex': 'f', 'income': 'l' })) # query is a dict (multiple elements) f(g1.has_attr({ 'sex': 'f', 'income': 'h' })) # query is a dict (multiple elements) # Relations (the mechanism is identical to that for attributes, so we only test two relations): t(g1.has_rel({'location': 'home'})) f(g1.has_rel({'location': 'work'}))
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))
GroupQry(attr={'team': 'blue'}, rel={Site.AT: loc[0]}), GroupQry(attr={'team': 'red'}, rel={Site.AT: loc[0]}), GroupQry(attr={'team': 'blue'}, rel={Site.AT: loc[1]}), GroupQry(attr={'team': 'red'}, rel={Site.AT: loc[1]}) ], qry_tot=None, msg_mode=ProbeMsgMode.DISP) (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]}), # probe_loc # the distribution should tend to 50%-50% probe_sim # mass should tend to move towards two of the four sites ]).run(70)) # ---------------------------------------------------------------------------------------------------------------------- # (2) Simulation (arbitrary numer of locations) # loc = [Site('a'), Site('b'), Site('c')] # # probe_loc = GroupSizeProbe.by_rel('site', Site.AT, loc, msg_mode=ProbeMsgMode.DISP) # # def grp_setup(pop, group):
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' },
# ax.plot(h[1][0], h[1][1], h[1][2]) # plt.show() # ---------------------------------------------------------------------------------------------------------------------- # (2) Lotka-Volterra: alpha = 1.1 # baboon beta = 0.4 delta = 0.1 # cheetah gamma = 0.4 def f_lotka_volterra(t, state): x, y = state return [x * (alpha - beta * y), y * (-gamma + delta * x)] r = ODESystem(f_lotka_volterra, [10, 10], dt=0.1) (Simulation().add([r, Group(n=1)]).run(500)) h = r.get_hist() import matplotlib.pyplot as plt plt.plot(h[0], h[1][0], 'b-', h[0], h[1][1], 'r-') # red - predator plt.show() # Phase-space plot: # plt.plot(h[1][0], h[1][1], 'k-') # plt.show()
'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': '--', 'marker': '+', 'color': 'blue',
def test_comparisons(self): eq = self.assertEqual ne = self.assertNotEqual eq(Group(), Group()) # different objects eq(Group('g.10', 100), Group('g.20', 100)) # different names eq(Group('g.10', 11), Group('g.20', 22)) # different sizes eq(Group(attr={}), Group()) # no attributes eq(Group(attr={}), Group(attr={})) # no attributes eq(Group(attr={}), Group(attr=None)) # no attributes eq(Group(), Group(rel=None)) # no relations eq(Group(attr={'sex': 'f'}), Group(attr={'sex': 'f'})) # same attributes (primitive data types) eq(Group(attr={'age': 99}), Group(attr={'age': 99})) # same attributes (primitive data types) eq(Group(attr={'sex': AttrSex.F}), Group( attr={'sex': AttrSex.F})) # same attributes (composite data types) eq(Group(attr={'sex': AttrFluStage.NO}), Group(attr={'sex': AttrFluStage.NO })) # same attributes (composite data types) ne(Group(attr={'sex': AttrFluStage.NO}), Group(attr={'sex': AttrFluStage.SYMPT })) # different attributes (composite data types) ne(Group(attr={'sex': 'f'}), Group(attr={'xes': 'f'})) # different attribute keys ne(Group(attr={'sex': 'f'}), Group(attr={'sex': 'm'})) # different attribute values eq(Group(attr={ 'sex': 'f', 'income': 'l' }), Group(attr={ 'income': 'l', 'sex': 'f' })) # same attributes, different order
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()
fpath_db = os.path.join(os.path.dirname(__file__), f'trajectory.sqlite3') # ---------------------------------------------------------------------------------------------------------------------- # (1) Create the database and run a trajectory ensemble: if os.path.isfile(fpath_db): os.remove(fpath_db) te = (TrajectoryEnsemble(fpath_db). add_trajectories([ Trajectory( (Simulation(). add([ SIRSModel('flu', beta, 0.50, 0.00), Group(m=1000, attr={ 'flu': 's' }) ]) ), f'SIR: b={round(beta,2)}' ) for beta in [0.05] # np.arange(0.05, 0.06, 0.01) ]). 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) ) # ---------------------------------------------------------------------------------------------------------------------- # (2) Restore a trajectory ensemble from the database for additional runs: