def test_DecayConvolution_init(self):
irf = fit2x.DecayCurve(x, irf_y)
lh = fit2x.DecayLifetimeHandler([1, 4])
settings = {
"instrument_response_function": irf,
"lifetime_handler": lh,
"convolution_method": 0,
"excitation_period": 100,
"irf_shift_channels": 0,
"irf_background_counts": 0,
"start": 0,
"stop": -1
}
ref = [
[4.70950187e-11, 9.33162000e-01, 2.56789386e-01, 7.06638168e-02],
[1.78095108e-87, 9.33162000e-01, 2.56789386e-01, 7.06638168e-02],
[4.49386205e-11, 9.27072464e-01, 2.65610708e-01, 7.60987419e-02],
[1.72529636e-87, 9.27072464e-01, 2.65610708e-01, 7.60987419e-02],
[1.72529636e-87, 9.27072464e-01, 2.65610708e-01, 7.60987419e-02]
]
for i in range(5):
settings["convolution_method"] = i
dc = fit2x.DecayConvolution(**settings)
decay = fit2x.DecayCurve(x)
dc.add(decay)
print(decay.y[::8])
self.assertEqual(np.allclose(decay.y[::8], ref[i]), True)
def test_DecayConvolution_init(self):
irf = fit2x.DecayCurve(x, irf_y)
lh = fit2x.DecayLifetimeHandler([1, 4])
settings = {
"instrument_response_function": irf,
"lifetime_handler": lh,
"use_corrected_irf_as_scatter": True,
"scatter_fraction": 0.0,
"convolution_method": 0,
"excitation_period": 100,
"irf_shift_channels": 0,
"irf_background_counts": 0,
"start": 0,
"stop": -1
}
dc = fit2x.DecayConvolution(**settings)
decay = fit2x.DecayCurve(x)
dc.add(decay)
ref = np.array([1.19203776e-10, 1.59816046e-05, 2.61648339e-02, 4.63676222e-01,
8.17250308e-01, 7.51713472e-01, 6.39828454e-01, 5.44522781e-01,
4.63413367e-01, 3.94385610e-01, 3.35639884e-01, 2.85644631e-01,
2.43096423e-01, 2.06885985e-01, 1.76069274e-01, 1.49842868e-01,
1.27523017e-01, 1.08527821e-01, 9.23620548e-02, 7.86042610e-02,
6.68957600e-02, 5.69312992e-02, 4.84510951e-02, 4.12340602e-02,
3.50920390e-02, 2.98649029e-02, 2.54163750e-02, 2.16304778e-02,
1.84085090e-02, 1.56664688e-02, 1.33328693e-02, 1.13468712e-02])
self.assertEqual(np.allclose(decay.y, ref), True)
ref = np.array([ 0. , 0.64516129, 1.29032258, 1.93548387, 2.58064516,
3.22580645, 3.87096774, 4.51612903, 5.16129032, 5.80645161,
6.4516129 , 7.09677419, 7.74193548, 8.38709677, 9.03225806,
9.67741935, 10.32258065, 10.96774194, 11.61290323, 12.25806452,
12.90322581, 13.5483871 , 14.19354839, 14.83870968, 15.48387097,
16.12903226, 16.77419355, 17.41935484, 18.06451613, 18.70967742,
19.35483871, 20. ])
self.assertEqual(np.allclose(decay.x, ref), True)
def test_pileup(self):
x = np.arange(0, 16)
y = np.ones_like(x) * 10000
decay_settings = {"x": x, "y": y, "acquisition_time": 0.1}
data = fit2x.DecayCurve(**decay_settings)
model = fit2x.DecayCurve(**decay_settings)
pileup_settings = {
"data": data,
"pile_up_model": "coates",
"repetition_rate": 100.0,
"instrument_dead_time": 120.0,
"active": True
}
dp = fit2x.DecayPileup(**pileup_settings)
self.assertEqual(dp.repetition_rate, 100.0)
self.assertEqual(dp.instrument_dead_time, 120.0)
dp.add(model)
ref = np.array([
10093.8673586, 10081.35171081, 10068.83606301, 10056.32041521,
10043.8047674, 10031.28911959, 10018.77347177, 10006.25782395,
9993.74217613, 9981.2265283, 9968.71088047, 9956.19523264,
9943.6795848, 9931.16393695, 9918.64828911, 9906.13264125
])
self.assertEqual(np.allclose(model.y, ref), True)
def test_lin(self):
x = np.arange(0, 16)
y = np.ones_like(x) * 10000
model = fit2x.DecayCurve(x, y)
lin = np.sin(x) * 0.2 + 0.8
linearization = fit2x.DecayCurve(x, lin)
dl = fit2x.DecayLinearization(linearization_table=linearization,
start=0,
stop=-1,
active=True)
dl.add(model)
ref = np.array([
8000., 9682.94196962, 9818.59485365, 8282.24001612, 6486.39500938,
6082.15145067, 7441.1690036, 9313.97319744, 9978.71649325,
8824.23697048, 6911.95777822, 6000.0195869, 6926.854164,
8840.33407365, 9981.21471139, 9300.57568031
])
self.assertEqual(np.allclose(model.y, ref), True)
model = fit2x.DecayCurve(x, y)
dl.active = False
dl.add(model)
self.assertEqual(np.allclose(model.y, y), True)
def test_scale_scale_2(self):
import numpy as np
import fit2x
x = np.arange(0, 16)
y = np.ones_like(x) * 100
y2 = y * 10
data = fit2x.DecayCurve(x, y2)
settings = {
"data": data,
"constant_background": 0,
"active": True,
"start": 0,
"stop": -1
}
ds = fit2x.DecayScale(**settings)
model = fit2x.DecayCurve(x, y)
self.assertEqual(
np.allclose(ds.data.y,
np.ones_like(ds.data.y) * 1000), True)
self.assertEqual(np.allclose(model.y,
np.ones_like(ds.data.y) * 100), True)
ds.add(model)
self.assertEqual(np.sum(model.y), np.sum(ds.data.y))
def test_DecayCurve_operator(self):
x = np.linspace(0, 10, 10)
y = np.sin(x)
ey = np.clip(np.sqrt(np.abs(y)), 1, 1e12)
# Multiplication
curve1 = fit2x.DecayCurve(x, y)
curve2 = curve1 * curve1
curve3 = curve1 * 2
curve1 *= 2
self.assertEqual(np.allclose(curve1.y, y * 2), True)
self.assertEqual(np.allclose(curve1.ey, ey * 2), True)
self.assertEqual(np.allclose(curve3.y, curve1.y), True)
self.assertEqual(np.allclose(curve2.x, curve1.x), True)
self.assertEqual(np.allclose(curve3.ey, curve1.ey), True)
self.assertEqual(np.allclose(curve2.y, y * y), True)
# Addition
curve1 = fit2x.DecayCurve(x, y)
curve3 = curve1 + curve1
curve2 = curve1 + 2
curve1 += 2
self.assertEqual(np.allclose(curve1.y, y + 2), True)
self.assertEqual(np.allclose(curve1.ey, ey), True)
self.assertEqual(np.allclose(curve2.y, curve1.y), True)
self.assertEqual(np.allclose(curve2.x, curve1.x), True)
self.assertEqual(np.allclose(curve2.ey, curve1.ey), True)
self.assertEqual(np.allclose(curve3.y, y + y), True)
def make_decay_curves(
data: np.ndarray = None,
data_noise: np.ndarray = None,
time_axis: np.array = None,
irf_histogram: np.array = None,
tttr_data: tttrlib.TTTR = None,
tttr_irf: tttrlib.TTTR = None,
tttr_micro_time_coarsening: int = 1,
acquisition_time: float = MAX_FLOAT,
) -> typing.Tuple[fit2x.DecayCurve, fit2x.DecayCurve]:
# Data
if time_axis is None:
time_axis = np.array([], np.float64)
if data is None:
data = np.array([], np.float64)
# IRF
if irf_histogram is None:
irf_histogram = np.zeros_like(data)
if len(irf_histogram) > 0:
irf_histogram[0] = 1.0
decay = fit2x.DecayCurve(x=time_axis,
y=data,
acquisition_time=acquisition_time)
irf = fit2x.DecayCurve(x=time_axis, y=irf_histogram)
if data_noise is not None:
decay.set_ey(data_noise)
# Handle TTTR data
if isinstance(tttr_data, tttrlib.TTTR):
decay.set_tttr(tttr_data, tttr_micro_time_coarsening)
if isinstance(tttr_irf, tttrlib.TTTR):
irf.set_tttr(tttr_irf, tttr_micro_time_coarsening)
return decay, irf
def test_DecayCurve_init(self):
x = np.linspace(0, 10, 10)
y = np.sin(x) * 1000
curve1 = fit2x.DecayCurve(x, y)
curve2 = fit2x.DecayCurve(x=x, y=y)
self.assertEqual(np.allclose(curve1.x, curve2.x), True)
self.assertEqual(np.allclose(curve1.y, curve2.y), True)
# Noise is by default Poisson noise
ey = np.clip(np.sqrt(np.abs(y)), 1, 1e12)
curve1 = fit2x.DecayCurve(x, y)
self.assertEqual(np.allclose(curve1.ey, ey), True)
def test_setter_getter(self):
dc = fit2x.DecayScore(**score_settings)
self.assertEqual(np.allclose(dc.model.y, model.y), True)
self.assertEqual(np.allclose(dc.data.y, data.y), True)
x = np.arange(10, dtype=np.float64)
a1 = np.ones_like(x, dtype=np.float64)
a2 = np.ones_like(x, dtype=np.float64) * 2
c1 = fit2x.DecayCurve(x, a1)
c2 = fit2x.DecayCurve(x, a2)
dc.data = c1
dc.model = c2
self.assertEqual(np.allclose(dc.data.y, c1.y), True)
self.assertEqual(np.allclose(dc.model.y, c2.y), True)
def test_setter_getter_2(self):
dc = fit2x.DecayScore(**score_settings)
self.assertEqual(np.allclose(dc.model.y, model.y), True)
self.assertEqual(np.allclose(dc.data.y, data.y), True)
x = np.arange(10, dtype=np.float64)
a1 = np.ones_like(x, dtype=np.float64)
a2 = np.ones_like(x, dtype=np.float64) * 2
# Works on pointers reference counting issues
# see: https://stackoverflow.com/questions/20029377/why-does-swig-appear-to-corrupt-contents-of-a-member-class
dc.data = fit2x.DecayCurve(x, a1)
dc.model = fit2x.DecayCurve(x, a2)
self.assertEqual(np.allclose(dc.data.y, a1), True)
self.assertEqual(np.allclose(dc.model.y, a2), True)
def test_getter_setter(self):
irf = fit2x.DecayCurve(x, irf_y)
lh = fit2x.DecayLifetimeHandler()
ls = np.array([1., 10.0])
dc = fit2x.DecayConvolution()
dc.irf = irf
self.assertEqual(dc.convolution_method, 0)
dc.convolution_method = 1
self.assertEqual(dc.convolution_method, 1)
self.assertEqual(dc.excitation_period, 100.0)
dc.excitation_period = 32.0
self.assertEqual(dc.excitation_period, 32.0)
self.assertEqual(dc.start, 0)
dc.start = 5
self.assertEqual(dc.start, 5)
self.assertEqual(dc.stop, -1)
dc.stop = 20
self.assertEqual(dc.stop, 20)
dc.lifetime_handler = lh
dc.lifetime_handler.lifetime_spectrum = ls
np.allclose(dc.lifetime_handler.lifetime_spectrum, ls)
def test_DecayCurve_set_tttr(self):
tttr_fn = "../tttr-data/bh/bh_spc132_sm_dna/m000.spc"
tttr = tttrlib.TTTR(tttr_fn, "SPC-130")
curve = fit2x.DecayCurve()
curve.set_tttr(tttr, 256)
# plt.semilogy(curve.x * 1e9, curve.y)
# plt.show()
self.assertEqual(
np.allclose(
curve.y,
np.array([
0., 547., 34014., 74748., 15763., 9930., 7289., 5942.,
4909., 4386., 4029., 3683., 3419., 4021., 1758., 0.
])), True)
self.assertEqual(
np.allclose(
curve.x,
np.array([
0.00000000e+00, 1.28746033e-14, 2.57492065e-14,
3.86238098e-14, 5.14984131e-14, 6.43730164e-14,
7.72476196e-14, 9.01222229e-14, 1.02996826e-13,
1.15871429e-13, 1.28746033e-13, 1.41620636e-13,
1.54495239e-13, 1.67369843e-13, 1.80244446e-13,
1.93119049e-13
])), True)
def test_mean_lifetime(self):
irf = fit2x.DecayCurve(x, irf_y)
lh = fit2x.DecayLifetimeHandler([1, 4])
settings = {
"instrument_response_function": irf,
"lifetime_handler": lh,
"convolution_method": 0,
"excitation_period": 100,
"irf_shift_channels": 0,
"irf_background_counts": 0,
"start": 0,
"stop": -1
}
dc = fit2x.DecayConvolution(**settings)
y = np.ones_like(x)
decay = fit2x.DecayCurve(x, y)
self.assertAlmostEqual(dc.get_mean_lifetime(decay), 7.812499963266247)
def test_decay_curve_resize(self):
d = fit2x.DecayCurve()
d.x = np.array([0, 0.1])
d.resize(5)
self.assertEqual(np.allclose(d.x, np.array([0., 0.1, 0.2, 0.3, 0.4])),
True)
d.resize(6)
self.assertEqual(
np.allclose(d.x, np.array([0., 0.1, 0.2, 0.3, 0.4, 0.5])), True)
def test_scale_scale_3(self):
ds = fit2x.DecayScale(**settings)
# Scaling considering noise & background of data
ds.constant_background = 100
# Set number of photons to negative value for scaling
model = fit2x.DecayCurve(x, y)
ds.add(model)
self.assertEqual(np.allclose(model.y, ds.data.y - 100), True)
self.assertEqual(ds.number_of_photons, 16000)
def test_shift_2(self):
x = np.arange(0, 8, dtype=np.float64)
y = np.zeros_like(x)
y[5] = 1.0
dc = fit2x.DecayCurve(x, y)
self.assertEqual(dc.shift, 0.0)
dc.shift = 2
self.assertEqual(np.allclose(np.roll(y, -2), dc.y), True)
dc.shift = 2.5
self.assertEqual(
np.allclose(np.array([0., 0., 0.5, 0.5, 0., 0., 0., 0.]), dc.y),
True)
def test_scale_scale_1(self):
x = np.arange(0, 16)
y = np.ones_like(x) * 100
y2 = y * 10
data = fit2x.DecayCurve(x, y2)
settings = {
"data": data,
"constant_background": 0,
"active": True,
"start": 0,
"stop": -1
}
ds = fit2x.DecayScale(**settings)
model = fit2x.DecayCurve(x, y)
ds.add(model)
self.assertEqual(np.allclose(model.y, data.y), True)
ds.active = False
self.assertEqual(ds.active, False)
model = fit2x.DecayCurve(x, y)
ds.add(model)
self.assertEqual(np.allclose(model.y, y), True)
def test_pileup_setter_getter(self):
x = np.arange(0, 16)
y = np.ones_like(x) * 10000
decay_settings = {"x": x, "y": y, "acquisition_time": 0.1}
data = fit2x.DecayCurve(**decay_settings)
model = fit2x.DecayCurve(**decay_settings)
dp = fit2x.DecayPileup()
dp.repetition_rate = 13.0
self.assertEqual(dp.repetition_rate, 13.0)
dp.pile_up_model = "coates"
self.assertEqual(dp.pile_up_model, "coates")
dp.instrument_dead_time = 89
self.assertEqual(dp.instrument_dead_time, 89)
dp.data = data
(np.allclose(dp.data.x, data.x), True)
(np.allclose(dp.data.y, data.y), True)
dp.resize(10)
self.assertEqual(len(dp.data.y), 10)
def test_irf(self):
irf = fit2x.DecayCurve(x=x, y=irf_y)
dc = fit2x.DecayConvolution()
dc.irf = irf
dc.irf_background_counts = 1e-3
self.assertEqual(np.allclose(dc.irf.y, irf_y), True)
self.assertEqual(dc.irf_background_counts, 1e-3)
np.allclose(dc.corrected_irf.y, np.clip(dc.irf.y - dc.irf_background_counts, 0, 1e30))
dc.irf_background_counts = 0.0
dc.irf_shift_channels = 0.0
self.assertEqual(
np.allclose(
dc.corrected_irf.y,
np.array([5.52094836e-087, 5.51600473e-040, 4.61808726e-011, 3.23985966e+000,
1.90465720e-007, 9.38283342e-033, 3.87326980e-076, 1.33982492e-137,
3.88369320e-217, 0.00000000e+000, 0.00000000e+000, 0.00000000e+000,
0.00000000e+000, 0.00000000e+000, 0.00000000e+000, 0.00000000e+000,
0.00000000e+000, 0.00000000e+000, 0.00000000e+000, 0.00000000e+000,
0.00000000e+000, 0.00000000e+000, 0.00000000e+000, 0.00000000e+000,
0.00000000e+000, 0.00000000e+000, 0.00000000e+000, 0.00000000e+000,
0.00000000e+000, 0.00000000e+000, 0.00000000e+000, 0.00000000e+000])
), True
)
dc.irf_shift_channels = 10.0
self.assertEqual(dc.irf_shift_channels, 10.0)
self.assertEqual(
np.allclose(
dc.corrected_irf.y,
np.array([0.00000000e+000, 0.00000000e+000, 0.00000000e+000, 0.00000000e+000,
0.00000000e+000, 0.00000000e+000, 0.00000000e+000, 0.00000000e+000,
0.00000000e+000, 0.00000000e+000, 0.00000000e+000, 0.00000000e+000,
0.00000000e+000, 0.00000000e+000, 0.00000000e+000, 0.00000000e+000,
0.00000000e+000, 0.00000000e+000, 0.00000000e+000, 0.00000000e+000,
0.00000000e+000, 0.00000000e+000, 5.52094836e-087, 5.51600473e-040,
4.61808726e-011, 3.23985966e+000, 1.90465720e-007, 9.38283342e-033,
3.87326980e-076, 1.33982492e-137, 3.88369320e-217, 0.00000000e+000])
), True
)
from __future__ import division
import unittest
import numpy as np
import fit2x
np.random.seed(42)
x = np.arange(0, 1024)
ym = np.ones_like(x) * 500
yd = np.random.poisson(ym)
data = fit2x.DecayCurve(x, yd)
model = fit2x.DecayCurve(x, ym)
score_settings = {"model": model, "data": data, "start": 0, "stop": -1}
class Tests(unittest.TestCase):
def test_score_1(self):
dc = fit2x.DecayScore(**score_settings)
self.assertAlmostEqual(dc.score, 1114.2359946704964)
dc.model.y = ym * 0.95
self.assertAlmostEqual(dc.score, 2185.4654851901237)
def test_score_range(self):
dc = fit2x.DecayScore(**score_settings)
dc.start, dc.stop = 10, 20
wr = dc.weighted_residuals
ref = np.array([
-0.13456839, -0.95951449, 0.26673253, 0.31088091, -0.58908623,
0.53033009, -1.38379681, -0.72727273, -0.58908623, 0.13376339
])
from __future__ import division
import unittest
import numpy as np
import fit2x
x = np.arange(0, 16)
y = np.ones_like(x) * 100
y2 = y * 10
data = fit2x.DecayCurve(x, y2)
settings = {
"data": data,
"constant_background": 0,
"active": True,
"start": 0,
"stop": -1
}
class Tests(unittest.TestCase):
def test_scale_init(self):
ds = fit2x.DecayScale(**settings)
self.assertEqual(np.allclose(ds.data.y, data.y), True)
self.assertEqual(np.allclose(ds.data.x, data.x), True)
self.assertEqual(ds.constant_background, 0.0)
self.assertEqual(ds.active, True)
def test_scale_scale_1(self):
x = np.arange(0, 16)
y = np.ones_like(x) * 100
y2 = y * 10
def __init__(
self,
data_settings=None, # type: DataSettings
lifetime_settings=None, # type: LifetimeSettings
convolution_settings=None, # type: ConvolutionSettings
scatter_settings=None, # type: PatternSettings
background_settings=None, # type: PatternSettings
pileup_settings=None, # type: PileupSettings
scaling_settings=None, # type: ScalingSettings
linearization_settings=None, # type: LinearizationSettings
score_settings=None # type: ScoreSettings
):
super().__init__()
if data_settings is None:
data_settings = DataSettings()
if lifetime_settings is None:
lifetime_settings = LifetimeSettings()
if convolution_settings is None:
convolution_settings = ConvolutionSettings()
if background_settings is None:
background_settings = PatternSettings()
if scatter_settings is None:
scatter_settings = PatternSettings()
if pileup_settings is None:
pileup_settings = PileupSettings()
if linearization_settings is None:
linearization_settings = LinearizationSettings()
if scaling_settings is None:
scaling_settings = ScalingSettings()
if score_settings is None:
score_settings = ScoreSettings()
# init decay curves
data, irf = self.make_decay_curves(*data_settings)
model = fit2x.DecayCurve(data.x)
lifetime_handler = fit2x.DecayLifetimeHandler(*lifetime_settings)
decay_convolution = fit2x.DecayConvolution(lifetime_handler, irf,
*convolution_settings)
decay_scatter = fit2x.DecayPattern(*scatter_settings)
decay_scatter.data = irf
decay_background = fit2x.DecayPattern(*background_settings)
decay_pileup = fit2x.DecayPileup(data, *pileup_settings)
decay_linearization = fit2x.DecayLinearization(*linearization_settings)
decay_scale = fit2x.DecayScale(data, *scaling_settings)
decay_score = fit2x.DecayScore(model, data, *score_settings)
self._data, self._irf, self._model = data, irf, model
self.lifetime_handler = lifetime_handler
self.decay_convolution = decay_convolution
self.decay_scatter = decay_scatter
self.decay_pileup = decay_pileup
self.decay_linearization = decay_linearization
self.decay_scale = decay_scale
self.decay_background = decay_background
self.decay_score = decay_score
self._decay_modifier = [
self.decay_convolution,
self.decay_scatter,
# self.decay_pileup, # TODO: seems broken
self.decay_linearization,
self.decay_scale,
self.decay_background,
]