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)
