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)
