def test_model_db(self):
from trait2d.analysis.models import ModelConfined
from trait2d.analysis.models import ModelHop
ModelDB().add_model(ModelConfined)
ModelDB().add_model(ModelHop)
self.assertTrue(
isinstance(ModelDB().get_model(ModelConfined), ModelConfined))
self.assertTrue(isinstance(ModelDB().get_model(ModelHop), ModelHop))
ModelDB().remove_model(ModelConfined)
with self.assertRaises(ValueError):
ModelDB().get_model(ModelConfined)
self.assertTrue(isinstance(ModelDB().get_model(ModelHop), ModelHop))
ModelDB().cleanup()
with self.assertRaises(ValueError):
ModelDB().get_model(ModelHop)
def plot_adc_analysis_results(self):
"""Plot the ADC analysis results.
Raises
------
ValueError
Track has not been analyzed using ADC analysis yet.
"""
import matplotlib.pyplot as plt
if self.get_adc_analysis_results() is None:
raise ValueError(
"Track has not been analyzed using adc_analysis yet!")
dt = self._t[1] - self._t[0]
N = self._t.size
T = np.linspace(1, N, N-3, endpoint=True) * dt
fit_results = self.get_adc_analysis_results()["fit_results"]
Dapp = self.get_adc_analysis_results()["Dapp"]
Dapp_err = self.get_adc_analysis_results()["Dapp_err"]
idxs = self.get_adc_analysis_results()["fit_indices"]
n_points = idxs[-1]
plt.figure(figsize=(8, 4))
plt.grid(linestyle='dashed', color='grey')
plt.semilogx(T, Dapp, label="Data", color='black')
plt.fill_between(T, Dapp-Dapp_err, Dapp+Dapp_err, color='black', alpha=0.5)
plt.semilogx(T[idxs], Dapp[idxs], label="Sampled Points", linestyle="", marker="|", markersize=15.0, color='red', zorder=-1)
for model in fit_results:
r = fit_results[model]["params"]
rel_likelihood = fit_results[model]["rel_likelihood"]
ks_p_value = fit_results[model]["KStestPValue"]
m = None
for c in ModelDB().models:
if c.__class__.__name__ == model:
m = c
break
if m is None:
raise ValueError("Can't plot results for model {}; make sure the model is loaded in ModelDB()".format(model))
pred = m(T, *r)
plt.semilogx(T[0:n_points], pred[0:n_points],
label=f"{model}\nrel. likelihood={rel_likelihood:.2e}\nKS p-value={ks_p_value:.2e}")
model = self.get_adc_analysis_results()["best_model"]
plt.axvspan(T[0], T[n_points], alpha=0.25,
color='gray', label="Fit region")
plt.xlabel("Time in s")
plt.ylabel("Normalized ADC")
plt.title("Diffusion Category: {}".format(model))
plt.xlim(T[0], T[-1])
plt.legend(bbox_to_anchor=(1, 1), loc='upper left')
plt.subplots_adjust(right=0.7)
plt.show()
def __init__(self, *args, **kwargs):
super(MainWindow, self).__init__(*args, **kwargs)
# Load .ui file
dirname = os.path.dirname(__file__)
uic.loadUi(os.path.join(dirname, 'gui_analysis.ui'), self)
# Add widgets to tabs
wid_msd = trait2d_analysis_gui.tab.msd.widgetMSD(self)
wid_adc = trait2d_analysis_gui.tab.adc.widgetADC(self)
self.layoutMSD.addWidget(wid_msd, 0, 0)
self.layoutADC.addWidget(wid_adc, 0, 0)
self.statusBar().setSizeGripEnabled(False)
# Initialize with no track
self.track = None
self.pushButtonLoadTrack.clicked.connect(self.load_track_dialog)
ModelDB().add_model(ModelBrownian)
ModelDB().add_model(ModelConfined)
ModelDB().add_model(ModelHop)
import numpy as np
class ModelBrownian(ModelBase):
lower = [0.0, 0.0]
upper = [np.inf, np.inf]
initial = [0.5e-12, 2.0e-9]
def __call__(self, t, D, delta):
return D + delta**2 / (2 * t * (1 - 2 * self.R * self.dt / t))
# %%
# After we've defined the model, we can simply add it to the :class:`trait2d.analysis.ModelDB`.
from trait2d.analysis import ModelDB
ModelDB().add_model(ModelBrownian)
# %%
# We can now run ADC analysis with the model.
from trait2d.analysis import Track
track = Track.from_file("track1.csv", unit_length='micrometres')
track.adc_analysis(fraction_fit_points=0.15)
track.plot_adc_analysis_results()
# %%
# It is a good idea to use `ModelDB().cleanup()` at the end of your notebooks to remove all models again. Otherwise they may carry over into other open notebooks.
ModelDB().cleanup()
# %% # The tracks are now imported and can be used for analysis. # The representation of the ``ListOfTracks`` instance holds some information about it. tracks # %% # To get an overview, we can use :meth:`trait2d.analysis.ListOfTracks.plot_trajectories` tracks.plot_trajectories() # %% In order to run an analysis, we need to load models first. from trait2d.analysis.models import ModelBrownian, ModelConfined, ModelHop from trait2d.analysis import ModelDB ModelDB().add_model(ModelBrownian) ModelDB().add_model(ModelConfined) ModelDB().add_model(ModelHop) # %% # For analysis, :class:`trait2d.analysis.ListOfTracks` uses the same semantics as :class:`Track` for analysis. You can get a summary of the analysis results using :meth:`trait2d.analysis.ListOfTracks.adc_summary`. tracks.adc_analysis(fraction_fit_points=0.15) tracks.adc_summary(plot_dapp=True, plot_pie_chart=True) # %% # Single tracks can also be retrieved and viewed easily. It is also possible to run individual analysis on these tracks. tracks.get_track(0).plot_adc_analysis_results() # %%
def analyze(self):
if self.parent.track == None:
self.parent.statusbar.showMessage("Load a track first!")
mb = QMessageBox()
mb.setText("Load a track first!")
mb.setWindowTitle("Error")
mb.setIcon(QMessageBox.Warning)
mb.exec()
return
T = self.parent.track.get_t()[0:-3]
fit_max_time = self.plot.get_range()
if fit_max_time <= 0.0:
fit_max_time = None
maxfev = int(self.lineEditMaxIt.text())
model_hop = ModelDB().get_model(ModelHop)
model_brownian = ModelDB().get_model(ModelBrownian)
model_confined = ModelDB().get_model(ModelConfined)
if self.checkBoxUseInitial.checkState():
if (self.lineEditParam1_1.text() != ""):
model_brownian.initial[0] = float(self.lineEditParam1_1.text())
if (self.lineEditParam2_1.text() != ""):
model_brownian.initial[1] = float(self.lineEditParam2_1.text())
if (self.lineEditParam1_2.text() != ""):
model_confined.initial[0] = float(self.lineEditParam1_2.text())
if (self.lineEditParam2_2.text() != ""):
model_confined.initial[1] = float(self.lineEditParam2_2.text())
if (self.lineEditParam3_2.text() != ""):
model_confined.initial[2] = float(self.lineEditParam3_2.text())
if (self.lineEditParam1_3.text() != ""):
model_hop.initial[0] = float(self.lineEditParam1_3.text())
if (self.lineEditParam2_3.text() != ""):
model_hop.initial[1] = float(self.lineEditParam2_3.text())
if (self.lineEditParam3_3.text() != ""):
model_hop.initial[2] = float(self.lineEditParam3_3.text())
if (self.lineEditParam4_3.text() != ""):
model_hop.initial[3] = float(self.lineEditParam4_3.text())
R = float(self.doubleSpinBoxInputParam1.value())
try:
results = self.parent.track.adc_analysis(R=R,
fit_max_time=fit_max_time,
maxfev=maxfev)
except RuntimeError:
mb = QMessageBox()
mb.setText(
"A model fit failed! Try raising the maximum iterations or different initial values."
)
mb.setWindowTitle("Fit Error")
mb.setIcon(QMessageBox.Warning)
mb.exec()
return
fit_results = results["fit_results"]
# Show results for brownian model in GUI
self.lineEditParam1_1.setText("{:5e}".format(
fit_results["ModelBrownian"]["params"][0]))
self.lineEditParam1Error_1.setText("{:5e}".format(
fit_results["ModelBrownian"]["errors"][0]))
self.lineEditParam2_1.setText("{:5e}".format(
fit_results["ModelBrownian"]["params"][1]))
self.lineEditParam2Error_1.setText("{:5e}".format(
fit_results["ModelBrownian"]["errors"][1]))
self.lineEditRelLikelihood_1.setText("{:5f}".format(
fit_results["ModelBrownian"]["rel_likelihood"]))
self.lineEditBIC_1.setText("{:5f}".format(
fit_results["ModelBrownian"]["bic"]))
# Show results for confined model in GUI
self.lineEditParam1_2.setText("{:5e}".format(
fit_results["ModelConfined"]["params"][0]))
self.lineEditParam1Error_2.setText("{:5e}".format(
fit_results["ModelConfined"]["errors"][0]))
self.lineEditParam2_2.setText("{:5e}".format(
fit_results["ModelConfined"]["params"][1]))
self.lineEditParam2Error_2.setText("{:5e}".format(
fit_results["ModelConfined"]["errors"][1]))
self.lineEditParam3_2.setText("{:5e}".format(
fit_results["ModelConfined"]["params"][2]))
self.lineEditParam3Error_2.setText("{:5e}".format(
fit_results["ModelConfined"]["errors"][2]))
self.lineEditRelLikelihood_2.setText("{:5f}".format(
fit_results["ModelConfined"]["rel_likelihood"]))
self.lineEditBIC_2.setText("{:5f}".format(
fit_results["ModelConfined"]["bic"]))
# Show results for hopping in GUI
self.lineEditParam1_3.setText("{:5e}".format(
fit_results["ModelHop"]["params"][0]))
self.lineEditParam1Error_3.setText("{:5e}".format(
fit_results["ModelHop"]["errors"][0]))
self.lineEditParam2_3.setText("{:5e}".format(
fit_results["ModelHop"]["params"][1]))
self.lineEditParam2Error_3.setText("{:5e}".format(
fit_results["ModelHop"]["errors"][1]))
self.lineEditParam3_3.setText("{:5e}".format(
fit_results["ModelHop"]["params"][2]))
self.lineEditParam3Error_3.setText("{:5e}".format(
fit_results["ModelHop"]["errors"][2]))
self.lineEditParam4_3.setText("{:5e}".format(
fit_results["ModelHop"]["params"][3]))
self.lineEditParam4Error_3.setText("{:5e}".format(
fit_results["ModelHop"]["errors"][3]))
self.lineEditRelLikelihood_3.setText("{:5f}".format(
fit_results["ModelHop"]["rel_likelihood"]))
self.lineEditBIC_3.setText("{:5f}".format(
fit_results["ModelHop"]["bic"]))
dt = T[1] - T[0]
Dapp = self.parent.track.get_adc_analysis_results()["Dapp"]
reg1 = fit_results["ModelBrownian"]["params"]
reg2 = fit_results["ModelConfined"]["params"]
reg3 = fit_results["ModelHop"]["params"]
m1 = model_brownian(T, *reg1)
m2 = model_confined(T, *reg2)
m3 = model_hop(T, *reg3)
self.plot.reset()
self.plot.setup()
indexes = results["fit_indices"]
self.plot_dapp.setData(T, Dapp)
self.plot_brownian.setData(T[indexes], m1[indexes])
self.plot_confined.setData(T[indexes], m2[indexes])
self.plot_hopping.setData(T[indexes], m3[indexes])
self.plot.set_range(T[indexes[-1]])
self.plot.autoRange()
simulator_hop.plot_trajectory() # %% # It is also possible to export the simulated tracks as videos using the ``trait2d.simulators.iscat_movie`` class. Currently, the tracks need first to be saved e.g. as a ``.csv`` using ``BrownianDiffusion.save()`` (or any other Diffusion model) and then load them again using ``iscat_movie.load_tracks()``. You also need to load a PSF with ``iscat_movie.load_psf()``. # %% # Analyse tracks # -------------- # %% # Before we start fitting our data, we need to add some models. ``trait2d.analysis.models`` contains a few models that we can add to ``ModelDB``. All models added this way will be used during analysis. from trait2d.analysis import ModelDB from trait2d.analysis.models import ModelBrownian, ModelConfined, ModelHop ModelDB().add_model(ModelBrownian) ModelDB().add_model(ModelConfined) ModelDB().add_model(ModelHop) # %% # Single tracks are stored in a ``Track`` object. from trait2d.analysis import Track # %% # We can create a single track from our last simulation: single_track = Track.from_dict(simulator_brownian.trajectory) # %% # We can now do ADC analysis on the track: