def setup_traps(number_sources=6, radius_sources=1000.0, strength_sources=10.0, trap_radius=5.): if number_sources > 1: #Standard geometry: 6 traps around the center location_list, strength_list = utility.create_circle_of_sources( number_sources, radius_sources, strength_sources) else: #Toy example with just one trap strength_list = [strength_sources] location_list = [(radius_sources * scipy.cos(scipy.pi / 3), radius_sources * scipy.sin(scipy.pi / 3))] # Set up the trap object (separated from odor object 3/8) trap_param = { 'source_locations': location_list, 'source_strengths': strength_list, 'epsilon': 0.01, 'trap_radius': trap_radius, 'source_radius': radius_sources } traps = trap_models.TrapModel(trap_param) return traps
#traps number_sources = 8 radius_sources = 1000.0 trap_radius = 0.5 location_list, strength_list = utility.create_circle_of_sources(number_sources, radius_sources,None) trap_param = { 'source_locations' : location_list, 'source_strengths' : strength_list, 'epsilon' : 0.01, 'trap_radius' : trap_radius, 'source_radius' : radius_sources } traps = trap_models.TrapModel(trap_param) #Odor arena xlim = (-1500., 1500.) ylim = (-1500., 1500.) sim_region = models.Rectangle(xlim[0], ylim[0], xlim[1], ylim[1]) wind_region = models.Rectangle(xlim[0]*2,ylim[0]*2, xlim[1]*2,ylim[1]*2) im_extents = xlim[0], xlim[1], ylim[0], ylim[1] source_pos = scipy.array([scipy.array(tup) for tup in traps.param['source_locations']]).T #lazy plume parameters puff_mol_amount = 1. r_sq_max=20;epsilon=0.00001;N=1e6
def main(detection_threshold): # for wind_mag in np.arange(0.4,3.8,0.2): # wind_mag = float(sys.argv[1]) wind_angle = 9*scipy.pi/8. wind_mag = 1.6 file_name = 'trap_arrival_by_wind_live_coarse_dt' file_name = file_name +'_wind_mag_'+str(wind_mag)#+'_wind_angle_'+str(wind_angle)[0:4] file_name = file_name +'_detection_threshold_'+str(detection_threshold) output_file = file_name+'.pkl' dt = 0.25 plume_dt = 0.25 frame_rate = 20 times_real_time = 60 # seconds of simulation / sec in video capture_interval = int(scipy.ceil(times_real_time*(1./frame_rate)/dt)) simulation_time = 50.*60. #seconds release_delay = 30.*60#/(wind_mag) t_start = 0.0 t = 0. - release_delay # Set up figure fig = plt.figure(figsize=(11, 11)) ax = fig.add_subplot(111) #Video FFMpegWriter = animate.writers['ffmpeg'] metadata = {'title':file_name,} writer = FFMpegWriter(fps=frame_rate, metadata=metadata) writer.setup(fig, file_name+'.mp4', 500) wind_param = { 'speed': wind_mag, 'angle': wind_angle, 'evolving': False, 'wind_dt': None, 'dt': dt } wind_field_noiseless = wind_models.WindField(param=wind_param) #traps number_sources = 8 radius_sources = 1000.0 trap_radius = 0.5 location_list, strength_list = utility.create_circle_of_sources(number_sources, radius_sources,None) trap_param = { 'source_locations' : location_list, 'source_strengths' : strength_list, 'epsilon' : 0.01, 'trap_radius' : trap_radius, 'source_radius' : radius_sources } traps = trap_models.TrapModel(trap_param) #Wind and plume objects #Odor arena xlim = (-1500., 1500.) ylim = (-1500., 1500.) sim_region = models.Rectangle(xlim[0], ylim[0], xlim[1], ylim[1]) wind_region = models.Rectangle(xlim[0]*1.2,ylim[0]*1.2, xlim[1]*1.2,ylim[1]*1.2) source_pos = scipy.array([scipy.array(tup) for tup in traps.param['source_locations']]).T #wind model setup diff_eq = False constant_wind_angle = wind_angle aspect_ratio= (xlim[1]-xlim[0])/(ylim[1]-ylim[0]) noise_gain=3. noise_damp=0.071 noise_bandwidth=0.71 wind_grid_density = 200 Kx = Ky = 10000 #highest value observed to not cause explosion: 10000 wind_field = models.WindModel(wind_region,int(wind_grid_density*aspect_ratio), wind_grid_density,noise_gain=noise_gain,noise_damp=noise_damp, noise_bandwidth=noise_bandwidth,Kx=Kx,Ky=Ky, diff_eq=diff_eq,angle=constant_wind_angle,mag=wind_mag) # Set up plume model centre_rel_diff_scale = 2. # puff_release_rate = 0.001 puff_release_rate = 10 puff_spread_rate=0.005 puff_init_rad = 0.01 max_num_puffs=int(2e5) # max_num_puffs=100 plume_model = models.PlumeModel( sim_region, source_pos, wind_field,simulation_time+release_delay, plume_dt,plume_cutoff_radius=1500, centre_rel_diff_scale=centre_rel_diff_scale, puff_release_rate=puff_release_rate, puff_init_rad=puff_init_rad,puff_spread_rate=puff_spread_rate, max_num_puffs=max_num_puffs) # Create a concentration array generator array_z = 0.01 array_dim_x = 1000 array_dim_y = array_dim_x puff_mol_amount = 1. array_gen = processors.ConcentrationArrayGenerator( sim_region, array_z, array_dim_x, array_dim_y, puff_mol_amount) #Setup fly swarm wind_slippage = (0.,1.) swarm_size=8000 use_empirical_release_data = False #Grab wind info to determine heading mean wind_x,wind_y = wind_mag*scipy.cos(wind_angle),wind_mag*scipy.sin(wind_angle) beta = 1. release_times = scipy.random.exponential(beta,(swarm_size,)) kappa = 2. heading_data=None swarm_param = { 'swarm_size' : swarm_size, 'heading_data' : heading_data, 'initial_heading' : scipy.radians(scipy.random.uniform(0.0,360.0,(swarm_size,))), 'x_start_position' : scipy.zeros(swarm_size), 'y_start_position' : scipy.zeros(swarm_size), 'flight_speed' : scipy.full((swarm_size,), 1.5), 'release_time' : release_times, 'release_delay' : release_delay, 'cast_interval' : [1, 3], 'wind_slippage' : wind_slippage, 'odor_thresholds' : { 'lower': 0.0005, 'upper': detection_threshold }, 'schmitt_trigger':False, 'low_pass_filter_length':3, #seconds 'dt_plot': capture_interval*dt, 't_stop':3000., 'cast_timeout':20, 'airspeed_saturation':True } swarm = swarm_models.BasicSwarmOfFlies(wind_field_noiseless,traps,param=swarm_param, start_type='fh',track_plume_bouts=False,track_arena_exits=False) # xmin,xmax,ymin,ymax = -1000,1000,-1000,1000 #Initial concentration plotting conc_array = array_gen.generate_single_array(plume_model.puffs) xmin = sim_region.x_min; xmax = sim_region.x_max ymin = sim_region.y_min; ymax = sim_region.y_max im_extents = (xmin,xmax,ymin,ymax) vmin,vmax = 0.,50. cmap = matplotlib.colors.ListedColormap(['white', 'orange']) conc_im = ax.imshow(conc_array.T[::-1], extent=im_extents, vmin=vmin, vmax=vmax, cmap=cmap) xmin,xmax,ymin,ymax = -1000,1000,-1000,1000 #For looking at the distace-bound plumes xmin,xmax,ymin,ymax = -3000,3000,-3000,3000 buffr = 100 ax.set_xlim((xmin-buffr,xmax+buffr)) ax.set_ylim((ymin-buffr,ymax+buffr)) #Conc array gen to be used for the flies sim_region_tuple = plume_model.sim_region.as_tuple() box_min,box_max = sim_region_tuple[1],sim_region_tuple[2] #for the plume distance cutoff version, make sure this is at least 2x radius box_min,box_max = -3000.,3000. r_sq_max=20;epsilon=0.00001;N=1e6 array_gen_flies = processors.ConcentrationValueFastCalculator( box_min,box_max,r_sq_max,epsilon,puff_mol_amount,N) # plt.ion() # plt.show() # raw_input() while t<simulation_time: for k in range(capture_interval): #update flies print('t: {0:1.2f}'.format(t)) #update the swarm for j in range(int(dt/plume_dt)): wind_field.update(plume_dt) plume_model.update(plume_dt,verbose=True) # velocity_field = wind_field.velocity_field # u,v = velocity_field[:,:,0],velocity_field[:,:,1] # u,v = u[0:full_size-1:shrink_factor,0:full_size-1:shrink_factor],\ # v[0:full_size-1:shrink_factor,0:full_size-1:shrink_factor] # vector_field.set_UVC(u,v) if t>0.: swarm.update(t,dt,wind_field_noiseless,array_gen_flies,traps,plumes=plume_model, pre_stored=False) t+= dt with open(output_file, 'w') as f: pickle.dump((wind_field_noiseless,swarm),f)
def main(plume_width_factor): file_name = 'plume_width_testing' output_file = file_name+'.pkl' file_name = file_name +'plume_width_factor'+str(plume_width_factor) dt = 0.25 plume_dt = 0.25 frame_rate = 20 times_real_time = 20 # seconds of simulation / sec in video capture_interval = int(scipy.ceil(times_real_time*(1./frame_rate)/dt)) simulation_time = 2.*60. #seconds release_delay = 30.*60#/(wind_mag) t_start = 0.0 t = 0. - release_delay # Set up figure fig = plt.figure(figsize=(11, 11)) ax = fig.add_subplot(111) wind_mag = 1.8 wind_angle = 13*scipy.pi/8. wind_param = { 'speed': wind_mag, 'angle': wind_angle, 'evolving': False, 'wind_dt': None, 'dt': dt } wind_field_noiseless = wind_models.WindField(param=wind_param) #traps number_sources = 8 radius_sources = 1000.0 trap_radius = 0.5 location_list, strength_list = utility.create_circle_of_sources(number_sources, radius_sources,None) trap_param = { 'source_locations' : location_list, 'source_strengths' : strength_list, 'epsilon' : 0.01, 'trap_radius' : trap_radius, 'source_radius' : radius_sources } traps = trap_models.TrapModel(trap_param) #Wind and plume objects #Odor arena xlim = (-1500., 1500.) ylim = (-1500., 1500.) sim_region = models.Rectangle(xlim[0], ylim[0], xlim[1], ylim[1]) wind_region = models.Rectangle(xlim[0]*1.2,ylim[0]*1.2, xlim[1]*1.2,ylim[1]*1.2) source_pos = scipy.array([scipy.array(tup) for tup in traps.param['source_locations']]).T #wind model setup diff_eq = False constant_wind_angle = wind_angle aspect_ratio= (xlim[1]-xlim[0])/(ylim[1]-ylim[0]) noise_gain=3. noise_damp=0.071 noise_bandwidth=0.71 wind_grid_density = 200 Kx = Ky = 10000 #highest value observed to not cause explosion: 10000 wind_field = models.WindModel(wind_region,int(wind_grid_density*aspect_ratio), wind_grid_density,noise_gain=noise_gain,noise_damp=noise_damp, noise_bandwidth=noise_bandwidth,Kx=Kx,Ky=Ky, diff_eq=diff_eq,angle=constant_wind_angle,mag=wind_mag) #Initial wind plotting -- subsampled velocity_field = wind_field.velocity_field u,v = velocity_field[:,:,0],velocity_field[:,:,1] x_origins,y_origins = wind_field._x_points,wind_field._y_points full_size = scipy.shape(u)[0] print(full_size) shrink_factor = 10 u,v = u[0:full_size-1:shrink_factor,0:full_size-1:shrink_factor],\ v[0:full_size-1:shrink_factor,0:full_size-1:shrink_factor] # x_origins,y_origins = x_origins[0:-1:full_size-1],\ # y_origins[0:-1:full_size-1] x_origins,y_origins = x_origins[0:full_size-1:shrink_factor],\ y_origins[0:full_size-1:shrink_factor] coords = scipy.array(list(itertools.product(x_origins, y_origins))) x_coords,y_coords = coords[:,0],coords[:,1] vector_field = ax.quiver(x_coords,y_coords,u,v) # plt.show() # Set up plume model centre_rel_diff_scale = plume_width_factor*2. # puff_release_rate = 0.001 puff_release_rate = 10 puff_spread_rate=0.005 puff_init_rad = 0.01 max_num_puffs=int(2e5) # max_num_puffs=100 plume_model = models.PlumeModel( sim_region, source_pos, wind_field,simulation_time+release_delay,plume_dt, centre_rel_diff_scale=centre_rel_diff_scale, puff_release_rate=puff_release_rate, puff_init_rad=puff_init_rad,puff_spread_rate=puff_spread_rate, max_num_puffs=max_num_puffs) # Create a concentration array generator array_z = 0.01 array_dim_x = 1000 array_dim_y = array_dim_x puff_mol_amount = 1. array_gen = processors.ConcentrationArrayGenerator( sim_region, array_z, array_dim_x, array_dim_y, puff_mol_amount) #Setup fly swarm wind_slippage = (0.,1.) swarm_size=2000 use_empirical_release_data = False #Grab wind info to determine heading mean wind_x,wind_y = wind_mag*scipy.cos(wind_angle),wind_mag*scipy.sin(wind_angle) beta = 1. release_times = scipy.random.exponential(beta,(swarm_size,)) kappa = 2. heading_data=None # xmin,xmax,ymin,ymax = -1000,1000,-1000,1000 #Initial concentration plotting conc_array = array_gen.generate_single_array(plume_model.puffs) xmin = sim_region.x_min; xmax = sim_region.x_max ymin = sim_region.y_min; ymax = sim_region.y_max im_extents = (xmin,xmax,ymin,ymax) vmin,vmax = 0.,50. cmap = matplotlib.colors.ListedColormap(['white', 'orange']) conc_im = ax.imshow(conc_array.T[::-1], extent=im_extents, vmin=vmin, vmax=vmax, cmap=cmap) xmin,xmax,ymin,ymax = -1000,1000,-1000,1000 buffr = 100 ax.set_xlim((xmin-buffr,xmax+buffr)) ax.set_ylim((ymin-buffr,ymax+buffr)) #Conc array gen to be used for the flies sim_region_tuple = plume_model.sim_region.as_tuple() box_min,box_max = sim_region_tuple[1],sim_region_tuple[2] #Put the time in the corner (xmin,xmax) = ax.get_xlim();(ymin,ymax) = ax.get_ylim() # text = '0 min 0 sec' # timer= ax.text(xmax,ymax,text,color='r',horizontalalignment='right') # ax.text(1.,1.02,'time since release:',color='r',transform=ax.transAxes, # horizontalalignment='right') # #traps for x,y in traps.param['source_locations']: #Black x plt.scatter(x,y,marker='x',s=50,c='orange') # Red circles # p = matplotlib.patches.Circle((x, y), 15,color='red') # ax.add_patch(p) # #Remove plot edges and add scale bar fig.patch.set_facecolor('white') # plt.plot([-900,-800],[900,900],color='k')#,transform=ax.transData,color='k') # ax.text(-900,820,'100 m') plt.axis('off') # plt.ion() # plt.show() # raw_input() while t<simulation_time: for k in range(capture_interval): #update flies print('t: {0:1.2f}'.format(t)) #update the swarm for j in range(int(dt/plume_dt)): wind_field.update(plume_dt) plume_model.update(plume_dt,verbose=True) t+= dt # plt.show() # Update live display if t>-30.*60.: # if t>-10.*60.: velocity_field = wind_field.velocity_field u,v = velocity_field[:,:,0],velocity_field[:,:,1] u,v = u[0:full_size-1:shrink_factor,0:full_size-1:shrink_factor],\ v[0:full_size-1:shrink_factor,0:full_size-1:shrink_factor] vector_field.set_UVC(u,v) # conc_array = array_gen.generate_single_array(plume_model.puffs) # conc_im.set_data(conc_array.T[::-1]) # # log_im = scipy.log(conc_array.T[::-1]) # cutoff_l = scipy.percentile(log_im[~scipy.isinf(log_im)],10) # cutoff_u = scipy.percentile(log_im[~scipy.isinf(log_im)],99) # # conc_im.set_data(log_im) # n = matplotlib.colors.Normalize(vmin=cutoff_l,vmax=cutoff_u) # conc_im.set_norm(n) plt.savefig(file_name+'.png',format='png') plt.show() t = simulation_time
def main(wind_angle): # for wind_mag in np.arange(0.4,3.8,0.2): # wind_mag = float(sys.argv[1]) # wind_angle = 13*scipy.pi/8. wind_mag = 1.4 file_name = 'trap_arrival_by_wind_live_coarse_dt' file_name = file_name + '_wind_mag_' + str( wind_mag) + '_wind_angle_' + str(wind_angle)[0:4] output_file = file_name + '.pkl' dt = 0.25 plume_dt = 0.25 frame_rate = 20 times_real_time = 60 # seconds of simulation / sec in video capture_interval = int(scipy.ceil(times_real_time * (1. / frame_rate) / dt)) simulation_time = 50. * 60. #seconds release_delay = 30. * 60 #/(wind_mag) t_start = 0.0 t = 0. - release_delay # Set up figure fig = plt.figure(figsize=(11, 11)) ax = fig.add_subplot(111) #Video FFMpegWriter = animate.writers['ffmpeg'] metadata = { 'title': file_name, } writer = FFMpegWriter(fps=frame_rate, metadata=metadata) writer.setup(fig, file_name + '.mp4', 500) wind_param = { 'speed': wind_mag, 'angle': wind_angle, 'evolving': False, 'wind_dt': None, 'dt': dt } wind_field_noiseless = wind_models.WindField(param=wind_param) #traps number_sources = 8 radius_sources = 1000.0 trap_radius = 0.5 location_list, strength_list = utility.create_circle_of_sources( number_sources, radius_sources, None) trap_param = { 'source_locations': location_list, 'source_strengths': strength_list, 'epsilon': 0.01, 'trap_radius': trap_radius, 'source_radius': radius_sources } traps = trap_models.TrapModel(trap_param) #Wind and plume objects #Odor arena xlim = (-1500., 1500.) ylim = (-1500., 1500.) sim_region = models.Rectangle(xlim[0], ylim[0], xlim[1], ylim[1]) wind_region = models.Rectangle(xlim[0] * 2, ylim[0] * 2, xlim[1] * 2, ylim[1] * 2) source_pos = scipy.array( [scipy.array(tup) for tup in traps.param['source_locations']]).T #wind model setup diff_eq = False constant_wind_angle = wind_angle aspect_ratio = (xlim[1] - xlim[0]) / (ylim[1] - ylim[0]) noise_gain = 3. noise_damp = 0.071 noise_bandwidth = 0.71 wind_grid_density = 200 Kx = Ky = 10000 #highest value observed to not cause explosion: 10000 wind_field = models.WindModel(wind_region, int(wind_grid_density * aspect_ratio), wind_grid_density, noise_gain=noise_gain, noise_damp=noise_damp, noise_bandwidth=noise_bandwidth, Kx=Kx, Ky=Ky, diff_eq=diff_eq, angle=constant_wind_angle, mag=wind_mag) # Set up plume model plume_width_factor = 1. centre_rel_diff_scale = 2. * plume_width_factor # puff_release_rate = 0.001 puff_release_rate = 10 puff_spread_rate = 0.005 puff_init_rad = 0.01 max_num_puffs = int(2e5) # max_num_puffs=100 plume_model = models.PlumeModel( sim_region, source_pos, wind_field, simulation_time + release_delay, plume_dt, plume_cutoff_radius=1500, centre_rel_diff_scale=centre_rel_diff_scale, puff_release_rate=puff_release_rate, puff_init_rad=puff_init_rad, puff_spread_rate=puff_spread_rate, max_num_puffs=max_num_puffs) # Create a concentration array generator array_z = 0.01 array_dim_x = 1000 array_dim_y = array_dim_x puff_mol_amount = 1. array_gen = processors.ConcentrationArrayGenerator(sim_region, array_z, array_dim_x, array_dim_y, puff_mol_amount) #Setup fly swarm wind_slippage = (0., 1.) swarm_size = 2000 use_empirical_release_data = False #Grab wind info to determine heading mean wind_x, wind_y = wind_mag * scipy.cos(wind_angle), wind_mag * scipy.sin( wind_angle) beta = 1. release_times = scipy.random.exponential(beta, (swarm_size, )) kappa = 2. heading_data = None swarm_param = { 'swarm_size': swarm_size, 'heading_data': heading_data, 'initial_heading': scipy.radians(scipy.random.uniform(0.0, 360.0, (swarm_size, ))), 'x_start_position': scipy.zeros(swarm_size), 'y_start_position': scipy.zeros(swarm_size), 'flight_speed': scipy.full((swarm_size, ), 1.5), 'release_time': release_times, 'release_delay': release_delay, 'cast_interval': [1, 3], 'wind_slippage': wind_slippage, 'odor_thresholds': { 'lower': 0.0005, 'upper': 0.05 }, 'schmitt_trigger': False, 'low_pass_filter_length': 3, #seconds 'dt_plot': capture_interval * dt, 't_stop': 3000., 'cast_timeout': 20, 'airspeed_saturation': True } swarm = swarm_models.BasicSwarmOfFlies(wind_field_noiseless, traps, param=swarm_param, start_type='fh', track_plume_bouts=False, track_arena_exits=False) # xmin,xmax,ymin,ymax = -1000,1000,-1000,1000 #Initial concentration plotting conc_array = array_gen.generate_single_array(plume_model.puffs) xmin = sim_region.x_min xmax = sim_region.x_max ymin = sim_region.y_min ymax = sim_region.y_max im_extents = (xmin, xmax, ymin, ymax) vmin, vmax = 0., 50. cmap = matplotlib.colors.ListedColormap(['white', 'orange']) conc_im = ax.imshow(conc_array.T[::-1], extent=im_extents, vmin=vmin, vmax=vmax, cmap=cmap) xmin, xmax, ymin, ymax = -1000, 1000, -1000, 1000 #For looking at the distace-bound plumes xmin, xmax, ymin, ymax = -3000, 3000, -3000, 3000 buffr = 100 ax.set_xlim((xmin - buffr, xmax + buffr)) ax.set_ylim((ymin - buffr, ymax + buffr)) #Conc array gen to be used for the flies sim_region_tuple = plume_model.sim_region.as_tuple() box_min, box_max = sim_region_tuple[1], sim_region_tuple[2] #for the plume distance cutoff version, make sure this is at least 2x radius box_min, box_max = -3000., 3000. r_sq_max = 20 epsilon = 0.00001 N = 1e6 array_gen_flies = processors.ConcentrationValueFastCalculator( box_min, box_max, r_sq_max, epsilon, puff_mol_amount, N) #Initial fly plotting #Sub-dictionary for color codes for the fly modes Mode_StartMode = 0 Mode_FlyUpWind = 1 Mode_CastForOdor = 2 Mode_Trapped = 3 edgecolor_dict = { Mode_StartMode: 'blue', Mode_FlyUpWind: 'red', Mode_CastForOdor: 'red', Mode_Trapped: 'black' } facecolor_dict = { Mode_StartMode: 'blue', Mode_FlyUpWind: 'red', Mode_CastForOdor: 'white', Mode_Trapped: 'black' } fly_edgecolors = [edgecolor_dict[mode] for mode in swarm.mode] fly_facecolors = [facecolor_dict[mode] for mode in swarm.mode] fly_dots = plt.scatter(swarm.x_position, swarm.y_position, edgecolor=fly_edgecolors, facecolor=fly_facecolors, alpha=0.9) #Put the time in the corner (xmin, xmax) = ax.get_xlim() (ymin, ymax) = ax.get_ylim() text = '0 min 0 sec' timer = ax.text(xmax, ymax, text, color='r', horizontalalignment='right') ax.text(1., 1.02, 'time since release:', color='r', transform=ax.transAxes, horizontalalignment='right') #Wind arrow plt.arrow(0.5, 0.5, 0.07, -0.07, transform=ax.transAxes, color='b', width=0.001) ax.text(0.75, 0.9, 'Wind', transform=ax.transAxes, color='b') # #traps for x, y in traps.param['source_locations']: #Black x plt.scatter(x, y, marker='x', s=50, c='k') # Red circles # p = matplotlib.patches.Circle((x, y), 15,color='red') # ax.add_patch(p) #Remove plot edges and add scale bar fig.patch.set_facecolor('white') plt.plot([-900, -800], [900, 900], color='k') #,transform=ax.transData,color='k') ax.text(-900, 820, '100 m') plt.axis('off') #Fly behavior color legend for mode, fly_facecolor, fly_edgecolor, a in zip( ['Dispersing', 'Surging', 'Casting', 'Trapped'], facecolor_dict.values(), edgecolor_dict.values(), [0, 50, 100, 150]): plt.scatter([1000], [-600 - a], edgecolor=fly_edgecolor, facecolor=fly_facecolor, s=20) plt.text(1050, -600 - a, mode, verticalalignment='center') # plt.ion() # plt.show() # raw_input() while t < simulation_time: for k in range(capture_interval): #update flies print('t: {0:1.2f}'.format(t)) #update the swarm for j in range(int(dt / plume_dt)): wind_field.update(plume_dt) plume_model.update(plume_dt, verbose=True) # velocity_field = wind_field.velocity_field # u,v = velocity_field[:,:,0],velocity_field[:,:,1] # u,v = u[0:full_size-1:shrink_factor,0:full_size-1:shrink_factor],\ # v[0:full_size-1:shrink_factor,0:full_size-1:shrink_factor] # vector_field.set_UVC(u,v) if t > 0.: swarm.update(t, dt, wind_field_noiseless, array_gen_flies, traps, plumes=plume_model, pre_stored=False) t += dt # time.sleep(0.001) # Update live display # '''plot the flies''' if t > 0: # Update time display release_delay = release_delay / 60. text = '{0} min {1} sec'.format(int(scipy.floor(abs(t / 60.))), int(scipy.floor(abs(t) % 60.))) timer.set_text(text) fly_dots.set_offsets(scipy.c_[swarm.x_position, swarm.y_position]) fly_edgecolors = [edgecolor_dict[mode] for mode in swarm.mode] fly_facecolors = [facecolor_dict[mode] for mode in swarm.mode] # fly_dots.set_edgecolor(fly_edgecolors) fly_dots.set_facecolor(fly_facecolors) trap_list = [] for trap_num, trap_loc in enumerate( traps.param['source_locations']): mask_trap = swarm.trap_num == trap_num trap_cnt = mask_trap.sum() trap_list.append(trap_cnt) total_cnt = sum(trap_list) conc_array = array_gen.generate_single_array(plume_model.puffs) # non_inf_log = log_im = scipy.log(conc_array.T[::-1]) cutoff_l = scipy.percentile(log_im[~scipy.isinf(log_im)], 10) cutoff_u = scipy.percentile(log_im[~scipy.isinf(log_im)], 99) # im = (log_im>cutoff_l) & (log_im<0.1) # n = matplotlib.colors.Normalize(vmin=0,vmax=1) # image.set_data(im) # image.set_norm(n) conc_im.set_data(log_im) n = matplotlib.colors.Normalize(vmin=cutoff_l, vmax=cutoff_u) conc_im.set_norm(n) # plt.pause(0.0001) writer.grab_frame() writer.finish() with open(output_file, 'w') as f: pickle.dump((wind_field_noiseless, swarm), f) #Trap arrival plot trap_locs = (2 * scipy.pi / swarm.num_traps) * scipy.array( swarm.list_all_traps()) sim_trap_counts = swarm.get_trap_counts() #Set 0s to 1 for plotting purposes sim_trap_counts[sim_trap_counts == 0] = .5 radius_scale = 0.3 plot_size = 1.5 plt.figure(200 + int(10 * wind_mag)) ax = plt.subplot(aspect=1) trap_locs_2d = [(scipy.cos(trap_loc), scipy.sin(trap_loc)) for trap_loc in trap_locs] patches = [ plt.Circle(center, size) for center, size in zip( trap_locs_2d, radius_scale * sim_trap_counts / max(sim_trap_counts)) ] coll = matplotlib.collections.PatchCollection(patches, facecolors='blue', edgecolors='blue') ax.add_collection(coll) ax.set_ylim([-plot_size, plot_size]) ax.set_xlim([-plot_size, plot_size]) ax.set_xticks([]) ax.set_xticklabels('') ax.set_yticks([]) ax.set_yticklabels('') #Wind arrow plt.arrow(0.5, 0.5, 0.1 * scipy.cos(wind_angle), 0.1 * scipy.sin(wind_angle), transform=ax.transAxes, color='b', width=0.001) # ax.text(0.55, 0.5,'Wind',transform=ax.transAxes,color='b') ax.text(0, 1.5, 'N', horizontalalignment='center', verticalalignment='center', fontsize=25) ax.text(0, -1.5, 'S', horizontalalignment='center', verticalalignment='center', fontsize=25) ax.text(1.5, 0, 'E', horizontalalignment='center', verticalalignment='center', fontsize=25) ax.text(-1.5, 0, 'W', horizontalalignment='center', verticalalignment='center', fontsize=25) # plt.title('Simulated') fig.patch.set_facecolor('white') plt.axis('off') ax.text(0, 1.7, 'Trap Counts' + ' (Wind Mag: ' + str(wind_mag)[0:3] + ')', horizontalalignment='center', verticalalignment='center', fontsize=20) plt.savefig(file_name + '.png', format='png')
def f(x_0,K): try: file_name = 'logistic_prob_sim_x_0_'+str(x_0)+'_K_'+str(K) output_file = file_name+'.pkl' dt = 0.25 frame_rate = 20 times_real_time = 20 # seconds of simulation / sec in video capture_interval = int(scipy.ceil(times_real_time*(1./frame_rate)/dt)) simulation_time = 50.*60. #seconds release_delay = 0.*60#/(wind_mag) t_start = 0.0 t = 0. - release_delay wind_angle = 7*scipy.pi/8. wind_mag = 1. # wind_angle = 7*scipy.pi/4. wind_param = { 'speed': wind_mag, 'angle': wind_angle, 'evolving': False, 'wind_dt': None, 'dt': dt } wind_field = wind_models.WindField(param=wind_param) #traps number_sources = 8 radius_sources = 1000.0 trap_radius = 0.5 location_list, strength_list = utility.create_circle_of_sources(number_sources, radius_sources,None) trap_param = { 'source_locations' : location_list, 'source_strengths' : strength_list, 'epsilon' : 0.01, 'trap_radius' : trap_radius, 'source_radius' : radius_sources } traps = trap_models.TrapModel(trap_param) #Wind and plume objects #Odor arena xlim = (-1500., 1500.) ylim = (-1500., 1500.) im_extents = xlim[0], xlim[1], ylim[0], ylim[1] source_pos = scipy.array([scipy.array(tup) for tup in traps.param['source_locations']]) # Set up logistic prob plume object logisticPlumes = models.LogisticProbPlume(K,x_0,source_pos,wind_angle) #To document the plume parameters, save a reference plot of the plume probability curve plt.figure() inputs = np.linspace(0,1000,1000) outputs = logisticPlumes.logistic_1d(inputs) plt.plot(inputs,outputs) plt.title('Logistic Curve with K: '+str(K)+', x_0: '+str(x_0),color='purple') plt.xlim(0,1000.) plt.ylim(-0.02,1.) plt.xlabel('Distance from Trap (m)') plt.ylabel('Trap Arrival Probability') plt.savefig(file_name+'.png',format='png') # Setup fly swarm wind_slippage = (0.,1.) # swarm_size=2000 swarm_size=20000 use_empirical_release_data = False #Grab wind info to determine heading mean wind_x,wind_y = wind_mag*scipy.cos(wind_angle),wind_mag*scipy.sin(wind_angle) beta = 1. release_times = scipy.random.exponential(beta,(swarm_size,)) kappa = 2. heading_data=None #Flies also use parameters (for schmitt_trigger, detection probabilities) # determined in #fly_behavior_sim/near_plume_simulation_sutton.py swarm_param = { 'swarm_size' : swarm_size, 'heading_data' : heading_data, 'initial_heading' : scipy.radians(scipy.random.uniform(0.0,360.0,(swarm_size,))), 'x_start_position' : scipy.zeros(swarm_size), 'y_start_position' : scipy.zeros(swarm_size), 'flight_speed' : scipy.full((swarm_size,), 1.5), 'release_time' : release_times, 'release_delay' : release_delay, 'cast_interval' : [1, 3], 'wind_slippage' : wind_slippage, 'odor_thresholds' : { 'lower': 0.0005, 'upper': 0.05 }, 'schmitt_trigger':False, 'low_pass_filter_length':3, #seconds 'dt_plot': capture_interval*dt, 't_stop':3000., 'cast_timeout':20, 'airspeed_saturation':True } swarm = swarm_models.ReducedSwarmOfFlies(wind_field,traps,param=swarm_param, start_type='fh') # xmin,xmax,ymin,ymax = -1000,1000,-1000,1000 xmin,xmax,ymin,ymax = -1000,1000,-1000,1000 # plt.show() # raw_input() while t<simulation_time: for k in range(capture_interval): #update flies print('t: {0:1.2f}'.format(t)) swarm.update(t,dt,wind_field,logisticPlumes,traps) t+= dt # time.sleep(0.001) with open(output_file, 'w') as f: pickle.dump((wind_field,swarm),f) except(ValueError): print('p>1 error for (x_0,K) pair '+str((x_0,K))) sys.exit()
def main(x_0, K): #np.arange(0.4,3.8,0.2): file_name = 'logistic_prob_sim_x_0_' + str(x_0) + '_K_' + str(K) output_file = file_name + '.pkl' dt = 0.25 frame_rate = 20 times_real_time = 20 # seconds of simulation / sec in video capture_interval = int(scipy.ceil(times_real_time * (1. / frame_rate) / dt)) simulation_time = 50. * 60. #seconds release_delay = 0. * 60 #/(wind_mag) t_start = 0.0 t = 0. - release_delay # Set up figure fig = plt.figure(figsize=(11, 11)) ax = fig.add_subplot(111) # Video FFMpegWriter = animate.writers['ffmpeg'] metadata = { 'title': file_name, } writer = FFMpegWriter(fps=frame_rate, metadata=metadata) writer.setup(fig, file_name + '.mp4', 500) wind_angle = 7 * scipy.pi / 8. wind_mag = 1.6 # wind_angle = 7*scipy.pi/4. wind_param = { 'speed': wind_mag, 'angle': wind_angle, 'evolving': False, 'wind_dt': None, 'dt': dt } wind_field = wind_models.WindField(param=wind_param) #traps number_sources = 8 radius_sources = 1000.0 trap_radius = 0.5 location_list, strength_list = utility.create_circle_of_sources( number_sources, radius_sources, None) trap_param = { 'source_locations': location_list, 'source_strengths': strength_list, 'epsilon': 0.01, 'trap_radius': trap_radius, 'source_radius': radius_sources } traps = trap_models.TrapModel(trap_param) #Wind and plume objects #Odor arena xlim = (-1500., 1500.) ylim = (-1500., 1500.) im_extents = xlim[0], xlim[1], ylim[0], ylim[1] source_pos = scipy.array( [scipy.array(tup) for tup in traps.param['source_locations']]) # Set up logistic prob plume object logisticPlumes = models.LogisticProbPlume(K, x_0, source_pos, wind_angle) #Setup fly swarm wind_slippage = (0., 1.) # wind_slippage = (0.,0.) swarm_size = 2000 use_empirical_release_data = False #Grab wind info to determine heading mean wind_x, wind_y = wind_mag * scipy.cos(wind_angle), wind_mag * scipy.sin( wind_angle) beta = 1. release_times = scipy.random.exponential(beta, (swarm_size, )) kappa = 2. heading_data = None #Flies also use parameters (for schmitt_trigger, detection probabilities) # determined in #fly_behavior_sim/near_plume_simulation_sutton.py swarm_param = { 'swarm_size': swarm_size, 'heading_data': heading_data, 'initial_heading': scipy.radians(scipy.random.uniform(0.0, 360.0, (swarm_size, ))), 'x_start_position': scipy.zeros(swarm_size), 'y_start_position': scipy.zeros(swarm_size), # For testing the 'inside band masks' # 'initial_heading' : (11./8)*scipy.pi*np.ones((swarm_size,)), # 'x_start_position' : scipy.linspace(0,800,swarm_size), # 'y_start_position' : scipy.zeros(swarm_size), 'flight_speed': scipy.full((swarm_size, ), 1.5), 'release_time': release_times, 'release_delay': release_delay, 'cast_interval': [1, 3], 'wind_slippage': wind_slippage, 'odor_thresholds': { 'lower': 0.0005, 'upper': 0.05 }, 'schmitt_trigger': False, 'low_pass_filter_length': 3, #seconds 'dt_plot': capture_interval * dt, 't_stop': 3000., 'cast_timeout': 20, 'airspeed_saturation': True # 'airspeed_saturation':False } swarm = swarm_models.ReducedSwarmOfFlies(wind_field, traps, param=swarm_param, start_type='fh') # xmin,xmax,ymin,ymax = -1000,1000,-1000,1000 #Concentration plotting conc_d = logisticPlumes.conc_im(im_extents) cmap = matplotlib.colors.ListedColormap(['white', 'orange']) cmap = 'YlOrBr' conc_im = plt.imshow(conc_d, extent=im_extents, interpolation='none', cmap=cmap, origin='lower') plt.colorbar() xmin, xmax, ymin, ymax = -1000, 1000, -1000, 1000 buffr = 100 ax.set_xlim((xmin - buffr, xmax + buffr)) ax.set_ylim((ymin - buffr, ymax + buffr)) #Initial fly plotting #Sub-dictionary for color codes for the fly modes Mode_StartMode = 0 Mode_FlyUpWind = 1 Mode_CastForOdor = 2 Mode_Trapped = 3 edgecolor_dict = { Mode_StartMode: 'blue', Mode_FlyUpWind: 'red', Mode_CastForOdor: 'red', Mode_Trapped: 'black' } facecolor_dict = { Mode_StartMode: 'blue', Mode_FlyUpWind: 'red', Mode_CastForOdor: 'white', Mode_Trapped: 'black' } fly_edgecolors = [edgecolor_dict[mode] for mode in swarm.mode] fly_facecolors = [facecolor_dict[mode] for mode in swarm.mode] fly_dots = plt.scatter(swarm.x_position, swarm.y_position, edgecolor=fly_edgecolors, facecolor=fly_facecolors, alpha=0.9) #Put the time in the corner (xmin, xmax) = ax.get_xlim() (ymin, ymax) = ax.get_ylim() text = '0 min 0 sec' timer = ax.text(xmax, ymax, text, color='r', horizontalalignment='right') ax.text(1., 1.02, 'time since release:', color='r', transform=ax.transAxes, horizontalalignment='right') # #traps for x, y in traps.param['source_locations']: #Black x plt.scatter(x, y, marker='x', s=50, c='k') # Red circles # p = matplotlib.patches.Circle((x, y), 15,color='red') # ax.add_patch(p) #Remove plot edges and add scale bar fig.patch.set_facecolor('white') plt.plot([-900, -800], [900, 900], color='k') #,transform=ax.transData,color='k') ax.text(-900, 820, '100 m') plt.axis('off') #Fly behavior color legend for mode, fly_facecolor, fly_edgecolor, a in zip( ['Dispersing', 'Surging', 'Casting', 'Trapped'], facecolor_dict.values(), edgecolor_dict.values(), [0, 50, 100, 150]): plt.scatter([1000], [-600 - a], edgecolor=fly_edgecolor, facecolor=fly_facecolor, s=20) plt.text(1050, -600 - a, mode, verticalalignment='center') plt.ion() # plt.show() # raw_input() while t < simulation_time: for k in range(capture_interval): #update flies print('t: {0:1.2f}'.format(t)) swarm.update(t, dt, wind_field, logisticPlumes, traps) t += dt # Update time display release_delay = release_delay / 60. text = '{0} min {1} sec'.format(int(scipy.floor(abs(t / 60.))), int(scipy.floor(abs(t) % 60.))) timer.set_text(text) # # '''plot the flies''' fly_dots.set_offsets(scipy.c_[swarm.x_position, swarm.y_position]) fly_edgecolors = [edgecolor_dict[mode] for mode in swarm.mode] fly_facecolors = [facecolor_dict[mode] for mode in swarm.mode] # fly_dots.set_edgecolor(fly_edgecolors) fly_dots.set_facecolor(fly_facecolors) # plt.pause(0.0001) writer.grab_frame() trap_list = [] for trap_num, trap_loc in enumerate(traps.param['source_locations']): mask_trap = swarm.trap_num == trap_num trap_cnt = mask_trap.sum() trap_list.append(trap_cnt) total_cnt = sum(trap_list) writer.finish()
def main(wind_mag,i):#np.arange(0.4,3.8,0.2): random_state = np.random.RandomState(i) file_name = 'test_lazy_plumes_single_plume_wind_mag_'+str(wind_mag) output_file = file_name+'.pkl' dt = 0.25 frame_rate = 20 times_real_time = 20 # seconds of simulation / sec in video capture_interval = int(scipy.ceil(times_real_time*(1./frame_rate)/dt)) simulation_time = 50.*60. #seconds release_delay = 0.*60#/(wind_mag) t_start = 0.0 t = 0. - release_delay # Set up figure fig = plt.figure(figsize=(11, 11)) ax = fig.add_subplot(111) # #Video FFMpegWriter = animate.writers['ffmpeg'] metadata = {'title':file_name,} writer = FFMpegWriter(fps=frame_rate, metadata=metadata) writer.setup(fig, file_name+'.mp4', 500) wind_angle = 0. wind_param = { 'speed': wind_mag, 'angle': wind_angle, 'evolving': False, 'wind_dt': None, 'dt': dt } wind_field_noiseless = wind_models.WindField(param=wind_param) #traps source_locations = [(0.,0.),] source_pos = scipy.array([scipy.array(tup) for tup in source_locations]).T trap_param = { 'source_locations' : [source_pos], 'source_strengths' : [1.], 'epsilon' : 0.01, 'trap_radius' : 1., 'source_radius' : 1000. } traps = trap_models.TrapModel(trap_param) #Odor arena xlim = (0., 1800.) ylim = (-500., 500.) sim_region = models.Rectangle(xlim[0], ylim[0], xlim[1], ylim[1]) wind_region = models.Rectangle(xlim[0]*2,ylim[0]*2, xlim[1]*2,ylim[1]*2) im_extents = xlim[0], xlim[1], ylim[0], ylim[1] #lazy plume parameters puff_mol_amount = 1. r_sq_max=20;epsilon=0.00001;N=1e6 lazyPompyPlumes = models.OnlinePlume(sim_region, source_pos, wind_field_noiseless, simulation_time,dt,r_sq_max,epsilon,puff_mol_amount,N) # Concentration plotting # conc_d = lazyPompyPlumes.conc_im(im_extents) # # cmap = matplotlib.colors.ListedColormap(['white', 'orange']) # cmap = 'YlOrBr' # # conc_im = plt.imshow(conc_d,extent=im_extents, # interpolation='none',cmap = cmap,origin='lower') # # plt.colorbar() # # # # # #traps # for x,y in traps.param['source_locations']: # # #Black x # plt.scatter(x,y,marker='x',s=50,c='k') # # plt.ion() # plt.show() while t<simulation_time: for k in range(capture_interval): #update flies print('t: {0:1.2f}'.format(t)) x_locs,y_locs = np.linspace(0., 1800.,1000),np.random.uniform(-500., 500.,1000) lazyPompyPlumes.value(x_locs,y_locs) raw_input() t+= dt # time.sleep(0.001) # Update live display # Update time display release_delay = release_delay/60. text ='{0} min {1} sec'.format( int(scipy.floor(abs(t/60.))),int(scipy.floor(abs(t)%60.))) timer.set_text(text) # '''plot the flies''' fly_dots.set_offsets(scipy.c_[swarm.x_position,swarm.y_position]) fly_edgecolors = [edgecolor_dict[mode] for mode in swarm.mode] fly_facecolors = [facecolor_dict[mode] for mode in swarm.mode] # fly_dots.set_edgecolor(fly_edgecolors) fly_dots.set_facecolor(fly_facecolors) plt.pause(0.0001) writer.grab_frame() trap_list = [] for trap_num, trap_loc in enumerate(traps.param['source_locations']): mask_trap = swarm.trap_num == trap_num trap_cnt = mask_trap.sum() trap_list.append(trap_cnt) total_cnt = sum(trap_list) # writer.finish() with open(output_file, 'w') as f: pickle.dump((wind_field,swarm),f)
def make_time_averaged_plume(wind_mag): dt = 0.25 simulation_time = 35 * 60. #seconds collection_begins = 25 * 60. #to let the plume fill the space #traps source_locations = [ (0., 0.), ] #Odor arena xlim = (0., 1200.) ylim = (-50., 50.) sim_region = models.Rectangle(xlim[0], ylim[0], xlim[1], ylim[1]) wxlim = (-1500., 1500.) wylim = (-1500., 1500.) wind_region = models.Rectangle(wxlim[0] * 1.2, wylim[0] * 1.2, wxlim[1] * 1.2, wylim[1] * 1.2) source_pos = scipy.array([scipy.array(tup) for tup in source_locations]).T #wind model setup diff_eq = False constant_wind_angle = 0. #directly positive x wind direction aspect_ratio = (wxlim[1] - wxlim[0]) / (wylim[1] - wylim[0]) noise_gain = 3. noise_damp = 0.071 noise_bandwidth = 0.71 wind_grid_density = 200 Kx = Ky = 10000 #highest value observed to not cause explosion: 10000 wind_field = models.WindModel(wind_region, int(wind_grid_density * aspect_ratio), wind_grid_density, noise_gain=noise_gain, noise_damp=noise_damp, noise_bandwidth=noise_bandwidth, Kx=Kx, Ky=Ky, diff_eq=diff_eq, angle=constant_wind_angle, mag=wind_mag) #detection_threshold detection_threshold = 0.05 # Set up plume model plume_width_factor = 1. centre_rel_diff_scale = 2. * plume_width_factor puff_release_rate = 10 puff_spread_rate = 0.005 puff_init_rad = 0.01 max_num_puffs = int(2e5) plume_model = models.PlumeModel( sim_region, source_pos, wind_field, simulation_time, dt, centre_rel_diff_scale=centre_rel_diff_scale, puff_release_rate=puff_release_rate, puff_init_rad=puff_init_rad, puff_spread_rate=puff_spread_rate, max_num_puffs=max_num_puffs) #Setup second plume model (Gaussian approximation) source_pos = scipy.array([scipy.array(tup) for tup in source_locations]) gaussianfitPlumes = models.AdjustedGaussianFitPlume( source_pos, constant_wind_angle, wind_mag) source_pos = scipy.array([scipy.array(tup) for tup in source_locations]).T # Create a concentration array generator array_z = 0.01 array_dim_y = 400 array_dim_x = 5000 puff_mol_amount = 1. array_gen = processors.ConcentrationArrayGenerator(sim_region, array_z, array_dim_x, array_dim_y, puff_mol_amount) conc_locs_x, conc_locs_y = np.meshgrid( np.linspace(xlim[0], xlim[1], array_dim_x), np.linspace(ylim[0], ylim[1], array_dim_y)) fig = plt.figure(figsize=(4 * 4, 4)) #Video collection file_name = 'adjusted_gaussian_test_comparison_wind_mag' + str(wind_mag) output_file = file_name + '.pkl' frame_rate = 20 times_real_time = 1 # seconds of simulation / sec in video capture_interval = int(scipy.ceil(times_real_time * (1. / frame_rate) / dt)) FFMpegWriter = animate.writers['ffmpeg'] metadata = { 'title': file_name, } writer = FFMpegWriter(fps=frame_rate, metadata=metadata) writer.setup(fig, file_name + '.mp4', 500) #Setup basic flies num_flies = 1000 fly_x_0, fly_y_0 = np.linspace(xlim[0], xlim[1], num_flies), 20. * np.ones(num_flies) fly_velocity = np.array([0., -1.6]) detection_threshold = 0.05 # # flies = basic_fly_models.Flies(fly_x_0,fly_y_0,fly_velocity,False, # puff_mol_amount / (8 * np.pi**3)**0.5,plume_model.puffs, # detection_threshold,utility.compute_Gaussian,use_grid=False) #Setup swarm flies trap_param = { 'source_locations': [source_pos], 'source_strengths': [1.], 'epsilon': 0.01, 'trap_radius': 1., 'source_radius': 1000. } traps = trap_models.TrapModel(trap_param) wind_param = { 'speed': wind_mag, 'angle': 2 * np.pi, 'evolving': False, 'wind_dt': None, 'dt': dt } wind_field_noiseless = wind_models.WindField(param=wind_param) swarm_param = { 'swarm_size': num_flies, 'initial_heading': scipy.radians(270 * np.ones(num_flies)), 'x_start_position': np.copy(fly_x_0), 'y_start_position': np.copy(fly_y_0), 'flight_speed': scipy.full((num_flies, ), 1.6), 'release_time': np.zeros(num_flies), 'release_delay': 0., 'cast_interval': [1, 3], 'wind_slippage': [0., 0.], 'heading_data': None, 'odor_thresholds': { 'lower': 0.0005, 'upper': detection_threshold }, 'schmitt_trigger': False, 'low_pass_filter_length': 3, #seconds 't_stop': 3000., 'dt_plot': dt, 'cast_timeout': 20, 'airspeed_saturation': True } swarm1 = swarm_models.BasicSwarmOfFlies(wind_field_noiseless, traps, param=swarm_param, start_type='fh', track_plume_bouts=False, track_arena_exits=False) swarm_param.update({ 'x_start_position': np.copy(fly_x_0), 'y_start_position': np.copy(fly_y_0) }) swarm2 = swarm_models.BasicSwarmOfFlies(wind_field_noiseless, traps, param=swarm_param, start_type='fh', track_plume_bouts=False, track_arena_exits=False) #concentration computer for flies box_min, box_max = -100., 1200. r_sq_max = 20 epsilon = 0.00001 N = 1e6 array_gen_flies = processors.ConcentrationValueFastCalculator( box_min, box_max, r_sq_max, epsilon, puff_mol_amount, N) #Compute initial concentration field and display as image ax = plt.subplot(211) buffr = 20 ax.set_xlim((xlim[0] - buffr, xlim[1] + buffr)) ax.set_ylim((ylim[0] - buffr, ylim[1] + buffr)) # zoom_x_min,zoom_x_max = 900,950 # ax.set_xlim((zoom_x_min,zoom_x_max)) # ax.set_ylim((-10,10)) conc_array = array_gen.generate_single_array(plume_model.puffs) xmin = sim_region.x_min xmax = sim_region.x_max ymin = sim_region.y_min ymax = sim_region.y_max im_extents = (xmin, xmax, ymin, ymax) # vmin,vmax = 0.,1. vmin, vmax = 0., .05 conc_im = ax.imshow(conc_array.T[::-1], extent=im_extents, vmin=vmin, vmax=vmax, cmap='Reds', aspect='auto') plt.colorbar(conc_im, ax=ax) # ax.set_aspect('equal') #Puff center scatter plot puffs_reshaped = plume_model.puffs.reshape(-1, plume_model.puffs.shape[-1]) px, py, _, r_sq = puffs_reshaped.T # puff_dots = plt.scatter(px,py,s=r_sq,alpha=0.5,color='k') #Plot flies edgecolor_dict1 = {0: 'red', 1: 'white'} facecolor_dict1 = {0: 'red', 1: 'white'} # fly_edgecolors = [edgecolor_dict1[mode] for mode in flies.mask_caught] # fly_facecolors = [facecolor_dict1[mode] for mode in flies.mask_caught] # fly_dots1 = plt.scatter(flies.x, flies.y, # edgecolor=fly_edgecolors,facecolor = fly_facecolors,alpha=0.9) #Plot swarm Mode_StartMode = 0 Mode_FlyUpWind = 1 Mode_CastForOdor = 2 Mode_Trapped = 3 edgecolor_dict2 = { Mode_StartMode: 'blue', Mode_FlyUpWind: 'yellow', Mode_CastForOdor: 'red', Mode_Trapped: 'black' } facecolor_dict2 = { Mode_StartMode: 'blue', Mode_FlyUpWind: 'yellow', Mode_CastForOdor: 'white', Mode_Trapped: 'black' } fly_edgecolors = [edgecolor_dict2[mode] for mode in swarm1.mode] fly_facecolors = [facecolor_dict2[mode] for mode in swarm1.mode] fly_dots2 = plt.scatter(swarm1.x_position, swarm1.x_position, edgecolor=fly_edgecolors, facecolor=fly_facecolors, alpha=0.9) axtext = ax.text(-0.1, 0.5, '', transform=ax.transAxes, verticalalignment='center', horizontalalignment='center') #Second image: Gaussian fit plume ax1 = plt.subplot(212) buffr = 20 ax1.set_xlim((xlim[0] - buffr, xlim[1] + buffr)) ax1.set_ylim((ylim[0] - buffr, ylim[1] + buffr)) conc_d = gaussianfitPlumes.conc_im(im_extents) #Perform adjustments to the probability plume cmap = 'YlOrBr' conc_im1 = plt.imshow(conc_d, extent=im_extents, interpolation='none', cmap=cmap, origin='lower', aspect='auto') plt.colorbar(conc_im1, ax=ax1) fly_dots3 = plt.scatter(swarm2.x_position, swarm2.x_position, edgecolor=fly_edgecolors, facecolor=fly_facecolors, alpha=0.9) ax1text = ax1.text(-0.1, 0.5, '', transform=ax1.transAxes, verticalalignment='center', horizontalalignment='center') #Display initial wind vector field -- subsampled from total velocity_field = wind_field.velocity_field u, v = velocity_field[:, :, 0], velocity_field[:, :, 1] full_size = scipy.shape(u)[0] shrink_factor = 10 x_origins, y_origins = wind_field.x_points, wind_field.y_points coords = scipy.array(list(itertools.product(x_origins, y_origins))) x_coords, y_coords = coords[:, 0], coords[:, 1] vector_field = ax.quiver(x_coords, y_coords, u, v) # # plt.ion() # plt.show() # t = 0. capture_interval = 25 # while t < simulation_time: for k in range(capture_interval): wind_field.update(dt) plume_model.update(dt, verbose=True) t += dt print(t) if t > collection_begins: # accum_threshold_crosses += (conc_array>=detection_threshold).astype(float) # flies.update(dt,t,plume_model.puffs) swarm1.update(t, dt, wind_field_noiseless, array_gen_flies, traps, plumes=plume_model, pre_stored=False) swarm2.update(t, dt, wind_field_noiseless, gaussianfitPlumes, traps) conc_array = array_gen.generate_single_array(plume_model.puffs) # conc_im.set_data((conc_array>=detection_threshold).astype(float).T)#[::-1]) # conc_im.set_data((conc_array>=0.01).astype(float).T[::-1]) conc_im.set_data(conc_array.T[::-1]) # conc_im1.set_data(accum_threshold_crosses.T[::-1]) # fly_dots1.set_offsets(np.c_[flies.x,flies.y]) # fly_edgecolors = [edgecolor_dict1[mode] for mode in flies.mask_caught] # fly_facecolors = [facecolor_dict1[mode] for mode in flies.mask_caught] # fly_dots1.set_edgecolor(fly_edgecolors) # fly_dots1.set_facecolor(fly_facecolors) fly_dots2.set_offsets(np.c_[swarm1.x_position, swarm1.y_position]) fly_edgecolors = [ edgecolor_dict2[mode] for mode in swarm1.mode ] fly_facecolors = [ facecolor_dict2[mode] for mode in swarm1.mode ] fly_dots2.set_edgecolor(fly_edgecolors) fly_dots2.set_facecolor(fly_facecolors) axtext.set_text( "Start Mode: {0:.3f} \n Surging: {1:.3f} \n Casting: {2:.3f} \n Trapped: {3:.3f} \n" .format( np.sum(swarm1.mode == Mode_StartMode).astype(float) / len(swarm1.mode), np.sum(swarm1.mode == Mode_FlyUpWind).astype(float) / len(swarm1.mode), np.sum(swarm1.mode == Mode_CastForOdor).astype(float) / len(swarm1.mode), np.sum(swarm1.mode == Mode_Trapped).astype(float) / len(swarm1.mode))) fly_dots3.set_offsets(np.c_[swarm2.x_position, swarm2.y_position]) fly_edgecolors = [ edgecolor_dict2[mode] for mode in swarm2.mode ] fly_facecolors = [ facecolor_dict2[mode] for mode in swarm2.mode ] fly_dots3.set_edgecolor(fly_edgecolors) fly_dots3.set_facecolor(fly_facecolors) ax1text.set_text( "Start Mode: {0:.3f} \n Surging: {1:.3f} \n Casting: {2:.3f} \n Trapped: {3:.3f} \n" .format( np.sum(swarm2.mode == Mode_StartMode).astype(float) / len(swarm1.mode), np.sum(swarm2.mode == Mode_FlyUpWind).astype(float) / len(swarm1.mode), np.sum(swarm2.mode == Mode_CastForOdor).astype(float) / len(swarm1.mode), np.sum(swarm2.mode == Mode_Trapped).astype(float) / len(swarm1.mode))) puffs_reshaped = plume_model.puffs.reshape( -1, plume_model.puffs.shape[-1]) px, py, _, r_sq = puffs_reshaped.T # puff_dots.set_offsets(np.c_[px,py]) # print(np.unique(r_sq[(px>zoom_x_min)&(px<zoom_x_max)])) # puff_dots.set_sizes(10*r_sq) # plt.pause(.0001) writer.grab_frame()
def f(detection_threshold): # def f(cast_timeout): # def f(cast_delay): # def f(cast_interval): no_repeat_tracking = True #Comment these out depending on which parameter we're iterating through # detection_threshold = 0.05 cast_timeout = 20. cast_interval = [1, 3] cast_delay = 3. #Wind angle wind_angle = 5 * np.pi / 4 wind_mag = 1.6 #arena size arena_size = 1000. #file info file_name = '1m_uniform_release_times_' file_name = file_name + 'detection_threshold_' + str(detection_threshold) # file_name = file_name +'cast_timeout_'+str(cast_timeout) # file_name = file_name +'cast_interval_'+str(cast_interval) # file_name = file_name +'cast_delay_'+str(cast_delay) # file_name = file_name +'errorless_surging_cast_delay_'+str(cast_delay) # file_name='for_viewing_purposes' # file_name='debugging_zero_peak_3' output_file = file_name + '.pkl' #Timing dt = 0.25 plume_dt = 0.25 frame_rate = 20 times_real_time = 30 # seconds of simulation / sec in video capture_interval = int(np.ceil(times_real_time * (1. / frame_rate) / dt)) # simulation_time = 20.*60. #seconds simulation_time = 12. * 60. #seconds release_delay = 25. * 60 #/(wind_mag) t_start = 0.0 t = 0. - release_delay # Set up figure fig = plt.figure(figsize=(11, 11)) ax = fig.add_subplot(111) wind_param = { 'speed': wind_mag, 'angle': wind_angle, 'evolving': False, 'wind_dt': None, 'dt': dt } wind_field_noiseless = wind_models.WindField(param=wind_param) #Setup ONE plume #traps trap_radius = 0.5 location_list = [(0, 100)] strength_list = [1] trap_param = { 'source_locations': location_list, 'source_strengths': strength_list, 'epsilon': 0.01, 'trap_radius': trap_radius, 'source_radius': 100 } traps = trap_models.TrapModel(trap_param) #Wind and plume objects #Odor arena xlim = (-arena_size, arena_size) ylim = (-arena_size, arena_size) sim_region = models.Rectangle(xlim[0], ylim[0], xlim[1], ylim[1]) wind_region = models.Rectangle(xlim[0] * 1.2, ylim[0] * 1.2, xlim[1] * 1.2, ylim[1] * 1.2) source_pos = np.array( [np.array(tup) for tup in traps.param['source_locations']]).T #wind model setup diff_eq = False constant_wind_angle = wind_angle aspect_ratio = (xlim[1] - xlim[0]) / (ylim[1] - ylim[0]) noise_gain = 3. noise_damp = 0.071 noise_bandwidth = 0.71 wind_grid_density = 200 Kx = Ky = 10000 #highest value observed to not cause explosion: 10000 wind_field = models.WindModel(wind_region, int(wind_grid_density * aspect_ratio), wind_grid_density, noise_gain=noise_gain, noise_damp=noise_damp, noise_bandwidth=noise_bandwidth, Kx=Kx, Ky=Ky, diff_eq=diff_eq, angle=constant_wind_angle, mag=wind_mag) # Set up plume model centre_rel_diff_scale = 2. puff_release_rate = 10 puff_spread_rate = 0.005 puff_init_rad = 0.01 max_num_puffs = int(2e5) # max_num_puffs=100 plume_model = models.PlumeModel( sim_region, source_pos, wind_field, simulation_time + release_delay, plume_dt, plume_cutoff_radius=1500, centre_rel_diff_scale=centre_rel_diff_scale, puff_release_rate=puff_release_rate, puff_init_rad=puff_init_rad, puff_spread_rate=puff_spread_rate, max_num_puffs=max_num_puffs, max_distance_from_trap=5000) # Create a concentration array generator array_z = 0.01 array_dim_x = 1000 array_dim_y = array_dim_x puff_mol_amount = 1. array_gen = processors.ConcentrationArrayGenerator(sim_region, array_z, array_dim_x, array_dim_y, puff_mol_amount) #Start a bunch of flies with uniformly random headings at (0,0) wind_slippage = (0., 0.) # swarm_size=20000 # swarm_size=200000 swarm_size = 1000000 # swarm_size=2000 release_times = scipy.random.uniform(0, simulation_time / 2, size=swarm_size) swarm_param = { 'swarm_size': swarm_size, 'heading_data': None, 'initial_heading': np.radians(np.random.uniform(45.0, 225.0, (swarm_size, ))), 'x_start_position': np.linspace(-arena_size, 50, swarm_size), 'y_start_position': np.linspace(-arena_size, 50, swarm_size), 'flight_speed': np.full((swarm_size, ), 1.5), 'release_time': release_times, 'release_delay': release_delay, 'cast_interval': cast_interval, 'wind_slippage': wind_slippage, 'odor_thresholds': { 'lower': 0.0005, 'upper': detection_threshold }, 'schmitt_trigger': False, 'low_pass_filter_length': cast_delay, #seconds 'dt_plot': capture_interval * dt, 't_stop': simulation_time, 'cast_timeout': cast_timeout, 'surging_error_std': scipy.radians(1e-10), 'airspeed_saturation': False } swarm = swarm_models.BasicSwarmOfFlies(wind_field_noiseless, traps, param=swarm_param, start_type='fh', track_plume_bouts=False, track_arena_exits=False) #Set up collector object #Check that source_pos is the right size collector = TrackBoutCollector(swarm_size, wind_angle, source_pos, repeats=False) #Conc array gen to be used for the flies sim_region_tuple = plume_model.sim_region.as_tuple() box_min, box_max = sim_region_tuple[1], sim_region_tuple[2] #for the plume distance cutoff version, make sure this is at least 2x radius box_min, box_max = -arena_size, arena_size r_sq_max = 20 epsilon = 0.00001 N = 1e6 array_gen_flies = processors.ConcentrationValueFastCalculator( box_min, box_max, r_sq_max, epsilon, puff_mol_amount, N) Mode_StartMode = 0 Mode_FlyUpWind = 1 Mode_CastForOdor = 2 Mode_Trapped = 3 #Start time loop while t < simulation_time: for k in range(capture_interval): #update flies print('t: {0:1.2f}'.format(t)) #update the swarm for j in range(int(dt / plume_dt)): wind_field.update(plume_dt) plume_model.update(plume_dt, verbose=True) if t > 0.: dispersing_last_step = (swarm.mode == Mode_StartMode) casting_last_step = (swarm.mode == Mode_CastForOdor) not_trapped_last_step = (swarm.mode != Mode_Trapped) ever_tracked_last_step = swarm.ever_tracked swarm.update(t, dt, wind_field_noiseless, array_gen_flies, traps, plumes=plume_model, pre_stored=False) #Update the collector object newly_surging = dispersing_last_step & (swarm.mode == Mode_FlyUpWind) newly_dispersing = casting_last_step & (swarm.mode == Mode_StartMode) newly_trapped = not_trapped_last_step & (swarm.mode == Mode_Trapped) dispersal_mode_flies = (swarm.mode == Mode_StartMode) collector.update_for_trapped(newly_trapped) collector.update_for_loss(newly_dispersing, swarm.x_position[newly_dispersing], swarm.y_position[newly_dispersing]) if no_repeat_tracking: newly_surging = newly_surging & (~ever_tracked_last_step) collector.update_for_detection(newly_surging, swarm.x_position[newly_surging], swarm.y_position[newly_surging]) collector.update_for_missed_detection(swarm.x_position, swarm.y_position, dispersal_mode_flies, ever_tracked_last_step) t += dt #Save the collector object with pickle with open(output_file, 'w') as f: swarm_param.update({'simulation_duration': t}) pickle.dump((swarm_param, collector), f)
def f(wind_angle, i): random_state = np.random.RandomState(i) wind_mag = 1.2 file_name = 'trap_arrival_by_wind_live_coarse_dt' file_name = file_name + '_wind_mag_' + str( wind_mag) + '_wind_angle_' + str(wind_angle)[0:4] + '_iter_' + str(i) output_file = file_name + '.pkl' dt = 0.25 plume_dt = 0.25 frame_rate = 20 times_real_time = 20 # seconds of simulation / sec in video capture_interval = int(scipy.ceil(times_real_time * (1. / frame_rate) / dt)) simulation_time = 50. * 60. #seconds release_delay = 30. * 60 #/(wind_mag) t_start = 0.0 t = 0. - release_delay wind_param = { 'speed': wind_mag, 'angle': wind_angle, 'evolving': False, 'wind_dt': None, 'dt': dt } wind_field_noiseless = wind_models.WindField(param=wind_param) #traps number_sources = 8 radius_sources = 1000.0 trap_radius = 0.5 location_list, strength_list = utility.create_circle_of_sources( number_sources, radius_sources, None) trap_param = { 'source_locations': location_list, 'source_strengths': strength_list, 'epsilon': 0.01, 'trap_radius': trap_radius, 'source_radius': radius_sources } traps = trap_models.TrapModel(trap_param) #Wind and plume objects #Odor arena xlim = (-1500., 1500.) ylim = (-1500., 1500.) sim_region = models.Rectangle(xlim[0], ylim[0], xlim[1], ylim[1]) wind_region = models.Rectangle(xlim[0] * 1.2, ylim[0] * 1.2, xlim[1] * 1.2, ylim[1] * 1.2) source_pos = scipy.array( [scipy.array(tup) for tup in traps.param['source_locations']]).T #wind model setup diff_eq = False constant_wind_angle = wind_angle aspect_ratio = (xlim[1] - xlim[0]) / (ylim[1] - ylim[0]) noise_gain = 3. noise_damp = 0.071 noise_bandwidth = 0.71 wind_grid_density = 200 Kx = Ky = 10000 #highest value observed to not cause explosion: 10000 wind_field = models.WindModel(wind_region, int(wind_grid_density * aspect_ratio), wind_grid_density, noise_gain=noise_gain, noise_damp=noise_damp, noise_bandwidth=noise_bandwidth, Kx=Kx, Ky=Ky, noise_rand=random_state, diff_eq=diff_eq, angle=constant_wind_angle, mag=wind_mag) # Set up plume model centre_rel_diff_scale = 2. # puff_release_rate = 0.001 puff_release_rate = 10 puff_spread_rate = 0.005 puff_init_rad = 0.01 max_num_puffs = int(2e5) # max_num_puffs=100 plume_model = models.PlumeModel( sim_region, source_pos, wind_field, simulation_time + release_delay, plume_dt, plume_cutoff_radius=1500, centre_rel_diff_scale=centre_rel_diff_scale, puff_release_rate=puff_release_rate, puff_init_rad=puff_init_rad, puff_spread_rate=puff_spread_rate, max_num_puffs=max_num_puffs, prng=random_state) puff_mol_amount = 1. #Setup fly swarm wind_slippage = (0., 1.) swarm_size = 2000 use_empirical_release_data = False #Grab wind info to determine heading mean wind_x, wind_y = wind_mag * scipy.cos(wind_angle), wind_mag * scipy.sin( wind_angle) beta = 1. release_times = scipy.random.exponential(beta, (swarm_size, )) kappa = 2. heading_data = None swarm_param = { 'swarm_size': swarm_size, 'heading_data': heading_data, 'initial_heading': scipy.radians(scipy.random.uniform(0.0, 360.0, (swarm_size, ))), 'x_start_position': scipy.zeros(swarm_size), 'y_start_position': scipy.zeros(swarm_size), 'flight_speed': scipy.full((swarm_size, ), 1.5), 'release_time': release_times, 'release_delay': release_delay, 'cast_interval': [1, 3], 'wind_slippage': wind_slippage, 'odor_thresholds': { 'lower': 0.0005, 'upper': 0.05 }, 'schmitt_trigger': False, 'low_pass_filter_length': 3, #seconds 'dt_plot': capture_interval * dt, 't_stop': 3000., 'cast_timeout': 20, 'airspeed_saturation': True } swarm = swarm_models.BasicSwarmOfFlies(wind_field_noiseless, traps, param=swarm_param, start_type='fh', track_plume_bouts=False, track_arena_exits=False) # xmin,xmax,ymin,ymax = -1000,1000,-1000,1000 #Conc array gen to be used for the flies sim_region_tuple = plume_model.sim_region.as_tuple() #for the plume distance cutoff version, make sure this is at least 2x radius box_min, box_max = -3000., 3000. r_sq_max = 20 epsilon = 0.00001 N = 1e6 array_gen_flies = processors.ConcentrationValueFastCalculator( box_min, box_max, r_sq_max, epsilon, puff_mol_amount, N) while t < simulation_time: for k in range(capture_interval): #update flies print('t: {0:1.2f}'.format(t)) #update the swarm for j in range(int(dt / plume_dt)): wind_field.update(plume_dt) plume_model.update(plume_dt, verbose=True) if t > 0.: swarm.update(t, dt, wind_field_noiseless, array_gen_flies, traps, plumes=plume_model, pre_stored=False) t += dt with open(output_file, 'w') as f: pickle.dump((wind_field_noiseless, swarm), f)
def main(puff_spread_rate_factor): file_name = 'puff_spread_rate_testing' output_file = file_name + '.pkl' file_name = file_name + '_puff_spread_rate' + str(puff_spread_rate_factor) dt = 0.25 plume_dt = 0.25 frame_rate = 20 times_real_time = 20 # seconds of simulation / sec in video capture_interval = int(scipy.ceil(times_real_time * (1. / frame_rate) / dt)) simulation_time = 50. * 60. #seconds release_delay = 30. * 60 #/(wind_mag) t_start = 0.0 t = 0. - release_delay # Set up figure fig = plt.figure(figsize=(11, 11)) ax = fig.add_subplot(111) wind_mag = 1.8 wind_angle = 13 * scipy.pi / 8. wind_param = { 'speed': wind_mag, 'angle': wind_angle, 'evolving': False, 'wind_dt': None, 'dt': dt } wind_field_noiseless = wind_models.WindField(param=wind_param) #traps number_sources = 8 radius_sources = 1000.0 trap_radius = 0.5 location_list, strength_list = utility.create_circle_of_sources( number_sources, radius_sources, None) trap_param = { 'source_locations': location_list, 'source_strengths': strength_list, 'epsilon': 0.01, 'trap_radius': trap_radius, 'source_radius': radius_sources } traps = trap_models.TrapModel(trap_param) #Wind and plume objects #Odor arena xlim = (-1500., 1500.) ylim = (-1500., 1500.) sim_region = models.Rectangle(xlim[0], ylim[0], xlim[1], ylim[1]) wind_region = models.Rectangle(xlim[0] * 1.2, ylim[0] * 1.2, xlim[1] * 1.2, ylim[1] * 1.2) source_pos = scipy.array( [scipy.array(tup) for tup in traps.param['source_locations']]).T #wind model setup diff_eq = False constant_wind_angle = wind_angle aspect_ratio = (xlim[1] - xlim[0]) / (ylim[1] - ylim[0]) noise_gain = 3. noise_damp = 0.071 noise_bandwidth = 0.71 wind_grid_density = 200 Kx = Ky = 10000 #highest value observed to not cause explosion: 10000 wind_field = models.WindModel(wind_region, int(wind_grid_density * aspect_ratio), wind_grid_density, noise_gain=noise_gain, noise_damp=noise_damp, noise_bandwidth=noise_bandwidth, Kx=Kx, Ky=Ky, diff_eq=diff_eq, angle=constant_wind_angle, mag=wind_mag) # Set up plume model plume_width_factor = 1. puff_mol_amount = 1. centre_rel_diff_scale = 2. * plume_width_factor # puff_release_rate = 0.001 puff_release_rate = 10 puff_spread_rate = 0.005 * puff_spread_rate_factor puff_init_rad = 0.01 max_num_puffs = int(2e5) # max_num_puffs=100 plume_model = models.PlumeModel( sim_region, source_pos, wind_field, simulation_time + release_delay, plume_dt, centre_rel_diff_scale=centre_rel_diff_scale, puff_release_rate=puff_release_rate, puff_init_rad=puff_init_rad, puff_spread_rate=puff_spread_rate, max_num_puffs=max_num_puffs) #Setup fly swarm wind_slippage = (0., 1.) swarm_size = 2000 use_empirical_release_data = False #Grab wind info to determine heading mean wind_x, wind_y = wind_mag * scipy.cos(wind_angle), wind_mag * scipy.sin( wind_angle) beta = 1. release_times = scipy.random.exponential(beta, (swarm_size, )) kappa = 2. heading_data = None swarm_param = { 'swarm_size': swarm_size, 'heading_data': heading_data, 'initial_heading': scipy.radians(scipy.random.uniform(0.0, 360.0, (swarm_size, ))), 'x_start_position': scipy.zeros(swarm_size), 'y_start_position': scipy.zeros(swarm_size), 'flight_speed': scipy.full((swarm_size, ), 1.5), 'release_time': release_times, 'release_delay': release_delay, 'cast_interval': [1, 3], 'wind_slippage': wind_slippage, 'odor_thresholds': { 'lower': 0.0005, 'upper': 0.05 }, 'schmitt_trigger': False, 'low_pass_filter_length': 3, #seconds 'dt_plot': capture_interval * dt, 't_stop': 3000., 'cast_timeout': 20, 'airspeed_saturation': True } swarm = swarm_models.BasicSwarmOfFlies(wind_field_noiseless, traps, param=swarm_param, start_type='fh', track_plume_bouts=False, track_arena_exits=False) # xmin,xmax,ymin,ymax = -1000,1000,-1000,1000 #Conc array gen to be used for the flies sim_region_tuple = plume_model.sim_region.as_tuple() #for the plume distance cutoff version, make sure this is at least 2x radius box_min, box_max = -3000., 3000. r_sq_max = 20 epsilon = 0.00001 N = 1e6 array_gen_flies = processors.ConcentrationValueFastCalculator( box_min, box_max, r_sq_max, epsilon, puff_mol_amount, N) while t < simulation_time: for k in range(capture_interval): #update flies print('t: {0:1.2f}'.format(t)) #update the swarm for j in range(int(dt / plume_dt)): wind_field.update(plume_dt) plume_model.update(plume_dt, verbose=True) if t > 0.: swarm.update(t, dt, wind_field_noiseless, array_gen_flies, traps, plumes=plume_model, pre_stored=False) t += dt with open(output_file, 'w') as f: pickle.dump((wind_field_noiseless, swarm), f) #Trap arrival plot trap_locs = (2 * scipy.pi / swarm.num_traps) * scipy.array( swarm.list_all_traps()) sim_trap_counts = swarm.get_trap_counts() #Set 0s to 1 for plotting purposes sim_trap_counts[sim_trap_counts == 0] = .5 radius_scale = 0.3 plot_size = 1.5 plt.figure(200 + int(10 * wind_mag)) ax = plt.subplot(aspect=1) trap_locs_2d = [(scipy.cos(trap_loc), scipy.sin(trap_loc)) for trap_loc in trap_locs] patches = [ plt.Circle(center, size) for center, size in zip( trap_locs_2d, radius_scale * sim_trap_counts / max(sim_trap_counts)) ] coll = matplotlib.collections.PatchCollection(patches, facecolors='blue', edgecolors='blue') ax.add_collection(coll) ax.set_ylim([-plot_size, plot_size]) ax.set_xlim([-plot_size, plot_size]) ax.set_xticks([]) ax.set_xticklabels('') ax.set_yticks([]) ax.set_yticklabels('') #Wind arrow plt.arrow(0.5, 0.5, 0.1 * scipy.cos(wind_angle), 0.1 * scipy.sin(wind_angle), transform=ax.transAxes, color='b', width=0.001) # ax.text(0.55, 0.5,'Wind',transform=ax.transAxes,color='b') ax.text(0, 1.5, 'N', horizontalalignment='center', verticalalignment='center', fontsize=25) ax.text(0, -1.5, 'S', horizontalalignment='center', verticalalignment='center', fontsize=25) ax.text(1.5, 0, 'E', horizontalalignment='center', verticalalignment='center', fontsize=25) ax.text(-1.5, 0, 'W', horizontalalignment='center', verticalalignment='center', fontsize=25) # plt.title('Simulated') fig.patch.set_facecolor('white') plt.axis('off') ax.text(0, 1.7, 'Trap Counts' + ' (Spread Rate Factor: ' + str(puff_spread_rate_factor) + ')', horizontalalignment='center', verticalalignment='center', fontsize=20) plt.savefig(file_name + '.png', format='png')
def run_tunnel_sim(file_name,release_time_constant, t_stop=15000.0,display_speed=50, wind_slippage = (0.,0.), swarm_size=10000,upper_prob=0.002,dt=0.01, video_name=None,wind_speed=0.5, upper_threshold=0.001,schmitt_trigger=True,track_plume_bouts=False): output_file = file_name+'.pkl' #Create wind field wind_field=srt.setup_wind_field(270.,None,dt,0.,wind_dt=None,wind_speed=wind_speed) #--- Setup odor arena xlim = (0., 0.3) ylim = (0., 1.5) odor_param = { 'wind_field' : wind_field, 'diffusion_coeff' : 0.00001, 'source_locations' : [(0.15,1.45)], 'source_strengths' : [1.], 'epsilon' : 2., 'trap_radius' : 0. } odor_field = odor_models.FakeDiffusionOdorField([],param=odor_param) odor_plot_param = { 'xlim' : xlim, 'ylim' : ylim, 'xnum' : 500, 'ynum' : 500, 'cmap' : 'binary', 'fignums' : (1,2) } #single trap trap_param = { 'source_locations' : odor_param['source_locations'], 'source_strengths' : odor_param['source_strengths'], 'epsilon' : 0.01, 'trap_radius' : 0.05, 'source_radius' : 0. } traps = trap_models.TrapModel(trap_param) #Setup fly swarm swarm_param = { 'swarm_size' : swarm_size, 'heading_data' : None, 'initial_heading_dist': scipy.radians(90.), 'initial_heading' : scipy.random.uniform(scipy.radians(80.),scipy.radians(100.),swarm_size), 'x_start_position' : scipy.random.uniform(0.075,0.225,swarm_size), 'y_start_position' : scipy.zeros((swarm_size,)), 'heading_error_std' : scipy.radians(10.0), 'flight_speed' : scipy.full((swarm_size,), 0.5), 'release_time' : scipy.random.exponential(release_time_constant,(swarm_size,)), 'release_time_constant': release_time_constant, 'release_delay' : 0., 'cast_interval' : [.05, .10], 'wind_slippage' : wind_slippage, 'odor_thresholds' : { 'lower': 0.002, 'upper': upper_threshold }, 'odor_probabilities' : { 'lower': 0.9, # detection probability/sec of exposure 'upper': upper_prob, # detection probability/sec of exposure }, 'schmitt_trigger':schmitt_trigger } swarm = swarm_models.BasicSwarmOfFlies(wind_field,traps,param=swarm_param, start_type='fh',track_plume_bouts=track_plume_bouts,track_arena_exits=True) plot_dict = srt.initial_plot(odor_field,odor_plot_param,True,0., swarm=swarm,fignum = 1,plumes=None) fig = plot_dict['fig'] fig.set_size_inches(8,12,True) fig.canvas.flush_events() ax = fig.add_subplot(111) plt.pause(0.001) t = 0.0 dt_plot = display_speed*dt t_plot_last = 0.0 '''Set up video tools''' if video_name is not None: FFMpegWriter = animate.writers['ffmpeg'] metadata = {'title':video_name,} fps = 24. writer = FFMpegWriter(fps=fps, metadata=metadata) writer.setup(fig, video_name+'.mp4', 500) '''Begin simulation loop''' while t<t_stop: print('t: {0:1.2f}'.format(t)) #update the swarm swarm.update(t,dt,wind_field,odor_field,traps,xlim=xlim,ylim=ylim) #Update time display timer = plot_dict['timer'] text ='{0} min {1} sec'.format(int(scipy.floor(abs(t/60.))),int(scipy.floor(abs(t)%60.))) timer.set_text(text) t+= dt # Update live display if t_plot_last + dt_plot <= t: image = plot_dict['image'] xmin,xmax,ymin,ymax=image.get_extent() ax.set_xlim(xmin,xmax) ax.set_ylim(ymin,ymax) '''plot the flies''' plt.figure(plot_dict['fignum']) fly_dots = plot_dict['fly_dots'] fly_dots.set_offsets(scipy.c_[swarm.x_position,swarm.y_position]) color_dict = plot_dict['color_dict'] fly_colors = [color_dict[mode] for mode in swarm.mode] fly_dots.set_color(fly_colors) '''plot the odor concentration field''' odor_mesh=odor_field.value_to_mesh(t,odor_plot_param) image.set_data(odor_mesh) plt.show() if video_name is not None: writer.grab_frame() fig.canvas.flush_events() t_plot_last = t if video_name is not None: writer.finish() with open(output_file, 'w') as f: pickle.dump((swarm,wind_field),f) plt.clf()
def main(wind_mag, i): #np.arange(0.4,3.8,0.2): random_state = np.random.RandomState(i) file_name = 'test_lazy_plumes_wind_mag_' + str(wind_mag) output_file = file_name + '.pkl' dt = 0.25 frame_rate = 20 times_real_time = 20 # seconds of simulation / sec in video capture_interval = int(scipy.ceil(times_real_time * (1. / frame_rate) / dt)) simulation_time = 50. * 60. #seconds release_delay = 0. * 60 #/(wind_mag) t_start = 0.25 t = 0.25 - release_delay # Set up figure # fig = plt.figure(figsize=(11, 11)) fig = plt.figure(figsize=(7, 7)) ax = fig.add_subplot(111) # #Video FFMpegWriter = animate.writers['ffmpeg'] metadata = { 'title': file_name, } writer = FFMpegWriter(fps=frame_rate, metadata=metadata) writer.setup(fig, file_name + '.mp4', 500) wind_angle = 7 * scipy.pi / 8. # wind_angle = 7*scipy.pi/4. wind_param = { 'speed': wind_mag, 'angle': wind_angle, 'evolving': False, 'wind_dt': None, 'dt': dt } wind_field_noiseless = wind_models.WindField(param=wind_param) #traps number_sources = 8 radius_sources = 1000.0 trap_radius = 0.5 location_list, strength_list = utility.create_circle_of_sources( number_sources, radius_sources, None) trap_param = { 'source_locations': location_list, 'source_strengths': strength_list, 'epsilon': 0.01, 'trap_radius': trap_radius, 'source_radius': radius_sources } traps = trap_models.TrapModel(trap_param) #Wind and plume objects #Odor arena xlim = (-1500., 1500.) ylim = (-1500., 1500.) sim_region = models.Rectangle(xlim[0], ylim[0], xlim[1], ylim[1]) wind_region = models.Rectangle(xlim[0] * 2, ylim[0] * 2, xlim[1] * 2, ylim[1] * 2) im_extents = xlim[0], xlim[1], ylim[0], ylim[1] source_pos = scipy.array( [scipy.array(tup) for tup in traps.param['source_locations']]).T #wind model setup # diff_eq = False # constant_wind_angle = wind_angle # aspect_ratio= (xlim[1]-xlim[0])/(ylim[1]-ylim[0]) # noise_gain=3. # noise_damp=0.071 # noise_bandwidth=0.71 # wind_grid_density = 200 # Kx = Ky = 10000 #highest value observed to not cause explosion: 10000 # wind_field = models.WindModel(wind_region,int(wind_grid_density*aspect_ratio), # wind_grid_density,noise_gain=noise_gain,noise_damp=noise_damp, # noise_bandwidth=noise_bandwidth,Kx=Kx,Ky=Ky,noise_rand=random_state, # diff_eq=diff_eq,angle=constant_wind_angle,mag=wind_mag) # source_pos = scipy.array([scipy.array(tup) for tup in traps.param['source_locations']]) #lazy plume parameters puff_mol_amount = 1. r_sq_max = 20 epsilon = 0.00001 N = 1e6 centre_rel_diff_scale = 2. puff_release_rate = 10 puff_spread_rate = 0.005 puff_init_rad = 0.01 max_num_puffs = int(2e5) lazyPompyPlumes = models.OnlinePlume( sim_region, source_pos, wind_field_noiseless, simulation_time, dt, r_sq_max, epsilon, puff_mol_amount, N, centre_rel_diff_scale=centre_rel_diff_scale, puff_release_rate=puff_release_rate, puff_spread_rate=puff_spread_rate, puff_init_rad=puff_init_rad) #Setup fly swarm wind_slippage = (0., 1.) swarm_size = 500 # swarm_size=10 use_empirical_release_data = False #Grab wind info to determine heading mean wind_x, wind_y = wind_mag * scipy.cos(wind_angle), wind_mag * scipy.sin( wind_angle) beta = 1. # release_times = scipy.random.exponential(beta,(swarm_size,)) release_times = np.zeros((swarm_size, )) kappa = 2. heading_data = None #Flies also use parameters (for schmitt_trigger, detection probabilities) # determined in #fly_behavior_sim/near_plume_simulation_sutton.py swarm_param = { 'swarm_size': swarm_size, 'heading_data': heading_data, 'initial_heading': scipy.radians(scipy.random.uniform(0.0, 360.0, (swarm_size, ))), 'x_start_position': scipy.zeros(swarm_size), # 'x_start_position' : np.random.uniform(900,1100,swarm_size), # 'y_start_position' : np.random.uniform(0,100,swarm_size), 'y_start_position': scipy.zeros(swarm_size), # 'x_start_position' : (-990/np.sqrt(2.))*scipy.ones(swarm_size), # 'y_start_position' : (990./np.sqrt(2.))*scipy.ones(swarm_size), 'flight_speed': scipy.full((swarm_size, ), 1.5), 'release_time': release_times, 'release_delay': release_delay, 'cast_interval': [1, 3], 'wind_slippage': wind_slippage, 'odor_thresholds': { 'lower': 0.0005, 'upper': 0.05 }, 'schmitt_trigger': False, 'low_pass_filter_length': 3, #seconds 'dt_plot': capture_interval * dt, 't_stop': 3000., 'cast_timeout': 20, 'airspeed_saturation': True } swarm = swarm_models.BasicSwarmOfFlies(wind_field_noiseless, traps, param=swarm_param, start_type='fh', track_plume_bouts=False, track_arena_exits=False) # xmin,xmax,ymin,ymax = -1000,1000,-1000,1000 # Concentration plotting # conc_d = lazyPompyPlumes.conc_im(im_extents) # # cmap = matplotlib.colors.ListedColormap(['white', 'orange']) # cmap = 'YlOrBr' # # conc_im = plt.imshow(conc_d,extent=im_extents, # interpolation='none',cmap = cmap,origin='lower') # # plt.colorbar() xmin, xmax, ymin, ymax = -1000, 1000, -1000, 1000 buffr = 100 ax.set_xlim((xmin - buffr, xmax + buffr)) ax.set_ylim((ymin - buffr, ymax + buffr)) #Initial fly plotting #Sub-dictionary for color codes for the fly modes Mode_StartMode = 0 Mode_FlyUpWind = 1 Mode_CastForOdor = 2 Mode_Trapped = 3 edgecolor_dict = { Mode_StartMode: 'blue', Mode_FlyUpWind: 'red', Mode_CastForOdor: 'red', Mode_Trapped: 'black' } facecolor_dict = { Mode_StartMode: 'blue', Mode_FlyUpWind: 'red', Mode_CastForOdor: 'white', Mode_Trapped: 'black' } fly_edgecolors = [edgecolor_dict[mode] for mode in swarm.mode] fly_facecolors = [facecolor_dict[mode] for mode in swarm.mode] fly_dots = plt.scatter(swarm.x_position, swarm.y_position, edgecolor=fly_edgecolors, facecolor=fly_facecolors, alpha=0.9) #Put the time in the corner (xmin, xmax) = ax.get_xlim() (ymin, ymax) = ax.get_ylim() text = '0 min 0 sec' timer = ax.text(xmax, ymax, text, color='r', horizontalalignment='right') ax.text(1., 1.02, 'time since release:', color='r', transform=ax.transAxes, horizontalalignment='right') # #traps for x, y in traps.param['source_locations']: #Black x plt.scatter(x, y, marker='x', s=50, c='k') # Red circles # p = matplotlib.patches.Circle((x, y), 15,color='red') # ax.add_patch(p) #Remove plot edges and add scale bar fig.patch.set_facecolor('white') plt.plot([-900, -800], [900, 900], color='k') #,transform=ax.transData,color='k') ax.text(-900, 820, '100 m') plt.axis('off') #Wind arrow arrow_size = 0.1 # arrowstyle=matplotlib.patches.ArrowStyle.Fancy(head_length=2, head_width=2, tail_width=.4) wind_arrow = matplotlib.patches.FancyArrowPatch( (0.9, 0.9), (0.9 + arrow_size * np.cos(wind_angle), 0.9 + arrow_size * np.sin(wind_angle)), transform=ax.transAxes, color='orange', mutation_scale=10) #,arrowstyle=arrowstyle) ax.add_patch(wind_arrow) #Fly behavior color legend for mode, fly_facecolor, fly_edgecolor, a in zip( ['Dispersing', 'Surging', 'Casting', 'Trapped'], facecolor_dict.values(), edgecolor_dict.values(), [0, 50, 100, 150]): plt.scatter([1000], [-600 - a], edgecolor=fly_edgecolor, facecolor=fly_facecolor, s=20) plt.text(1050, -600 - a, mode, verticalalignment='center') plt.ion() plt.show() # raw_input() while t < simulation_time: for k in range(capture_interval): #update flies print('t: {0:1.2f}'.format(t)) swarm.update(t, dt, wind_field_noiseless, lazyPompyPlumes, traps) t += dt # time.sleep(0.001) # Update live display # Update time display release_delay = release_delay / 60. text = '{0} min {1} sec'.format(int(scipy.floor(abs(t / 60.))), int(scipy.floor(abs(t) % 60.))) timer.set_text(text) # '''plot the flies''' fly_dots.set_offsets(scipy.c_[swarm.x_position, swarm.y_position]) fly_edgecolors = [edgecolor_dict[mode] for mode in swarm.mode] fly_facecolors = [facecolor_dict[mode] for mode in swarm.mode] # fly_dots.set_edgecolor(fly_edgecolors) fly_dots.set_facecolor(fly_facecolors) plt.pause(0.0001) # writer.grab_frame() trap_list = [] for trap_num, trap_loc in enumerate(traps.param['source_locations']): mask_trap = swarm.trap_num == trap_num trap_cnt = mask_trap.sum() trap_list.append(trap_cnt) total_cnt = sum(trap_list) # writer.finish() with open(output_file, 'w') as f: pickle.dump((wind_field, swarm), f)
def run_small_sim(file_name,wind_angle,release_time_constant, t_stop=15000.0,display_speed=1, wind_slippage = (0.,0.),flies=True, swarm_size=100,upper_prob=0.002,dt=0.25,wind_dt=None,pompy_wind_model=False, wind_speed=0.5,wind_data_file=None,video=True,release_delay=5., upper_threshold=0.001,schmitt_trigger=False,track_plume_bouts=False, puff_horizontal_diffusion=1.,plot_scale = 2.0,puff_mol_amount=1.): output_file = file_name+'.pkl' #traps trap_param = { 'source_locations' : [(7.5,25.),], 'source_strengths' : [1.,], 'epsilon' : 0.01, 'trap_radius' : 2., 'source_radius' : 0. } traps = trap_models.TrapModel(trap_param) #--- Setup odor arena xlim = (-15., 15.) ylim = (0., 40.) #Create wind field wind_field=srt.setup_wind_field(wind_angle, wind_data_file,dt,0.,traps, plot_scale,xlim=xlim,ylim=ylim, wind_dt=wind_dt,wind_speed=wind_speed,pompy_wind_model=pompy_wind_model) odor_plot_param,odor_field,plumes = srt.setup_odor_field(wind_field,traps, plot_scale,puff_mol_amount=puff_mol_amount,puffs=True, xlim=xlim,ylim=ylim) #Setup fly swarm swarm_param = { 'swarm_size' : swarm_size, 'heading_data' : None, 'initial_heading_dist': scipy.radians(90.), 'initial_heading' : scipy.random.uniform(scipy.radians(80.),scipy.radians(100.),swarm_size), 'x_start_position' : scipy.random.uniform(0,5,swarm_size), 'y_start_position' : 5.*scipy.ones((swarm_size,)), 'heading_error_std' : scipy.radians(10.0), 'flight_speed' : scipy.full((swarm_size,), 0.5), 'release_time' : scipy.random.exponential(release_time_constant,(swarm_size,)), 'release_time_constant': release_time_constant, 'release_delay' : 0., 'cast_interval' : [5, 10], 'wind_slippage' : wind_slippage, 'odor_thresholds' : { 'lower': 0.002, 'upper': upper_threshold }, 'odor_probabilities' : { 'lower': 0.9, # detection probability/sec of exposure 'upper': upper_prob, # detection probability/sec of exposure }, 'schmitt_trigger':schmitt_trigger, 'dt_plot': display_speed, 't_stop':t_stop } if flies: swarm = swarm_models.BasicSwarmOfFlies(wind_field,traps,param=swarm_param, start_type='fh',track_plume_bouts=track_plume_bouts,track_arena_exits=True) else: swarm = None plot_dict = srt.initial_plot(odor_field,wind_field,odor_plot_param,flies,0., swarm=swarm,fignum = 1,plumes=plumes,pompy_wind_model=pompy_wind_model) fig = plot_dict['fig'] fig.set_size_inches(8,8,True) fig.canvas.flush_events() ax = fig.add_subplot(111) plt.pause(0.001) t = 0.0 dt_plot = display_speed*dt t_plot_last = 0.0 '''Set up video tools''' if video: FFMpegWriter = animate.writers['ffmpeg'] metadata = {'title':file_name,} fps = 24. writer = FFMpegWriter(fps=fps, metadata=metadata) writer.setup(fig, file_name+'.mp4', 500) '''Begin simulation loop''' while t<t_stop: print('t: {0:1.2f}'.format(t)) #update the swarm if flies: swarm.update(t,dt,wind_field,odor_field,traps,xlim=xlim,ylim=ylim, plumes=plumes) wind_field.update(t,dt) plumes.update(t,dt) #Update time display timer = plot_dict['timer'] text ='{0} min {1} sec'.format(int(scipy.floor(abs(t/60.))),int(scipy.floor(abs(t)%60.))) timer.set_text(text) t+= dt # Update live display if t_plot_last + dt_plot <= t: image = plot_dict['image'] xmin,xmax,ymin,ymax=image.get_extent() ax = plot_dict['ax'] ax.set_xlim(xmin,xmax) ax.set_ylim(ymin,ymax) '''plot the flies''' plt.figure(plot_dict['fignum']) #This piece puts an arrow on the image giving the empirical wind direction wind_arrow = plot_dict['wind_arrow'] arrow_magn = 4 x_wind,y_wind = wind_field._empirical_velocity print(x_wind,y_wind) wind_arrow.set_positions((xmin+(xmax-xmin)/2,ymax-0.2*(ymax-ymin)), (xmin+(xmax-xmin)/2+arrow_magn*x_wind, ymax-0.2*(ymax-ymin)+arrow_magn*y_wind)) if pompy_wind_model: #To make sure the pompy wind model is space-varying, plot the wind vector field velocity_field = wind_field.velocity_field u,v = velocity_field[:,:,0],velocity_field[:,:,1] vector_field = plot_dict['vector_field'] vector_field.set_UVC(u,v) if flies: fly_dots = plot_dict['fly_dots'] fly_dots.set_offsets(scipy.c_[swarm.x_position,swarm.y_position]) color_dict = plot_dict['color_dict'] fly_colors = [color_dict[mode] for mode in swarm.mode] fly_dots.set_color(fly_colors) trap_list = [] for trap_num, trap_loc in enumerate(traps.param['source_locations']): mask_trap = swarm.trap_num == trap_num trap_cnt = mask_trap.sum() trap_list.append(trap_cnt) total_cnt = sum(trap_list) plt.title('{0}/{1}: {2}'.format(total_cnt,swarm.size,trap_list)) '''plot the odor concentration field''' conc_array = ( odor_field.generate_single_array(plumes.puff_array).T[::-1]) image.set_data(conc_array) if video: writer.grab_frame() fig.canvas.flush_events() t_plot_last = t if video: writer.finish() with open(output_file, 'w') as f: pickle.dump((swarm,wind_field),f) plt.clf()
def main(x_0, K): #np.arange(0.4,3.8,0.2): file_name = 'logistic_prob_sim_x_0_' + str(x_0) + '_K_' + str(K) output_file = file_name + '.pkl' dt = 0.25 frame_rate = 20 times_real_time = 20 # seconds of simulation / sec in video capture_interval = int(scipy.ceil(times_real_time * (1. / frame_rate) / dt)) simulation_time = 2. * 60. #seconds release_delay = 0. * 60 #/(wind_mag) t_start = 0.0 t = 0. - release_delay # Set up figure fig = plt.figure(figsize=(11, 11)) ax = fig.add_subplot(111) wind_angle = 3 * scipy.pi / 2 wind_mag = 1.6 # wind_angle = 7*scipy.pi/4. wind_param = { 'speed': wind_mag, 'angle': wind_angle, 'evolving': False, 'wind_dt': None, 'dt': dt } wind_field = wind_models.WindField(param=wind_param) #traps number_sources = 1 radius_sources = 1000.0 trap_radius = 0.5 location_list = [(0, 0)] strength_list = [1] trap_param = { 'source_locations': location_list, 'source_strengths': strength_list, 'epsilon': 0.01, 'trap_radius': trap_radius, 'source_radius': radius_sources } traps = trap_models.TrapModel(trap_param) #Wind and plume objects #Odor arena xlim = (-500., 500.) ylim = (-1500., 0.) im_extents = xlim[0], xlim[1], ylim[0], ylim[1] source_pos = scipy.array( [scipy.array(tup) for tup in traps.param['source_locations']]) # Set up logistic prob plume object logisticPlumes = models.LogisticProbPlume(K, x_0, source_pos, wind_angle) #To document the plume parameters, save a reference plot of the plume probability curve #Setup fly swarm wind_slippage = (0., 0.) # swarm_size=2000 swarm_size = 20000 use_empirical_release_data = False #Grab wind info to determine heading mean wind_x, wind_y = wind_mag * scipy.cos(wind_angle), wind_mag * scipy.sin( wind_angle) beta = 1. release_times = scipy.random.exponential(beta, (swarm_size, )) kappa = 2. heading_data = None #Flies also use parameters (for schmitt_trigger, detection probabilities) # determined in #fly_behavior_sim/near_plume_simulation_sutton.py swarm_param = { 'swarm_size': swarm_size, 'heading_data': heading_data, 'initial_heading': np.pi * np.ones(swarm_size), 'x_start_position': 100 * scipy.ones(swarm_size), 'y_start_position': np.linspace(0, -1000, swarm_size), 'flight_speed': scipy.full((swarm_size, ), 1.5), 'release_time': release_times, 'release_delay': release_delay, 'cast_interval': [1, 3], 'wind_slippage': wind_slippage, 'odor_thresholds': { 'lower': 0.0005, 'upper': 0.05 }, 'schmitt_trigger': False, 'low_pass_filter_length': 3, #seconds 'dt_plot': capture_interval * dt, 't_stop': 3000., 'cast_timeout': 20, 'airspeed_saturation': True } swarm = swarm_models.ReducedSwarmOfFlies(wind_field, traps, param=swarm_param, start_type='fh') #Concentration plotting conc_d = logisticPlumes.conc_im(im_extents) cmap = matplotlib.colors.ListedColormap(['white', 'orange']) cmap = 'YlOrBr' conc_im = plt.imshow(conc_d, extent=im_extents, interpolation='none', cmap=cmap, origin='lower') plt.colorbar() xmin, xmax, ymin, ymax = (-500., 500., -1500., 0.) buffr = 100 ax.set_xlim((xmin - buffr, xmax + buffr)) ax.set_ylim((ymin - buffr, ymax + buffr)) #Initial fly plotting #Sub-dictionary for color codes for the fly modes Mode_StartMode = 0 Mode_FlyUpWind = 1 Mode_CastForOdor = 2 Mode_Trapped = 3 edgecolor_dict = { Mode_StartMode: 'blue', Mode_FlyUpWind: 'red', Mode_CastForOdor: 'red', Mode_Trapped: 'black' } facecolor_dict = { Mode_StartMode: 'blue', Mode_FlyUpWind: 'red', Mode_CastForOdor: 'white', Mode_Trapped: 'black' } fly_edgecolors = [edgecolor_dict[mode] for mode in swarm.mode] fly_facecolors = [facecolor_dict[mode] for mode in swarm.mode] fly_dots = plt.scatter(swarm.x_position, swarm.y_position, edgecolor=fly_edgecolors, facecolor=fly_facecolors, alpha=0.9) #Put the time in the corner (xmin, xmax) = ax.get_xlim() (ymin, ymax) = ax.get_ylim() text = '0 min 0 sec' timer = ax.text(xmax, ymax, text, color='r', horizontalalignment='right') ax.text(1., 1.02, 'time since release:', color='r', transform=ax.transAxes, horizontalalignment='right') # #traps for x, y in traps.param['source_locations']: #Black x plt.scatter(x, y, marker='x', s=50, c='k') # Red circles # p = matplotlib.patches.Circle((x, y), 15,color='red') # ax.add_patch(p) #Remove plot edges and add scale bar fig.patch.set_facecolor('white') plt.plot([-900, -800], [900, 900], color='k') #,transform=ax.transData,color='k') ax.text(-900, 820, '100 m') plt.axis('off') #Fly behavior color legend for mode, fly_facecolor, fly_edgecolor, a in zip( ['Dispersing', 'Surging', 'Casting', 'Trapped'], facecolor_dict.values(), edgecolor_dict.values(), [0, 50, 100, 150]): plt.scatter([1000], [-600 - a], edgecolor=fly_edgecolor, facecolor=fly_facecolor, s=20) plt.text(1050, -600 - a, mode, verticalalignment='center') plt.ion() # plt.show() # raw_input() while t < simulation_time: for k in range(capture_interval): #update flies print('t: {0:1.2f}'.format(t)) swarm.update(t, dt, wind_field, logisticPlumes, traps) t += dt plt.pause(0.001) # time.sleep(0.001) release_delay = release_delay / 60. text = '{0} min {1} sec'.format(int(scipy.floor(abs(t / 60.))), int(scipy.floor(abs(t) % 60.))) timer.set_text(text) # # '''plot the flies''' fly_dots.set_offsets(scipy.c_[swarm.x_position, swarm.y_position]) fly_edgecolors = [edgecolor_dict[mode] for mode in swarm.mode] fly_facecolors = [facecolor_dict[mode] for mode in swarm.mode] # fly_dots.set_edgecolor(fly_edgecolors) fly_dots.set_facecolor(fly_facecolors) #the expected curve plt.figure(2) inputs = np.linspace(0, 1000, 1000) outputs = logisticPlumes.logistic_1d(inputs) plt.plot(inputs, outputs, 'r') plt.title('Logistic Curve with K: ' + str(K) + ', x_0: ' + str(x_0), color='purple') plt.xlim(0, 1000.) plt.ylim(-0.02, 1.) plt.xlabel('Distance from Trap (m)') plt.ylabel('Trap Arrival Probability') #Examine the empirical success rate by distance passed_thru_mask = (swarm.mode == Mode_StartMode) num_bins = 100 max_trap_distance = 1000 bin_width = max_trap_distance / num_bins fly_release_density = swarm_size / max_trap_distance fly_release_density_per_bin = fly_release_density * bin_width bins = np.linspace(0, max_trap_distance, num_bins) n_successes, _ = np.histogram(-1. * swarm.y_position[passed_thru_mask], bins) n_successes = n_successes.astype(float) # print(n_successes) # print(fly_release_density_per_bin) plt.plot(bins[:-1], 1. - (n_successes / (fly_release_density_per_bin)), 'o ') plt.show() raw_input() with open(output_file, 'w') as f: pickle.dump((wind_field, swarm), f)