OSCR

AgRP neuron activity predicts and tracks the glycemic response to oral glucose.

Code ↔ Paper

The paper beside its authors' code: matches between them have not been computed for this paper yet.

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Python · 753 lines · 39 KB · MIT

  1. # -*- coding: utf-8 -*-
  2. """
  3. Created on Fri Aug 21 13:33:46 2020
  5. @author: nwh5j
  6. """
  8. #To do: save "snapshots" of the subset of hdf5 files used when making a jupyter report
  9. #want to be able to run through photometry data and save the jupyter report
  10. #look at https://github.com/LernerLab/GuPPy/blob/main/GuPPy/savingInputParameters.ipynb
  13. import tdt
  14. import numpy as np
  15. from scipy.ndimage.filters import uniform_filter1d, median_filter
  16. import pandas as pd
  17. import os
  18. import matplotlib.pyplot as plt
  19. import matplotlib.gridspec as gridspec
  20. import matplotlib as mpl
  21. from math import sqrt
  22. import time
  23. import re
  24. import tables as tb
  25. import xlsxwriter
  28. def time2sec(time):
  29. """ Input is a string in the format: "h,m,s" i.e. "0,2,3" """
  30. time = [int(x) for x in time.split(',')]
  31. seconds = (time[0] * 60**2) + (time[1] * 60) + time[2]
  32. return seconds
  35. def xlsx2dataframe(xlsx_file, path=None, sheet_list=False):
  36. """Sheets should just be an index. path=os.getcwd() is probably wha tyou want to default to"""
  38. if path is None:
  39. path = os.getcwd()
  41. for root, dirs, files in os.walk(path, topdown=True): #maybe add path option here for raw recordings
  42. if xlsx_file in files:
  43. path_xlsx = r"{}".format(root + "/" + xlsx_file)
  45. xlsx_file = pd.ExcelFile(path_xlsx) #xlsx_file gets reassigned here
  46. sheet_names = xlsx_file.sheet_names
  47. df_list = []
  49. for i, sheet in enumerate(sheet_names):
  50. if sheet_list == False:
  51. df_list.append(xlsx_file.parse(sheet_name=sheet, header=0))
  52. else:
  53. if i in sheet_list or sheet in sheet_list:
  54. df_list.append(xlsx_file.parse(sheet_name=sheet, header=0))
  56. exp_df = pd.concat(df_list, ignore_index=True, sort=False)
  57. exp_df.dropna(how='all') #drop empty rows
  58. exp_df['Date'] = exp_df['Date'].dt.strftime("%m/%d/%y")
  59. index_list = []
  61. for i, row in exp_df.iterrows():
  62. if type(row["File"]) != str:
  63. print("Empty excel line at row ", i + 1)
  64. pass
  65. else:
  66. filename = re.sub("-", "_", row["File"])
  67. identity = str(row["Mouse"]) + "_from_" + filename
  68. if identity[0] in "0123456789": #Need this for mice with no letter in front
  69. identity = "Mouse" + identity
  70. else:
  71. identity = str(row["Mouse"]) + "_from_" + filename
  72. index_list.append(identity)
  73. exp_df.index = index_list
  74. # have line that checks that the mouse is actually in the file as a failsafe
  75. return exp_df
  79. def generate_recording(file_path, mouse_channel, channel_config, down_hz, smoothing_method="moving avg", smoothing_window=1):
  80. """TDT formatting: https://www.tdt.com/docs/sdk/offline-data-analysis/offline-data-python/00_Intro/"""
  82. data = tdt.read_block(file_path)
  84. data_channels = set(data.streams.keys())
  85. processed_traces = []
  86. for count, i in enumerate(channel_config["colors"]):
  88. possible_color_channels = channel_config[i][mouse_channel]
  89. color_channel = list(data_channels.intersection(possible_color_channels))[0]
  91. trace_raw = data.streams[color_channel].data
  92. raw_hz = data.streams[color_channel].fs
  94. if smoothing_method == "moving avg":
  95. trace_smooth = uniform_filter1d(trace_raw, size=smoothing_window*(1000)) #rolling mean filter
  96. elif smoothing_method == "median": # median filter algo is slower
  97. trace_smooth = median_filter(trace_raw, size=smoothing_window*(1000))
  98. else:
  99. trace_smooth = trace_raw
  101. trace_final = trace_smooth[0:(len(trace_smooth)-1):int(raw_hz/down_hz)]
  103. if count == 0:
  104. time_vec = np.linspace(0, (len(trace_final) - 1)/(down_hz * 60), len(trace_final))
  105. processed_traces.append(time_vec)
  107. processed_traces.append(trace_final)
  109. # *** to do: make it channel agnostic. For now time_vec, gcamp470, isos405 order should stay the same
  111. return processed_traces
  115. def extract_experiment(exp_df, channel_config, hdf5_name, xlsx_path=None, hdf5_path=None, down_hz=1):
  116. """Recording files refer to the TDT folders that have the recording files within."""
  118. if xlsx_path is None:
  119. xlsx_path = os.getcwd()
  120. if hdf5_path is None:
  121. hdf5_path = os.getcwd()
  123. hdf5_name = hdf5_name + ".h5"
  124. hdf5_title = "Photometry Data: " + hdf5_name
  126. with tb.open_file(hdf5_name, 'a', title=hdf5_title) as hdf5_file:
  128. missing_hdf5recordings_bool = False
  129. missing_hdf5recordings = {}
  131. for identity, row in exp_df.iterrows():
  132. recording_file = row["File"]
  133. if ("/" + identity) not in hdf5_file:
  134. missing_hdf5recordings[recording_file] = missing_hdf5recordings.get(recording_file, [])
  135. missing_hdf5recordings[recording_file].append(identity)
  136. print("")
  137. if len(missing_hdf5recordings.keys()) > 0: #if greater than 0 it means there are missing recordings
  138. raw_recordings_paths = {}
  139. for root, dirs, files in os.walk(xlsx_path, topdown=True): #maybe add path option here for raw recordings
  140. if "StoresListing.txt" in files:
  141. recording_file = os.path.split(root)[-1]
  142. if recording_file in missing_hdf5recordings.keys(): #tells you if recordings not in hdf5 file but is in a path that can be uploaded
  143. path = root
  144. raw_recordings_paths[recording_file] = path
  146. missing_raw_recordings_bool = False # *** Change this to set intersection
  147. for recording_file, identities in missing_hdf5recordings.items():
  148. if recording_file not in raw_recordings_paths.keys():
  149. missing_raw_recordings_bool = True
  151. if missing_raw_recordings_bool == True: # *** Change this to set intersection
  152. print(hdf5_name + " is missing recordings which it needs to be up to date based on excel data sheet.\n")
  153. print("The recordings that are not in working directory or subfolders:")
  154. for recording_file, identities in missing_hdf5recordings.items():
  155. if recording_file not in raw_recordings_paths.keys():
  156. print(recording_file)
  157. print("")
  158. question_continue = "Do you want to continue? Enter y or n: "
  159. answer_continue = input(question_continue)
  160. if answer_continue == "y":
  161. pass
  162. elif answer_continue == "n":
  163. hdf5_file.close()
  164. return None
  165. else:
  166. print("Input should be y or n")
  167. hdf5_file.close()
  168. return None
  170. if len(missing_hdf5recordings.keys()) > 0:
  171. print("Based on xlsx data sheet " + hdf5_name + " is missing these recordings which are ready to be added: ")
  172. recordings_2b_added = set()
  173. for recording_file, identities in missing_hdf5recordings.items():
  174. if recording_file in raw_recordings_paths.keys():
  175. recordings_2b_added.update(identities)
  176. print(" and ".join(identities))
  178. question_hdf5_update = "Update " + hdf5_name + " to include recordings? Enter y or n: "
  179. answer_hdf5_update = input(question_hdf5_update)
  180. print("")
  182. if answer_hdf5_update == "y":
  183. for identity in recordings_2b_added:
  184. recording_name = str(exp_df.loc[identity]["File"]) #this appeared as a pandas.core.series.Series in a certain instance why??
  185. recording_group_name = exp_df.loc[identity]["Group"]
  186. recording_path = raw_recordings_paths[recording_name]
  187. mouse_channel = exp_df.loc[identity]["Channel"]
  188. print("Adding " + identity + " downsampled to " + str(down_hz) + "hz")
  189. print("from group " + recording_group_name)
  190. recording_data = generate_recording(recording_path, mouse_channel, channel_config, down_hz)
  191. print("")
  193. recording_group = hdf5_file.create_group("/", str(identity), "")
  194. recording_group._v_attrs.identity = identity
  195. recording_group._v_attrs.group = recording_group_name
  196. hdf5_file.create_array(recording_group, "timevec", recording_data[0], ("Time vector " + str(down_hz) + "hz"))
  197. hdf5_file.create_array(recording_group, "gcamp470", recording_data[1], ("Gcamp470 " + str(down_hz) + "hz"))
  198. hdf5_file.create_array(recording_group, "isos405", recording_data[2], ("Isos405 " + str(down_hz) + "hz"))
  199. #except:
  200. # return recording_data
  201. elif answer_hdf5_update == "n":
  202. pass
  203. else:
  204. print("Input should be y or n")
  206. else:
  207. print("All recordings present in " + hdf5_name)
  209. recordings_dict = {}
  211. for rec_identity in hdf5_file.walk_groups():
  212. if "identity" in rec_identity._v_attrs:
  213. recordings_dict[rec_identity._v_attrs.identity] = (rec_identity.timevec.read(),
  214. rec_identity.gcamp470.read(),
  215. rec_identity.isos405.read())
  217. return recordings_dict
  221. def extract_intervention(full_recording, start_time, experiment_len, deltapercent,
  222. buff_len, buff_offset, ema_smooth, ema_strength, start_buff=True, sampling_hz=1):
  224. gcamp470 = full_recording[1]
  225. isos405 = full_recording[2]
  226. full_traces = [gcamp470, isos405]
  227. start_time = time2sec(start_time) * sampling_hz #convert time format to sec to data point in time
  228. experiment_len = int(experiment_len * 60 * sampling_hz) #convert min to sec to data point scaled
  229. buff_len = int(buff_len * 60 * sampling_hz)
  230. buff_offset = int(buff_offset * 60 * sampling_hz)
  232. extracted_traces = []
  233. if start_buff == True: #the start buffer window prior to intervention is for normalization/visualization purposes
  234. for trace in full_traces:
  235. extracted_trace = np.array(trace[(start_time - buff_len - buff_offset):(start_time + experiment_len + 1)])
  237. if ema_smooth == True:
  238. extracted_trace = pd.DataFrame(extracted_trace)
  239. extracted_trace = extracted_trace.ewm(span=(60*sampling_hz*ema_strength)).mean()
  240. extracted_trace = extracted_trace.values.tolist()
  241. extracted_trace = [element for sublist in extracted_trace for element in sublist]
  242. extracted_trace = np.array(extracted_trace)
  243. #formatted_time_vec = np.linspace(-(buff_len + buff_offset)/60, (len((extracted_trace) - (buff_len + buff_offset)))/60, num=len(extracted_trace))
  244. formatted_time_vec = np.linspace(-(buff_len + buff_offset)/(60 * sampling_hz), experiment_len/(60 * sampling_hz), num=len(extracted_trace))
  245. mean2normalize2 = np.mean(trace[(start_time - buff_len - buff_offset):(start_time - buff_offset)])
  246. trace_norm = (extracted_trace / mean2normalize2) - 1
  247. if deltapercent == True:
  248. trace_norm = trace_norm * 100
  249. trace_data = (formatted_time_vec, trace_norm, extracted_trace)
  250. extracted_traces.append(trace_data)
  252. else:
  253. for trace in full_traces:
  254. extracted_trace = np.array(trace[start_time:(start_time + experiment_len)])
  255. if ema_smooth == True:
  256. extracted_trace = pd.DataFrame(extracted_trace)
  257. extracted_trace = extracted_trace.ewm(span=(60*sampling_hz*ema_strength)).mean()
  258. extracted_trace = extracted_trace.values.tolist()
  259. extracted_trace = [element for sublist in extracted_trace for element in sublist]
  260. extracted_trace = np.array(extracted_trace)
  261. formatted_time_vec = np.linspace(0, len(extracted_trace)/(60 * sampling_hz), num=len(extracted_trace))
  262. mean2normalize2 = np.mean(extracted_trace)
  263. trace_norm = (extracted_trace / mean2normalize2) - 1
  264. if deltapercent == True: #****
  265. trace_norm = trace_norm * 100
  266. trace_data = (formatted_time_vec, trace_norm, extracted_trace) #This is the time vector, deltaF over F, trace
  267. extracted_traces.append(trace_data)
  269. gcamp470, isos405 = extracted_traces
  270. gcamp470_isocorr_norm = gcamp470[1] - isos405[1]
  271. gcamp460_isocorr_timevec = gcamp470[0]
  272. gcamp470_isocorr = (gcamp460_isocorr_timevec, gcamp470_isocorr_norm)
  274. return gcamp470_isocorr, gcamp470, isos405
  278. def collate_traces(traces_list):
  279. traces = []
  280. for trace in traces_list:
  281. traces.append(trace[1])
  282. time_vec = traces_list[0][0] #take tme vec from first trace
  283. mean_of_traces = np.mean(traces, axis=0)
  284. stderr_of_traces = np.std(traces, axis=0)/sqrt(len(traces))
  285. return time_vec, mean_of_traces, stderr_of_traces
  289. def group_epochs_extraction(exp_df, recordings_dict, epoch_list, sampling_hz=1, ema_smooth=True, ema_strength=1, deltapercent=True):
  290. """epoch1 = ["Epoch Name from group_df", epoch_length, normbufferlen_min, normbufferoffset_min]
  291. epoch_list = [epoch1, epoch2, epoch3, etc]"""
  292. epoch_dict = {}
  293. reverse_epoch_dict = {}
  295. for identity, recording in recordings_dict.items():
  296. if identity not in exp_df.index:
  297. pass
  298. else:
  299. # create full length trace
  300. first_epoch_name, epoch_length, epoch_bufflen, epoch_buffoffset = epoch_list[0] #takes info from first epoch so should be chronological
  301. full_start = exp_df.loc[identity, first_epoch_name]
  302. full_length =(len(recording[0]) - time2sec(full_start))/(60 * sampling_hz) #NEED TO check to make sure time vector is accurately aligned with data sampling
  303. full_trace = extract_intervention(recording, full_start, full_length, deltapercent, epoch_bufflen, epoch_buffoffset, ema_smooth, ema_strength)
  305. epoch_dict[identity] = epoch_dict.get(identity, {})
  306. epoch_dict[identity]["Full Trace"] = epoch_dict[identity].get("Full Trace", {})
  307. epoch_dict[identity]["Full Trace"] = (full_trace, full_start)
  309. reverse_epoch_dict["Full Trace"] = reverse_epoch_dict.get("Full Trace", {})
  310. reverse_epoch_dict["Full Trace"][identity] = reverse_epoch_dict["Full Trace"].get(identity, {})
  311. reverse_epoch_dict["Full Trace"][identity] = (full_trace, full_start)
  313. for epoch_data in epoch_list:
  314. epoch_name, epoch_length, epoch_bufflen, epoch_buffoffset = epoch_data
  315. epoch_start = exp_df.loc[identity, epoch_name]
  316. epoch_trace = extract_intervention(recording, epoch_start, epoch_length, deltapercent, epoch_bufflen, epoch_buffoffset, ema_smooth, ema_strength)
  317. full_epoch_length = (epoch_length + epoch_bufflen + epoch_buffoffset) * 60 * sampling_hz
  318. if full_epoch_length > len(epoch_trace[0][0]):
  319. print(identity + " is shorter than " + epoch_name + " length! It is " + str(len(epoch_trace[0][0])) + " but needs to be " + str(full_epoch_length))
  320. epoch_dict[identity][epoch_name] = epoch_dict[identity].get(epoch_name, {})
  321. epoch_dict[identity][epoch_name] = (epoch_trace, epoch_start)
  323. reverse_epoch_dict[epoch_name] = reverse_epoch_dict.get(epoch_name, {})
  324. reverse_epoch_dict[epoch_name][identity] = reverse_epoch_dict[epoch_name].get(identity, {})
  325. reverse_epoch_dict[epoch_name][identity] = (epoch_trace, epoch_start)
  327. return epoch_dict, reverse_epoch_dict
  331. def inspect_recordings(exp_df, r_epoch_dict, show=True):
  332. """new one"""
  334. full_traces = r_epoch_dict["Full Trace"]
  336. for identity, full_trace in full_traces.items():
  338. fig1 = plt.figure(figsize=(15,12))
  340. rawtraces_plt = fig1.add_subplot(211)
  341. rawtraces_plt.set_ylabel(r'Fluorescence Units', fontsize=25, labelpad=15)
  342. rawtraces_plt.plot(full_trace[0][1][0], full_trace[0][1][2], label="GCaMP", linewidth=2, color="green")
  343. rawtraces_plt.plot(full_trace[0][2][0], full_trace[0][2][2], label="UV", linewidth=2, color="magenta")
  344. rawtraces_plt.legend(loc="upper left", fontsize="large", shadow=True)
  345. rawtraces_plt.axes.get_xaxis().set_visible(False)
  347. #axvspan
  348. deltaF_plt = fig1.add_subplot(212)
  349. deltaF_plt.set_ylabel(r'% $\Delta$F/F', fontsize=25, labelpad=15)
  350. deltaF_plt.set_xlabel("Minutes", fontsize=25, labelpad=15)
  351. deltaF_plt.plot(full_trace[0][1][0], full_trace[0][1][1], label="Gcamp_original", linewidth=2, color="seagreen") #shows isosbestic trace
  352. deltaF_plt.plot(full_trace[0][1][0], full_trace[0][0][1], label="Gcamp_corrected", linewidth=2, color="red")
  353. deltaF_plt.legend(loc="upper left", fontsize="large", shadow=True)
  354. deltaF_plt.set_ybound((-50, 50))
  355. deltaF_plt.set_axisbelow(True)
  357. full_start = time2sec(r_epoch_dict["Full Trace"][identity][1])
  358. for epoch_name, epoch_data in r_epoch_dict.items():
  359. if epoch_name != "Full Trace":
  360. epoch_start = time2sec(epoch_data[identity][1])
  361. deltaF_plt.axvline(x=(epoch_start-full_start)/60, color = "maroon", linestyle="--", zorder=1)
  362. deltaF_plt.axhline(y=0, color = "k", linestyle="-", linewidth=1, zorder=1)
  364. group = str(exp_df.loc[identity, "Group"])
  365. mouse = str(exp_df.loc[identity, "Mouse"])
  366. date = exp_df.loc[identity, "Date"]
  367. rawtraces_plt.tick_params(axis="x", labelsize=15)
  368. rawtraces_plt.tick_params(axis="y", labelsize=15)
  369. deltaF_plt.tick_params(axis="x", labelsize=15)
  370. deltaF_plt.tick_params(axis="y", labelsize=15)
  371. fig_title = group + " <" + str(mouse) + "> (" + str(date) + ")"
  372. fig1.suptitle(fig_title, fontsize=25, fontweight="bold")
  373. fig1.tight_layout()
  374. if show == True:
  375. plt.show()
  379. def average_epochs(sub_df, epoch_dict, epoch_list, channel = "gcamp_isocorr"):
  380. """Takes epochs and for each situation where a mouse has two recordings for one "group""
  381. experimental condition, it will average them together. For example, if there are a number
  382. of PBS traces. Returns a new epoch dict along with a data frame to be used for the graphing"""
  383. group_mouse_means_df = pd.DataFrame()
  384. group_mouse_means_df.insert(0, "Group",'')
  385. group_mouse_means_df.insert(1, "Mouse",'')
  386. list1 = list(sub_df.index)
  387. list2 = list(epoch_dict.keys())
  388. channel_dict = {"gcamp_isocorr":0, "gcamp":1, "isos":2} #consider renaming channel, since two different meanings appear in codebase
  389. epoch_dict_averaged = {} #averages same mice within each group
  390. for epoch in epoch_list:
  391. epoch_dict_averaged[epoch[0]] = epoch_dict_averaged.get(epoch[0], {})
  392. for identity1 in list1:
  393. if identity1 in list2:
  394. list2collate = []
  395. mouse = sub_df.loc[identity1]["Mouse"]
  396. group_mouse_means_df["Mouse"] = mouse
  397. group = sub_df.loc[identity1]["Group"]
  398. group_mouse_means_df["Group"] = group
  399. for identity2 in list2:
  400. if (mouse == sub_df.loc[identity2]["Mouse"]) and (group == sub_df.loc[identity2]["Group"]):
  401. list2collate.append(identity2)
  402. for epoch in epoch_list:
  403. trace_list = []
  404. epoch_name = epoch[0]
  405. epoch_dict_averaged[epoch_name][group] = epoch_dict_averaged[epoch_name].get(group, {})
  406. epoch_dict_averaged[epoch_name][group][mouse] = epoch_dict_averaged[epoch_name][group].get(mouse, [])
  407. for identity in list2collate:
  408. traces = epoch_dict[identity][epoch_name][0][channel_dict[channel]] #modified this from 0
  409. trace_list.append(traces[0:2]) #includes just time and deltaff traces
  410. time_vec, mean_of_traces, stderr_of_traces = collate_traces(trace_list)
  411. epoch_dict_averaged[epoch_name][group][mouse] = [time_vec, mean_of_traces]
  412. for identity in list2collate:
  413. list2.remove(identity) #remove them from list so you don't redundantly add them
  414. else:
  415. pass
  416. return epoch_dict_averaged
  419. def averagedepochs_to_excel(excel_name, epoch_dict_averaged, groups2compare):
  420. """Take an average reverse epoch dict (Epochs -> Individual Traces) and convert to dataframe.
  421. Name excel_name as a "string" "without using spaces or slashes or special characters.
  422. example: avgepochdata_to_excel("epochdata.xlsx", avg_epoch_dict, groups2compare)"""
  423. workbook = xlsxwriter.Workbook(excel_name) #needs to include .xlsx
  424. for epoch_name, exp_group_data in epoch_dict_averaged.items():
  425. worksheet = workbook.add_worksheet(epoch_name)
  426. n = 0
  427. for exp_group_name, mice_data in exp_group_data.items():
  428. for mouse_name, epoch_trace in mice_data.items(): #epoch_trace includes [time, deltaf]
  429. if n == 0:
  430. column_content = ["Time", ""]
  431. column_content.extend(epoch_trace[0])
  432. worksheet.write_column(0, n, column_content)
  433. n = n + 1
  434. column_content = [exp_group_name, mouse_name]
  435. column_content.extend(epoch_trace[1])
  436. worksheet.write_column(0, n, column_content)
  437. n = n + 1
  438. workbook.close()
  442. def auc_finder(avg_epoch_dict, epoch_name, start_minute, end_minute):
  443. group_auc_dict = {}
  444. for epoch, groups in avg_epoch_dict.items():
  445. if epoch == epoch_name:
  446. group_auc_dict = {}
  447. for group, mice in groups.items():
  448. group_auc_dict[group] = ()
  449. auc_list = []
  450. for mouse, trace_data in mice.items():
  451. start_min_ind = 0
  452. end_min_ind = 0
  453. time_vec, trace_vec = trace_data
  454. for i in range(len(time_vec)):
  455. if time_vec[i] == start_minute:
  456. start_min_ind = i
  457. if int(time_vec[i]) == end_minute:
  458. end_min_ind = i
  459. break
  460. auc_time_vec = time_vec[start_min_ind:end_min_ind + 1]
  461. auc_trace_vec = trace_vec[start_min_ind:end_min_ind + 1]
  462. auc_time_vec = auc_time_vec.tolist()
  463. auc_trace_vec = auc_trace_vec.tolist()
  465. auc = np.trapz(auc_trace_vec, auc_time_vec) #performs auc
  466. auc_list.append(auc)
  467. group_auc_dict[group] = (auc_time_vec, auc_list)
  468. return group_auc_dict
  472. def average_window(epoch_dict_averaged, groups2compare, epoch_name, start_minute, end_minute, down_hz=1):
  473. """times are in minutes"""
  475. epoch_dict_groups = epoch_dict_averaged[epoch_name]
  476. average_window_dict = {}
  478. for group in groups2compare:
  479. mice_data = epoch_dict_groups[group]
  480. average_window_dict[group] = average_window_dict.get(group, [])
  481. for mouse, traces in mice_data.items():
  482. time_trace = traces[0]
  483. gcamp_trace = traces[1]
  485. time_point_start = np.where(time_trace==float(start_minute))
  486. time_point_start = int(list(time_point_start)[0])
  487. time_point_end = np.where(time_trace==float(end_minute))
  488. time_point_end = int(list(time_point_end)[0])
  490. gcamp_window = gcamp_trace[time_point_start:time_point_end + 1]
  492. gcamp_window_mean = gcamp_window.mean()
  493. average_window_dict[group].append((mouse, gcamp_window_mean))
  495. return average_window_dict
  500. def plot_epochs(exp_df, reverse_epoch_dict, groups2compare, exp_df_column="Group", deltapercent=True):
  501. """Group legend follows order in groups2compare. group_traces is for the main graph
  502. comparing all groups whereas group_trace is for the within group graphs."""
  503. for epoch_name, identities in reverse_epoch_dict.items():
  504. if epoch_name != "Full Trace":
  505. group_epoch_dict = {}
  506. for group in groups2compare:
  507. for identity, trace_data in identities.items():
  508. if exp_df.loc[identity, "Group"] != group:
  509. pass
  510. else:
  511. group_epoch_dict[group] = group_epoch_dict.get(group, [])
  512. group_epoch_dict[group].append((identity, trace_data[0][0])) #just getting the deltaF trace
  514. fig3 = plt.figure(figsize=(15,12))
  515. title = epoch_name + " Photometry Period"
  516. fig3.suptitle(title, fontsize="30", fontweight="bold")
  517. group_traces_plt = fig3.add_subplot(211)
  518. if deltapercent==True:
  519. group_traces_plt.set_ylabel(r'% $\Delta$F/F', fontsize="x-large")
  520. else:
  521. group_traces_plt.set_ylabel(r'$\Delta$F/F', fontsize="x-large")
  522. group_traces_plt.set_xlabel("Minutes", fontsize="x-large")
  524. for group_name, traces_info in group_epoch_dict.items():
  526. fig2 = plt.figure(figsize=(15,12))
  527. individual_traces_plt = fig2.add_subplot(211)
  528. group_trace_plt = fig2.add_subplot(212)
  529. if deltapercent==True:
  530. group_trace_plt.set_ylabel(r'% $\Delta$F/F', fontsize="x-large")
  531. else:
  532. group_traces_plt.set_ylabel(r'$\Delta$F/F', fontsize="x-large")
  533. group_trace_plt.set_ylabel(r'$\Delta$F/F', fontsize="x-large")
  534. group_trace_plt.set_xlabel("Minutes", fontsize="x-large")
  536. traces_data = []
  537. for identity, trace_data in traces_info:
  538. traces_data.append(trace_data)
  539. time_axis, trace = trace_data
  540. individual_traces_plt.plot(time_axis, trace, linewidth=0.8, label=exp_df.loc[identity,"Mouse"])
  542. individual_traces_plt.legend(loc="lower left", fontsize="medium", shadow=True)
  543. individual_traces_plt.axes.get_xaxis().set_visible(False)
  545. time_axis, mean_trace, stderr_trace = collate_traces(traces_data)
  546. group_trace_plt.plot(time_axis, mean_trace, linewidth=1, label="Mean Trace + Std.Error", color="darkcyan")
  547. group_trace_plt.fill_between(time_axis, mean_trace+stderr_trace, mean_trace-stderr_trace, alpha=0.4, color="salmon")
  548. group_trace_plt.legend(loc="lower left", fontsize="medium", shadow=True)
  550. group_traces_plt.plot(time_axis, mean_trace, linewidth=1, label=group_name)
  551. group_traces_plt.fill_between(time_axis, mean_trace+stderr_trace, mean_trace-stderr_trace, alpha=0.35)
  553. fig2.suptitle((group_name + " (" + epoch_name + ")"), fontsize="30", fontweight="bold")
  554. fig2.tight_layout()
  556. group_traces_plt.legend(loc="upper right", fontsize="large", shadow=True)
  558. fig3.tight_layout()
  562. def plot_permouse_interventioncompare(exp_df, reverse_epoch_dict, groups2compare, mice2plot, exp_df_column="Group"):
  564. for mouse in mice2plot:
  565. for epoch_name, identities in reverse_epoch_dict.items():
  566. if epoch_name != "Full Trace":
  567. group_epoch_dict = {}
  568. for identity, trace_data in identities.items():
  569. if exp_df.loc[identity]["Mouse"] != mouse:
  570. print("searching for " + exp_df.loc[identity]["Mouse"] + " but is " + mouse)
  571. pass
  572. else:
  573. group_name = exp_df.loc[identity, exp_df_column]
  574. if group_name in groups2compare:
  575. #print(identity + " " + group_name)
  576. group_epoch_dict[group_name] = group_epoch_dict.get(group_name, [])
  577. #mouse_name = exp_df.loc[identity, "Mouse"]
  578. group_epoch_dict[group_name].append((identity, trace_data[0][0])) #just getting the deltaF trace
  579. print("else")
  580. fig3 = plt.figure(figsize=(15,12))
  581. fig3.suptitle((mouse + " " + epoch_name), fontsize="27", fontweight="bold")
  582. group_traces_plt = fig3.add_subplot(211)
  583. group_traces_plt.set_ylabel(r'$\Delta$F/F', fontsize="x-large")
  584. group_traces_plt.set_xlabel("Minutes", fontsize="x-large")
  585. group_traces_plt.legend(loc="lower left", fontsize="large", shadow=True)
  587. fig3.tight_layout()
  591. def plot_averagedepochs(avg_epoch_dict, groups2compare):
  592. """Group legend follows order in groups2compare"""
  593. for epoch_name, groups in avg_epoch_dict.items():
  594. if epoch_name != "Full Trace":
  595. group_epoch_dict = {}
  596. for group, mice in groups.items():
  597. if group in groups2compare:
  598. for mouse, trace_data in mice.items():
  599. group_epoch_dict[group] = group_epoch_dict.get(group, [])
  600. group_epoch_dict[group].append((mouse, trace_data))
  602. fig3 = plt.figure(figsize=(15,12))
  603. fig3.suptitle(epoch_name, fontsize="30", fontweight="bold")
  604. group_traces_plt = fig3.add_subplot(211)
  605. group_traces_plt.set_ylabel(r'$\Delta$F/F', fontsize="x-large")
  606. group_traces_plt.set_xlabel("Minutes", fontsize="x-large")
  608. for group_name, traces_info in group_epoch_dict.items():
  610. fig2 = plt.figure(figsize=(15,12))
  611. individual_traces_plt = fig2.add_subplot(211)
  612. group_trace_plt = fig2.add_subplot(212)
  613. group_trace_plt.set_ylabel(r'$\Delta$F/F', fontsize="x-large")
  614. group_trace_plt.set_xlabel("Minutes", fontsize="x-large")
  616. traces_data = []
  617. for mouse, trace_data in traces_info:
  618. traces_data.append(trace_data)
  619. time_axis, trace = trace_data
  620. individual_traces_plt.plot(time_axis, trace, linewidth=0.8, label=mouse)
  622. individual_traces_plt.legend(loc="lower left", fontsize="medium", shadow=True)
  623. individual_traces_plt.axes.get_xaxis().set_visible(False)
  625. time_axis, mean_trace, stderr_trace = collate_traces(traces_data)
  626. group_trace_plt.plot(time_axis, mean_trace, linewidth=1, label="Mean Trace + Std.Error", color="darkcyan")
  627. group_trace_plt.fill_between(time_axis, mean_trace+stderr_trace, mean_trace-stderr_trace, alpha=0.4, color="salmon")
  628. group_trace_plt.legend(loc="lower right", fontsize="medium", shadow=True)
  630. group_traces_plt.plot(time_axis, mean_trace, linewidth=1, label=group_name)
  631. group_traces_plt.fill_between(time_axis, mean_trace+stderr_trace, mean_trace-stderr_trace, alpha=0.35)
  633. fig2.suptitle((group_name + " (" + epoch_name + ")"), fontsize="30", fontweight="bold")
  634. fig2.tight_layout()
  636. group_traces_plt.legend(loc="lower right", fontsize="large", shadow=True)
  638. fig3.tight_layout()
  643. def plot_averagedepochs_with_heat(epochs, avg_epoch_dict, groups2compare, heatmap_dim, my_cmap=None):
  644. """Group legend follows order in groups2compare"""
  645. for epoch_name, groups in avg_epoch_dict.items():
  646. if epoch_name in epochs.keys():
  647. group_epoch_dict = {}
  648. for group, mice in groups.items():
  649. if group in groups2compare:
  650. for mouse, trace_data in mice.items():
  651. group_epoch_dict[group] = group_epoch_dict.get(group, [])
  652. group_epoch_dict[group].append((mouse, trace_data))
  654. all_groups_plt = plt.figure(figsize=(15,12))
  655. all_groups_plt.suptitle(epoch_name, fontsize="30", fontweight="bold")
  656. group_traces_plt = all_groups_plt.add_subplot(211)
  657. group_traces_plt.set_ylabel(r'$\Delta$F/F %', fontsize="x-large")
  658. group_traces_plt.set_xlabel("Minutes", fontsize="x-large")
  660. for group_name, traces_info in group_epoch_dict.items():
  662. fig2 = plt.figure(figsize=(15,12))
  663. individual_traces_plt = fig2.add_subplot(211)
  664. group_trace_plt = fig2.add_subplot(212)
  665. group_trace_plt.set_ylabel(r'$\Delta$F/F %', fontsize="x-large")
  666. group_trace_plt.set_xlabel("Minutes", fontsize="x-large")
  668. mice_list = []
  669. traces_data = []
  670. for mouse, trace_data in traces_info:
  671. mice_list.append(mouse)
  672. traces_data.append(trace_data)
  673. time_axis, trace = trace_data
  674. individual_traces_plt.plot(time_axis, trace, linewidth=0.8, label=mouse)
  676. traces_fluorescence = [trace for time_axis, trace in traces_data]
  678. time_axis = traces_data[0][0]
  679. fig_width = heatmap_dim[0]
  680. fig_height = heatmap_dim[1] #len(traces_fluorescence)
  681. fig_heattraces = plt.figure(figsize=(fig_width, (fig_height))) #fig_heattraces = plt.figure(figsize=(15,3))
  682. spec_heattraces = gridspec.GridSpec(ncols=fig_width, nrows=len(traces_fluorescence) + 2,
  683. wspace=0, hspace=0, figure=fig_heattraces)
  685. row = 0
  686. subplot_dict = {}
  688. for trace in traces_fluorescence:
  689. trace = np.expand_dims(trace, axis=0)
  690. subplot_dict[row] = fig_heattraces.add_subplot(spec_heattraces[row, 0:])
  691. if row != len(traces_fluorescence) - 1: #last row you want ticks
  692. subplot_dict[row].tick_params(
  693. axis='both', # changes apply to the x-axis
  694. which='both', # both major and minor ticks are affected
  695. bottom=False, # ticks along the bottom edge are off
  696. top=False, # ticks along the top edge are off
  697. left=True,
  698. labelleft=True,
  699. labelbottom=False # labels along the bottom edge are off)
  700. )
  702. elif row == len(traces_fluorescence) - 1:
  703. subplot_dict[row].tick_params(
  704. axis='x', # changes apply to the x-axis
  705. which='both', # both major and minor ticks are affected
  706. bottom=True, # ticks along the bottom edge are off
  707. top=False, # ticks along the top edge are off
  708. labelbottom=True, # labels along the bottom edge are off
  709. labelsize=30
  710. )
  712. vmax = epochs[epoch_name][0]
  713. vmin = epochs[epoch_name][1]
  714. norm_exp = mpl.colors.Normalize(vmin=vmin, vmax=vmax)
  716. aspect = "auto"
  718. subplot_dict[row].imshow(trace, norm=norm_exp, cmap = my_cmap, interpolation='bicubic', aspect=aspect,
  719. extent =[time_axis[0], time_axis[-1], (-10 * 1/len(traces_fluorescence)), (10 * 1/len(traces_fluorescence))])
  721. subplot_dict[row].get_yaxis().set_visible(False)
  722. row = row + 1
  725. cbarax = fig_heattraces.add_subplot(spec_heattraces[-1, int(fig_width/4) :int(fig_width*3/4)])
  726. cbar = fig_heattraces.colorbar(mpl.cm.ScalarMappable(norm=norm_exp, cmap=my_cmap), cax=cbarax, orientation="horizontal") #use_gridspec=True
  727. cbarax.tick_params(labelsize=20)
  729. fig_heattraces.tight_layout(pad=0)
  731. individual_traces_plt.legend(loc="lower left", fontsize="medium", shadow=True)
  732. individual_traces_plt.axes.get_xaxis().set_visible(False)
  733. individual_traces_plt.set_ybound((-60, 20))
  735. time_axis, mean_trace, stderr_trace = collate_traces(traces_data)
  736. group_trace_plt.plot(time_axis, mean_trace, linewidth=1, label="Mean Trace + Std.Error", color="darkcyan")
  737. group_trace_plt.fill_between(time_axis, mean_trace+stderr_trace, mean_trace-stderr_trace, alpha=0.4, color="salmon")
  738. group_trace_plt.legend(loc="upper right", fontsize="small", shadow=True)
  739. group_trace_plt.set_ybound((-60, 20))
  741. group_traces_plt.plot(time_axis, mean_trace, linewidth=1, label=group_name)
  742. group_traces_plt.fill_between(time_axis, mean_trace+stderr_trace, mean_trace-stderr_trace, alpha=0.35)
  743. group_traces_plt.set_ybound((-60, 30))
  745. fig2.suptitle((group_name + " (" + epoch_name + ")"), fontsize="30", fontweight="bold")
  747. group_traces_plt.legend(loc="lower left", fontsize="large", shadow=True)
  749. all_groups_plt.tight_layout()

