OSCR

Osmotic stress triggers fast and reversible PMF collapse in Escherichia coli.

Code ↔ Paper

10 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 10 matches
  1. [1] § Materials and methods › Curve fitting ↔ code/bead-assay/sucrose_shock_analysis.ipynb, lines 685–758 · score 0.85 · Green triangles, Red circles, linear fit, viscosity driven, Normalized speed reduction, sucrose shocks
  2. [2] § Materials and methods › Curve fitting ↔ code/bead-assay/sucrose_shock_analysis.ipynb, lines 403–490 · score 0.79 · inflection, 155 s, 215 s, 235 s, 240 s, sigmoidal
  3. [3] § Materials and methods › Curve fitting ↔ code/bead-assay/adaptation_curve_fitting.ipynb, lines 105–155 · score 0.72 · 175–240 s, 175 s, fit, motor speed, Curve
  4. [4] § Results › Rotation speed decrease does not require potassium ions ↔ code/bead-assay/sucrose_shock_analysis.ipynb, lines 685–758 · score 0.71 · Red circles, linear fit, Normalized speed reduction, normalized speed decrease, sucrose shocks, SD
  5. [5] § Materials and methods › Curve fitting ↔ code/bead-assay/bead_shock_curve_fits.ipynb, lines 36–107 · score 0.63 · exponential function, speed increase, normalized speed, fit, Curve, motor speed
  6. [6] § Materials and methods › Curve fitting ↔ code/bead-assay/adaptation_curve_fitting.ipynb, lines 264–334 · score 0.59 · speeds normalized, 600 s, exponential, plateau, fit, 250 s
  7. [7] § Results › Motor speed response is independent of rotor conformation ↔ code/bead-assay/sucrose_shock_analysis.ipynb, lines 761–811 · score 0.58 · Blue squares, viscosity corrected speed, sucrose shocks, speed decrease, SD, osmolarity
  8. [8] § Materials and methods › TMRM quantification ↔ code/TMRM-anaylsis/analyze_tmrm_population_dff.py, lines 66–88 · score 0.51 · analyze TMRM fluorescence, pre shock, background, ratio, signal, baseline
  9. [9] § Materials and methods › TMRM quantification ↔ code/TMRM-anaylsis/analyze_tmrm_single_condition_dff.py, lines 40–62 · score 0.51 · analyze TMRM fluorescence, pre shock, background, ratio, signal, baseline
  10. [10] § Materials and methods › Single-motor measurements ↔ code/bead-assay/sucrose_shock_analysis.ipynb, lines 403–490 · score 0.50 · single motors, Raw, median, rotation speed, mask, filter

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

