OSCR

Central complex representations of self-movement are sufficient to compute wind direction in flight.

Code ↔ Paper

14 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 14 matches · 2 of them tie a paragraph to a whole file, not to given lines: weak matches, whose lines are not tinted
  1. [1] § RESULTS › Generating and validating dynamic encoding models for PFNs ↔ Python/PFN_Model_Predictions/PFN_model.py, lines 567–655 · score 0.75 · steady state, single modality, Speed tuning, Direction tuning, rises, decays
  2. [2] § MATERIALS AND METHODS › Free-flight behavior recording and analysis › Heading estimation for measured and simulated trajectories ↔ Python/drosophila_body_orientation_predictor/Notebooks/drosophila_body_orientation_predictor.ipynb, lines 747–879 · score 0.67 · single wind direction, multiple wind direction, sine, thrust, rotational, Drosophila
  3. [3] § RESULTS › Generating and validating dynamic encoding models for PFNs ↔ MATLAB/FBmodel/model_code/on_off_de.m, the whole file · a weak match · score 0.66 · steady state, single modality, Speed tuning, rises, transient, PB
  4. [4] § MATERIALS AND METHODS › Free-flight behavior recording and analysis › Heading estimation for measured and simulated trajectories ↔ Python/drosophila_body_orientation_predictor/Notebooks/helper_functions.py, lines 274–394 · score 0.65 · single wind direction, multiple wind direction, sine, rotational, Drosophila, body
  5. [5] § RESULTS › Ambient wind direction is observable from PFN activity during saccadic flight turns ↔ MATLAB/FBmodel/model_code/FBmodel7.m, lines 1–45 · score 0.64 · egocentric optic flow, egocentric airflow direction, optic flow speed, frame, PFN, heading
  6. [6] § MATERIALS AND METHODS › Free-flight behavior recording and analysis › Dynamic encoding model for PFNs ↔ MATLAB/FBmodel/model_code/FBmodel7.m, lines 1–45 · score 0.63 · egocentric airflow, Bump position, optic flow, sinusoid, amplitude, PFNd
  7. [7] § RESULTS › Generating and validating dynamic encoding models for PFNs ↔ Python/PFN_Model_Predictions/PFN_model.py, lines 567–655 · score 0.61 · direction tuning curves, single modality, speed tuning, AF, coefficient, offset
  8. [8] § RESULTS › Generating and validating dynamic encoding models for PFNs ↔ MATLAB/FBmodel/model_code/on_off_de.m, the whole file · a weak match · score 0.58 · single modality, tuning curves, speed tuning, AF, coefficient, offset
  9. [9] § MATERIALS AND METHODS › Imaging data analysis ↔ MATLAB/Nagel2pNoRMCorre/2pCode/Register_ROIs-main/NoRMCorre/NoRMCorreSetParms.m, lines 1–65 · score 0.58 · NoRMCorre, motion correction, rigid, shifts, frames
  10. [10] § MATERIALS AND METHODS › Free-flight behavior recording and analysis › Artificial neural networks ↔ notebooks/data_correction_and_model_training.ipynb, lines 1567–1647 · score 0.57 · validation loss, Keras, hidden layer, dropout, training, epochs
  11. [11] § MATERIALS AND METHODS › Free-flight behavior recording and analysis › Artificial neural networks ↔ utils/utils.py, lines 976–1019 · score 0.56 · hidden layer, ReLU, adam, activation, Loss, MSE
  12. [12] § RESULTS › The wind speed–to–ground speed ratio defines two solution regimes in both the ANN and real flies ↔ Python/AnalyzeRealFliesVSANNs/extract_trajectories_from_orcoflashStupski.py, lines 19–88 · score 0.55 · wind tunnel, ground speed, Real flies, ambient, trajectories
  13. [13] § MATERIALS AND METHODS › Statistical testing ↔ MATLAB/Nagel2pNoRMCorre/2pCode/circ_kuipertest.m, lines 1–84 · score 0.54 · Kolmogorov Smirnov, philippberens, Kuiper, circular
  14. [14] § RESULTS › Ambient wind direction can be decoded from PFN representations by a simple feedforward ANN ↔ Python/drosophila_body_orientation_predictor/Notebooks/drosophila_body_orientation_predictor.ipynb, lines 1–114 · score 0.52 · body orientations, wind speeds, wind direction, training, predicted, flight

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 · 802 lines · 31 KB · GPL-3.0 · 2 matches

  1. import numpy as np
  2. import matplotlib.pyplot as plt
  3. #import figurefirst as fifi
  4. import utils
  6. from utils import wrapToPi
  9. class PFN:
  10. """ Model of PFN neural responses to air speed/direction & optic flow speed/direction.
  11. Will generate sinusoidal bumps for the compass/EB and in the PB and FB (for PFNs).
  12. Takes parameters previously determined from fitting for time-courses
  13. of PFN calcium intensity and bump position in the PB.
  14. """
  16. def __init__(self, PFNd_params=None, PFNv_params=None, PFNpc_params=None, PFNa_params=None):
  17. """ Initialize the model.
  19. PFNd_params:
  20. PFNv_params:
  21. PFNpc_params:
  22. PFNa_params:
  23. """
  25. # Set parameters
  26. if PFNd_params is None:
  27. PFNd_params = np.array([[0.5, 1.0, 1.4, 0.88, 0.4, 1.23, 0.0, 1.0],
  28. [0.4, 1.0, 1.4, 0.38, 1.0, 1.35, 0.0, 0.0]]) #0.4
  30. if PFNv_params is None:
  31. PFNv_params = np.array([[0.0, 1.0, -1.74, 0.88, 0.4, 1.23, 0.0, 1.0], # v params [0,0] = 0.5 fitted
  32. [0.4, 1.0, -1.74, 0.38, 1.0, 1.35, 0.0, 0.0]]) #0.4
  34. #if PFNpc_params is None:
  35. # PFNpc_params = np.array([[1.24, 0.01, 0.97, 2.6, 0.0, 1.77, -0.3, 1.0],
  36. # [0.01, 1.00, 2.10, 15.0, 0.6, 2.00, 0.0, 1.0]]) # pc params [1,0] = 0.01 fitted
  38. if PFNpc_params is None:
  39. PFNpc_params = np.array([[1.16, 0.01, 0.97, 2.6, 0.0, 1.77, -0.3, 1.0],
  40. [1.0, 0.01, 0.2, 2.6, 0.0, 6, -0.3, 1.0],
  41. [0.01, 1.0, 2.1, 15.0, 0.6, 2.0, 0.0, 1.0], # pc params [2,0] = 0.01 fitted
  42. [0.0, 1.0, 2.1, 15.0, 0.6, 2.0, 0.0, 0.0]])
  44. if PFNa_params is None:
  45. PFNa_params = np.array([[1.34, 0.57, 1.12, 0.48, 0.22, -0.24, 1.57, 1.0],
  46. [0.2, -0.3, 1.12, 0.48, 1.0, -0.24, 1.57, 0.0]]) # a params [1,0] = 0.2 fitted
  48. # Store model parameters for each neuron type
  49. self.model_param = {'PFNd': PFNd_params,
  50. 'PFNv': PFNv_params,
  51. 'PFNpc': PFNpc_params,
  52. 'PFNa': PFNa_params}
  54. # Set inputs
  55. self.tsim = np.array(0.0)
  56. self.phi = np.array(0.0)
  57. self.gamma = np.array(0.0)
  58. self.a = np.array(0.0)
  59. self.psi = np.array(0.0)
  60. self.g = np.array(0.0)
  61. self.initcond = np.zeros((9,2))
  63. # Outputs
  64. self.res = {}
  65. self.heatmap = {}
  66. self.allpts = {}
  67. self.new_inits = np.zeros((9,2))
  69. def run(self, tsim=None, phi=None, a=None, gamma=None, g=None, psi=None, initcond=None, unwrap=False):
  70. """ Set inputs & run.
  72. tsim: time [s]
  73. phi: heading angle [rad]
  74. a: air speed [m/s]
  75. gamma: air speed direction [rad]
  76. g: ground speed [m/s]
  77. psi: ground speed direction [rad]
  79. """
  81. # Set inputs
  82. self.tsim = tsim
  83. self.phi = phi #np.zeros_like(phi)
  84. self.gamma = gamma
  85. self.a = a
  86. self.psi = psi
  87. self.g = g
  89. # Run model
  90. self.stims = {'t': self.tsim,
  91. 'heading': self.phi,
  92. 'Atheta': self.gamma,
  93. 'Amag': self.a,
  94. 'Otheta': self.psi,
  95. 'Omag': self.g,
  96. }
  98. # Set initial conditions
  99. if initcond is not None:
  100. # print('not None')
  101. self.initcond = initcond
  102. else:
  103. print('No initials')
  105. # Run model
  106. self.res, self.heatmap, self.new_inits = FBmodel_obs(self.stims,
  107. self.model_param['PFNd'],
  108. self.model_param['PFNv'],
  109. self.model_param['PFNpc'],
  110. self.model_param['PFNa'],
  111. self.initcond
  112. )
  114. # Unwrap bump position
  115. if unwrap:
  116. wrap_data = ['PFNd_bumpFB', 'PFNv_bumpFB', 'PFNpc_bumpFB', 'PFNa_bumpFB']
  117. for w in wrap_data:
  118. self.res[w] = np.unwrap(self.res[w])
  120. def runstep(self, tsim=None, phi=None, a=None, gamma=None, g=None, psi=None, unwrap=False, start=None, win=None, initcond=None):
  121. """ Set inputs & run FBmodel_obs for a portion of the model.
  123. tsim: time [s]
  124. phi: heading angle [rad]
  125. a: air speed [m/s]
  126. gamma: air speed direction [rad]
  127. g: ground speed [m/s]
  128. psi: ground speed direction [rad]
  129. start_fin: start and end frames for window
  131. """
  133. # Set inputs
  134. self.tsim = tsim
  135. self.phi = phi
  136. self.gamma = gamma
  137. self.a = a
  138. self.psi = psi
  139. self.g = g
  140. self.start = start
  141. self.win = win
  142. self.initcond = initcond
  144. # Run model
  145. self.stims = {'t': self.tsim[self.start:self.start+self.win],
  146. 'heading': self.phi[self.start:self.start+self.win],
  147. 'Atheta': self.gamma[self.start:self.start+self.win],
  148. 'Amag': self.a[self.start:self.start+self.win],
  149. 'Otheta': self.psi[self.start:self.start+self.win],
  150. 'Omag': self.g[self.start:self.start+self.win],
  151. }
  153. self.res,self.new_inits = FBmodel_obs(self.stims,
  154. self.model_param['PFNd'],
  155. self.model_param['PFNv'],
  156. self.model_param['PFNpc'],
  157. self.model_param['PFNa'],
  158. #self.initcond
  159. )
  161. # Unwrap bump position
  162. if unwrap:
  163. wrap_data = ['PFNd_bumpFB', 'PFNv_bumpFB', 'PFNpc_bumpFB', 'PFNa_bumpFB']
  164. for w in wrap_data:
  165. self.res[w] = np.unwrap(self.res[w])
  168. def plot_stimulus(self, fig_size=1):
  169. stim_keys = list(self.stims.keys())
  170. n_k = len(stim_keys)
  172. fig, ax = plt.subplots(n_k-1,1, figsize=( fig_size * 2, fig_size * 1.5 * n_k), sharex=True, dpi=100)
  173. for n, k in enumerate(stim_keys[1:]):
  174. ax[n].plot(self.stims['t'], self.stims[k])
  175. ax[n].set_ylabel(k)
  176. ax[n].set_yticks((min(self.stims[k])-5,max(self.stims[k]+5)))
  177. ax[0].set_ylim(-np.pi,np.pi)
  178. ax[1].set_ylim(-np.pi,np.pi)
  179. ax[3].set_ylim(-np.pi,np.pi)
  181. def plot_bump(self, fig_size=1):
  182. """ Plot bump position & amplitude over time for each neuron type.
  183. """
  185. keys = list(self.res.keys())
  186. n_key = len(keys)
  188. n_col = 4
  189. n_row = np.ceil(n_key / n_col).astype(int)
  191. plot_order = np.hstack((np.arange(1, n_key, step=1), np.array(0)))
  193. fig, ax = plt.subplots(n_row, n_col, figsize=(fig_size * 3 * n_col, fig_size * 2 * n_row), sharex=True)
  194. for n, k in enumerate(plot_order):
  195. ax.flat[n].plot(self.stims['t'], self.res[keys[k]].T)
  196. ax.flat[n].set_title(keys[k])
  198. for a in ax.flat:
  199. a.set_xticks(np.arange(0, self.stims['t'][-1], step=10))
  201. for y in [4,5,6,7,8,9,10,11,24,25,26,27,28]:
  202. ax.flat[y].set_yticks(np.arange(-4, 4.1, step=1))
  203. for y2 in [0,1,2,3,12,13,14,15,16,17,18,19,20,21,22,23]:
  204. ax.flat[y2].set_yticks(np.arange(-0.5, 3.1, step = 1))
  206. fig.subplots_adjust(left=0.1, bottom=0.1, right=0.9, top=0.9, wspace=0.6, hspace=0.4)
  208. def plot_heatmap(self, fig_size=7, cmap='jet'):
  209. """ Plot bump position & amplitude as a heatmap over time for each neuron type.
  210. """
  212. fig, ax = plt.subplots(1, 9, figsize=(fig_size, 1.2 * fig_size), sharex=True, sharey=True, dpi=100)
  214. pos = ax[0].imshow(self.heatmap['EPG'], vmin=0, vmax=1.2, cmap=cmap)
  215. ax[1].imshow(self.heatmap['PFNdL_pb'], vmin=0, vmax=1.2, cmap=cmap)
  216. ax[2].imshow(self.heatmap['PFNdR_pb'], vmin=0, vmax=1.2, cmap=cmap)
  217. ax[3].imshow(self.heatmap['PFNvL_pb'], vmin=0, vmax=1.2, cmap=cmap)
  218. ax[4].imshow(self.heatmap['PFNvR_pb'], vmin=0, vmax=1.2, cmap=cmap)
  219. ax[5].imshow(self.heatmap['PFNpcL_pb'], vmin=0, vmax=1.2, cmap=cmap)
  220. ax[6].imshow(self.heatmap['PFNpcR_pb'], vmin=0, vmax=1.2, cmap=cmap)
  221. ax[7].imshow(self.heatmap['PFNaL_pb'], vmin=0, vmax=1.2, cmap=cmap)
  222. ax[8].imshow(self.heatmap['PFNaR_pb'], vmin=0, vmax=1.2, cmap=cmap)
  224. ax[0].set_title('EPG')
  225. fig.colorbar(pos,ax=ax[0])
  226. ax[1].set_title('PFNd PB')
  227. ax[3].set_title('PFNv PB')
  228. ax[5].set_title('PFNpc PB')
  229. ax[7].set_title('PFNa PB')
  232. for a in ax.flat:
  233. a.set_aspect(0.5)
  234. a.set_xlim(0, 16)
  235. #fifi.mpl_functions.adjust_spines(a, [])
  236. # a.set_tick_params(left=None, right=None, top=None, bottom=None)
  239. def FBmodel_obs(gust_res, p_PFNd, p_PFNv, p_PFNpc, p_PFNa, initcond=None):
  240. # like FBmodel_observ() in Matlab
  241. # initcond is a dict with the following keys:
  242. # dL, dR, vL, vR, pcL, pcR, aL, aR
  243. # each key references a 1x2 (tuple? array?) with col=0 AF and col=1 OF initial values
  245. p_bump = 2
  247. heading = gust_res['heading']
  248. thva = gust_res['Atheta']
  249. spda = gust_res['Amag']
  250. thvo = gust_res['Otheta']
  251. spdo = gust_res['Omag']
  252. t = gust_res['t']
  254. if initcond is None:
  255. print('it is None')
  256. AFinput = np.array([thva[0],spda[0]])
  257. OFinput = np.array([thvo[0],spdo[0]])
  258. bumpinput = np.array([heading[0],thva[0],spda[0]])
  259. initcond = BuildSSInitial(p_PFNd, p_PFNv,
  260. p_PFNpc, p_PFNa,
  261. AFinput,
  262. OFinput,
  263. bumpinput
  264. )
  266. #print(initcond)
  267. Rinputs = np.vstack((thva, spda, thvo, spdo, t))
  268. Linputs = np.vstack((-thva, spda, -thvo, spdo, t))
  270. # If you want to make PFNv unresponsive to airflow, run the following line:
  271. #p_PFNv[0,0] = 0
  273. new = np.zeros((18, len(t)))
  275. PFNd_amp = np.zeros((2, len(t)))
  276. PFNd_amp[0, :],new[0,:],new[1,:] = PFNd_integ(p_PFNd, Linputs,initcond[0,:])
  277. PFNd_amp[1, :],new[2,:],new[3,:] = PFNd_integ(p_PFNd, Rinputs,initcond[1,:])
  279. PFNv_amp = np.zeros((2, len(t)))
  280. PFNv_amp[0, :],new[4,:],new[5,:] = PFNd_integ(p_PFNv, Linputs,initcond[2,:])
  281. PFNv_amp[1, :],new[6,:],new[7,:] = PFNd_integ(p_PFNv, Rinputs,initcond[3,:])
  283. PFNpc_amp = np.zeros((2, len(t)))
  284. PFNpc_amp[0, :],new[8,:],new[9,:] = PFNpc_integ2(p_PFNpc, Linputs,initcond[4,:])
  285. PFNpc_amp[1, :],new[10,:],new[11,:] = PFNpc_integ2(p_PFNpc, Rinputs,initcond[5,:])
  287. PFNa_amp = np.zeros((2, len(t)))
  288. PFNa_amp[0, :],new[12,:],new[13,:] = PFNa_integ(p_PFNa, Linputs,initcond[6,:])
  289. PFNa_amp[1, :],new[14,:],new[15,:] = PFNa_integ(p_PFNa, Rinputs,initcond[7,:])
  291. # Bump movement code.
  292. # This will allow us to test the information in the system if bump movement
  293. # is driven by heading, airflow direction, both, or neither.
  294. ha = np.zeros_like(spda)
  295. for x in range(len(ha)):
  296. if spda[x]>0: ha[x]=1
  298. # If airflow drives bump movement, use bumpmdl_de(); if not, use np.zeros().
  299. # bumppos = bumpmdl_de(p_bump, thva, t, ha,initcond[8,0]) # comment out for noAF
  300. bumppos = np.zeros((len(t),)) # comment in for noAF
  302. #print(bumppos)
  303. new[16,:] = bumppos.copy()
  304. new[17,:] = bumppos.copy()
  306. ## If heading drives bump movement: (otherwise, comment out)
  307. bumppos = bumppos - heading # bumppos in radians
  309. PFNd_bump = np.zeros((2, len(t)))
  310. # PFNd_bump[0, :] = wrapToPi(bumppos + np.pi/4)
  311. # PFNd_bump[1, :] = wrapToPi(bumppos - np.pi/4)
  313. PFNd_bump[0, :] = wrapToPi(bumppos)
  314. PFNd_bump[1, :] = wrapToPi(bumppos)
  316. PFNv_bump = np.zeros((2, len(t)))
  317. # PFNv_bump[0, :] = wrapToPi(bumppos + np.pi/4)
  318. # PFNv_bump[1, :] = wrapToPi(bumppos - np.pi/4)
  320. PFNv_bump[0, :] = wrapToPi(bumppos)
  321. PFNv_bump[1, :] = wrapToPi(bumppos)
  323. PFNpc_bump = np.zeros((2, len(t)))
  324. # If PFNpc bump moves like other PFN bumps, use:
  325. #bumppos_pc = bumppos.copy()
  326. # If PFNpc bump doesn't move with heading, use one of the next two lines:
  327. #bumppos_pc = new[16,:]
  328. #bumppos_pc = bumpmdl_de(p_bump,thva,t,ha,initcond[8,0])
  329. # If PFNpc bump doesn't move with airflow, use:
  330. #bumppos_pc = -heading
  331. # If PFNpc bump doesn't move with airflow or heading, use:
  332. bumppos_pc = np.zeros_like(bumppos)
  333. # PFNpc_bump[0, :] = wrapToPi(bumppos_pc + np.pi/4)
  334. # PFNpc_bump[1, :] = wrapToPi(bumppos_pc - np.pi/4)
  336. PFNpc_bump[0, :] = wrapToPi(bumppos_pc)
  337. PFNpc_bump[1, :] = wrapToPi(bumppos_pc)
  339. PFNa_bump = np.zeros((2, len(t)))
  340. # PFNa_bump[0, :] = bumppos + np.pi/4
  341. # PFNa_bump[1, :] = bumppos - np.pi/4
  343. PFNa_bump[0, :] = bumppos
  344. PFNa_bump[1, :] = bumppos
  346. for i,v in enumerate(wrapToPi(thva)):
  347. if spda[i]>0:
  348. if v>0.78 or v<-2.35:
  349. PFNa_bump[0, i] = PFNa_bump[0, i]+np.pi
  350. elif v<-0.78 or v>2.35:
  351. PFNa_bump[1, i] = PFNa_bump[1, i]+np.pi
  352. PFNa_bump[0, :] = wrapToPi(PFNa_bump[0, :])
  353. PFNa_bump[1, :] = wrapToPi(PFNa_bump[1, :])
  355. res = {'bump': wrapToPi(bumppos),
  356. 'PFNd_amp': PFNd_amp,
  357. 'PFNv_amp': PFNv_amp,
  358. 'PFNpc_amp': PFNpc_amp,
  359. 'PFNa_amp': PFNa_amp,
  360. 'PFNd_bumpL': PFNd_bump[0,:],
  361. 'PFNd_bumpR': PFNd_bump[1,:],
  362. 'PFNv_bumpL': PFNv_bump[0,:],
  363. 'PFNv_bumpR': PFNv_bump[1,:],
  364. 'PFNpc_bumpL': PFNpc_bump[0,:],
  365. 'PFNpc_bumpR': PFNpc_bump[1,:],
  366. 'PFNa_bumpL': PFNa_bump[0,:],
  367. 'PFNa_bumpR': PFNa_bump[1,:],
  368. 'PFNd_ampL': PFNd_amp[0, :],
  369. 'PFNd_ampR': PFNd_amp[1, :],
  370. 'PFNv_ampL': PFNv_amp[0, :],
  371. 'PFNv_ampR': PFNv_amp[1, :],
  372. 'PFNpc_ampL': PFNpc_amp[0, :],
  373. 'PFNpc_ampR': PFNpc_amp[1, :],
  374. 'PFNa_ampL': PFNa_amp[0, :],
  375. 'PFNa_ampR': PFNa_amp[1, :],
  376. }
  378. PFNd_bumpFB, PFNd_ampFB = sumPFNvecs(PFNd_bump, PFNd_amp)
  379. PFNv_bumpFB, PFNv_ampFB = sumPFNvecs(PFNv_bump, PFNv_amp)
  380. PFNpc_bumpFB, PFNpc_ampFB = sumPFNvecs(PFNpc_bump, PFNpc_amp)
  381. PFNa_bumpFB, PFNa_ampFB = sumPFNvecs(PFNa_bump, PFNa_amp)
  383. res['PFNd_ampFB'] = PFNd_ampFB
  384. res['PFNv_ampFB'] = PFNv_ampFB
  385. res['PFNpc_ampFB'] = PFNpc_ampFB
  386. res['PFNa_ampFB'] = PFNa_ampFB
  387. res['PFNd_bumpFB'] = PFNd_bumpFB
  388. res['PFNv_bumpFB'] = PFNv_bumpFB
  389. res['PFNpc_bumpFB'] = PFNpc_bumpFB
  390. res['PFNa_bumpFB'] = PFNa_bumpFB
  392. new = new[:,-1]
  393. new_inits = new.reshape((9,2))
  395. # Heatmaps
  396. #angle_map = np.arange(-135, 181, step=45)
  397. angle_map = np.arange(-np.pi,np.pi,step=np.pi/4)
  398. n_angles = angle_map.shape[0]
  399. n_sim = t.shape[0]
  401. EPG = np.zeros((n_angles, n_sim))
  402. PFNdL_pb = np.zeros((n_angles, n_sim))
  403. PFNdR_pb = np.zeros((n_angles, n_sim))
  404. PFNvL_pb = np.zeros((n_angles, n_sim))
  405. PFNvR_pb = np.zeros((n_angles, n_sim))
  406. PFNpcL_pb = np.zeros((n_angles, n_sim))
  407. PFNpcR_pb = np.zeros((n_angles, n_sim))
  408. PFNaL_pb = np.zeros((n_angles, n_sim))
  409. PFNaR_pb = np.zeros((n_angles, n_sim))
  411. for i in range(len(t)):
  412. EPG[:, i] = 0.5 + 0.5 * np.cos(angle_map - bumppos[i])
  413. PFNdL_pb[:, i] = (PFNd_amp[0, i] + 0.5) * (0.5 + 0.5 * np.cos(angle_map - res['PFNd_bumpL'][i]))
  414. PFNdR_pb[:, i] = (PFNd_amp[1, i] + 0.5) * (0.5 + 0.5 * np.cos(angle_map - res['PFNd_bumpR'][i]))
  415. PFNvL_pb[:, i] = (PFNv_amp[0, i] + 0.5) * (0.5 + 0.5 * np.cos(angle_map - res['PFNv_bumpL'][i]))
  416. PFNvR_pb[:, i] = (PFNv_amp[1, i] + 0.5) * (0.5 + 0.5 * np.cos(angle_map - res['PFNv_bumpR'][i]))
  417. PFNpcL_pb[:, i] = (PFNpc_amp[0, i] + 0.5) * (0.5 + 0.5 * np.cos(angle_map - res['PFNpc_bumpL'][i]))
  418. PFNpcR_pb[:, i] = (PFNpc_amp[1, i] + 0.5) * (0.5 + 0.5 * np.cos(angle_map - res['PFNpc_bumpR'][i]))
  419. PFNaL_pb[:, i] = (PFNa_amp[0, i] + 0.5) * (0.5 + 0.5 * np.cos(angle_map - res['PFNa_bumpL'][i]))
  420. PFNaR_pb[:, i] = (PFNa_amp[1, i] + 0.5) * (0.5 + 0.5 * np.cos(angle_map - res['PFNa_bumpR'][i]))
  422. heatmap = {}
  423. heatmap['EPG'] = np.vstack((EPG,EPG[0, :])).T
  425. heatmap['PFNdL_pb'] = np.vstack((PFNdL_pb,PFNdL_pb[0, :])).T
  426. heatmap['PFNdR_pb'] = np.vstack((PFNdR_pb,PFNdR_pb[0, :])).T
  427. heatmap['PFNvL_pb'] = np.vstack((PFNvL_pb,PFNvL_pb[0, :])).T
  428. heatmap['PFNvR_pb'] = np.vstack((PFNvR_pb,PFNvR_pb[0, :])).T
  429. heatmap['PFNpcL_pb'] = np.vstack((PFNpcL_pb,PFNpcL_pb[0, :])).T
  430. heatmap['PFNpcR_pb'] = np.vstack((PFNpcR_pb,PFNpcR_pb[0, :])).T
  431. heatmap['PFNaL_pb'] = np.vstack((PFNaL_pb,PFNaL_pb[0, :])).T
  432. heatmap['PFNaR_pb'] = np.vstack((PFNaR_pb,PFNaR_pb[0, :])).T
  434. return res, heatmap, new_inits
  437. def circshift(arr, shift): # don't need this, just np.roll?
  438. """
  439. Circularly shift the elements of the array by the specified shift amount.
  441. Parameters:
  442. arr (array-like): The input array.
  443. shift (int): The number of positions by which elements are shifted.
  445. Returns:
  446. np.ndarray: The circularly shifted array.
  447. """
  448. n = len(arr)
  449. shift = shift % n # Ensure shift is within the range [0, n)
  450. return np.concatenate((arr[-shift:], arr[:-shift]))
  453. def bumpmdl_de(params, thetavec, t, h, initcond):
  454. # output radians
  455. tau = 2#np.atleast_2d(params)[0]
  456. res = np.zeros_like(t)
  457. #res[0] = thetavec[0]*h[0]
  458. res[0] = initcond
  460. for i in range(len(t) - 1):
  461. coeff = -(utils.wrapToPi(np.array(thetavec[i] * h[i])))
  462. res[i + 1] = res[i] + (coeff - res[i]) * ((t[i + 1] - t[i]) / tau)
  464. return res
  467. def A_response_de(params, inputs, initcond):
  468. # This function generates a vector of intensity values over time for one
  469. # half of the PB innervated by PFNa, to a sequence of single-modality experience (either AF or OF).
  471. # Setup with arguments.
  472. # inputs are sensory info
  473. thetavec = inputs[0, :] # radians, (+) is ipsi to the PB half
  474. speedvec = np.fmax(np.zeros_like(inputs[1,:]),inputs[1, :]) # cm/s, zero-floored
  475. t = inputs[2, :] # seconds
  477. # Parameters
  478. a = params[0] # like Amp
  479. c = params[1] # coeff for second cosine term
  480. prefdir = params[2] # in rads; parameter formerly known as theta0
  481. b = params[3] # like offset
  482. r = params[4] # offset to arrive at steady-state
  483. d = params[5] # amplitude of steady-state driven by direction tuning
  484. tau = params[6] # time constant
  485. flip = params[7] # for rising OF response =0 vs. falling AF response !=0
  487. #% Set anchoring values for numerical solution: C is like max value,
  488. # T is full tau expression, res(1) is the initial result
  489. # (assumed to be the steady state if the first timestep inputs were held constant).
  490. C = a * (1 - np.exp(-speedvec)) * (np.cos(thetavec - prefdir) ** 2 + c * np.cos(thetavec - prefdir + np.pi) + b)
  491. T = tau
  492. ratio = r + d * np.cos(thetavec - prefdir)
  493. res = np.zeros_like(t)
  494. #res[0] = C[0]
  495. res[0] = initcond
  497. # Handle direction of response (rise/decay).
  498. if flip != 0: # if AF response curve
  499. res[0] = C[0]-initcond
  500. ratio = 1 - ratio
  502. # Calculate numerical solution using the given inputs and parameters.
  503. for i in range(len(t) - 1):
  504. dt = (t[i + 1] - t[i])
  505. res[i + 1] = (res[i] + ((ratio[i]) * C[i] - res[i]) * (dt / (T)))
  507. r = res
  509. if flip != 0: # if AF response curve
  510. # res = np.maximum(0, C - res)
  511. res = np.abs(C - res)
  512. r = C-r
  514. return res, r
  517. def D_response_de(params, inputs, initcond):
  518. # This function generates a vector of intensity values over time for one
  519. # half of the PB innervated by PFNd, to a sequence of single-modality experience (either AF or OF).
  521. # Setup with arguments.
  522. # inputs are sensory info
  523. thetavec = inputs[0, :] # radians, (+) is ipsi to the PB half
  524. speedvec = np.fmax(np.zeros_like(inputs[1,:]),inputs[1, :]) # cm/s, zero-floored
  525. t = inputs[2, :] # seconds
  527. # Parameters
  528. a = params[0] # like Amp
  529. c = params[1] # speed coefficient for max, =1 for non-speed-tuned PFNs
  530. prefdir = params[2] # in rads; parameter formerly known as theta0
  531. b = params[3] # like offset
  532. ratio = abs(params[4]) # ratio of steady-state to max amp; =0 for steady-state=0;
  533. # ratio=1 for PFNd OF
  534. tau = params[5] # time constant (offset)
  535. tauslope = params[6] # speed coefficient for tau
  536. flip = params[7] # for rising OF response =0 vs. falling AF response !=0
  538. # Set anchoring values for numerical solution: C is like max value, T is
  539. # full tau expression, res(1) is the initial result (assumed to be the
  540. # steady state if the first timestep inputs were held constant).
  541. C = a * (1 - np.exp(c * -speedvec)) * (np.cos(thetavec - prefdir) + b)
  542. T = tau + tauslope * np.exp(speedvec / 100)
  543. res = np.zeros_like(t)
  544. #res[0] = C[0]
  545. res[0] = initcond
  547. if flip != 0: # if AF response curve
  548. res[0] = C[0]-initcond
  549. ratio = 1 - ratio
  551. # Calculate numerical solution using the given inputs and parameters.
  552. for i in range(len(t) - 1):
  553. dt = (t[i + 1] - t[i])
  554. res[i + 1] = (res[i] + ((ratio) * C[i] - res[i]) * (dt / (T[i])))
  556. r = res
  558. # Handle negative values for AF response curves.
  559. if flip != 0: # if AF response curve
  560. res = np.maximum(0, C - res)
  561. # res = np.abs(C - res)
  562. r = C-r
  564. return res, r
  567. def PC_response_de(params, inputs, initcond):
  568. # This function generates a vector of intensity values over time for one
  569. # half of the PB to a sequence of single-modality experience (either AF or
  570. # OF). It can handle PFNpc and PFNa offset responses if given the correct
  571. # parameters (see 'script_20240404.m')
  573. # 'params' is a 2x8 matrix where first row is for onset/stimulus responses
  574. # and second row is for offset responses.
  576. # REFERENCE: on_off_de.m in MatLab
  578. # Setup with arguments.
  579. # inputs are sensory info
  580. thetavec = inputs[0, :] # radians, (+) is ipsi to the PB half
  581. speedvec = np.fmax(np.zeros_like(inputs[1,:]),inputs[1, :]) # cm/s, zero-floored
  582. t = inputs[2, :] # seconds
  584. ## Alt: get stimulus OFF periods (speed==0) and change speedvec to produce desired results
  585. offs = np.zeros_like(t)
  586. offinds = [i for i in range(len(speedvec)) if speedvec[i]==0]
  587. offs[offinds] = 1
  588. dspd = np.diff(speedvec)
  589. offs = np.zeros_like(t)
  590. for i in range(len(speedvec)-1):
  591. if dspd[i] !=0:
  592. speedvec[i+1] = speedvec[i]+(0.5*abs(dspd[i]))
  593. else:
  594. speedvec[i+1] = speedvec[i]
  596. # Parameters
  597. # a is like Amp
  598. a = np.ones_like(t)*params[0,0]
  599. a[np.nonzero(offs)[0]] = params[1,0]
  600. # c is speed coefficient for max, =1 for non-speed-tuned PFNs
  601. c = np.ones_like(t)*params[0,1] ## comment out `*params[0,1]` for no speed tuning
  602. c[np.nonzero(offs)[0]] = params[1,1] ## comment this line out entirely for no speed tuning
  603. # prefdir is in rads; parameter formerly known as theta0
  604. prefdir = np.ones_like(t)*params[0,2]
  605. prefdir[np.nonzero(offs)[0]] = params[1,2]
  606. # b is the tuning curve offset/shift term
  607. b = np.ones_like(t)*params[0,3]
  608. b[np.nonzero(offs)[0]] = params[1,3]
  609. # ratio is of steady-state to max amp; =0 for steady-state=0; ratio=1 for PFNd OF
  610. ratio = np.ones_like(t)*np.abs(params[0,4])
  611. ratio[np.nonzero(offs)[0]] = params[1,4]
  612. # tau is time constant with no dependency
  613. tau = np.ones_like(t)*params[0,5]
  614. tau[np.nonzero(offs)[0]] = params[1,5]
  615. # tauslope is speed coefficient for tau
  616. tauslope = np.ones_like(t)*params[0,6]
  617. tauslope[np.nonzero(offs)[0]] = params[1,6]
  618. # flip is to indicate whether activity is rising OF response =0 vs. falling AF response !=0
  619. flip = np.ones_like(t)*params[0,7]
  620. flip[np.nonzero(offs)[0]] = params[1,7]
  622. # Set anchoring values for numerical solution: C is like max value, T is
  623. # full tau expression, res[0] is the initial result (assumed to be the
  624. # steady state if the first timestep inputs were held constant).
  626. ## uncomment the following line and comment out the `C = ...` line below it if PFNpc is direction tuned.
  627. C = np.multiply(a, np.multiply((1 - np.exp(np.multiply(c, -speedvec))), (np.cos(thetavec - prefdir) + b)))
  628. ## comment out above line and use the following line instead if no PFNpc direction tuning
  629. #C = np.multiply(a, np.multiply((1 - np.exp(np.multiply(c, -speedvec))), (np.cos(0 - prefdir) + b)))
  630. T = tau + np.multiply(tauslope, np.exp(-speedvec))
  631. res = np.zeros_like(t)
  633. res[0] = initcond
  635. # Handle direction of response (rise/decay).
  636. for i in range(len(t)):
  637. if flip[i] != 0: # if AF response curve
  638. res[i] = C[i]-initcond
  639. ratio[i] = 1 - ratio[i]
  641. # Calculate numerical solution using the given inputs and parameters.
  642. for i in range(len(t) - 1):
  643. dt = (t[i + 1] - t[i])
  644. res[i + 1] = (res[i] + ((ratio[i]) * C[i] - res[i]) * (dt / (T[i])))
  646. r = res
  648. # Handle negative values for AF response curves.
  649. for i in range(len(t)):
  650. if flip[i] != 0:
  651. res[i] = np.abs(C[i] - res[i])
  652. #res[i] = C[i]-res[i]
  653. r[i] = r[i]
  655. return res, r
  658. def sumPFNvecs(PFN_bumps, PFN_amps):
  659. # assumes PFN_bumps is already pi/4-rad shifted.
  660. adj = PFN_amps[0, :] * np.cos(PFN_bumps[0, :]) + PFN_amps[1, :] * np.cos(PFN_bumps[1, :])
  661. opp = PFN_amps[0, :] * np.sin(PFN_bumps[0, :]) + PFN_amps[1, :] * np.sin(PFN_bumps[1, :])
  662. va = np.arctan2(opp, adj)
  663. vm = np.sqrt(opp ** 2 + adj ** 2)
  665. return va, vm
  668. def PFNd_integ(params, inputs, initcond):
  669. # params = array where first row is AF, second row is OF
  670. # inputs = array where:
  671. # [ AF directions;
  672. # AF speeds;
  673. # OF directions;
  674. # OF speeds;
  675. # time ]
  677. if len(initcond.shape)==1:
  678. AF, a = D_response_de(params[0, :], np.vstack((inputs[0:2, :], inputs[4, :])), initcond[0])
  679. OF, o = D_response_de(params[1, :], inputs[2:5, :], initcond[1])
  680. else:
  681. AF, a = D_response_de(params[0, :], np.vstack((inputs[0:2, :], inputs[4, :])), initcond[0,:])
  682. OF, o = D_response_de(params[1, :], inputs[2:5, :], initcond[1,:])
  684. res = AF + OF # comment out for noAF or noOF
  685. # res = OF # comment in for noAF
  686. # res = AF # comment in for noOF
  688. return res, a, o
  691. def PFNa_integ(params, inputs, initcond):
  692. # params = array where first row is AF, second row is OF
  693. # inputs = array where:
  694. # [ AF directions;
  695. # AF speeds;
  696. # OF directions;
  697. # OF speeds;
  698. # time ]
  700. if len(initcond.shape)==1:
  701. AF, a = A_response_de(params[0, :], np.vstack((inputs[0:2, :], inputs[4, :])), initcond[0])
  702. OF, o = A_response_de(params[1, :], inputs[2:5, :], initcond[1])
  703. else:
  704. AF, a = A_response_de(params[0, :], np.vstack((inputs[0:2, :], inputs[4, :])), initcond[0,:])
  705. OF, o = A_response_de(params[1, :], inputs[2:5, :], initcond[1,:])
  707. # Instantiate result
  708. res = np.zeros(inputs.shape[1])
  710. # Where OF response exists, insert into result
  711. OFinds = np.where(OF)[0] # comment out for noOF
  712. res[OFinds] = OF[OFinds] # comment out for noOF
  714. # Where AF or AFOF response exists, insert into result (overwriting OF
  715. # except where OF is alone).
  716. AFinds = np.where(AF)[0] # comment out for noAF
  717. res[AFinds] = AF[AFinds] # comment out for noAF
  719. return res, a, o
  722. def PFNpc_integ2(params, inputs, initcond):
  724. if len(initcond.shape)==1:
  725. AF, a = PC_response_de(params[0:2, :], np.vstack((inputs[0:2, :], inputs[4, :])), initcond[0])
  726. OF, o = PC_response_de(params[2:, :], inputs[2:5, :], initcond[1])
  727. else:
  728. AF, a = PC_response_de(params[0:2, :], np.vstack((inputs[0:2, :], inputs[4, :])), initcond[0,:])
  729. OF, o = PC_response_de(params[2:, :], inputs[2:5, :], initcond[1,:])
  731. res = np.zeros(inputs.shape[1])
  733. OF_inds = np.where(OF)[0] # comment out for noOF
  734. res[OF_inds] = OF[OF_inds] # comment out for noOF
  736. AF_inds = np.where(AF)[0] # comment out for noAF
  737. res[AF_inds] = AF[AF_inds] # comment out for noAF
  739. return res, a, o
  742. def SteadyStateInitial_amp(params,inputs,isPFNa=False):
  743. # params is the parameter vector for one half of the PB to one stimulus modality, e.g. p_PFNd[0,:]
  744. # inputs is a vector of len=2, the starting direction (0) and speed (1) for the modality of interest
  745. # returns the steady-state value of the amplitude model for the given inputs
  746. if isPFNa:
  747. C = params[0] * (1 - np.exp(-inputs[1])) * (np.cos(inputs[0] - params[2]) ** 2 + params[1] * np.cos(inputs[0] - params[2] + np.pi) + params[3])
  748. ratio = params[4] + params[5] * np.cos(inputs[0] - params[2])
  749. ss = ratio * C
  750. else:
  751. C = params[0] * (1 - np.exp(params[1] * -inputs[1])) * (np.cos(inputs[0] - params[2]) + params[3])
  752. ss = params[4] * C
  754. return ss
  757. def SteadyStateInitial_bump(inputs):
  758. ## This is a holdover from when bump position is sensitive to airflow direction
  759. ## inputs is a vector of len=3, for heading direction, airflow direction, and airspeed
  760. #h = -inputs[0]
  761. if inputs[2]!=0:
  762. ss = -inputs[1]
  763. else:
  764. ss = 0
  766. ss=0 # set to zero if no influence of airflow on bump position. (Heading added in later in the model)
  768. return ss
  771. def BuildSSInitial(p_PFNd, p_PFNv, p_PFNpc, p_PFNa, input_AF, input_OF, bump_inputs):
  773. # if you don't want PFNv responses to airflow, run the following line:
  774. #p_PFNv[0,0] = 0
  775. #p_PFNpc[1,0] = 0 # no pc response to optic flow
  777. Raf = input_AF
  778. Laf = [-(input_AF[0]),input_AF[1]]
  779. Rof = input_OF
  780. Lof = [-(input_OF[0]),input_OF[1]]
  782. ssinit = np.zeros((9,2))
  783. ssinit[0,0] = SteadyStateInitial_amp(p_PFNd[0,:],Laf) # comment out for noAF
  784. ssinit[0,1] = SteadyStateInitial_amp(p_PFNd[1,:],Lof) # comment out for noOF
  785. ssinit[1,0] = SteadyStateInitial_amp(p_PFNd[0,:],Raf) # comment out for noAF
  786. ssinit[1,1] = SteadyStateInitial_amp(p_PFNd[1,:],Rof) # comment out for noOF
  787. ssinit[2,0] = SteadyStateInitial_amp(p_PFNv[0,:],Laf) # comment out for noAF
  788. ssinit[2,1] = SteadyStateInitial_amp(p_PFNv[1,:],Lof) # comment out for noOF
  789. ssinit[3,0] = SteadyStateInitial_amp(p_PFNv[0,:],Raf) # comment out for noAF
  790. ssinit[3,1] = SteadyStateInitial_amp(p_PFNv[1,:],Rof) # comment out for noOF
  791. ssinit[4,0] = SteadyStateInitial_amp(p_PFNpc[0,:],Laf) # comment out for noAF
  792. ssinit[4,1] = SteadyStateInitial_amp(p_PFNpc[1,:],Lof) # comment out for noOF
  793. ssinit[5,0] = SteadyStateInitial_amp(p_PFNpc[0,:],Raf) # comment out for noAF
  794. ssinit[5,1] = SteadyStateInitial_amp(p_PFNpc[1,:],Rof) # comment out for noOF
  795. ssinit[6,0] = SteadyStateInitial_amp(p_PFNa[0,:],Laf,True) # comment out for noAF
  796. ssinit[6,1] = SteadyStateInitial_amp(p_PFNa[1,:],Lof,True) # comment out for noOF
  797. ssinit[7,0] = SteadyStateInitial_amp(p_PFNa[0,:],Raf,True) # comment out for noAF
  798. ssinit[7,1] = SteadyStateInitial_amp(p_PFNa[1,:],Rof,True) # comment out for noOF
  799. ssinit[8,0] = SteadyStateInitial_bump(bump_inputs)
  800. ssinit[8,1] = SteadyStateInitial_bump(bump_inputs)
  802. return ssinit

