State and parameter estimation for a neural model of local field potentials.

Code ↔ Paper

5 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 5 matches

[1] § Appendix B Robustness › B.2 Noise intensities ↔ NPF.ipynb, lines 381 to 457 · score 0.72 · state weights, particle ensemble, observation noise, intensities, inner, resampling · Report a mismatch
[2] § Problem setting and background › Background on particle filters and Bayesian estimation › Bayesian filtering ↔ NPF.ipynb, lines 235 to 352 · score 0.63 · weighted empirical, updated weights, positions, Gaussian, Particle filters · Report a mismatch
[3] § Problem setting and background › Background on particle filters and Bayesian estimation › Bayesian filtering ↔ NPF.ipynb, lines 381 to 457 · score 0.59 · stratified resampling, particle ensemble, threshold, weights, filtering · Report a mismatch
[4] § Appendix B Robustness › B.4 Tukey window ↔ NPF.ipynb, lines 226 to 233 · score 0.53 · Tukey window, tapering fraction · Report a mismatch
[5] § Nested particle filter for the Radon transformed cortical data › Results ↔ NPF.ipynb, lines 226 to 233 · score 0.51 · tapering fraction, Tukey window · Report a mismatch

Paper

Loaded from Europe PMC by your browser; OSCR does not store it: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The paper is loaded by your browser, with JavaScript: read it at doi.org or on Europe PMC.

The authors' code

Jupyter notebook · 574 lines · 17 KB · CC-BY-SA-4.0 · 5 matches