fibphoflow.py at commit dde0864, under MIT · at the source

Overview

Authors: Micaela Glat1, Anna J Bowen1, Yang Gou1, Elizabeth Giering1,2, Jarrad M Scarlett1,3, Gregory J Morton1, Michael W Schwartz1
ORCID iDs: Micaela Glat
  1. University of Washington Medicine Diabetes Institute, Department of Medicine, Seattle, WA, 98109, USA
  2. Veterans Affairs Puget Sound Health Care System, Seattle, WA, 98108, USA
  3. Department of Pediatric Gastroenterology and Hepatology, Seattle Children's Hospital, Seattle, WA, 98145, USA
Institutions: University of Washington (United States); VA Puget Sound Health Care System (United States); Seattle Children's Hospital (United States)
Journal: Molecular metabolism, volume 108, article 102372
Dates: received 2 April 2026; accepted 10 April 2026; published online 17 April 2026; in print June 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1016/j.molmet.2026.102372 · PMID 42002224 · PMCID PMC13141783 · OpenAlex W7154743481
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: optical imaging (calcium, voltage, 2-photon) (modality), mouse (organism), cellular / molecular (subfield)
Methods: Spectral & time-frequency, Connectivity, Statistics, Machine learning, Preprocessing, Single-unit activity, calcium imaging, Smoothing, state filtering, decompositions
Keywords: AgRP neurons, Anticipatory, Glycemia, Continuous glucose monitoring, Fiber photometry
MeSH: Agouti-Related Protein*, Blood Glucose*, Glucose*, Neurons*, Administration, Oral, Animals, Hypothalamus, Male, Mice (* major topic)
Topic: Regulation of Appetite and Obesity (Endocrine and Autonomic Systems, Neuroscience), according to OpenAlex
Funding: NIDDK NIH HHS (P30 DK017047, R01 DK089056)
Citations: not cited yet (Europe PMC); 41 references in the paper