PFN_model.py at commit c500bd6, under GPL-3.0 · at the source

Overview

Authors: Christina E May1, Benjamin Cellini2, S David Stupski2, Austin P Lopez2, Nehal Mangat2, Floris van Breugel2, Katherine I Nagel1
ORCID iDs: Christina E May, Benjamin Cellini, Austin P Lopez, Nehal Mangat, Floris van Breugel, Katherine I Nagel
  1. Department of Neuroscience, NYU Grossman School of Medicine, New York, NY 10016, USA
  2. Department of Mechanical Engineering, University of Nevada Reno, Reno, NV 89512, USA
Institutions: New York University (United States); University of Nevada, Reno (United States)
Journal: Science advances, volume 12, issue 35, article eaeh7220
Dates: received 1 April 2026; accepted 20 July 2026; published online 28 August 2026; in print August 2026
Type: Research article · Language: English
License: CC BY-NC
Identifiers: DOI 10.1126/sciadv.aeh7220 · PMID 42664356 · PMCID PMC13524059 · OpenAlex W7168277023
Open access: gold, a free copy (OpenAlex)
Status: code verified
Methods: Spectral & time-frequency, Connectivity, Evoked potentials, Statistics, fMRI & imaging, Single-unit activity, calcium imaging, Physiology & signal measures
Topic: Neurobiology and Insect Physiology Research (Cellular and Molecular Neuroscience, Neuroscience), according to OpenAlex
Funding: NINDS NIH HHS (R01 NS127129, R01 NS136555); NIDA NIH HHS (R34 DA059500)
Citations: not cited yet (Europe PMC); 102 references in the paper

