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
wind_angle = 0. wind_mag = 1. 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) #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,
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()
num_flies = 20000 # num_flies = 5 # num_flies = 10000 fly_speed = 1.6 release_times = 0. K = -.4 x_0 = 300 # K = -1. # x_0 = 1000 number_sources = 8 radius_sources = 1000.0 source_locations, _ = utility.create_circle_of_sources(number_sources, radius_sources, None) source_pos = scipy.array([scipy.array(tup) for tup in source_locations]) release_location = np.zeros(2) intended_heading_angles = np.random.uniform(0, 2 * np.pi, num_flies) intended_heading_angles = np.linspace(0, 2 * np.pi, num_flies) # intended_heading_angles = np.radians(np.array([190,350])) # Set up logistic prob plume object #For visualization purposes for testing xlim = (-1500., 1500.) ylim = (-1500., 1500.) im_extents = xlim[0], xlim[1], ylim[0], ylim[1] gaussianfitPlumes = models.GaussianFitPlume(source_pos, wind_angle, wind_mag)
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 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)