Abstract

Hypothalamic AgRP neurons are uniquely responsive to nutritional cues and play an important role in fuel homeostasis. To investigate the temporal relationship between the activity of these neurons and the glycemic response to an oral glucose load, we simultaneously monitored AgRP neuron activity (by fiber photometry in AgRP-IRES-cre mice) and the arterial glucose level, both before and after oral gavage (OG) of either water or glucose (0.5–2.5 g/kg). We report that the AgRP neuron response to an OG glucose load can be subdivided into two functionally distinct phases – one that begins prior to glucose delivery and a second that extends from peak inhibition through the return towards baseline. The ‘first phase’ appears to be anticipatory in nature and is also predictive of subsequent changes in glycemia, suggesting a role in the handling of an oral glucose load. To analyze the relationship between the second phase response and changes of glycemia, we employed a model that allows residual activity to be removed subsequent to the ‘first phase’ component. This analysis reveals that unlike the first phase, the degree of residual inhibition – the second phase – tracks the glycemic response. Moreover, this response is temporally aligned with the blood glucose (BG) rate of change (which is predictive of future BG levels), with AgRP neurons lagging BG rate of change by ∼5 min. We conclude that the AgRP neuron response to an oral glucose challenge consists of two distinct phases, each with its own determinants and metabolic implications: an initial anticipatory component that is predictive of the subsequent glycemic response, and a second phase that tracks the rate of BG change.

