def make_hybrid_contacts(pop_size, ages, contacts, school_ages=None, work_ages=None): ''' Create "hybrid" contacts -- microstructured contacts for households and random contacts for schools and workplaces, both of which have extremely basic age structure. A combination of both make_random_contacts() and make_microstructured_contacts(). ''' # Handle inputs and defaults layer_keys = ['h', 's', 'w', 'c'] contacts = sc.mergedicts({ 'h': 4, 's': 20, 'w': 20, 'c': 20 }, contacts) # Ensure essential keys are populated if school_ages is None: school_ages = [6, 22] if work_ages is None: work_ages = [22, 65] # Create the empty contacts list -- a list of {'h':[], 's':[], 'w':[]} contacts_list = [{key: [] for key in layer_keys} for i in range(pop_size)] # Start with the household contacts for each person h_contacts, _, clusters = make_microstructured_contacts( pop_size, {'h': contacts['h']}) # Make community contacts c_contacts, _ = make_random_contacts(pop_size, {'c': contacts['c']}) # Get the indices of people in each age bin ages = np.array(ages) s_inds = sc.findinds((ages >= school_ages[0]) * (ages < school_ages[1])) w_inds = sc.findinds((ages >= work_ages[0]) * (ages < work_ages[1])) # Create the school and work contacts for each person s_contacts, _ = make_random_contacts(len(s_inds), {'s': contacts['s']}) w_contacts, _ = make_random_contacts(len(w_inds), {'w': contacts['w']}) # Construct the actual lists of contacts for i in range(pop_size): contacts_list[i]['h'] = h_contacts[i][ 'h'] # Copy over household contacts -- present for everyone for i, ind in enumerate(s_inds): contacts_list[ind]['s'] = s_inds[s_contacts[i] ['s']] # Copy over school contacts for i, ind in enumerate(w_inds): contacts_list[ind]['w'] = w_inds[w_contacts[i] ['w']] # Copy over work contacts for i in range(pop_size): contacts_list[i]['c'] = c_contacts[i][ 'c'] # Copy over community contacts -- present for everyone return contacts_list, layer_keys, clusters
def sample_hypershell(self): ''' Sample points from a hypershell. ''' # Initialize fitinds = sc.findinds( self.fittable) # The indices of the fittable parameters nfittable = len(fitinds) # How many fittable parameters npars = len(self.x) # Total number of parameters standard_normal = st.norm( loc=0, scale=1) # Initialize a standard normal distribution radius_normal = st.norm(loc=self.relstepsize * self.mp.mu_r, scale=self.relstepsize * self.mp.sigma_r) # And a scaled one # Calculate deviations deviations = np.zeros( (self.mp.N, nfittable)) # Deviations from current center point for r in range(self.mp.N): # Loop over repeats sn_rvs = standard_normal.rvs( size=nfittable) # Sample from the standard distribution sn_nrm = np.linalg.norm( sn_rvs) # Calculate the norm of these samples radius = radius_normal.rvs() # Sample from the scaled distribution deviations[ r, :] = radius / sn_nrm * sn_rvs # Deviation is the scaled sample adjusted by the rescaled standard sample # Calculate parameter samples samples = np.zeros((self.mp.N, npars)) # New samples for p in range(npars): # Loop over all parameters if self.fittable[p]: ind = sc.findinds( fitinds == p )[0] # Convert the parameter index back to the fittable parameter index delta = deviations[:, ind] * ( self.xmax[p] - self.xmin[p] ) # Scale the deviation by the allowed parameter range else: delta = 0 # If not fittable, set to zero samples[:, p] = self.x[p] + delta # Set new parameter value # Overwrite with center repeats for r in range(self.mp.center_repeats): samples[r, :] = self.x # Just replace with the current center # Clamp for p in range(npars): samples[:, p] = np.minimum( self.xmax[p], np.maximum(self.xmin[p], samples[:, p])) # Ensure all samples are within range self.samples = samples self.allsamples[self.key] = sc.dcp(samples) self.iteration += 1 return self.samples
def ftest_num_subtarg5(sim, sev=5.0): ''' Subtarget ''' drop_inds = sc.findinds(sim.people.age < 80) sev_inds = np.intersect1d(sim.people.true('severe'), sc.findinds(sim.people.age > 79)) drop_vals = np.zeros(len(drop_inds)) sev_vals = sev * np.ones(len(sev_inds)) inds = np.concatenate([drop_inds, sev_inds]) vals = np.concatenate([drop_vals, sev_vals]) return {'inds': inds, 'vals': vals}
def remove_ltcf_community(sim, debug=False): ''' Ensure LTCF residents don't have community contacts ''' over_65 = sc.findinds(sim.people.age > 65) llayer = sim.people.contacts['l'] clayer = sim.people.contacts['c'] in_ltcf = np.union1d(llayer['p1'], llayer['p2']) over_65_in_ltcf = np.intersect1d(over_65, in_ltcf) p1inds = sc.findinds(np.isin(clayer['p1'], over_65_in_ltcf)) p2inds = sc.findinds(np.isin(clayer['p2'], over_65_in_ltcf)) popinds = np.union1d(p1inds, p2inds) clayer.pop_inds(popinds) return clayer
def ftest_num_subtarg3(sim, sev=5.0): ''' Subtarget ''' drop_inds = sc.findinds(np.logical_or(sim.people.age < 40, sim.people.age > 59)) sev_inds = np.intersect1d(sim.people.true('severe'), sc.findinds(np.logical_and(sim.people.age > 39, sim.people.age < 60))) drop_vals = np.zeros(len(drop_inds)) sev_vals = sev * np.ones(len(sev_inds)) inds = np.concatenate([drop_inds, sev_inds]) vals = np.concatenate([drop_vals, sev_vals]) return {'inds': inds, 'vals': vals}
def find_day(arr, t=None, which='first'): ''' Helper function to find if the current simulation time matches any day in the intervention. Although usually never more than one index is returned, it is returned as a list for the sake of easy iteration. Args: arr (list): list of days in the intervention, or else a boolean array t (int): current simulation time (can be None if a boolean array is used) which (str): what to return: 'first', 'last', or 'all' indices Returns: inds (list): list of matching days; length zero or one unless which is 'all' ''' all_inds = sc.findinds(val1=arr, val2=t) if len(all_inds) == 0 or which == 'all': inds = all_inds elif which == 'first': inds = [all_inds[0]] elif which == 'last': inds = [all_inds[-1]] else: errormsg = f'Argument "which" must be "first", "last", or "all", not "{which}"' raise ValueError(errormsg) return inds
def compute_r_eff(self): ''' Effective reproductive number based on number of people each person infected. ''' # Initialize arrays to hold sources and targets infected each day sources = np.zeros(self.npts) targets = np.zeros(self.npts) for t in self.tvec: # Sources are easy -- count up the arrays recov_inds = cvu.true( t == self.people.date_recovered ) # Find people who recovered on this timestep dead_inds = cvu.true( t == self.people.date_dead) # Find people who died on this timestep outcome_inds = np.concatenate((recov_inds, dead_inds)) sources[t] = len(outcome_inds) # Targets are hard -- loop over the transmission tree for ind in outcome_inds: targets[t] += len(self.people.transtree.targets[ind]) # Populate the array -- to avoid divide-by-zero, skip indices that are 0 inds = sc.findinds(sources > 0) r_eff = targets[inds] / sources[inds] self.results['r_eff'].values[inds] = r_eff return
def plotdata(trendselection=None, startdate='2000-01-01', enddate='2018-01-01', trendline=False): # Handle inputs startyear = convertdate(startdate, '%Y-%m-%d') endyear = convertdate(enddate, '%Y-%m-%d') trendoptions = getoptions(tojson=False) if trendselection is None: trendselection = trendoptions.keys()[0] datatype = trendoptions[trendselection] # Make graph fig = pl.figure() fig.add_subplot(111) thesedata = df.findrows(key=datatype, col='type') years = thesedata['date'] vals = thesedata['close'] validinds = sc.findinds(pl.logical_and(years>=startyear, years<=endyear)) x = years[validinds] y = vals[validinds] pl.plot(x, y) pl.xlabel('Date') pl.ylabel('Trend index') # Add optional trendline if trendline: newy = sc.smoothinterp(x, x, y, smoothness=200) pl.plot(x, newy, lw=3) # Convert to FE graphjson = sw.mpld3ify(fig, jsonify=False) # Convert to dict return graphjson # Return the JSON representation of the Matplotlib figure
def compute_r_eff(self): ''' Effective reproductive number based on number of people each person infected. ''' # Initialize arrays to hold sources and targets infected each day sources = np.zeros(self.npts) targets = np.zeros(self.npts) # Loop over each person to pull out the transmission for person in self.people: if person.date_exposed is not None: # Skip people who were never exposed if person.date_recovered is not None: outcome_date = person.date_recovered elif person.date_dead is not None: outcome_date = person.date_dead else: errormsg = f'No outcome (death or recovery) can be determined for the following person:\n{person}' raise ValueError(errormsg) if outcome_date is not None and outcome_date < self.npts: outcome_date = int(outcome_date) sources[outcome_date] += 1 targets[outcome_date] += len(person.infected) # Populate the array -- to avoid divide-by-zero, skip indices that are 0 inds = sc.findinds(sources > 0) r_eff = targets[inds] / sources[inds] self.results['r_eff'].values[inds] = r_eff return
def apply(self, sim): t = sim.t if t < self.start_day: return elif self.end_day is not None and t > self.end_day: return adults = sim.people.age > 18 adults_inds = sc.findinds(adults) screen_inds = cvu.choose( len(adults_inds), self.daily_screens) # Who will we screen today - untargeted screen_inds = np.unique(screen_inds) screened_adult_inds = adults_inds[screen_inds] is_symptomatic = cvu.itruei(sim.people.symptomatic, screened_adult_inds) pos_screen = cvu.n_binomial(self.sensitivity, len(is_symptomatic)) is_sym_pos = is_symptomatic[pos_screen] not_diagnosed = is_sym_pos[np.isnan( sim.people.date_diagnosed[is_sym_pos])] will_quar = cvu.n_binomial(self.prob_quar_after_fever, len(not_diagnosed)) final_inds = not_diagnosed[will_quar] sim.people.quarantine(final_inds) sim.results['new_quarantined'][t] += len(final_inds) #print(f'{final_inds} put into quarantine by screening.') return
def findinds(df, *args): ''' Find matching indices in a large dataframe ''' inds = np.arange(len(df)) for arg in args: filterinds = sc.findinds(arg) inds = np.intersect1d(inds, filterinds) return inds
def make_hybrid_contacts(pop_size, ages, contacts, school_ages=None, work_ages=None): ''' Create "hybrid" contacts -- microstructured contacts for households and random contacts for schools and workplaces, both of which have extremely basic age structure. A combination of both make_random_contacts() and make_microstructured_contacts(). ''' # Handle inputs and defaults contacts = sc.mergedicts({ 'h': 4, 's': 20, 'w': 20, 'c': 20 }, contacts) # Ensure essential keys are populated if school_ages is None: school_ages = [6, 22] if work_ages is None: work_ages = [22, 65] contacts_dict = {} # Start with the household contacts for each person contacts_dict['h'] = make_microstructured_contacts(pop_size, contacts['h']) # Make community contacts contacts_dict['c'] = make_random_contacts(pop_size, contacts['c']) # Get the indices of people in each age bin ages = np.array(ages) s_inds = sc.findinds((ages >= school_ages[0]) * (ages < school_ages[1])) w_inds = sc.findinds((ages >= work_ages[0]) * (ages < work_ages[1])) # Create the school and work contacts for each person contacts_dict['s'] = make_random_contacts(len(s_inds), contacts['s'], mapping=s_inds) contacts_dict['w'] = make_random_contacts(len(w_inds), contacts['w'], mapping=w_inds) return contacts_dict
def plot_cascade(self, vertical=True): if vertical: fig_size = (12, 12) ax_size = [0.45, 0.05, 0.5, 0.9] else: fig_size = (16, 8) ax_size = [0.05, 0.45, 0.9, 0.5] df = sc.dcp(self.data) cutoff = 200e3 fig = pl.figure(figsize=fig_size) df.sort(col='icer', reverse=False) DA_data = hp.arr(df['opt_spend']) inds = sc.findinds(DA_data > cutoff) DA_data = DA_data[inds] DA_data /= 1e6 DA_labels = df['shortname'][inds] npts = len(DA_data) colors = sc.gridcolors(npts, limits=(0.25, 0.75)) x = np.arange(len(DA_data)) pl.axes(ax_size) for pt in range(npts): loc = x[pt:] this = DA_data[pt] start = sum(DA_data[:pt]) prop = 0.9 color = colors[pt] amount = sum(DA_data[:pt + 1]) amountstr = '%0.1f' % amount if vertical: pl.barh(loc, width=this, left=start, height=prop, color=color) pl.text(amount, x[pt], amountstr, verticalalignment='center', color=colors[pt]) else: pl.bar(loc, height=this, bottom=start, width=prop, color=color) pl.text(x[pt], amount + 1, amountstr, horizontalalignment='center', color=colors[pt]) if vertical: pl.xlabel('Spending for optimized investment cascade') pl.gca().set_yticks(x) ticklabels = pl.gca().set_yticklabels(DA_labels) else: pl.ylabel('Optimized investment cascade') pl.gca().set_xticks(x) ticklabels = pl.gca().set_xticklabels(DA_labels, rotation=90) for t, tl in enumerate(ticklabels): tl.set_color(colors[t]) pl.gca().set_facecolor('none') pl.title('Investment cascade') return fig
def vacc_subtarg(sim): ''' Subtarget by age''' # retrieves the first ind that is = or < sim.t ind = get_ind_of_min_value(sim.vxsubtarg.days, sim.t) age = sim.vxsubtarg.age[ind] prob = sim.vxsubtarg.prob[ind] inds = sc.findinds((sim.people.age >= age) * ~sim.people.vaccinated) vals = prob * np.ones(len(inds)) return {'inds': inds, 'vals': vals}
def test_num_subtarg(sim, sev=100.0, u20=0.5, quar=1.0): ''' Subtarget severe people with more testing, and young people with less ''' inds = np.arange(len(sim.people)) vals = np.ones(len(sim.people)) vals[sc.findinds( (sim.people.age < 20) * (~sim.people.severe) )] *= u20 # People who are under 20 and severe test as if they're severe; * is element-wise "and" vals[sim.people.true('severe')] *= sev vals[sim.people.true('quarantined')] *= quar return {'inds': inds, 'vals': vals}
def test_num_subtarg(sim, sev=100.0, u20=0.5): ''' Subtarget severe people with more testing, and young people with less ''' sev_inds = sim.people.true('severe') u20_inds = sc.findinds( (sim.people.age < 20) * (~sim.people.severe) ) # People who are under 20 and severe test as if they're severe; * is element-wise "and" u20_vals = u20 * np.ones(len(u20_inds)) sev_vals = sev * np.ones(len(sev_inds)) inds = np.concatenate([u20_inds, sev_inds]) vals = np.concatenate([u20_vals, sev_vals]) return {'inds': inds, 'vals': vals}
def apply(self, sim, t): ''' Loop over the parameters, and then loop over the days, applying them if any are found ''' for parkey, parval in self.pars.items(): inds = sc.findinds(parval['days'], t) # Look for matches if len(inds): if len(inds) > 1: raise ValueError( f'Duplicate days are not allowed for Dynamic interventions (day={t}, indices={inds})' ) else: sim[parkey] = parval['vals'][ inds[0]] # Actually set the parameter return
def apply(self, sim): # If this day is found in the list, apply the intervention inds = sc.findinds(self.days, sim.t) if len(inds): for lkey, new_beta in self.orig_betas.items(): for ind in inds: new_beta = new_beta * self.changes[ind] if lkey == 'overall': sim['beta'] = new_beta else: sim['beta_layer'][lkey] = new_beta return
def compute_r_eff(self, window=7): ''' Effective reproductive number based on number of people each person infected. Args: window (int): the size of the window used (larger values are more accurate but less precise) ''' # Initialize arrays to hold sources and targets infected each day sources = np.zeros(self.npts) targets = np.zeros(self.npts) window = int(window) for t in self.tvec: # Sources are easy -- count up the arrays recov_inds = cvu.true( t == self.people.date_recovered ) # Find people who recovered on this timestep dead_inds = cvu.true( t == self.people.date_dead) # Find people who died on this timestep outcome_inds = np.concatenate((recov_inds, dead_inds)) sources[t] = len(outcome_inds) # Targets are hard -- loop over the transmission tree for ind in outcome_inds: targets[t] += len(self.people.transtree.targets[ind]) # Populate the array -- to avoid divide-by-zero, skip indices that are 0 inds = sc.findinds(sources > 0) r_eff = np.zeros(self.npts) * np.nan r_eff[inds] = targets[inds] / sources[inds] # use stored weights calculate the moving average over the window of timesteps, n num = np.nancumsum(r_eff * sources) num[window:] = num[window:] - num[:-window] den = np.cumsum(sources) den[window:] = den[window:] - den[:-window] # avoid dividing by zero values = np.zeros(num.shape) * np.nan ind = den > 0 values[ind] = num[ind] / den[ind] self.results['r_eff'].values = values return
def apply(self, sim, t): # If this is the first time it's being run, store beta if self.orig_beta is None: self.orig_beta = sim['beta'] # If this day is found in the list, apply the intervention inds = sc.findinds(self.days, t) if len(inds): new_beta = self.orig_beta for ind in inds: new_beta = new_beta * self.changes[ind] sim['beta'] = new_beta return
def apply(self, sim): ''' Loop over the parameters, and then loop over the days, applying them if any are found ''' t = sim.t for parkey,parval in self.pars.items(): inds = sc.findinds(parval['days'], t) # Look for matches if len(inds): if len(inds)>1: raise ValueError(f'Duplicate days are not allowed for Dynamic interventions (day={t}, indices={inds})') else: val = parval['vals'][inds[0]] if isinstance(val, dict): sim[parkey].update(val) # Set the parameter if a nested dict else: sim[parkey] = val # Set the parameter if not a dict return
def modify_sim(sim, scenpars, label=None, runinfo=None): ''' Modify the simulation for the scenarios ''' print( f' Note: modifying simulation {label} at day={sim.t}, date={sim.date(sim.t)}, scenpars:\n{scenpars}' ) # Do reopening: modify clip_edges last_calib_day = sim.day(sim.sceninfo.calib_end) first_scen_day = sim.day(sim.sceninfo.scen_start) for ilabel in ['clip_w', 'clip_c']: interv = get_interv(sim, ilabel) valid_days = sc.findinds(interv.days <= last_calib_day) interv.days = np.append( interv.days[valid_days], first_scen_day ) # NB, repr of intervention will be wrong with direct modification! interv.changes = np.append(interv.changes[valid_days], scenpars['reopen']) # Change iso_factor and quar_factor sim.pars['iso_factor'] = sc.dcp(scenpars['i_factor']) sim.pars['quar_factor'] = sc.dcp(scenpars['q_factor']) # Implement testing & tracing interventions tppars = { k: scenpars[k] for k in [ 'symp_prob', 'asymp_prob', 'symp_quar_prob', 'asymp_quar_prob', 'test_delay' ] } ctpars = {k: scenpars[k] for k in ['trace_probs', 'trace_time']} tp = cv.test_prob(start_day=first_scen_day, quar_policy=[0], **tppars) ct = cv.contact_tracing(start_day=first_scen_day, label='contact_tracing', **ctpars) sim['interventions'] += [tp, ct] # Final tidying sim.label = label sim.runinfo = runinfo sim.sceninfo.scenpars = scenpars return sim
def filter_people(pop, ages=None, uids=None): """ Helper function to filter people based on their uid and age. Args: pop (sp.Pop) : population ages (list or array) : ages of people to include uids (list or array) : ids of people to include Returns: array: An array of the ids of people to include for further analysis. """ output = np.arange(pop.n) if uids is not None: # catch instance where the only uids supplied is the first one, 0 output = np.intersect1d(output, uids) if ages is not None: # catch instance where the only ages supplied is age 0 output = np.intersect1d(output, sc.findinds(np.isin(pop.age_by_uid, ages))) return output
def apply(self, sim): # If this is the first time it's being run, store beta if self.orig_betas is None: self.orig_betas = {} for layer in self.layers: if layer is None: self.orig_betas['overall'] = sim['beta'] else: self.orig_betas[layer] = sim['beta_layers'][layer] # If this day is found in the list, apply the intervention inds = sc.findinds(self.days, sim.t) if len(inds): for layer,new_beta in self.orig_betas.items(): for ind in inds: new_beta = new_beta * self.changes[ind] if layer == 'overall': sim['beta'] = new_beta else: sim['beta_layers'][layer] = new_beta return
def count_targets(self, start_day=None, end_day=None): ''' Count the number of targets each infected person has. If start and/or end days are given, it will only count the targets of people who got infected between those dates (it does not, however, filter on the date the target got infected). Args: start_day (int/str): the day on which to start counting people who got infected end_day (int/str): the day on which to stop counting people who got infected ''' # Handle start and end days start_day = self.day(start_day, which='start') end_day = self.day(end_day, which='end') n_targets = np.nan+np.zeros(self.pop_size) for i in range(self.pop_size): if self.sources[i] is not None: if self.source_dates[i] >= start_day and self.source_dates[i] <= end_day: n_targets[i] = len(self.targets[i]) n_target_inds = sc.findinds(~np.isnan(n_targets)) n_targets = n_targets[n_target_inds] return n_targets
for i in range(nsims): pl.subplot(nsims // 2, 2, i + 1) data = results[i, :, :] for j in range(seeds): pl.plot(s0.tvec, results[i, j, :]) dur = 10 # Duration of symptoms mintest = 0.0 maxtest = 0.2 test_vals = np.linspace(mintest, maxtest, nsims) # TODO: remove duplication test_pct = (1 - (1 - test_vals)**dur) * 100 # Trim indices only_high_testing = True if not only_high_testing: low_inds = sc.findinds(test_pct <= 4) med_inds = sc.findinds(np.logical_and(test_pct > 4, test_pct <= 20)) high_inds = sc.findinds(test_pct > 20) inds = low_inds[::1].tolist() + med_inds[::2].tolist( ) + high_inds[::10].tolist() else: med_inds = sc.findinds(np.logical_and(test_pct > 28, test_pct <= 50)) high_inds = sc.findinds(test_pct > 50) inds = med_inds[::2].tolist() + high_inds[::8].tolist() xlims = [s0.tvec[0], s0.tvec[-1]] ylims = [0, results[inds, :, :].max()] # Actually plot if plot_movie: fig = pl.figure(figsize=(10, 6)) # Create a new figure
[0.905, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]) # Equally susceptible prognoses['severe_probs'] = np.array( [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]) # Zero'd out prognoses['crit_probs'] = np.array( [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]) # Zero'd out prognoses['death_probs'] = np.array( [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]) # Zero'd out pars['prognoses'] = prognoses pars['start_day'] = '2020-01-01' pars['n_days'] = 60 pars['quar_period'] = 140 sim = cv.Sim(pars=pars) # Setup sim sim.initialize() people = cv.make_people(sim) # Make the actual people for the simulation inds_o5 = sc.findinds(people.age >= 10) people.rel_sus[inds_o5] = 0 inds_u5 = sc.findinds(people.age < 10) imm_frac = 0.8 inds_u5imm = inds_u5[sc.findinds( np.random.uniform(low=0.0, high=1.0, size=len(inds_u5)) < imm_frac)] people.rel_sus[inds_u5imm] = 0 sim.people = people # sim['interventions'] = [cv.test_prob(symp_prob=1.00, asymp_prob=0.00)] # Test 100% of symptomatics and 0% of asymptomatics sim['interventions'] = [ cv.test_prob(symp_prob=1.00, asymp_prob=0.00), cv.contact_tracing() ] sim.run() sim.plot()
'days': tti_day, 'vals': iso_vals }}) ] pars['interventions'] = [ttq_june_2, isolation_june_2, june_tests_extra] sim.update_pars(interventions=interventions) for intervention in sim['interventions']: intervention.do_plot = False # Changing kids' transmissability sim.initialize() # Create the population reduce_kids = True #set tgis to True to change the transmissibility numbers below if reduce_kids: print('Reducing transmission among kids') children = sim.people.age < 18 # Find people who are children child_inds = sc.findinds( children) # Turn the boolean array into a list of indices for lkey in sim.people.layer_keys(): # Loop over each layer child_contacts = np.isin( sim.people.contacts[lkey]['p1'], child_inds) # Find contacts where the source is a child child_contact_inds = sc.findinds(child_contacts) # Convert to indices sim.people.contacts[lkey]['beta'][ child_contact_inds] = 1.0 # MODIFY TRANSMISSION #sim.people.contacts[lkey]['beta'][:] = 0.0 # MODIFY TRANSMISSION if __name__ == '__main__': #msim = cv.MultiSim(n_runs=10) msim.run(n_runs=8, keep_people=True) # Run with uncertainty # Recalculate R_eff with a larger window for sim in msim.sims:
def target_over_65(sim, prob=1.0): ''' Subtarget ''' inds = sc.findinds(sim.people.age > 65) vals = prob * np.ones(len(inds)) return {'inds': inds, 'vals': vals}
transition = mplt.colors.LinearSegmentedColormap.from_list( "transition", [cmap1(1.), cmap2(0)])(np.linspace(0, 1, transition_steps)) colors = np.vstack((colors1, transition, colors2)) colors = np.flipud(colors) new_cmap = mplt.colors.LinearSegmentedColormap.from_list(new_cmap_name, colors) cmap = new_cmap # Assign colors to age groups age_cutoffs = np.arange( 0, 101, 10) # np.array([0, 4, 6, 18, 22, 30, 45, 65, 80, 90, 100]) if discrete: raw_colors = sc.vectocolor(len(age_cutoffs), cmap=cmap) colors = [] for age in sim.people.age: ind = sc.findinds(age_cutoffs <= age)[-1] colors.append(raw_colors[ind]) colors = np.array(colors) else: age_map = sim.people.age * 0.1 + np.sqrt(sim.people.age) colors = sc.vectocolor(age_map, cmap=cmap) # Create the legend if plot_stacked: ax = fig.add_axes([0.85, 0.05, 0.14, 0.93]) elif len(keys_to_plot) % 2 != 0: ax = fig.add_axes([0.85, 0.05, 0.14, 0.93]) else: ax = fig.add_axes([0.82, 0.05, 0.14, 0.90]) ax.axis('off')