def eval_analysis(event, values, window, func, func_kwargs, data, figure_agg, fig, save_to, save_as, graph_dict):
if event == 'DATASET_DIR':
if values['DATASET_DIR'] != '':
d = LarvaDataset(dir=values['DATASET_DIR'])
data[d.id] = d
update_data_list(window, data)
# window['DATASET_DIR'] = ''
elif event == 'Add ref':
d = LarvaDataset(dir=RefFolder)
data[d.id] = d
window.Element('DATASET_IDS').Update(values=list(data.keys()))
elif event == 'Remove':
if len(values['DATASET_IDS']) > 0:
id = values['DATASET_IDS'][0]
data.pop(id, None)
update_data_list(window, data)
elif event == 'Change ID':
data = change_dataset_id(window, values, data)
elif event == 'Save':
save_plot(fig, save_to, save_as)
elif event == 'Graph args':
func_kwargs = set_kwargs(func_kwargs, title='Graph arguments')
elif event == 'Draw':
figure_agg, fig, save_to, save_as = draw_figure(window, func, func_kwargs, data, figure_agg)
func, func_kwargs = update_func(window, values, func, func_kwargs, graph_dict)
# print(values['DATASET_DIR'], type(values['DATASET_DIR']))
# print(window.FindElement('DATASET_DIR').values)
return window, func, func_kwargs, data, figure_agg, fig, save_to, save_as
def get_datasets(datagroup_id,
names,
last_common='processed',
folders=None,
suffixes=None,
mode='load',
load_data=True,
ids=None,
arena_pars=None):
datagroup = LarvaDataGroup(datagroup_id)
data_conf = datagroup.get_conf()['data']
par_conf = datagroup.get_par_conf()
last_common = f'{datagroup.get_path()}/{last_common}'
if folders is None:
new_ids = ['']
folders = [last_common]
else:
new_ids = folders
folders = [f'{last_common}/{f}' for f in folders]
if suffixes is not None:
names = [f'{n}_{s}' for (n, s) in list(product(names, suffixes))]
new_ids = [f'{id}{n}' for (id, n) in list(product(new_ids, names))]
if ids is None:
ids = new_ids
dirs = [f'{f}/{n}' for (f, n) in list(product(folders, names))]
ds = []
for dir, id in zip(dirs, ids):
if mode == 'load':
if not os.path.exists(dir):
print(f'No dataset found at {dir}')
continue
d = LarvaDataset(dir=dir, load_data=load_data)
elif mode == 'initialize':
try:
shutil.rmtree(dir)
except:
pass
if arena_pars is None:
arena_pars = datagroup.arena_pars
d = LarvaDataset(dir=dir,
id=id,
par_conf=par_conf,
arena_pars=arena_pars,
load_data=False,
**data_conf)
ds.append(d)
print(f'{len(ds)} datasets loaded.')
return ds
def end_scatter_generation(traj):
d = save_results_df(traj)
parent_dir = traj.config.dataset_path
dirs = [f'{parent_dir}/{d}' for d in os.listdir(parent_dir)]
dirs.sort()
ds = [LarvaDataset(dir) for dir in dirs]
kwargs = {
'datasets': ds,
'labels': [d.id for d in ds],
'save_to': traj.config.dir_path
}
plot_endpoint_scatter(**kwargs, par_shorts=traj.config.end_parshorts_1)
plot_endpoint_scatter(**kwargs, par_shorts=traj.config.end_parshorts_2)
plot_endpoint_scatter(**kwargs, par_shorts=traj.config.end_parshorts_3)
return d
def deb_analysis(traj):
data_dir = traj.config.dataset_path
parent_dir = traj.config.dir_path
df = save_results_df(traj)
runs_idx, runs, par_names, par_full_names, par_values, res_names, res_values = get_results(
traj, res_names=None)
if len(par_names) == 2:
# z0s=[1.0,0.5,1.0]
for i in range(len(res_names)):
r = res_names[i]
labels = par_names + [r]
plot_3pars(df, labels, save_to=traj.config.dir_path, pref=r)
# plot_3pars(df, labels, z0=z0s[i], save_to = traj.config.dir_path, pref=r)
dirs = [f'{data_dir}/{dir}' for dir in os.listdir(data_dir)]
dirs.sort()
ds = [LarvaDataset(dir) for dir in dirs]
if len(ds) == 1:
new_ids = [None]
else:
if len(par_names) == 1:
new_ids = [f'{par_names[0]} : {v}' for v in par_values[0]]
else:
new_ids = [d.id for d in ds]
plot_endpoint_params(ds, new_ids, mode='deb', save_to=parent_dir)
# print(new_ids,[d.id for d in ds])
# raise
deb_dicts = flatten_list(
[[deb_dict(d, id, new_id=new_id) for id in d.agent_ids]
for d, new_id in zip(ds, new_ids)])
plot_debs(deb_dicts=deb_dicts,
save_to=parent_dir,
save_as='deb_f.pdf',
mode='f')
plot_debs(deb_dicts=deb_dicts, save_to=parent_dir, save_as='deb.pdf')
plot_debs(deb_dicts=deb_dicts,
save_to=parent_dir,
save_as='deb_minimal.pdf',
mode='minimal')
return df
def load_reference_dataset():
reference_dataset = LarvaDataset(dir=paths.RefFolder, load_data=False)
reference_dataset.load(step_data=False)
return reference_dataset
def run_sim_basic(
sim_params,
env_params,
life_params={},
collections=None,
save_to=None,
media_name=None,
save_data_flag=True,
enrich=False,
experiment=None,
par_config=dat.SimParConf,
seed=1,
**kwargs):
if collections is None:
collections = ['pose']
np.random.seed(seed)
id = sim_params['sim_id']
dt = sim_params['dt']
Nsec = sim_params['sim_dur'] * 60
path = sim_params['path']
Box2D = sim_params['Box2D']
if save_to is None:
save_to = paths.SimFolder
if path is not None:
save_to = os.path.join(save_to, path)
dir_path = os.path.join(save_to, id)
# Store the parameters so that we can save them in the results folder
sim_date = datetime.datetime.now()
param_dict = locals()
start = time.time()
Nsteps = int(Nsec / dt)
# # FIXME This only takes the first configuration into account
# print(env_params['larva_params'].values())
Npoints = list(env_params['larva_params'].values())[0]['model']['body_params']['Nsegs'] + 1
d = LarvaDataset(dir=dir_path, id=id, fr=int(1 / dt),
Npoints=Npoints, Ncontour=0,
arena_pars=env_params['arena_params'],
par_conf=par_config, save_data_flag=save_data_flag, load_data=False,
life_params=life_params
)
collected_pars = collection_conf(dataset=d, collections=collections)
env = LarvaWorldSim(id=id, dt=dt, Box2D=Box2D,
# larva_pars=larva_pars,
env_params=env_params, collected_pars=collected_pars,
life_params=life_params, Nsteps=Nsteps,
media_name=media_name, save_to=d.vis_dir,experiment=experiment,
** kwargs)
# Prepare the odor layer for a number of timesteps
odor_prep_time = 0.0
larva_prep_time = 0.5
env.prepare_odor_layer(int(odor_prep_time * 60 / env.dt))
# Prepare the flies for a number of timesteps
env.prepare_flies(int(larva_prep_time * 60 / env.dt))
print(f'Initialized simulation {id}!')
# Run the simulation
completed = env.run()
if not completed:
d.delete()
print(f'Simulation not completed!')
res = None
else:
# Read the data collected during the simulation
env.larva_end_col.collect(env)
env.food_end_col.collect(env)
d.set_step_data(env.larva_step_col.get_agent_vars_dataframe())
d.set_end_data(env.larva_end_col.get_agent_vars_dataframe().droplevel('Step'))
d.set_food_end_data(env.food_end_col.get_agent_vars_dataframe().droplevel('Step'))
end = time.time()
dur = end - start
param_dict['duration'] = np.round(dur, 2)
# Save simulation data and parameters
if save_data_flag:
if enrich and experiment is not None:
d = sim_enrichment(d, experiment)
d.save()
fun.dict_to_file(param_dict, d.sim_pars_file_path)
# Save the odor layer
if env.Nodors > 0:
env.plot_odorscape(save_to=d.plot_dir)
print(f'Simulation completed in {dur} seconds!')
res= d
env.close()
return res
def run_sim_basic(sim_id,
sim_params,
env_params,
fly_params,
save_to=None,
common_folder=None,
media_name=None,
save_data_flag=True,
enrich=False,
experiment=None,
par_config=conf.SimParConf,
starvation_hours=[],
deb_base_f=1,
preview=False,
**kwargs):
# print(starvation_hours)
if save_to is None:
save_to = paths.SimFolder
# current_date = date.today()
# Store the parameters so that we can save them in the results folder
sim_date = datetime.datetime.now()
param_dict = locals()
start = time.time()
dt = sim_params['dt']
Nsec = sim_params['sim_time_in_min'] * 60
Nsteps = int(Nsec / dt)
print(sim_params['sim_time_in_min'])
if common_folder:
parentdir = os.path.join(save_to, common_folder)
else:
parentdir = save_to
dir_path = os.path.join(parentdir, sim_id)
# FIXME This only takes the first configuration into account
if not type(fly_params) == list:
Npoints = fly_params['body_params']['Nsegs'] + 1
else:
Npoints = fly_params[0]['body_params']['Nsegs'] + 1
# Build the environment
# try :
d = LarvaDataset(dir=dir_path,
id=sim_id,
fr=int(1 / dt),
Npoints=Npoints,
Ncontour=0,
arena_pars=env_params['arena_params'],
par_conf=par_config,
save_data_flag=save_data_flag,
load_data=False,
starvation_hours=starvation_hours,
deb_base_f=deb_base_f)
collected_pars = data_collection_config(dataset=d, sim_params=sim_params)
env = LarvaWorldSim(fly_params,
id=sim_id,
env_params=env_params,
dt=dt,
Nsteps=Nsteps,
collected_pars=collected_pars,
media_name=media_name,
save_to=d.vis_dir,
starvation_hours=starvation_hours,
deb_base_f=deb_base_f,
**kwargs)
# Prepare the odor layer for a number of timesteps
env.prepare_odor_layer(
int(sim_params['odor_prep_time_in_min'] * 60 / env.dt))
# Prepare the flies for a number of timesteps
env.prepare_flies(int(sim_params['fly_prep_time_in_min'] * 60 / env.dt))
print(f'Initialized simulation {sim_id}!')
if preview:
env.step()
env.render()
im = env.get_image_path()
env.close()
return im
# except :
# print (f'Failed to initialize simulation {sim_id}.')
# return None
# Run the simulation
completed = env.run()
if not completed:
print(f'Simulation not completed!')
return None
else:
# Read the data collected during the simulation
larva_step_data = env.larva_step_collector.get_agent_vars_dataframe()
env.larva_endpoint_collector.collect(env)
env.food_endpoint_collector.collect(env)
larva_endpoint_data = env.larva_endpoint_collector.get_agent_vars_dataframe(
)
food_endpoint_data = env.food_endpoint_collector.get_agent_vars_dataframe(
)
env.close()
larva_endpoint_data = larva_endpoint_data.droplevel('Step')
food_endpoint_data = food_endpoint_data.droplevel('Step')
if 'cum_dur' in sim_params['end_pars']:
larva_endpoint_data['cum_dur'] = larva_step_data.index.unique(
'Step').size * d.dt
if 'num_ticks' in sim_params['end_pars']:
larva_endpoint_data['num_ticks'] = larva_step_data.index.unique(
'Step').size
d.set_step_data(larva_step_data)
d.set_endpoint_data(larva_endpoint_data)
d.set_food_endpoint_data(food_endpoint_data)
end = time.time()
dur = end - start
param_dict['duration'] = np.round(dur, 2)
# Save simulation data and parameters
if save_data_flag:
if enrich and experiment is not None:
d = sim_enrichment(d, experiment)
d.save()
fun.dict_to_file(param_dict, d.sim_pars_file_path)
# Show the odor layer
if env.Nodors > 0:
env.plot_odorscape(save_to=d.plot_dir)
print(f'Simulation completed in {dur} seconds!')
return d