Reproduced under the paper's license (CC BY), from the paper cited above.

Repository

Its files are read in the Code ↔ Paper reader above.

nikhayes/fibphoflow

License: MIT
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Commit: dde086457be2aa31925fbf7891b86629dd748603, 19 December 2023
Languages: Python (3)
Size: 10 files, 3 scripts
Software Heritage: archived
Found in: the text, “Fiber photometry analysis”
Holds: README, license file, environment (environment.yml)
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (2 files), pandas (2 files), Matplotlib (1 file), SciPy (1 file), seaborn (1 file)
Availability: 1 check, the latest on 29 September 2026: the link answers
  • 29 September 2026: the link answers
5 files
At the source: github.com/nikhayes/fibphoflow

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 3 scripts, each with its path and the digest of its content;
  • no match between paragraphs and code yet;
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

No dataset and no data link were found in the paper.

Data availability

I have shared the link to my data

Reproduced under the paper's license (CC BY), from the paper cited above.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 29 September 2026: the first record

Recorded: type, language, journal, volume, pages, dates, 7 authors, 5 keywords, 9 MeSH terms, 1 funder, 41 references.

Cite

This paper

Glat, M., Bowen, A. J., Gou, Y., Giering, E., Scarlett, J. M., Morton, G. J., & Schwartz, M. W. (2026). AgRP neuron activity predicts and tracks the glycemic response to oral glucose. Molecular metabolism, 108, 102372. https://doi.org/10.1016/j.molmet.2026.102372