# %% [markdown]
# ##### Import libraries
# %%
import numpy as np
import matplotlib.pyplot as plt
import numpy.random as npr
from math import *
from numpy.fft import ifft,fft,ifftshift,fftshift,rfft,rfftfreq
from numba import jit, njit, prange, objmode, vectorize
from scipy.ndimage import maximum_filter
from scipy.signal.windows import tukey
from scipy.sparse import csr_matrix, random
from scipy.integrate import solve_ivp
from skimage.transform import radon
# %% [markdown]
# ##### Matplotlib settings
# %%
plt.style.use('classic')
plt.rc('xtick', labelsize=8)
plt.rc('ytick', labelsize=8)
plt.rc('axes', labelsize=8)
plt.rc('legend', handlelength=1.0)
plt.rc('axes', titlesize=8)
plt.rc('figure', dpi=400)
plt.rc('lines', linewidth=0.5)
plt.rc('font',**{'family':'serif','serif':['Arial']})
plt.rcParams['axes.spines.top'] = False
plt.rcParams['axes.spines.right'] = False
plt.rcParams['ytick.right']=False
plt.rcParams['xtick.top']=False
plt.rcParams['text.usetex']= False
# %%
Figure_dir='Figures/'
# %% [markdown]
# ##### Helping functions
# %%
# functions for frequency extractions
# numba versions of functions
@njit(fastmath=True)
def numba_sum(arr):
return np.sum(arr)
@njit(fastmath=True)
def numba_mean(x):
return np.mean(x)
@njit(fastmath=True)
def numba_mean_2(x):
'''mean of 2D array along first dimension'''
with objmode(out='float64[:]'):
out=np.mean(x,axis=0)
return out
@njit(fastmath=True)
def numba_mean_3(x):
'''mean of 3D array along the two first dimensions'''
with objmode(out='float64[:]'):
out=np.mean(x,axis=(0,1))
return out
@njit(fastmath=True)
def numba_std(x):
return np.std(x)
@njit(fastmath=True)
def numba_std_2(x):
'''Standard deviation of 2D array along first dimension'''
with objmode(out='float64[:]'):
out=np.std(x,axis=0)
return out
@njit(fastmath=True)
def numba_std_3(x):
'''Standard deviation of 3D array along the two first dimension'''
with objmode(out='float64[:]'):
out=np.std(x,axis=(0,1))
return out
def get_Power(sig,dt):
sig_=sig-np.mean(sig)
fft_=np.fft.rfft(sig_)
freqs=np.fft.rfftfreq(len(sig_), d=dt)
Ny=(2*dt)/len(sig_)
P=Ny*np.real(fft_*np.conj(fft_))
return freqs, P
@njit(fastmath=True)
def numba_random(N):
noise = np.empty(N,dtype=np.float64)
for i in prange(N):
noise[i] = npr.random()
return noise
@njit(parallel=True,fastmath=True)
def noise_2d(n,m):
noise = np.empty((n,m),dtype=np.float64)
for i in prange(n):
for j in range(m):
noise[i,j] = np.random.normal()
return noise
@njit
def seed(a):
np.random.seed(a)
@njit
def numba_ifft(arr):
'''1D ifft'''
with objmode(out='complex128[:]'):
out = np.fft.ifft(arr)
return out
@njit
def numba_ifft2(arr):
'''2D ifft'''
with objmode(out='complex128[:,:]'):
out = np.fft.ifft(arr)
return out
@njit
def numba_fft(arr):
'''1D fft'''
with objmode(out='complex128[:]'):
out = np.fft.fft(arr)
return out
@njit
def numba_fft2(arr):
'''2D fft'''
with objmode(out='complex128[:,:]'):
out = np.fft.fft(arr)
return out
# %% [markdown]
# ##### LFP
# %% [markdown]
# ###### Fetch data
# %%
data_dir=''
R7_A4=
# %%
''' the dataset used in the paper is called 'R7_A4', it is a dictionary with the following relevant keys:
-'Pos_ch': an array of shape (n_channels,2), give the (x,y) positions of each channel in the 2D grid
-'vsdi_cut': an array of shape (n_channels, time): contains the timeseries of neural activity at each channel
-'REM_0','REM_1','SWS_0' and 'SWS_1': the indices of the start and end of sws and rem stages (Undefined--> SWS--> REM)'''
# %%
#mapping channels to grid
@njit(fastmath=True)
def Square_data(data,channels,Z):
'''maps channels to grid: data is 'vsdi_cut' of shape (channels,time), channels is 'Pos_ch',
Z is a buffer for the output array of shape (time,x,y)'''
for i in prange(len(channels)):
m,n=channels[i]-1
Z[:,m,n]=data[i]
return Z
# %%
Z=np.zeros((R7_A4['vsdi_cut'].shape[1],len(R7_A4['X']),len(R7_A4['Y'])))
data=Square_data(R7_A4['vsdi_cut'],R7_A4['Pos_ch'],Z)
# %%
#get dimensions of measurements (n_t,n_x,ny, dt), sleep stages indices...
t4_sws=20000 #R7_A4['SWS_0']
t4_rem=40533 #R7_A4['REM_0']
# %% [markdown]
# ###### Radon transform
# %%
#angles range, discretisation step
angles=np.arange(0,180,15)
data_r=np.array(list(map(lambda x: radon(x, theta=angles,preserve_range=True,circle=False),data)))
# %%
def get_obs(sig,idx):
'''gets the transformed signal for angles[idx] and removes the extra zero-padding from the radon transform'''
sig=sig[:,:,idx]
obs=sig[:, ~np.all(sig == 0, axis=0)]
return np.hstack([np.zeros((len(obs),1)),obs,np.zeros((len(obs),1))])
# %% [markdown]
# ##### Evolution model
# %%
#Fixed parameters appearing in Table 1
tau_=0.03 #time constant
lambda_,mu=5,0.5 #sigmoid steepness and theshold
A_ex, A_in, l_ex, l_in=10, 6, .5, 1. #synaptic kernel parameters
# %%
@njit(fastmath=True)
def sigmoid_(u,l=lambda_,mu=mu):
x=l*(u-mu)
return 1. / (1 + np.exp(-x))
@njit(fastmath=True)
def w(x,y,a=A_ex,b=l_ex,c=A_in,d=l_in):
z=(x-y)**2
return a*np.exp(-z/(l_ex**2))-c*np.exp(-z/(l_in**2))
@njit(fastmath=True)
def I_trav(x,t,A,nu,f):
'''Space time traveling wave with amplitude A, spatial frequency nu and temporal frequency f'''
return A*np.cos(2*pi*(nu*x-f*t))
# %% [markdown]
# ##### Observation model
# %%
#Tukey window
beta_=0.5 #tapering fraction
def get_TW(J,taper=beta_):
return tukey(J,beta_)
# %% [markdown]
# ##### Nested particle filter
# %%
SQRT_2PI = np.sqrt(2 * np.pi)
@jit(nopython=True, parallel=True)
def normals(x, means, sds):
'''Gaussian PDF evaluated at x'''
result = np.exp(-0.5*((x - means)/sds)**2)
return (1 / (sds * SQRT_2PI)) * result
@njit(fastmath=True,parallel=True)
def likelihood_obs(obs, particles, std):
"""Calculates likelihoods assuming Gaussian observational noise."""
#obs (J,) particles (M,J)
M=particles.shape[0]
d=np.empty((M,))
for i in prange(M):
d[i] = np.sqrt((obs- particles[i])@(obs- particles[i]).T)
return normals(0,d,std)
#likelihood before normalisation
@njit(fastmath=True)
def update_Nest(obs,particles,weights,R,M):
''' returns updated weights for U and likelihood of parameter theta'''
likeli_U=likelihood_obs(obs,particles,R)
weights *= likeli_U
weights += 1.e-300
likeli_theta=(1./M)*numba_sum(weights)
# avoid round-off to zero
weights /= numba_sum(weights)
likeli_theta+=1.e-300
return weights,likeli_theta
@njit(fastmath=True)
def get_truncN(mean,std,A,B):
'''One sample from truncated normal'''
out=mean+std*npr.normal()
while not ((out<=B)&(out>=A)):
out=mean+std*npr.normal()
return out
@njit(fastmath=True)
def jitter(theta,N,theta_range_sq,theta_range):
'''Jitters a single parameter particle using a truncated normal kernel'''
#theta_range_sq is sqrt(range(theta))
eps=1./sqrt(N)
u=npr.rand()
if u<=(1-eps):
return theta
else:
for i in range(len(theta)):
std_i=theta_range_sq[i]/(N**0.75)
theta[i]=get_truncN(theta[i],std_i,theta_range[i][0],theta_range[i][1])
return theta
@njit(fastmath=True)
def estimate(particles,weights):
w=numba_sum(weights)
mean=np.sum(np.multiply(weights[:,np.newaxis],particles),axis=0)
var=np.sum(np.multiply(weights[:,np.newaxis],(particles-mean)**2),axis=0)
return mean/w, var/w
@njit(fastmath=True)
def estimate_p(particles,weights):
'''Weighted empirical mean of parameters'''
return particles.T@weights
@njit(fastmath=True)
def estimate_u(particles,weights_p,weights_u):
'''Weighted empirical mean of state'''
wpu=weights_p[:,np.newaxis]*weights_u
return np.average(particles,weights=wpu,axis=(0,1))
@njit(fastmath=True)
def Neff(weights):
'''Estimates the effective number of particles'''
return 1. / (weights@weights.T)
@njit(fastmath=True)
def stratified_resample(weights):
N = len(weights)
# make N subdivisions, chose a random position within each one
positions = (numba_random(N) + np.arange(N)) / N
indexes = np.zeros(N, 'i')
cumulative_sum = np.cumsum(weights)
i, j = 0, 0
while i < N:
if positions[i] < cumulative_sum[j]:
indexes[i] = j
i += 1
else:
j += 1
return indexes
@njit(fastmath=True)
def resample(particles, indexes):
particles[:] = particles[indexes]
return particles
@njit(fastmath=True)
def get_GP_U(M,x):
'''M samples from GP prior for the state'''
mx=np.zeros_like(x) #GP mean
K=np.zeros((len(x),len(x)))
for i in range(len(x)):
for j in range(i,len(x)):
k_=2*np.exp(-0.5*(x[i]-x[j])**2) #covariance function
K[i][j]=k_
K[j][i]=k_
with objmode(out='float64[:,:]'):
out = np.random.multivariate_normal(mx,K,M)
return out
# %%
@njit(fastmath=True)
def predict_U(particles,W,l,mu,to_dt,x,J,q,M,t_n,params):
'''performs one prediction step for the state ensemble associated to the parameter particle params'''
A,nu,f=params
particles+=to_dt*(-particles+I_trav(x,t_n,A,nu,f)+(W@sigmoid_(particles,l,mu).T).T)+q*noise_2d(M,J)
return particles
# %%
@njit(fastmath=True,parallel=True)
def inner_filter(N,M,n,Y_n,w_u,w_p,Ny,x, J,G, t_n,W,to_dt,l,mu,theta_range, theta_range_Sq, particles_all, theta_parts,q,R):
'''for each parameter particle, the function jitters it then conditional on the jittered particle, it performs state ensemble prediction,
update and potentially resampling if the effective number of particles is below a threshold'''
for i in prange(N):
theta=theta_parts[i]
#jitter
theta_=jitter(theta,N,theta_range_Sq,theta_range)
theta_parts[i]=theta_
particles_all[i]=G*predict_U(particles_all[i],W,l,mu,to_dt,x,J,q,M,t_n,theta_)
# print(likelihood_obs(Y_n,U_,R).max())
w_u[i],w_p[i]=update_Nest(Y_n,particles_all[i],w_u[i],R,M)
if Neff(w_u[i])<M/2:
indexes = stratified_resample(w_u[i])
particles_all[i]=resample(particles_all[i], indexes)
w_u[i]=(1/M)*np.ones((M,))
return particles_all,theta_parts,w_u,w_p
# %%
def Nested(N,M,obs,t,Ny, G,J, dt,x,W,to_dt,l,mu,theta_range, theta_range_Sq, particles_all, theta_parts,q,R):
'''Loops over observations and saves estimated means and std of parameters and state
parameters
----------
N,M:int
Numbers of parameter and state partcles
Ny:int
number of observations
J:int
size of each observation vector
obs:np.ndarray
Array of observations of shape (Ny+1,J)
t:np.ndarray
Temporal grid of shape(Ny+1,)
dt,to_dt:float
to_dt=dt/tau where tau is the time constant
G:int or np.ndarray
Observation operator
x:np.ndarray
Spatial grid of shape (J,)
l,mu:float
Sigmoid steepness and threshold
theta_range, theta_range_Sq:np.ndarray
Prior range of theta and its square root, shape (dim_theta,2)
particles_all:np.ndarray
Ensembles of state particles sampled from the prior, of shape (N,M,J)
theta_parts:
Ensemble of parameter particles sampled from the prior, of shape (N,dim_theta)
q,R:float
intensities of process and observation noises
'''
dim_theta=theta_range.shape[0] #number of parameters to be inferred
Ess=-np.ones((Ny+1,)) #effective sample size
theta_hist=np.empty((Ny+1,2,dim_theta)) #container for mean and std of parameters
U_hist=np.empty((Ny+1,J)) #container for estimated mean of state
w_u=(1/M)*np.ones((N,M)) #state weights
w_p=(1/N)*np.ones((N,)) #parameter weights
U_hist[0]=np.mean(particles_all,axis=(0,1)) #initializing the state estimated mean
theta_hist[0,0]=np.mean(theta_parts,axis=0) #initializing the parameters estimated mean
theta_hist[0,1]=np.std(theta_parts,axis=0) #initializing the parameters estimated std
for n in range(0,Ny):
Y_n=obs[n+1]
t_n=t[n+1]
particles_all,theta_parts,w_u,w_p=inner_filter(N,M,n,Y_n,w_u,w_p,Ny,x, J,G, t_n,W,to_dt,l,mu,theta_range, theta_range_Sq, particles_all, theta_parts,q,R)
w_p /= numba_sum(w_p)
w_p+=1.e-300
#visualizing particle ensemble each 100 time step
if n%100==1:
fig,axs=plt.subplots(1,3,figsize=(12,3))
axs[0].scatter(theta_parts[:,0],theta_parts[:,2],c='k',marker='.',s=0.3)
axs[0].set_xlabel('A')
axs[0].set_ylabel('f')
axs[1].scatter(theta_parts[:,1],theta_parts[:,2],c='k',marker='.',s=0.3)
axs[1].set_xlabel(r'$\nu$')
axs[1].set_ylabel('f')
axs[2].scatter(theta_parts[:,0],theta_parts[:,1],c='k',marker='.',s=0.3)
axs[2].set_xlabel('A')
axs[2].set_ylabel(r'$\nu$')
plt.show()
#resampling the ensembles according to parameters weights
if Neff(w_p)<N/2:
Ess[n+1]=Neff(w_p)
indexes = stratified_resample(w_p)
particles_all=resample(particles_all, indexes)
theta_parts=resample(theta_parts,indexes)
w_p=(1/N)*np.ones((N,))
#estimation of mean/std for parameters and mean for state
U_hist[n+1]=numba_mean_3(particles_all)
# =np.average(particles_all,weights=w_p[:,np.newaxis]*w_u,axis=(0,1))
# theta_mean=
theta_hist[n+1,0]=theta_parts.T@w_p #use theta_hist[n+1,0]=numba_mean_2(theta_parts) for 1/N weights
theta_hist[n+1,1]=numba_std_2(theta_parts)
return theta_hist,U_hist,Ess
# %% [markdown]
# ##### Synthetic test
# %%
@njit(fastmath=True)
def I_chirp(x,t,A,nu,f,ax):
return A*np.cos(2*pi*(nu*x-f*t-ax*t**2))
# %%
L=10 #spatial domain [0,L]
Mx=500
Dx=L/Mx
x_grid=np.arange(0,L+Dx,Dx)
T=100 #final time
Nt=20000
Dt=T/Nt
t_grid=np.arange(0,T+Dt,Dt)
u0=np.sin(pi*x_grid)
to_Dt=Dt/tau_ #dt/tau
W0=Dx*w(x_grid[:,None],x_grid,10,4,6,1) #synaptic connections matrix
W0[:,0]*=0.5 #weights for trapezium
W0[:,-1]*=0.5
A0,nu0,f0,ax=1,0.1,0.5,-0.005 #true parameters
# %%
u_hist=np.empty((Nt+1,Mx+1))
u_hist[0]=np.copy(u0)
u=np.copy(u0)
for n in range(Nt):
u+=to_Dt*(-u+W0@sigmoid_(u)+I_chirp(x_grid,t_grid[n],A0,nu0,f0,ax))
u_hist[n+1,:]=u
# %%
plt.imshow(u_hist,aspect='auto')
# %%
#generate noisy observations
J=30
Ny= Nt//2#
t= np.linspace(0,T,Ny+1)#time domain of the observations and inference
x=np.linspace(0,L,J) #spatial domain of the observations and inference
dt,dx=t[1],x[1]
to_dt=dt/tau_
Ys=np.array(list(map(lambda U: np.interp(t,t_grid,U),u_hist.T))).T #interpolation of u_hist on the temporal domain
Ys=np.array(list(map(lambda U: np.interp(x,x_grid,U),Ys)))
eps=0.5
Ys+=eps*npr.randn(Ny+1,J) #adding noise
# %%
plt.imshow(Ys,aspect='auto')
# %% [markdown]
# ##### Run inference
# %%
W=dx*w(x[:,np.newaxis],x) #connection matrix used for the inference, different from W0 used to generate the observations
W[:,0]*=0.5
W[:,-1]*=0.5
N=500#number of parameter particles
M=500 #number of state particles for each parameter particle
theta_range=np.array([[0,10],[0,1],[0,1]]) #range of the prior for theta
theta_range_Sq=np.array([10,2,2])*np.sqrt(np.abs(theta_range[:,1]-theta_range[:,0])) #square root of the range multiplied by constants of the magnitude of each parameter range, used in jittering
theta_parts=np.empty((N,len(theta_range)))
for i in range(len(theta_range)):
theta_parts[:, i] = npr.uniform(theta_range[i][0], theta_range[i][1], size=N)
#theta_parts[:, i] = npr.normal(means[i], std, size=N) can be used to generate gaussian priors istead
particles_all=np.empty((N,M,J))
for i in range(N):
particles_all[i]=get_GP_U(M,x)
# %%
q=.1
R=.5
G=1 #no observation matrix, change this to Tukey window if running for LFP data
ps,us,ess=Nested(N,M,Ys,t,5, G,J, dt,x,W,to_dt,lambda_,mu,theta_range, theta_range_Sq, particles_all, theta_parts,q,R)
# %%
mm=ps1[:,0]
std_2=2*ps1[:,1]
v0=[A0,nu0,f0]
v1=[0,0,ax]
labels_params=['A',r'$\nu$','f']
for i in range(3):
fig=plt.figure(figsize=(4,3))
plt.plot(t,mm[:,i])
plt.plot(t,v0[i]+v1[i]*t[:-1],'r-')
plt.fill_between(x=t,y1=mm[:,i]+std_2[:,i],y2=mm[:,i]-std_2[:,i],color='skyblue')
plt.ylabel(labels_params[i],fontsize=10,rotation=0,labelpad=8)
plt.xticks(np.arange(min(t), max(t)+1, 20))
plt.xlabel('Time (s)')
# %% [markdown]
# ##### Postprocessing
# %%
def get_stats(theta_runs):
'''calculates the combined empirical mean, std and variances from multiple runs'''
#theta_runs has shape (N_runs, time,2,dim_theta), where the third dimension contains the mean and std of each run
means = theta_runs[:,:,0,:] # (N_runs, T)
stds = theta_runs[:,:,1,:] # (N_runs, T)
mu_combined = means.mean(axis=0) # (T,)
var_within = (stds**2).mean(axis=0) # (T,)
var_between = ((means - mu_combined)**2).mean(axis=0) # (T,)
std_combined = np.sqrt(var_within + var_between)
return mu_combined, var_within,var_between,std_combined
# %%
#Figures
# %%
# %%

