def test_fit_2_sigmas(sigmas=[0.01, 0.03],
n_tracks=5000,
D_free=0.1,
plot=False):
"""
Simulate confined state
"""
sim1 = simulate.tracks(n_tracks=n_tracks,
D_free=D_free,
loc_error=sigmas[0],
use_tqdm=False)
sim2 = simulate.tracks(n_tracks=n_tracks,
D_free=D_free,
loc_error=sigmas[1],
use_tqdm=False)
sim = sim1 + sim2
fit_2_sigmas = fit2.fit_spoton_2_0(
sim,
D=[0, 0.0, 0.1],
F=[0.3, 0.3, 0.4],
fit_D=[False, False, True],
fit_F=[1, 1, 1],
sigma=[0.01, 0.04],
fit_sigma=[True, True],
n_bins=100,
dt=0.06,
n_lags=3,
plot=plot,
)
fit_1_sigmas = fit2.fit_spoton_2_0(
sim,
D=[0, 0.1],
F=[0.3, 0.7],
fit_D=[False, True],
fit_F=[1, 1],
sigma=[0.01],
fit_sigma=[True, True],
n_bins=100,
dt=0.06,
n_lags=3,
plot=plot,
)
for s, S in zip(sigmas, fit_2_sigmas["sigma"]):
np.testing.assert_almost_equal(S, s, 2)
assert fit_1_sigmas["chi2_norm"] > fit_2_sigmas["chi2_norm"]
return fit_2_sigmas
def test_get_switching_matrix(num_tracks=1000,
p_binding=0.01,
p_unbinding=0.1):
tracks = simulate.tracks(
num_tracks=num_tracks,
p_binding=p_binding,
p_unbinding=p_unbinding,
use_tqdm=False,
)
switching_matrix = switch.get_switching_matrix(tracks,
column="free",
n_states=2)
assert switching_matrix.shape == (2, 2)
np.testing.assert_almost_equal(switching_matrix[1, 0],
p_binding,
decimal=abs(
np.log10(p_binding).astype(int)))
np.testing.assert_almost_equal(
switching_matrix[0, 1],
p_unbinding,
decimal=abs(np.log10(p_unbinding).astype(int)),
)
switching_matrix, raw_matrix = switch.get_switching_matrix(
tracks, column="free", n_states=2, return_raw_counts=True)
assert raw_matrix.shape == (2, 2)
with pytest.raises(ValueError):
tr = simulate.track(min_len=3)
tr1 = tr.add_column("states", np.arange(len(tr)), "test")
switch.get_switching_matrix([tr1], column="states", n_states=2)
def test_2_states_classification_smooth(Ds=[0.0, 0.08], num_tracks=1000):
tracks = simulate.tracks(
num_tracks=num_tracks,
D_bound=Ds[0],
D_free=Ds[1],
loc_error=0.02,
p_binding=1e-2,
p_unbinding=4e-2,
p_out_of_focus=1e-5,
p_bleaching=0.1,
use_tqdm=False,
)
bayes_filter = bayes.BayesFilter(**{
"D": Ds,
"F": [0.2, 0.8],
"sigma": [0.02],
"dt": 0.06
})
predictions = [
bayes_filter.predict_states(track, max_lag=4, smooth=1)
for track in tracks
]
n_bound = sum([sum(track.free == 0) for track in tracks])[0]
total = sum([len(track) for track in tracks])
n_predicted = sum([sum(prediction == 0) for prediction in predictions])
print(f"bound fraction sim: {n_bound/total:.1%}, \
predicted: {n_predicted/total:.1%}")
np.testing.assert_almost_equal(n_predicted / total, n_bound / total, 1)
def test_select_pops(
p_binding=1e-2, p_unbinding=4e-2, num_tracks=100, p_bleaching=0.05
):
tracks = simulate.tracks(
num_tracks,
p_binding=p_binding,
p_unbinding=p_unbinding,
p_bleaching=p_bleaching,
)
pops = segments.get_populations(
tracks, column_with_states="free", values=(0, 1), min_len=3
)
assert len(pops) == 2
for p in pops:
assert len(p) > 0
n_bound = sum([len(p) for p in pops[0]])
n_free = sum([len(p) for p in pops[1]])
bound_f = n_bound / (n_bound + n_free)
bound_sim = p_binding / (p_unbinding + p_binding)
np.testing.assert_almost_equal(bound_f, bound_sim, 1)
def test_decay_rate(num_tracks=1000, p_bleaching=0.05, p_out_of_focus=1e-5):
tracks = simulate.tracks(num_tracks=num_tracks,
p_bleaching=p_bleaching,
p_out_of_focus=p_out_of_focus,
use_tqdm=False)
decay_rate = tracklen.get_track_lengths_dist(tracks, plot=False)
np.testing.assert_almost_equal(decay_rate, p_bleaching, 1)
def test_fit_tracks():
sim_params = dict(
num_tracks=4e3,
dt=0.06,
D_bound=0.0,
D_free=0.05,
loc_error=0.03,
p_binding=0.0001,
p_unbinding=0.001,
p_bleaching=1e-1,
p_out_of_focus=1e-5,
min_len=5,
use_tqdm=False,
)
fit_params = dict(
n_lags=7,
plot=False,
dt=0.06,
D=(0.0, 0.1),
fit_D=(True, True),
F=(0.5, 0.5),
fit_F=(True, True),
sigma=(0.2, ),
fit_sigma=(True, ),
n_bins=100,
max_um=2,
verbose=False,
)
F_bound = sim_params["p_binding"] / (sim_params["p_binding"] +
sim_params["p_unbinding"])
tracks = simulate.tracks(**sim_params)
assert len(tracks) == sim_params["num_tracks"]
fit = fit2.fit_spoton_2_0(tracks, **fit_params)
np.testing.assert_almost_equal(
fit["D"][1],
(sim_params["D_free"]),
decimal=0,
err_msg=f"D_free input: {sim_params['D_free']}, fit: {fit['D'][1]}",
)
np.testing.assert_almost_equal(fit["sigma"][0],
sim_params["loc_error"],
decimal=2)
np.testing.assert_almost_equal(
fit["F"][0],
F_bound,
decimal=1,
err_msg=f"Fitted F_bound {fit['F'][0]:.2f}, \
simulated {F_bound:.2f}",
)
def test_fit_return_fit():
tracks = simulate.tracks(num_tracks=100, min_len=3)
fit = fit2.fit_spoton_2_0(tracks,
n_lags=5,
plot=False,
return_hists=False,
return_fit_result=True)
fit_result = fit["fit_result"]
assert isinstance(fit_result, fit2.lmfit.minimizer.MinimizerResult)
def test_2_states_classification(Ds=[0.0, 0.08], num_tracks=1000):
tracks = simulate.tracks(
num_tracks=num_tracks,
D_bound=Ds[0],
D_free=Ds[1],
loc_error=0.02,
p_binding=1e-2,
p_unbinding=4e-2,
p_out_of_focus=1e-5,
p_bleaching=0.1,
use_tqdm=False,
)
bayes_filter = bayes.BayesFilter(**{
"D": Ds,
"F": [0.2, 0.8],
"sigma": [0.02],
"dt": 0.06
})
predictions = [
bayes_filter.predict_states(track, max_lag=4, smooth=0)
for track in tracks
]
n_bound = sum([sum(track.free == 0) for track in tracks])[0]
total = sum([len(track) for track in tracks])
n_predicted = sum([sum(prediction == 0) for prediction in predictions])
print(f"bound fraction sim: {n_bound/total:.1%}, \
predicted: {n_predicted/total:.1%}")
np.testing.assert_almost_equal(n_predicted / total, n_bound / total, 1)
r = np.arange(0.01, 0.3, 0.01)
fig1 = bayes_filter.plot_bayes(r)
fig2 = bayes_filter.plot_jd(r)
assert isinstance(fig1, plot.plt.Figure)
assert isinstance(fig2, plot.plt.Figure)
assert isinstance(repr(bayes_filter), str)
assert isinstance(repr(bayes_filter[0]), str)
with pytest.raises(AssertionError):
bayes_filter(True)
with pytest.raises(AssertionError):
bayes_filter([1, 2], 0)
def test_switching_rates():
tracks = simulate.tracks(
num_tracks=1e3,
dt=0.06,
D_bound=0,
D_free=0.06,
loc_error=0.02,
p_binding=1e-4,
p_unbinding=1e-3,
p_bleaching=1e-1,
p_out_of_focus=1e-5,
min_len=5,
use_tqdm=False,
)
out = bayes.get_switching_rates(tracks, fps=15, column="free")
assert isinstance(out, dict)
np.testing.assert_almost_equal(out["u_rate_frame"], 1e-3, 2)
np.testing.assert_almost_equal(out["b_rate_frame"], 1e-4, 3)
def test_sim_tracks():
tracks = simulate.tracks(num_tracks=100)
assert len(tracks) == 100
def test_result_2_table():
data = [simulate.tracks(100) for _ in range(2)]
fits = [fit2.fit_spoton_2_0(d, plot=False) for d in data]
table = fit2.result_2_table(*fits)
assert isinstance(table, pd.DataFrame)
assert len(table) == 2
def test_fit_return_hists():
tracks = simulate.tracks(num_tracks=100, min_len=3)
fit = fit2.fit_spoton_2_0(tracks, n_lags=5, plot=False, return_hists=True)
hists = fit["hists"]
assert len(hists) == 5
assert [isinstance(h, fit2.JumpLengthHistogram) for h in hists]
def test_fit_high_lags():
tracks = simulate.tracks(num_tracks=100, min_len=3)
fit = fit2.fit_spoton_2_0(tracks, n_lags=5, plot=False)
assert isinstance(fit, dict)
def test_track_add():
tracks = simulate.tracks(20)
sum_tracks = reduce(__add__, tracks)
assert isinstance(sum_tracks, core.Track)
assert len(sum_tracks) == sum(map(len, tracks))