BibTeX

@article{glat2026agrp,
author = {Glat, Micaela and Bowen, Anna J and Gou, Yang and Giering, Elizabeth and Scarlett, Jarrad M and Morton, Gregory J and Schwartz, Michael W},
title = {{AgRP neuron activity predicts and tracks the glycemic response to oral glucose}},
journal = {Molecular metabolism},
year = {2026},
month = apr,
volume = {108},
pages = {102372},
publisher = {Elsevier},
issn = {2212-8778},
doi = {10.1016/j.molmet.2026.102372},
url = {https://doi.org/10.1016/j.molmet.2026.102372},
pmid = {42002224},
pmcid = {PMC13141783}
}

RIS

TY - JOUR
AU - Glat, Micaela
AU - Bowen, Anna J
AU - Gou, Yang
AU - Giering, Elizabeth
AU - Scarlett, Jarrad M
AU - Morton, Gregory J
AU - Schwartz, Michael W
TI - AgRP neuron activity predicts and tracks the glycemic response to oral glucose
T2 - Molecular metabolism
J2 - Mol Metab
PY - 2026
DA - 2026/04/17
VL - 108
SP - 102372
SN - 2212-8778
PB - Elsevier
DO - 10.1016/j.molmet.2026.102372
UR - https://doi.org/10.1016/j.molmet.2026.102372
LA - en
ER -

CSL-JSON

{
"id": "10.1016/j.molmet.2026.102372",
"type": "article-journal",
"title": "AgRP neuron activity predicts and tracks the glycemic response to oral glucose",
"container-title": "Molecular metabolism",
"author": [
{
"family": "Glat",
"given": "Micaela"
},
{
"family": "Bowen",
"given": "Anna J"
},
{
"family": "Gou",
"given": "Yang"
},
{
"family": "Giering",
"given": "Elizabeth"
},
{
"family": "Scarlett",
"given": "Jarrad M"
},
{
"family": "Morton",
"given": "Gregory J"
},
{
"family": "Schwartz",
"given": "Michael W"
}
],
"container-title-short": "Mol Metab",
"volume": "108",
"page": "102372",
"DOI": "10.1016/j.molmet.2026.102372",
"PMID": "42002224",
"PMCID": "PMC13141783",
"ISSN": "2212-8778",
"publisher": "Elsevier",
"URL": "https://doi.org/10.1016/j.molmet.2026.102372",
"language": "en",
"issued": {
"date-parts": [
[
2026,
4,
17
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.1111/jne.70202 [code]
Altered responses to ghrelin and food cues in AgRP neurons during pregnancy and lactation.
Journal: Journal of neuroendocrinology
In common: pandas, SciPy, Matplotlib, 1 other tool, mouse, cellular / molecular, 7 references
[2] doi:10.1038/s41467-026-75650-0 [code]
Reduced melanocortin tone modulates feeding during pregnancy in mice.
Journal: Nature communications
In common: mouse, 5 references
[3] doi:10.1016/j.stem.2026.05.005 [code]
Generation of human appetite-regulating neurons and tanycytes from pluripotent stem cells.
Journal: Cell stem cell
In common: seaborn, pandas, SciPy, 2 other tools, cellular / molecular, 2 references
[4] doi:10.1038/s41467-026-76242-8 [code]
Whole-brain, all-optical interrogation of neuronal dynamics underlying gut and vascular interoception in zebrafish.
Journal: Nature communications
In common: pandas, SciPy, Matplotlib, 1 other tool, 2 references
[5] doi:10.7554/elife.109717 [code]
Retrosplenial cortex enables context-dependent goal-directed sensorimotor transformation.
Journal: eLife
In common: seaborn, pandas, SciPy, 2 other tools, mouse, 1 reference
[6] doi:10.1016/j.isci.2026.115552 [code]
Physical and cognitive contributions to fatigue perception: The interplay between local muscle fatigue and sensory prediction error.
Journal: iScience
In common: seaborn, pandas, SciPy, 2 other tools, 1 reference
[7] doi: [code]
Real-time closed-loop feedback system for mouse mesoscale cortical signal and movement control
Journal: eLife
In common: seaborn, pandas, SciPy, 2 other tools, optical imaging (calcium, voltage, 2-photon), mouse
[8] doi:10.1016/j.xpro.2026.104678 [code]
Protocol for longitudinal two-photon calcium imaging and holographic optogenetic manipulation to investigate memory in mice.
Journal: STAR protocols
In common: seaborn, pandas, SciPy, 2 other tools, optical imaging (calcium, voltage, 2-photon), mouse
[9] doi:10.7554/elife.110277 [code]
Functional imaging of nine distinct neuronal populations under a miniscope in freely behaving animals.
Journal: eLife
In common: seaborn, pandas, SciPy, 2 other tools, optical imaging (calcium, voltage, 2-photon), mouse
[10] doi:10.1002/advs.202519479 [code]
Diminished Signal-to-Noise Ratio Disrupts Somatosensory Population Encoding and Drives Tactile Hyposensitivity in the Fmr1&lt;sup&gt;-/y&lt;/sup&gt; Autism Model.
Journal: Advanced science (Weinheim, Baden-Wurttemberg, Germany)
In common: seaborn, pandas, SciPy, 2 other tools, optical imaging (calcium, voltage, 2-photon), mouse

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.