NPF.ipynb, under CC-BY-SA-4.0 · at the source

Overview

Authors: Daniele Avitabile^1,2, Gabriel J Lord³, Khadija Meddouni³

ORCID iDs: Khadija Meddouni

Institutions: Institut national de recherche en sciences et technologies du numérique (France); Academic Center for Dentistry Amsterdam (Netherlands); Radboud University Nijmegen (Netherlands)

Journal: Journal of mathematical biology, volume 93, issue 4, article 52

Dates: received 1 December 2025; accepted 28 July 2026; published online 3 October 2026; in print 2026

Type: Research article · Language: English

License: CC BY

Identifiers: DOI 10.1007/s00285-026-02451-w · PMID 42828681 · PMCID PMC13634030 · OpenAlex W7114809393

Open access: hybrid, a free copy (OpenAlex)

Preprint: arxiv:2512.07842

Status: code verified (how the code is found and verified)

Categories: extracellular electrophysiology (units, LFP) (modality), mouse (organism), computational (subfield)

Keywords: Wilson–Cowan–Amari model, Bayesian inference, Particle filters, Local field potential, Parameter estimation

MeSH: Models, Neurological*, Animals, Bayes Theorem, Cerebral Cortex, Computer Simulation, Local Field Potential Measurement, Mathematical Concepts, Mice, Neurons, Sleep (* major topic)