Abstract

Flying flies can determine ambient wind direction in flight, but what neural representations might support this behavior are unclear. Ambient wind acting on a flying fly creates distinct patterns of airflow and optic flow. Here, we used two-photon imaging to characterize encoding of these two variables across columnar inputs to the fly navigation center, called PFNs. We find tuning for airflow direction and speed across many PFN types but only optic flow direction tuning in limited types. We do not observe tuning to optic flow speed. We build and validate an encoding model that enables simulation of PFN representations during real and simulated flight maneuvers. We show that these representations are sufficient to decode ambient wind direction both theoretically and using a simple feedforward ANN. Our work shows how a compact multisensory representation of self-motion could be used to infer a property of the external world that cannot be directly measured by a single sensory system.

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

Repositories

Its files are read in the Code ↔ Paper reader above, with 14 matches between paragraphs and lines of code.

Zenodo 20558337

License: CC-BY-4.0
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Size: 2 files
Software Heritage: not checked
Found in: “Data, code, and materials availability:”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Availability: 1 check, the latest on 27 September 2026: the link answers (HTTP 200)
  • 27 September 2026: the link answers (HTTP 200)
At the source: doi.org/10.5281/zenodo.20558337

nagellab/Mayetal2026

License: GPL-3.0
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: c500bd65728dd7bd2aba29e2a66b0e4f83a258eb, 13 July 2026
Languages: MATLAB (1072), C (71), Python (26), Jupyter (19), JavaScript (9), C/C++ (4), Java (2)
Size: 1,541 files, 1,203 scripts
Software Heritage: not archived
Found in: “Data, code, and materials availability:”
Holds: license file, environment (Python/drosophila_body_orientation_predictor/Dockerfile, Python/drosophila_body_orientation_predictor/requirements.txt), tests, documentation, 10 notebooks
Not found: README, CITATION.cff, continuous integration
Tools: NumPy (36 files), Statistics and Machine Learning Toolbox (33 files), CircStat (32 files), Matplotlib (29 files), pandas (29 files), Image Processing Toolbox (28 files), SciPy (28 files), shadedErrorBar (13 files), Keras (8 files), Signal Processing Toolbox (8 files), Parallel Computing Toolbox (6 files), seaborn (6 files), scikit-learn (4 files), TensorFlow (4 files), SymPy (3 files), Curve Fitting Toolbox (1 file), Optimization Toolbox (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
1,204 files
At the source: github.com/nagellab/Mayetal2026

nehalsinghmangat/drosophila_body_orientation_predictor

License: MIT
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 00ad4ef6015d6cc751018c6ad966b1b2e4da50cc, 15 September 2026
Languages: Python (2), Jupyter (1)
Size: 116 files, 3 scripts
Software Heritage: not archived
Found in: “Data, code, and materials availability:”
Holds: README, license file, CITATION.cff, environment (requirements.txt), 1 notebook
Not found: tests, continuous integration, documentation
Tools: Matplotlib (3 files), NumPy (3 files), Keras (2 files), pandas (2 files), SciPy (2 files), scikit-learn (1 file), statsmodels (1 file), SymPy (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
5 files
At the source: github.com/nehalsinghmangat/drosophila_body_orientation_predictor

The paper's code and data availability statement is in the Data section.

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:

  • 3 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 1,206 scripts, each with its path and the digest of its content;
  • 14 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • 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, code, and materials availability

All data and code needed to evaluate and reproduce the results in the paper are present in the paper and/or the Supplementary Materials. All data collected and code generated in this manuscript are publicly available on Zenodo (https://doi.org/10.5281/zenodo.20558337). All code generated for this manuscript (encoding model and observability) and CAD files for fly holders are available at GitHub at https://github.com/nagellab/Mayetal2026. Code used to create and train the naturalistic heading directions was forked from https://github.com/nehalsinghmangat/drosophila_body_orientation_predictor. No new materials were generated during the study.

Reproduced under the paper's license (CC BY-NC), 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, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 7 authors, 2 funders, 87 references.

Cite

This paper

May, C. E., Cellini, B., Stupski, S. D., Lopez, A. P., Mangat, N., van Breugel, F., & Nagel, K. I. (2026). Central complex representations of self-movement are sufficient to compute wind direction in flight. Science advances, 12(35), eaeh7220. https://doi.org/10.1126/sciadv.aeh7220

BibTeX

@article{may2026central,
author = {May, Christina E and Cellini, Benjamin and Stupski, S David and Lopez, Austin P and Mangat, Nehal and van Breugel, Floris and Nagel, Katherine I},
title = {{Central complex representations of self-movement are sufficient to compute wind direction in flight}},
journal = {Science advances},
year = {2026},
month = aug,
volume = {12},
number = {35},
pages = {eaeh7220},
publisher = {American Association for the Advancement of Science},
issn = {2375-2548},
doi = {10.1126/sciadv.aeh7220},
url = {https://doi.org/10.1126/sciadv.aeh7220},
pmid = {42664356},
pmcid = {PMC13524059}
}

RIS

TY - JOUR
AU - May, Christina E
AU - Cellini, Benjamin
AU - Stupski, S David
AU - Lopez, Austin P
AU - Mangat, Nehal
AU - van Breugel, Floris
AU - Nagel, Katherine I
TI - Central complex representations of self-movement are sufficient to compute wind direction in flight
T2 - Science advances
J2 - Sci Adv
PY - 2026
DA - 2026/08/28
VL - 12
IS - 35
SP - eaeh7220
SN - 2375-2548
PB - American Association for the Advancement of Science
DO - 10.1126/sciadv.aeh7220
UR - https://doi.org/10.1126/sciadv.aeh7220
LA - en
ER -

CSL-JSON

{
"id": "10.1126/sciadv.aeh7220",
"type": "article-journal",
"title": "Central complex representations of self-movement are sufficient to compute wind direction in flight",
"container-title": "Science advances",
"author": [
{
"family": "May",
"given": "Christina E"
},
{
"family": "Cellini",
"given": "Benjamin"
},
{
"family": "Stupski",
"given": "S David"
},
{
"family": "Lopez",
"given": "Austin P"
},
{
"family": "Mangat",
"given": "Nehal"
},
{
"family": "van Breugel",
"given": "Floris"
},
{
"family": "Nagel",
"given": "Katherine I"
}
],
"container-title-short": "Sci Adv",
"volume": "12",
"issue": "35",
"page": "eaeh7220",
"DOI": "10.1126/sciadv.aeh7220",
"PMID": "42664356",
"PMCID": "PMC13524059",
"ISSN": "2375-2548",
"publisher": "American Association for the Advancement of Science",
"URL": "https://doi.org/10.1126/sciadv.aeh7220",
"language": "en",
"issued": {
"date-parts": [
[
2026,
8,
28
]
]
}
}

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.1038/s41467-026-75945-2 [code]
Neural dynamics for working memory and evidence integration during olfactory navigation in Drosophila.
Journal: Nature communications
In common: shadedErrorBar, Curve Fitting Toolbox, Image Processing Toolbox, 2 other tools, 13 references, author Katherine I Nagel
[2] doi:10.1038/s41586-026-10827-7 [code]
A vector-based strategy for olfactory navigation in Drosophila.
Journal: Nature
In common: pandas, SciPy, Matplotlib, 1 other tool, 16 references
[3] doi:10.3389/fnsys.2026.1822122 [code]
Convergence-divergence circuits for multimodal integration of innate and learned opponent valences.
Journal: Frontiers in systems neuroscience
In common: Keras, TensorFlow, seaborn, 5 other tools, 9 references
[4] doi:10.1038/s41586-026-10735-w [code]
Distributed control circuits across a brain-and-cord connectome.
Journal: Nature
In common: seaborn, scikit-learn, pandas, 3 other tools, 11 references
[5] doi:10.1016/j.neuron.2026.03.034 [code]
Dentate gyrus interneurons modulate winner-take-all network dynamics in freely behaving mice.
Journal: Neuron
In common: CircStat, shadedErrorBar, Curve Fitting Toolbox, 11 other tools
[6] doi:10.1073/pnas.2609141123
Odor tracking in flying &lt;i&gt;Drosophila&lt;/i&gt; requires visual reafference and compass neurons.
Journal: Proceedings of the National Academy of Sciences of the United States of America
In common: 11 references
[7] doi:10.1038/s41586-026-10631-3 [code]
A prognostic human brain network for diffuse midline glioma.
Journal: Nature
In common: Curve Fitting Toolbox, Keras, Optimization Toolbox, 11 other tools
[8] doi:10.1038/s41467-026-73106-z [code]
Respiratory pauses highlight sleep architecture in mice.
Journal: Nature communications
In common: CircStat, Curve Fitting Toolbox, Keras, 9 other tools
[9] doi:10.1002/hbm.70602 [code]
Neuroimaging Correlates of Post-Stroke Pain After Ischemic Stroke: Secondary Analysis of the INSPiRE-TMS Trial.
Journal: Human brain mapping
In common: Curve Fitting Toolbox, Keras, Optimization Toolbox, 10 other tools
[10] doi:10.1111/ene.70678 [code]
Who Falls After a Stroke? Evidence From a Prospective Stroke Cohort.
Journal: European journal of neurology
In common: Curve Fitting Toolbox, Keras, Optimization Toolbox, 10 other tools

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.