Jupyter notebook · 924 lines · 34 KB · no license · 5 matches

  1. # %% [markdown]
  2. # # Sucrose Shock Analysis
  3. #
  4. # Status: cleaned for the publication supplement. Supported cells start from the curated time-series data committed under `data/time-series/` and write generated files under `outputs/` directories.
  5. #
  6. # Upstream image/video processing, raw acquisition data, segmentation outputs, bead-center detection outputs, and other large intermediates are intentionally not included in this repository. Cells from the original notebook that depended on those local upstream files have been replaced by archived notes.
  8. # %% [markdown]
  9. # ### 📦 Importing Required Libraries
  10. #
  11. # This cell imports all the necessary Python libraries for data analysis and plotting:
  12. #
  13. # - `numpy`, `pandas` for data handling
  14. # - `matplotlib.pyplot`, `seaborn` for plotting and visualization
  15. # - `os`, `pathlib.Path` for file handling
  16. # - `scipy` libraries for signal processing and curve fitting
  17. # - `sklearn.metrics.r2_score` for computing the R² value
  18. # - `%matplotlib inline` ensures that plots display directly in the notebook
  20. # %%
  21. # Import necessary libraries
  22. import numpy as np
  23. import pandas as pd
  24. import matplotlib.pyplot as plt
  25. import seaborn as sns
  26. import os
  27. from pathlib import Path
  28. import scipy
  29. from scipy.optimize import curve_fit
  30. import scipy.signal
  31. import re
  32. from scipy.interpolate import interp1d
  33. import scipy.signal as signal
  34. from sklearn.metrics import r2_score
  36. import sys
  37. NOTEBOOK_DIR = Path.cwd()
  38. if (NOTEBOOK_DIR / "bead_time_series.py").exists():
  39. sys.path.insert(0, str(NOTEBOOK_DIR))
  40. else:
  41. sys.path.insert(0, str((NOTEBOOK_DIR / "code" / "bead-assay").resolve()))
  42. from bead_time_series import ROOT, legacy_speed_tree, legacy_condition_folder, read_legacy_speed_csv, iter_condition_traces, median_kernel_size
  44. # Ensure plots are rendered in the notebook
  45. %matplotlib inline
  47. # %% [markdown]
  48. # ## Defining terms for the exponential function
  50. # %%
  51. dict_for_plotting = {}
  52. for name in ['0', '100', '200', '300', '400', '500']:
  53. dict_for_plotting[name] = []
  55. # %%
  56. # Define exponential functions
  57. def old_exp_decrease(t, A, tau, C, t0):
  58. return A / (1 + np.exp((t-175-t0) / tau)) + C
  60. def exp_decrease(t, tau, t0):
  61. global speed_initial
  62. global speed_final
  63. return (speed_initial-speed_final) / (1 + np.exp((t-175-t0) / tau)) + speed_final
  65. def exp_increase(t, tau, t0):
  66. global speed_increase_max
  67. global speed_increase_min
  68. return speed_increase_min + (speed_increase_max - speed_increase_min)/ (1 + np.exp(-(t-270-t0) / tau))
  70. def old_exp_increase(t, B, tau, D, t0):
  71. return B * (1 - np.exp(-(t - t0) / tau)) + D
  73. def exponential_decay(t, tau, t0):
  74. global speed_initial
  75. global speed_final
  76. return np.where(t < t0, speed_initial, (speed_initial-speed_final) * np.exp(-(t - t0) / tau) + speed_final)
  78. def calculate_time_constants(time, speed, filename, sucrose_choice):
  79. results = []
  81. #normalize speed for ease of fitting
  82. speed = speed / np.average(speed[time<=180]) #normally 300
  84. # Filter data for decrease and increase
  85. mask_decrease = (time >= 175) & (time <= 240)
  86. time_decrease = time[mask_decrease]
  87. speed_decrease = speed[mask_decrease]
  89. mask_increase = (time > 250) & (time <= 360)
  90. time_increase = time[mask_increase]
  91. speed_increase = speed[mask_increase]
  93. global speed_initial
  94. global speed_final
  95. speed_initial = np.average(speed[(time >= 155) & (time <= 175)])
  96. speed_final = np.average(speed[(time >= 215) & (time <= 235)])
  98. global speed_increase_max
  99. global speed_increase_min
  100. speed_increase_min = np.average(speed[(time >= 240) & (time <= 260)])
  101. speed_increase_max = np.average(speed[(time >= 330) & (time <= 350)])
  104. global dict_for_plotting
  105. dict_for_plotting[filename].append(speed[(time >= 155) & (time <= 175)])
  106. dict_for_plotting['0'].append(speed[(time >= 215) & (time <= 235)])
  108. #Fit the decrease segment
  109. try:
  110. popt_decrease, _ = curve_fit(
  111. exp_decrease,
  112. time_decrease,
  113. speed_decrease,
  114. p0=[10, 10],
  115. bounds=(0, np.inf)
  116. )
  117. A_dec, C_dec = speed_initial-speed_final, speed_final
  118. tau_dec, t0_dec = popt_decrease
  119. except Exception as e:
  120. print(f"Error fitting decrease for {filename}: {e}")
  121. tau_dec = np.nan
  122. A_dec, tau_dec, C_dec, t0_dec = [np.nan, np.nan, np.nan, np.nan]
  123. popt_decrease = [np.nan, np.nan, np.nan, np.nan]
  125. if True: #plotting to double check
  126. if filename == "500": #filename[-13:-10]
  127. #print('here')
  128. plt.plot(time, speed)
  129. plt.plot(time_decrease, exp_decrease(time_decrease, *popt_decrease))
  132. # Fit the increase segment
  133. try:
  134. popt_increase, _ = curve_fit(
  135. exp_increase, time_increase, speed_increase, p0=[3, -10]
  136. )
  137. tau_inc, t0_inc = popt_increase
  138. except Exception as e:
  139. print(f"Error fitting increase for {filename}: {e}")
  140. tau_inc = np.nan
  141. popt_increase = [np.nan, np.nan]
  143. if True:
  144. if filename == "500":
  145. plt.plot(time_increase, exp_increase(time_increase, *popt_increase))
  147. # Save results for this concentration
  148. condition = filename.split(".csv")[
  149. 0
  150. ] # Assuming the filename contains the concentration info
  151. results.append(
  152. {
  153. "Condition": condition,
  154. "Tau (Decrease)": tau_dec,
  155. "Tau (Increase)": tau_inc,
  156. "Time Range (Decrease)": f"180-270",
  157. "Time Range (Increase)": f"270-{time[-1]}",
  158. }
  159. )
  161. return tau_dec, t0_dec, A_dec, tau_inc
  163. # %% [markdown]
  164. # ### Data Processing Functions
  165. #
  166. # This section defines three functions used to process time-series data by interpolating to a fixed frame rate and binning into defined intervals:
  168. # %%
  169. def convert_to_300fps(time_stamps, data, target_fps=300):# Calculate the total duration
  170. total_time = time_stamps[-1]
  172. # Generate new time stamps at the target FPS
  173. new_time_stamps = np.linspace(0, total_time, int(total_time * target_fps))
  175. # Create a linear interpolator
  176. interpolator = interp1d(time_stamps, data, kind='linear', fill_value='extrapolate')
  178. # Interpolate data to the new time stamps
  179. interpolated_data = interpolator(new_time_stamps)
  181. return new_time_stamps[:380*target_fps], interpolated_data[:380*target_fps]
  183. def bin_data(time_stamps, data, bin_size=0.1):
  184. data = data[time_stamps < 380]
  185. time_stamps = time_stamps[time_stamps < 380]
  187. # Determine the range of time stamps
  188. start_time = 0
  189. end_time = 380
  191. # Create bin edges
  192. bin_edges = np.arange(start_time, end_time + bin_size, bin_size)
  194. # Calculate bin indices for each time stamp
  195. bin_indices = np.digitize(time_stamps, bin_edges, right=False) - 1 # Bin indices (0-based)
  197. # Initialize lists to store results
  198. binned_times = np.arange(0,end_time,0.1)
  199. averaged_data = np.zeros_like(binned_times)
  201. # Iterate over each bin
  202. for i in range(len(bin_edges) - 1):
  203. # Get indices of data points in the current bin
  204. indices_in_bin = np.where(bin_indices == i)[0]
  206. if len(indices_in_bin) > 0:
  207. # Calculate the midpoint of the current bin
  208. bin_midpoint = (bin_edges[i] + bin_edges[i + 1]) / 2
  209. binned_times[i] = (bin_midpoint)
  211. # Calculate the average of data points in the current bin
  212. average_value = np.mean(data[indices_in_bin])
  213. averaged_data[i] = (average_value)
  215. return np.array(binned_times), np.array(averaged_data)
  217. def bin_data_2(time_stamps, data, bin_size=0.1):
  218. T = time_stamps[time_stamps<=380]
  219. F = data[time_stamps<=380]
  221. # Resample into 4000 bins
  222. data_F = np.zeros(3800)
  223. data_T = np.zeros(3800)
  225. bin = 0
  226. counter = 0
  228. for kk in range(len(T)):
  229. counter += 1
  230. pos = int(T[kk] // 0.1)
  231. if pos < 3800:
  232. data_F[pos] += F[kk]
  233. if T[kk] // 0.1 > bin + 1:
  234. data_F[pos - 1] /= counter
  235. data_T[pos - 1] = (bin + 0.5) * 0.1
  236. counter = 0
  237. bin += 1
  238. else:
  239. data_F[pos - 1] /= counter
  240. data_T[pos - 1] = (bin + 0.5) * 0.1
  241. break
  243. return data_T, data_F
  245. # %% [markdown]
  246. # ## Sucrose
  247. # Extracing motor speeds from the sucrose results folder
  249. # %%
  250. parentDir = legacy_speed_tree(assay="Sucrose")
  251. outputDir = ROOT / "outputs" / "bead" / "sucrose-shock"
  252. os.makedirs(outputDir, exist_ok=True)
  254. sucrose_choice = True
  255. time_mult = 10
  257. # Initialize the list to store time, data, and sucrose concentrations
  258. all_time = []
  259. all_data = []
  260. concentrations = []
  262. tau_values = {}
  263. t0_values = {}
  264. A_values = {}
  265. tau_inc_values = {}
  267. for concentration in [200, 300, 400, 500]:
  268. condition_dir = Path(parentDir) / f"{concentration}mM"
  269. csv_files = sorted(condition_dir.glob("*.csv"))
  270. if not csv_files:
  271. print(f"No traces found for {concentration} mM in {condition_dir}")
  272. continue
  274. tau_values[str(concentration)] = []
  275. t0_values[str(concentration)] = []
  276. A_values[str(concentration)] = []
  277. tau_inc_values[str(concentration)] = []
  278. condition_cells = []
  280. for file_path in csv_files:
  281. if concentration == 200 and "cell4" in file_path.stem:
  282. continue
  284. trace = read_legacy_speed_csv(file_path)
  285. time = trace["frame"].to_numpy() / 300
  286. data = trace["frequency_hz"].to_numpy()
  287. if len(data) == 0:
  288. continue
  289. if data[0] < 0:
  290. data = data * -1
  292. data = signal.medfilt(data, kernel_size=median_kernel_size(time, window_s=1.0))
  293. new_time, interp_data = bin_data(time, data)
  295. tau_dec, t0_dec, A_dec, tau_inc = calculate_time_constants(new_time, interp_data, str(concentration), sucrose_choice)
  296. if ((tau_dec > 0) & (tau_dec < 40)):
  297. tau_values[str(concentration)] += [float(tau_dec)]
  298. t0_values[str(concentration)] += [float(t0_dec)]
  299. A_values[str(concentration)] += [float(A_dec)]
  300. tau_inc_values[str(concentration)] += [float(tau_inc)]
  302. condition_cells.append(interp_data)
  304. if not condition_cells:
  305. continue
  307. allcells = np.asarray(condition_cells)
  308. data_mean = np.average(allcells, axis=0)
  309. data_mean_norm = data_mean / np.average(data_mean[:180 * time_mult])
  310. data_std = np.std(allcells, axis=0) / np.average(data_mean[:180 * time_mult])
  311. upper = data_mean_norm + 0.5 * data_std
  312. lower = data_mean_norm - 0.5 * data_std
  314. time = new_time
  315. all_time.append(time)
  316. all_data.append(data_mean_norm)
  317. concentrations.append(float(concentration))
  319. df_output = pd.DataFrame({
  320. 'Time': time,
  321. 'Normalized Data': data_mean_norm
  322. })
  323. output_file = outputDir / f"normalized_data_{concentration}mM.csv"
  324. # df_output.to_csv(output_file, index=False)
  326. # Sort the concentrations and associated data
  327. sorted_indices = np.argsort(concentrations)
  328. sorted_concentrations = [concentrations[i] for i in sorted_indices]
  329. sorted_data = [all_data[i] for i in sorted_indices]
  330. sorted_times = [all_time[i] for i in sorted_indices]
  332. # %%
  333. sorted_indices = np.argsort(concentrations)
  334. sorted_concentrations = [concentrations[i] for i in sorted_indices]
  335. sorted_data = [all_data[i] for i in sorted_indices]
  336. sorted_times = [all_time[i] for i in sorted_indices]
  338. print("Sorted concentrations:", sorted_concentrations)
  340. # Save a code-generated panel corresponding to the sucrose motor-speed panel.
  341. figure_dir = ROOT / "outputs" / "figure-panels"
  342. figure_dir.mkdir(parents=True, exist_ok=True)
  344. plt.rcParams.update({'font.size': 25, 'font.family': 'Arial'})
  345. fig, ax = plt.subplots(figsize=(10, 5.5))
  346. for axis in ['top', 'bottom', 'left', 'right']:
  347. ax.spines[axis].set_linewidth(2)
  348. ax.tick_params(axis='x', direction='in', width=2, length=7.5, pad=8)
  349. ax.tick_params(axis='y', direction='in', width=2, length=7.5, pad=8)
  351. for time_arr, mean_arr, conc in zip(sorted_times, sorted_data, sorted_concentrations):
  352. ax.plot(time_arr, mean_arr, label=f'{int(conc)} mM')
  354. ax.axvspan(180, 270, color='lightgray', alpha=0.6)
  355. ax.set_xlabel('Time (s)', fontsize=25)
  356. ax.set_ylabel('Rotation Speed (Normalized)', fontsize=25)
  357. ax.set_xlim(0, 380)
  358. ax.set_ylim(0, 1.25)
  359. ax.set_xticks(np.arange(0, 381, 50))
  360. ticks = np.arange(0, 1.26, 0.25)
  361. ax.set_yticks(ticks[:-1])
  362. ax.legend(loc='lower left', fontsize=25, frameon=False)
  363. fig.tight_layout()
  364. fig.savefig(figure_dir / "figure-1d-sucrose-motor-speed.pdf", dpi=350, bbox_inches='tight')
  365. plt.close(fig)
  368. # %%
  369. def equalize_lists(data):
  370. if not data:
  371. return {}
  373. lengths = [len(v) for v in data.values()]
  374. if max(lengths) == 0:
  375. return {k: [] for k in data}
  377. max_length = max(lengths)
  378. return {
  379. k: v + [np.nan] * (max_length - len(v))
  380. for k, v in data.items()
  381. }
  383. # %%
  384. # Save per-cell fit parameters to intermediate CSVs in the output directory.
  385. # Downstream cells (tau/magnitude vs osmolarity) read from these files.
  386. new_tau_values = equalize_lists(tau_values)
  387. new_tau_inc_values = equalize_lists(tau_inc_values)
  388. new_t0_values = equalize_lists(t0_values)
  389. new_A_values = equalize_lists(A_values)
  391. csv_dir = outputDir
  392. pd.DataFrame(new_tau_values).to_csv( csv_dir / "sucrose_tau_values.csv")
  393. pd.DataFrame(new_tau_inc_values).to_csv(csv_dir / "sucrose_tau_inc_values.csv")
  394. pd.DataFrame(new_t0_values).to_csv( csv_dir / "sucrose_t0_values.csv")
  395. pd.DataFrame(new_A_values).to_csv( csv_dir / "sucrose_A_values.csv")
  397. print("tau_values :", tau_values)
  398. print("tau_inc_values:", tau_inc_values)
  399. print("t0_values :", t0_values)
  400. print("A_values :", A_values)
  403. # %%
  404. # Figure 1C – example single-motor trace (cell3, 500 mM sucrose) with inset
  405. # showing the normalised speed and the sigmoidal fit.
  406. # Corresponds to manuscript figure panel sucrose.pdf / Fig. 1C.
  408. # --- load the example trace ---------------------------------------------------
  409. example_row = None
  410. example_trace = None
  411. for row, trace in iter_condition_traces(assay="Sucrose", condition_mM=500):
  412. if row["cell_id"] == "cell3":
  413. example_row = row
  414. example_trace = trace
  415. break
  417. time_raw = example_trace["time_s"].to_numpy()
  418. freq_raw = example_trace["frequency_hz"].to_numpy()
  420. # --- plot settings ------------------------------------------------------------
  421. plt.rcParams.update({"font.size": 25, "font.family": "Arial"})
  422. fig, ax = plt.subplots(figsize=(10, 5.5))
  423. for axis in ["top", "bottom", "left", "right"]:
  424. ax.spines[axis].set_linewidth(2)
  425. ax.tick_params(axis="x", direction="in", labelsize=25, width=2, length=7.5, pad=8)
  426. ax.tick_params(axis="y", direction="in", labelsize=25, width=2, length=7.5, pad=8)
  428. # main trace (already mean-binned at 0.1 s in the parquet)
  429. ax.plot(time_raw, freq_raw)
  430. ax.set_xlabel("Time (s)", fontsize=25)
  431. ax.set_ylabel("Rotation Speed (Hz)", fontsize=25)
  432. ax.set_xticks(np.arange(0, 381, 50))
  433. ax.set_xlim(0, 370)
  434. ax.set_yticks(np.arange(0, 70, 10))
  435. ax.set_ylim(0, 70)
  436. ax.axvspan(180, 270, color="lightgray", alpha=0.6)
  438. # --- inset: normalised + filtered + fitted -----------------------------------
  439. inset_ax = plt.axes([0.19, 0.20, 0.29, 0.45])
  441. data_filt = signal.medfilt(freq_raw, kernel_size=median_kernel_size(time_raw, window_s=1.0))
  442. time_b, data_b = bin_data(time_raw, data_filt)
  443. data_norm = data_b / np.average(data_b[time_b <= 180])
  445. inset_ax.plot(time_b, data_norm, alpha=0.6)
  447. mask_dec = (time_b >= 175) & (time_b <= 240)
  448. time_dec = time_b[mask_dec]
  449. speed_dec = data_norm[mask_dec]
  451. global speed_initial, speed_final
  452. speed_initial = np.average(data_norm[(time_b >= 155) & (time_b <= 175)])
  453. speed_final = np.average(data_norm[(time_b >= 215) & (time_b <= 235)])
  455. popt_dec, _ = curve_fit(exp_decrease, time_dec, speed_dec, p0=[10, 10], bounds=(0, np.inf))
  456. tau_ex, t0_ex = popt_dec
  458. inset_ax.plot(time_dec, exp_decrease(time_dec, *popt_dec),
  459. "--", color="black", linewidth=2.25, label="Fit")
  461. # magnitude annotation (red vertical error bar)
  462. x_mag = 170
  463. y_mag_top = 1.05
  464. y_mag_bot = float(np.min(data_norm[(time_b >= 215) & (time_b <= 235)]))
  465. y_mag_mid = (y_mag_top + y_mag_bot) / 2
  466. inset_ax.errorbar([x_mag], [y_mag_mid],
  467. yerr=[(y_mag_top - y_mag_bot) / 2],
  468. marker="None", linestyle="None",
  469. ecolor="red", capsize=4, elinewidth=1.75, capthick=1.75)
  470. inset_ax.text(x_mag - 3, y_mag_mid, "Magnitude",
  471. ha="right", va="center", rotation=90, fontsize=25)
  473. # timescale annotation (purple horizontal error bar)
  474. x_inflect = 175 + t0_ex
  475. inset_ax.errorbar([x_inflect], [0.05], xerr=[6],
  476. marker="None", linestyle="None",
  477. ecolor="purple", capsize=4, elinewidth=1.75, capthick=1.75)
  478. inset_ax.text(x_inflect, 0.07, "Time", ha="center", va="bottom", fontsize=25)
  480. inset_ax.set_xlim(155, 245)
  481. inset_ax.set_ylim(-0.05, 1.15)
  482. inset_ax.axvspan(180, 270, color="lightgray", alpha=0.6)
  483. inset_ax.tick_params(which="both", direction="in")
  484. inset_ax.set_xticks([160, 200, 240])
  485. inset_ax.set_yticks([0, 0.5, 1.0])
  487. figure_dir = ROOT / "outputs" / "figure-panels"
  488. fig.savefig(figure_dir / "figure-1c-sucrose-example-trace.pdf", dpi=350, bbox_inches="tight")
  489. plt.close(fig)
  490. print("Saved figure-1c-sucrose-example-trace.pdf")
  493. # %%
  494. # Supplemental example trace – cell2 at 200 mM sucrose.
  495. # Single-cell quality check; matches the style used in the supplemental
  496. # individual-cells figure (sucros_individual-cells_all.pdf).
  498. for row, trace in iter_condition_traces(assay="Sucrose", condition_mM=200):
  499. if row["cell_id"] == "cell2":
  500. ex200_trace = trace
  501. break
  503. plt.rcParams.update({"font.size": 50, "font.family": "Arial"})
  504. fig, ax = plt.subplots(figsize=(20, 10))
  505. for axis in ["top", "bottom", "left", "right"]:
  506. ax.spines[axis].set_linewidth(10)
  507. ax.tick_params(axis="x", direction="in", labelsize=150, width=10, length=50, pad=8)
  508. ax.tick_params(axis="y", direction="in", labelsize=150, width=10, length=50, pad=8)
  510. ax.plot(ex200_trace["time_s"], ex200_trace["frequency_hz"], linewidth=6, color="blue")
  511. ax.set_xticks(np.arange(0, 381, 150))
  512. ax.set_xlim(0, 380)
  513. ax.set_yticks(np.arange(0, 90, 40))
  514. ax.set_ylim(0, 80)
  515. ax.axvspan(180, 270, color="lightgray", alpha=0.6)
  517. figure_dir = ROOT / "outputs" / "figure-panels"
  518. fig.savefig(figure_dir / "supplement-sucrose-example-cell-200mM.pdf", dpi=350, bbox_inches="tight")
  519. plt.close(fig)
  520. print("Saved supplement-sucrose-example-cell-200mM.pdf")
  523. # %%
  524. # Supplemental Figure – Viscosity-sucrose.pdf
  525. # 4 panels (A–D): per-concentration population-averaged normalised speed
  526. # with a dashed black line marking the estimated viscosity-driven speed reduction.
  528. viscosity_reduction = {200: 0.18, 300: 0.26, 400: 0.36, 500: 0.43}
  530. plt.rcParams.update({"font.size": 25, "font.family": "Arial"})
  531. fig, axes = plt.subplots(1, 4, figsize=(20, 5.5), sharey=True)
  533. for ax, (time_arr, mean_arr, conc) in zip(axes, zip(sorted_times, sorted_data, sorted_concentrations)):
  534. conc_i = int(conc)
  535. ax.plot(time_arr, mean_arr, linewidth=2)
  537. # dashed viscosity line: flat at (1 - reduction) during shock; 1.0 elsewhere
  538. visc_red = viscosity_reduction[conc_i]
  539. visc_level = 1.0 - visc_red
  540. t = np.asarray(time_arr)
  541. visc_line = np.where((t >= 180) & (t <= 270), visc_level, 1.0)
  542. ax.plot(t, visc_line, "--", color="black", linewidth=2)
  544. ax.axvspan(180, 270, color="lightgray", alpha=0.6)
  545. ax.set_xlim(0, 380)
  546. ax.set_ylim(0, 1.4)
  547. ax.set_xticks(np.arange(0, 381, 150))
  548. ax.set_xlabel("Time (s)", fontsize=25)
  549. ax.set_title(f"{conc_i} mM", fontsize=25)
  550. for spine in ["top", "bottom", "left", "right"]:
  551. ax.spines[spine].set_linewidth(2)
  552. ax.tick_params(direction="in", width=2, length=7.5)
  554. axes[0].set_ylabel("Rotation Speed (Normalised)", fontsize=25)
  555. fig.tight_layout()
  557. figure_dir = ROOT / "outputs" / "figure-panels"
  558. fig.savefig(figure_dir / "supplement-sucrose-viscosity.pdf", dpi=350, bbox_inches="tight")
  559. plt.close(fig)
  560. print("Saved supplement-sucrose-viscosity.pdf")
  563. # %%
  564. import os
  565. import numpy as np
  566. import matplotlib.pyplot as plt
  568. # -------------------------------
  569. # Global plot settings
  570. # -------------------------------
  571. plt.rcParams['font.family'] = 'Arial'
  572. plt.rcParams.update({'font.size': 25})
  574. # -------------------------------
  575. # Paths
  576. # -------------------------------
  577. save_root = ROOT / "outputs" / "bead" / "sucrose-individual-cells"
  578. os.makedirs(save_root, exist_ok=True)
  580. # -------------------------------
  581. # Loop through compact canonical traces
  582. # -------------------------------
  583. for row, trace in iter_condition_traces(assay="Sucrose"):
  584. fig, ax = plt.subplots(figsize=(20, 10))
  586. for axis in ['top','bottom','left','right']:
  587. ax.spines[axis].set_linewidth(10)
  589. ax.tick_params(axis='x', direction='in', labelsize=150, width=10, length=50, pad=8)
  590. ax.tick_params(axis='y', direction='in', labelsize=150, width=10, length=50, pad=8)
  592. ax.plot(trace["time_s"], trace["frequency_hz"], linewidth=6, color="blue")
  594. ax.set_xticks(np.arange(0, 381, 150))
  595. ax.set_xlim(0, 380)
  596. ax.set_yticks(np.arange(0, 90, 40))
  597. ax.set_ylim(0, 80)
  598. ax.axvspan(180, 270, color="lightgray", alpha=0.6)
  600. save_path = save_root / f"{row['condition_mM']}mM_{row['cell_id']}.pdf"
  601. plt.savefig(save_path, dpi=350)
  602. plt.close(fig)
  603. print(f"Saved figure: {save_path}")
  605. # %%
  606. # Supplemental Figure – tau decrease vs. change in osmolarity
  607. # (Panel A of sucros-time-charc.pdf / sfig:tau-sucro-increa-decrease).
  609. import openpyxl # noqa: F401 (ensure available; pandas uses it)
  611. osmo_excel = ROOT / "data" / "Osmolarity-readings" / "sucrose-old.xlsx"
  612. df_osmo = pd.read_excel(osmo_excel)
  613. df_osmo.columns = df_osmo.columns.str.strip().str.lower()
  614. osmotic_shock_values = df_osmo["change_in_osmolarity"].iloc[1:].values # skip baseline row
  615. concentrations_ordered = [200, 300, 400, 500]
  617. tau_means, tau_stds = [], []
  618. for c in concentrations_ordered:
  619. vals = [v for v in tau_values[str(c)] if not np.isnan(v)]
  620. tau_means.append(np.mean(vals))
  621. tau_stds.append(np.std(vals))
  623. plt.rcParams.update({"font.size": 30, "font.family": "Arial"})
  624. fig, ax = plt.subplots(figsize=(10, 5.5))
  625. for spine in ["top", "bottom", "left", "right"]:
  626. ax.spines[spine].set_linewidth(2)
  627. ax.tick_params(axis="x", direction="in", labelsize=30, width=2, length=7.5, pad=8)
  628. ax.tick_params(axis="y", direction="in", labelsize=30, width=2, length=7.5, pad=8)
  630. ax.errorbar(osmotic_shock_values, tau_means, yerr=tau_stds,
  631. marker="o", markeredgecolor="k", markersize=12,
  632. linestyle="None", color="black", ecolor="black", capsize=4)
  633. ax.set_xticks(osmotic_shock_values)
  634. ax.set_xlabel("Change in osmolarity (mOsmol/Kg)")
  635. ax.set_ylabel("Characteristic Time (s)")
  636. ax.set_xlim(80, 796.5)
  637. ax.set_ylim(-0.5, 6.5)
  638. ax.set_yticks([0, 1, 2, 3, 4, 5, 6])
  640. figure_dir = ROOT / "outputs" / "figure-panels"
  641. fig.savefig(figure_dir / "supplement-sucrose-tau-decrease.pdf", dpi=350, bbox_inches="tight")
  642. plt.close(fig)
  643. print("Saved supplement-sucrose-tau-decrease.pdf")
  646. # %%
  647. # Supplemental Figure – tau increase (recovery) vs. change in osmolarity
  648. # (Panel B of sucros-time-charc.pdf / sfig:tau-sucro-increa-decrease).
  650. osmo_excel = ROOT / "data" / "Osmolarity-readings" / "sucrose-old.xlsx"
  651. df_osmo = pd.read_excel(osmo_excel)
  652. df_osmo.columns = df_osmo.columns.str.strip().str.lower()
  653. osmotic_shock_values = df_osmo["change_in_osmolarity"].iloc[1:].values
  654. concentrations_ordered = [200, 300, 400, 500]
  656. tinc_means, tinc_stds = [], []
  657. for c in concentrations_ordered:
  658. vals = [v for v in tau_inc_values[str(c)] if not np.isnan(v)]
  659. tinc_means.append(np.mean(vals))
  660. tinc_stds.append(np.std(vals))
  662. plt.rcParams.update({"font.size": 30, "font.family": "Arial"})
  663. fig, ax = plt.subplots(figsize=(10, 5.5))
  664. for spine in ["top", "bottom", "left", "right"]:
  665. ax.spines[spine].set_linewidth(2)
  666. ax.tick_params(axis="x", direction="in", labelsize=30, width=2, length=7.5, pad=8)
  667. ax.tick_params(axis="y", direction="in", labelsize=30, width=2, length=7.5, pad=8)
  669. ax.errorbar(osmotic_shock_values, tinc_means, yerr=tinc_stds,
  670. marker="o", markeredgecolor="k", markersize=12,
  671. linestyle="None", color="black", ecolor="black", capsize=4)
  672. ax.set_xticks(osmotic_shock_values)
  673. ax.set_xlabel("Change in osmolarity (mOsmol/Kg)")
  674. ax.set_ylabel("Characteristic Time (s)")
  675. ax.set_xlim(185, 796.5)
  676. ax.set_ylim(-0.5, 6.5)
  677. ax.set_yticks([0, 1, 2, 3, 4, 5, 6])
  679. figure_dir = ROOT / "outputs" / "figure-panels"
  680. fig.savefig(figure_dir / "supplement-sucrose-tau-increase.pdf", dpi=350, bbox_inches="tight")
  681. plt.close(fig)
  682. print("Saved supplement-sucrose-tau-increase.pdf")
  685. # %%
  686. # Figure 1E - normalised speed reduction vs. change in osmolarity.
  687. # Red circles: total speed decrease (mean ± SD).
  688. # Green triangles + dashed green line: estimated viscosity-driven reduction.
  689. # Corresponds to manuscript panel sucrose.pdf / Fig. 1E.
  691. from scipy.stats import linregress
  693. osmo_excel = ROOT / "data" / "Osmolarity-readings" / "sucrose-old.xlsx"
  694. df_osmo = pd.read_excel(osmo_excel)
  695. df_osmo.columns = df_osmo.columns.str.strip().str.lower()
  696. osmotic_shock_values = df_osmo["change_in_osmolarity"].iloc[1:].values
  697. concentrations_ordered = [200, 300, 400, 500]
  699. A_means, A_stds = [], []
  700. for c in concentrations_ordered:
  701. vals = [v for v in A_values[str(c)] if not np.isnan(v)]
  702. A_means.append(np.mean(vals))
  703. A_stds.append(np.std(vals))
  705. viscosity_dict = {200: 0.18, 300: 0.26, 400: 0.36, 500: 0.43}
  706. viscosities = [viscosity_dict[c] for c in concentrations_ordered]
  708. plt.rcParams.update({"font.size": 25, "font.family": "Arial"})
  709. fig, ax = plt.subplots(figsize=(10, 5.5))
  710. for spine in ["top", "bottom", "left", "right"]:
  711. ax.spines[spine].set_linewidth(2)
  712. ax.tick_params(axis="x", direction="in", labelsize=25, width=2, length=7.5, pad=8)
  713. ax.tick_params(axis="y", direction="in", labelsize=25, width=2, length=7.5, pad=8)
  715. x_data = np.array(osmotic_shock_values)
  717. # total speed decrease
  718. ax.errorbar(x_data, A_means, yerr=A_stds,
  719. marker="o", markeredgecolor="k", markersize=12,
  720. linestyle="None", color="red", ecolor="black", capsize=4)
  722. slope, intercept, *_ = linregress(x_data, A_means)
  723. x_fit = np.linspace(x_data.min(), x_data.max(), 1000)
  724. ax.plot(x_fit, slope * x_fit + intercept, "--", color="black", linewidth=3,
  725. label="Total speed decrease")
  727. # viscosity estimate
  728. ax.errorbar(x_data, viscosities,
  729. marker="^", markeredgecolor="green", markersize=12,
  730. linestyle="None", color="green", ecolor="green", capsize=4)
  731. slope_v, intercept_v, *_ = linregress(x_data, viscosities)
  732. ax.plot(x_fit, slope_v * x_fit + intercept_v, "--", color="green", linewidth=3,
  733. label="Speed decrease due to\nchange in viscosity")
  735. ax.set_xticks(x_data)
  736. ax.set_xlabel("Change in osmolarity (mOsmol/Kg)")
  737. ax.set_ylabel("Speed Decrease (Normalised)")
  738. ax.set_xlim(185, 796.5)
  739. ax.set_ylim(-0.05, 1.15)
  740. ax.legend(loc="upper left", frameon=False)
  742. figure_dir = ROOT / "outputs" / "figure-panels"
  743. fig.savefig(figure_dir / "figure-1e-sucrose-speed-decrease.pdf", dpi=350, bbox_inches="tight")
  744. plt.close(fig)
  745. print("Saved figure-1e-sucrose-speed-decrease.pdf")
  747. # save stats
  748. diff_values = np.array(A_means) - np.array(viscosities)
  749. slope_d, intercept_d, r_d, p_d, err_d = linregress(x_data, diff_values)
  750. stats_path = outputDir / "sucrose_A_linear_fit_stats.txt"
  751. with open(stats_path, "w", encoding="utf-8") as f:
  752. f.write("Linear Fit -- Speed Decrease\n====================\n")
  753. f.write(f"Slope: {slope:.6f}\nIntercept: {intercept:.6f}\n\n")
  754. f.write("Linear Fit -- Viscosity\n====================\n")
  755. f.write(f"Slope: {slope_v:.6f}\nIntercept: {intercept_v:.6f}\n\n")
  756. f.write("Linear Fit -- Difference (Speed - Viscosity)\n====================\n")
  757. f.write(f"Slope: {slope_d:.6f}\nIntercept: {intercept_d:.6f}\nR2: {r_d**2:.6f}\n")
  758. print("Stats saved to", stats_path)
  761. # %%
  762. # Figure 1F – viscosity-corrected speed decrease vs. change in osmolarity.
  763. # Blue squares: (total speed decrease − viscosity estimate), mean ± SD.
  764. # Corresponds to manuscript panel sucrose.pdf / Fig. 1F.
  766. from scipy.stats import linregress
  768. osmo_excel = ROOT / "data" / "Osmolarity-readings" / "sucrose-old.xlsx"
  769. df_osmo = pd.read_excel(osmo_excel)
  770. df_osmo.columns = df_osmo.columns.str.strip().str.lower()
  771. osmotic_shock_values = df_osmo["change_in_osmolarity"].iloc[1:].values
  772. concentrations_ordered = [200, 300, 400, 500]
  774. A_means_20, A_stds_20 = [], []
  775. for c in concentrations_ordered:
  776. vals = [v for v in A_values[str(c)] if not np.isnan(v)]
  777. A_means_20.append(np.mean(vals))
  778. A_stds_20.append(np.std(vals))
  780. viscosity_dict = {200: 0.18, 300: 0.26, 400: 0.36, 500: 0.43}
  781. viscosities = [viscosity_dict[c] for c in concentrations_ordered]
  782. diff_values = np.array(A_means_20) - np.array(viscosities)
  784. plt.rcParams.update({"font.size": 25, "font.family": "Arial"})
  785. fig, ax = plt.subplots(figsize=(10, 5.5))
  786. for spine in ["top", "bottom", "left", "right"]:
  787. ax.spines[spine].set_linewidth(2)
  788. ax.tick_params(axis="x", direction="in", labelsize=25, width=2, length=7.5, pad=8)
  789. ax.tick_params(axis="y", direction="in", labelsize=25, width=2, length=7.5, pad=8)
  791. x_data = np.array(osmotic_shock_values)
  793. ax.errorbar(x_data, diff_values, yerr=A_stds_20,
  794. marker="s", markeredgecolor="blue", markersize=12,
  795. linestyle="None", color="blue", ecolor="blue", capsize=4)
  796. slope_d, intercept_d, *_ = linregress(x_data, diff_values)
  797. x_fit = np.linspace(x_data.min(), x_data.max(), 1000)
  798. ax.plot(x_fit, slope_d * x_fit + intercept_d, "--", color="blue", linewidth=3,
  799. label="Viscosity-corrected speed decrease")
  801. ax.set_xticks(x_data)
  802. ax.set_xlabel("Change in osmolarity (mOsmol/Kg)")
  803. ax.set_ylabel("Speed Decrease (Normalised)")
  804. ax.set_xlim(185, 796.5)
  805. ax.set_ylim(-0.05, 1.15)
  806. ax.legend(loc="upper left", frameon=False)
  808. figure_dir = ROOT / "outputs" / "figure-panels"
  809. fig.savefig(figure_dir / "figure-1f-sucrose-viscosity-corrected.pdf", dpi=350, bbox_inches="tight")
  810. plt.close(fig)
  811. print("Saved figure-1f-sucrose-viscosity-corrected.pdf")
  814. # %%
  815. # Supplemental Figure – combined sucrose + sorbitol viscosity-corrected speed decrease.
  816. # Corresponds to sucrose-sorb-combin-speed-decrease.pdf / sfig:tau-sorb-sucrose-combine.
  818. from scipy.stats import linregress
  819. from matplotlib.lines import Line2D
  821. # ---- sucrose data (already in memory) ----------------------------------------
  822. osmo_suc_xl = ROOT / "data" / "Osmolarity-readings" / "sucrose-old.xlsx"
  823. df_suc_osmo = pd.read_excel(osmo_suc_xl)
  824. df_suc_osmo.columns = df_suc_osmo.columns.str.strip().str.lower()
  825. sucrose_osmo = df_suc_osmo["change_in_osmolarity"].iloc[1:].values
  827. concs_suc = [200, 300, 400, 500]
  828. suc_means = [np.mean(A_values[str(c)]) for c in concs_suc]
  829. suc_stds = [np.std(A_values[str(c)]) for c in concs_suc]
  830. suc_visc = {200: 0.18, 300: 0.26, 400: 0.36, 500: 0.43}
  831. suc_diff = np.array(suc_means) - np.array([suc_visc[c] for c in concs_suc])
  833. # ---- sorbitol A values (compute from parquet) --------------------------------
  834. sorb_A_values = {200: [], 300: [], 400: [], 500: []}
  836. for conc_s in [200, 300, 400, 500]:
  837. for row_s, trace_s in iter_condition_traces(assay="Sorbitol", condition_mM=conc_s):
  838. t_s = trace_s["time_s"].to_numpy()
  839. f_s = trace_s["frequency_hz"].to_numpy()
  840. if len(f_s) == 0:
  841. continue
  842. if f_s[0] < 0:
  843. f_s = f_s * -1
  844. f_filt = signal.medfilt(f_s, kernel_size=median_kernel_size(t_s, window_s=1.0))
  845. t_b, f_b = bin_data(t_s, f_filt)
  846. # normalise
  847. baseline = np.average(f_b[t_b <= 180])
  848. if baseline == 0:
  849. continue
  850. f_norm = f_b / baseline
  851. # extract magnitude
  852. s_init = np.average(f_norm[(t_b >= 155) & (t_b <= 175)])
  853. s_fin = np.average(f_norm[(t_b >= 215) & (t_b <= 235)])
  854. A_sorb = s_init - s_fin
  855. if 0 < A_sorb < 2: # sanity filter
  856. sorb_A_values[conc_s].append(float(A_sorb))
  858. sorb_means = [np.mean(sorb_A_values[c]) for c in concs_suc]
  859. sorb_stds = [np.std(sorb_A_values[c]) for c in concs_suc]
  860. sorb_visc = {200: 0.14, 300: 0.20, 400: 0.26, 500: 0.32}
  861. sorb_diff = np.array(sorb_means) - np.array([sorb_visc[c] for c in concs_suc])
  863. # ---- sorbitol osmolarity -----------------------------------------------------
  864. osmo_sorb_xl = ROOT / "data" / "Osmolarity-readings" / "sorbitol.xlsx"
  865. df_sorb_osmo = pd.read_excel(osmo_sorb_xl)
  866. df_sorb_osmo.columns = df_sorb_osmo.columns.str.strip().str.lower()
  867. # find change_in_osmolarity or compute it
  868. if "change_in_osmolarity" in df_sorb_osmo.columns:
  869. sorbitol_osmo = df_sorb_osmo["change_in_osmolarity"].iloc[1:].values
  870. else:
  871. read_cols = [col for col in df_sorb_osmo.columns if "read" in col]
  872. df_sorb_osmo["avg_osmolarity"] = df_sorb_osmo[read_cols[:2]].mean(axis=1)
  873. df_sorb_osmo["change_in_osmolarity"] = (
  874. df_sorb_osmo["avg_osmolarity"] - df_sorb_osmo["avg_osmolarity"].iloc[0]
  875. )
  876. sorbitol_osmo = df_sorb_osmo["change_in_osmolarity"].iloc[1:].values
  878. # ---- plot --------------------------------------------------------------------
  879. plt.rcParams.update({"font.size": 25, "font.family": "Arial"})
  880. fig, ax = plt.subplots(figsize=(10, 5.5))
  881. for spine in ["top", "bottom", "left", "right"]:
  882. ax.spines[spine].set_linewidth(2)
  883. ax.tick_params(axis="x", direction="in", width=2, length=7.5, pad=8)
  884. ax.tick_params(axis="y", direction="in", width=2, length=7.5, pad=8)
  886. # sucrose
  887. ax.errorbar(sucrose_osmo, suc_diff, yerr=suc_stds,
  888. marker="s", markersize=12, linestyle="None",
  889. color="blue", ecolor="blue", capsize=4)
  890. sl_s, ic_s, *_ = linregress(sucrose_osmo, suc_diff)
  891. x_suc = np.linspace(sucrose_osmo.min(), sucrose_osmo.max(), 1000)
  892. ax.plot(x_suc, sl_s * x_suc + ic_s, "--", color="blue", linewidth=3)
  894. # sorbitol
  895. ax.errorbar(sorbitol_osmo, sorb_diff, yerr=sorb_stds,
  896. marker="^", markersize=12, linestyle="None",
  897. color="blue", ecolor="blue", capsize=4)
  898. sl_r, ic_r, *_ = linregress(sorbitol_osmo, sorb_diff)
  899. x_sor = np.linspace(sorbitol_osmo.min(), sorbitol_osmo.max(), 1000)
  900. ax.plot(x_sor, sl_r * x_sor + ic_r, ":", color="blue", linewidth=3)
  902. ax.set_xlabel("Change in osmolarity (mOsmol/Kg)")
  903. ax.set_ylabel("Speed Decrease (Normalised)")
  904. ax.set_ylim(-0.05, 1.15)
  905. ax.set_xlim(185, 800)
  906. ax.set_yticks(np.arange(0.0, 1.2, 0.2))
  907. ax.yaxis.set_major_formatter(plt.FuncFormatter(lambda y, _: f"{y:.1f}"))
  909. handles = [
  910. Line2D([0], [0], color="blue", marker="s", markersize=12,
  911. linestyle="--", linewidth=3, label="sucrose",
  912. markerfacecolor="blue", markeredgecolor="blue"),
  913. Line2D([0], [0], color="blue", marker="^", markersize=12,
  914. linestyle=":", linewidth=3, label="sorbitol",
  915. markerfacecolor="blue", markeredgecolor="blue"),
  916. ]
  917. ax.legend(handles=handles, loc="upper left", frameon=False)
  919. figure_dir = ROOT / "outputs" / "figure-panels"
  920. fig.savefig(figure_dir / "supplement-sucrose-sorbitol-combined.pdf", dpi=350, bbox_inches="tight")
  921. plt.close(fig)
  922. print("Saved supplement-sucrose-sorbitol-combined.pdf")
  923. print("sorbitol A values computed:", sorb_A_values)

sucrose_shock_analysis.ipynb at commit d14d0ca, no license · at the source

Overview

Authors: Luis Meneses1, Farhad Javi1, Eric M. Dudebout1, Sophia Belser2, Jinming Yang3, Navish Wadhwa1,4
ORCID iDs: Eric M. Dudebout, Navish Wadhwa
  1. Biodesign Center for Mechanisms of Evolution, Arizona State University, Tempe, AZ, USA
  2. Cavendish Laboratory, University of Cambridge, Cambridge, UK
  3. Department of Physics, Yale University, New Haven, CT, USA
  4. Center for Biological Physics and Department of Physics, Arizona State University, Tempe, AZ, USA
Institutions: Arizona State University (United States); University of Cambridge (United Kingdom); Yale University (United States)
Journal: Biophysical journal, volume 125, issue 11, pages 2618-2631
Dates: received 18 November 2025; accepted 14 April 2026; published online 21 April 2026; in print 2 June 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1016/j.bpj.2026.04.014 · PMID 42021485 · PMCID PMC13235824 · OpenAlex W7155039277
Open access: hybrid, a free copy (OpenAlex)
Status: code verified
Categories: cellular / molecular (subfield)
Methods: fMRI & imaging, Single-unit activity, calcium imaging
MeSH: Escherichia coli*, Osmotic Pressure*, Escherichia coli Proteins, Flagella (* major topic)
Topic: Bacterial Genetics and Biotechnology (Genetics, Biochemistry, Genetics and Molecular Biology), according to OpenAlex
Funding: NIGMS; NIH (R00GM134124); Arizona Biomedical Research Centre (RFGA2023-008-14)
Citations: cited by 1 paper (Europe PMC); 83 references in the paper

Abstract

The abstract is not reproduced here: the paper's license (CC BY-NC-ND) does not allow it. Read it in the paper, at the publisher or on Europe PMC.

Repository

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

wadhwalab/2026-Meneses-Osmotic

License: none: the authors keep all their rights
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Commit: d14d0caaa07299f13d1b1121d1e4630454fd724b, 4 May 2026
Languages: Python (7), Jupyter (3)
Size: 115 files, 10 scripts
Software Heritage: not archived
Found in: “Data availability”
Holds: README, environment (environment.yml, requirements.txt), tests, documentation, 3 notebooks
Not found: license file, CITATION.cff, continuous integration
Tools: NumPy (9 files), pandas (9 files), Matplotlib (8 files), SciPy (3 files), scikit-learn (2 files), seaborn (2 files)
Availability: 1 check, the latest on 29 September 2026: the link answers
  • 29 September 2026: the link answers
11 files
At the source: github.com/wadhwalab/2026-Meneses-Osmotic

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:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 10 scripts, each with its path and the digest of its content;
  • 10 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.

Code and data availability statement

The paper has a code and data availability statement. Its license (CC BY-NC-ND) does not allow reproducing it here; in short, from what the harvester recognized in it:

Read it in the paper: doi.org/10.1016/j.bpj.2026.04.014.

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, issue, pages, dates, 6 authors, 4 MeSH terms, 3 funders, 82 references.

Cite

This paper

Meneses, L., Javi, F., Dudebout, E. M., Belser, S., Yang, J., & Wadhwa, N. (2026). Osmotic stress triggers fast and reversible PMF collapse in Escherichia coli. Biophysical journal, 125(11), 2618-2631. https://doi.org/10.1016/j.bpj.2026.04.014

BibTeX

@article{meneses2026osmotic,
author = {Meneses, Luis and Javi, Farhad and Dudebout, Eric M. and Belser, Sophia and Yang, Jinming and Wadhwa, Navish},
title = {{Osmotic stress triggers fast and reversible PMF collapse in Escherichia coli}},
journal = {Biophysical journal},
year = {2026},
month = apr,
volume = {125},
number = {11},
pages = {2618--2631},
publisher = {The Biophysical Society},
issn = {0006-3495},
doi = {10.1016/j.bpj.2026.04.014},
url = {https://doi.org/10.1016/j.bpj.2026.04.014},
pmid = {42021485},
pmcid = {PMC13235824}
}

RIS

TY - JOUR
AU - Meneses, Luis
AU - Javi, Farhad
AU - Dudebout, Eric M.
AU - Belser, Sophia
AU - Yang, Jinming
AU - Wadhwa, Navish
TI - Osmotic stress triggers fast and reversible PMF collapse in Escherichia coli
T2 - Biophysical journal
J2 - Biophys J
PY - 2026
DA - 2026/04/21
VL - 125
IS - 11
SP - 2618
EP - 2631
SN - 0006-3495
PB - The Biophysical Society
DO - 10.1016/j.bpj.2026.04.014
UR - https://doi.org/10.1016/j.bpj.2026.04.014
LA - en
ER -

CSL-JSON

{
"id": "10.1016/j.bpj.2026.04.014",
"type": "article-journal",
"title": "Osmotic stress triggers fast and reversible PMF collapse in Escherichia coli",
"container-title": "Biophysical journal",
"author": [
{
"family": "Meneses",
"given": "Luis"
},
{
"family": "Javi",
"given": "Farhad"
},
{
"family": "Dudebout",
"given": "Eric M."
},
{
"family": "Belser",
"given": "Sophia"
},
{
"family": "Yang",
"given": "Jinming"
},
{
"family": "Wadhwa",
"given": "Navish"
}
],
"container-title-short": "Biophys J",
"volume": "125",
"issue": "11",
"page": "2618-2631",
"DOI": "10.1016/j.bpj.2026.04.014",
"PMID": "42021485",
"PMCID": "PMC13235824",
"ISSN": "0006-3495",
"publisher": "The Biophysical Society",
"URL": "https://doi.org/10.1016/j.bpj.2026.04.014",
"language": "en",
"issued": {
"date-parts": [
[
2026,
4,
21
]
]
}
}

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-71629-z
Extracellular K&lt;sup&gt;+&lt;/sup&gt; modulates the pore conformations of Cys-loop receptor anion channels.
Journal: Nature communications
In common: cellular / molecular, 1 reference

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.