Topic: Neural dynamics and brain function (Cognitive Neuroscience, Neuroscience), according to OpenAlex

Citations: not cited yet (Europe PMC); 48 references in the paper

Abstract

The study of cortical dynamics during different states such as decision making, sleep and movement, is an important topic in Neuroscience. Modelling efforts aim to relate the neural rhythms present in cortical recordings to the underlying dynamics responsible for their emergence. We present an effort to capture certain features of the neural activity from the cortex of a mouse during natural sleep, obtained through local field potential measurements. Our approach relies on using a discretized Wilson–Cowan Amari neural field model for neural activity, along with a data assimilation method that allows the Bayesian joint estimation of the state and parameters. We demonstrate the feasibility of our approach on synthetic measurements before applying it to a dataset available in literature. Our findings suggest the potential of our approach to characterize the parameters of the external forcing in the neural activity model, while simultaneously inferring a state that aligns with the observed signal.

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

Repository

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

Zenodo 21795156

License: CC-BY-SA-4.0

State: the link answers, verified on 6 October 2026

Evidence: files inventoried

Languages: Jupyter (1)

Size: 1 file, 1 script

Software Heritage: not checked

Found in: “Code availability”

Holds: 1 notebook

Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation

Tools: Matplotlib (1 file), Numba (1 file), NumPy (1 file), scikit-image (1 file), SciPy (1 file)

Availability: 1 check, the latest on 6 October 2026: the link answers (HTTP 200)

6 October 2026: the link answers (HTTP 200)

1 file

NPF.ipynb, Jupyter, 574 lines, 5 matches

At the source: doi.org/10.5281/zenodo.21795156

Code availability

A repository with codes is available at https://doi.org/10.5281/zenodo.21795156.

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

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;
1 script, each with its path and the digest of its content;
5 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 availability

Imaging data used in this work have been deposited in the Donders Repository https://doi.org/10.34973/2w2s-tg07.

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

Versions

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

Version 1, 6 October 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 3 authors, 5 keywords, 10 MeSH terms, 30 references.

Cite

This paper

Avitabile, D., Lord, G. J., & Meddouni, K. (2026). State and parameter estimation for a neural model of local field potentials. Journal of mathematical biology, 93(4), 52. https://doi.org/10.1007/s00285-026-02451-w

BibTeX

@article{avitabile2026state, author = {Avitabile, Daniele and Lord, Gabriel J and Meddouni, Khadija}, title = {{State and parameter estimation for a neural model of local field potentials}}, journal = {Journal of mathematical biology}, year = {2026}, month = oct, volume = {93}, number = {4}, pages = {52}, publisher = {Springer Science+Business Media}, issn = {0303-6812}, doi = {10.1007/s00285-026-02451-w}, url = {https://doi.org/10.1007/s00285-026-02451-w}, pmid = {42828681}, pmcid = {PMC13634030} }

RIS

TY - JOUR AU - Avitabile, Daniele AU - Lord, Gabriel J AU - Meddouni, Khadija TI - State and parameter estimation for a neural model of local field potentials T2 - Journal of mathematical biology J2 - J Math Biol PY - 2026 DA - 2026/10/03 VL - 93 IS - 4 SP - 52 SN - 0303-6812 PB - Springer Science+Business Media DO - 10.1007/s00285-026-02451-w UR - https://doi.org/10.1007/s00285-026-02451-w LA - en ER -

CSL-JSON

{ "id": "10.1007/s00285-026-02451-w", "type": "article-journal", "title": "State and parameter estimation for a neural model of local field potentials", "container-title": "Journal of mathematical biology", "author": [ { "family": "Avitabile", "given": "Daniele" }, { "family": "Lord", "given": "Gabriel J" }, { "family": "Meddouni", "given": "Khadija" } ], "container-title-short": "J Math Biol", "volume": "93", "issue": "4", "page": "52", "DOI": "10.1007/s00285-026-02451-w", "PMID": "42828681", "PMCID": "PMC13634030", "ISSN": "0303-6812", "publisher": "Springer Science+Business Media", "URL": "https://doi.org/10.1007/s00285-026-02451-w", "language": "en", "issued": { "date-parts": [ [ 2026, 10, 3 ] ] } }

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

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.

Add the badge to the code's README

If you are an author or a maintainer of this paper's code, you can add this badge. It says what OSCR knows of the paper (its code, its validated tracing map) and links the code to this page. Paste one of these snippets under the README's title. Keep the two marks around it, so that the badge can be replaced in place and is never added twice. OSCR changes nothing in your repository.

Markdown

<!-- oscr-badge:start -->
[![OSCR](https://openscicode.org/badge/doi/10.1007/s00285-026-02451-w.svg)](https://openscicode.org/badge/doi/10.1007/s00285-026-02451-w)
<!-- oscr-badge:end -->

reStructuredText

.. oscr-badge:start

.. image:: https://openscicode.org/badge/doi/10.1007/s00285-026-02451-w.svg
   :target: https://openscicode.org/badge/doi/10.1007/s00285-026-02451-w
   :alt: OSCR

.. oscr-badge:end

HTML

<!-- oscr-badge:start -->
<a href="https://openscicode.org/badge/doi/10.1007/s00285-026-02451-w"><img src="https://openscicode.org/badge/doi/10.1007/s00285-026-02451-w.svg" alt="OSCR"></a>
<!-- oscr-badge:end -->

If you choose to, you can have the badge kept up to date for you, with oscr badge --write from the command line or with the GitHub Action in your repository's workflows. Every other form and option (a card, AsciiDoc, LaTeX, shields.io) is on the badge 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: code errors and mismatches between the code and the paper about this paper and its code, from readers and its authors, beside the paper and its tracing map.

Report a mismatch between the code and the paper · Report a code error (signed in)

Reproductions: reports from readers who ran the authors' code and did not get the paper's result, what they ran, with which environment, commit and data.

Report a reproduction failure (signed in)

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

State and parameter estimation for a neural model of local field potentials.

Code ↔ Paper

Paper

The authors' code

Overview

Abstract

Repository

Zenodo 21795156

Code availability

Tracing map

Data

Data availability

Versions

Version 1, 6 October 2026: the first record

Cite

This paper

Similar papers

Contribute

Claim this paper

Correct its record

Validate its tracing map

Add the badge to the code's README

Request its removal

Discussion, reproductions, activity