class OneCompartmentDecay:
scale = 2
wanted_parameters = ParameterGroup.from_list([101e-4])
initial_parameters = ParameterGroup.from_list([100e-5, [scale, {"vary": False}]])
global_axis = np.asarray([1.0])
model_axis = np.arange(0, 150, 1.5)
sim_model_dict = {
"megacomplex": {"m1": {"is_index_dependent": False}, "m2": {"type": "global_complex"}},
"dataset": {
"dataset1": {
"initial_concentration": [],
"megacomplex": ["m1"],
"global_megacomplex": ["m2"],
"kinetic": ["1"],
}
},
}
sim_model = DecayModel.from_dict(sim_model_dict)
model_dict = {
"megacomplex": {"m1": {"is_index_dependent": False}},
"dataset": {
"dataset1": {
"initial_concentration": [],
"megacomplex": ["m1"],
"kinetic": ["1"],
"scale": "2",
}
},
}
model_dict["dataset"]["dataset1"]["scale"] = "2"
model = DecayModel.from_dict(model_dict)
class TwoCompartmentDecay:
wanted_parameters = ParameterGroup.from_list([11e-4, 22e-5])
initial_parameters = ParameterGroup.from_list([10e-4, 20e-5])
global_axis = np.asarray([1.0])
model_axis = np.arange(0, 150, 1.5)
sim_model = DecayModel.from_dict(
{
"megacomplex": {"m1": {"is_index_dependent": False}, "m2": {"type": "global_complex"}},
"dataset": {
"dataset1": {
"initial_concentration": [],
"megacomplex": ["m1"],
"global_megacomplex": ["m2"],
"kinetic": ["1", "2"],
}
},
}
)
model = DecayModel.from_dict(
{
"megacomplex": {"m1": {"is_index_dependent": False}},
"dataset": {
"dataset1": {
"initial_concentration": [],
"megacomplex": ["m1"],
"kinetic": ["1", "2"],
}
},
}
)
class ThreeDatasetDecay:
wanted_parameters = ParameterGroup.from_list([101e-4, 201e-3])
initial_parameters = ParameterGroup.from_list([100e-5, 200e-3])
e_axis = np.asarray([1.0])
c_axis = np.arange(0, 150, 1.5)
e_axis2 = np.asarray([1.0, 2.01])
c_axis2 = np.arange(0, 100, 1.5)
e_axis3 = np.asarray([0.99, 3.0])
c_axis3 = np.arange(0, 150, 1.5)
model_dict = {
"dataset": {
"dataset1": {
"initial_concentration": [],
"megacomplex": [],
"kinetic": ["1"]
},
"dataset2": {
"initial_concentration": [],
"megacomplex": [],
"kinetic": ["1", "2"]
},
"dataset3": {
"initial_concentration": [],
"megacomplex": [],
"kinetic": ["2"]
},
},
}
sim_model = DecayModel.from_dict(model_dict)
model = sim_model
class OneComponentOneChannelGaussianIrf:
model = KineticImageModel.from_dict({
'initial_concentration': {
'j1': {
'compartments': ['s1'],
'parameters': ['2']
},
},
'megacomplex': {
'mc1': {'k_matrix': ['k1']},
},
'k_matrix': {
"k1": {'matrix': {("s1", "s1"): '1', }}
},
'irf': {
'irf1': {'type': 'gaussian', 'center': '2', 'width': '3'},
},
'dataset': {
'dataset1': {
'initial_concentration': 'j1',
'irf': 'irf1',
'megacomplex': ['mc1'],
},
},
})
initial = ParameterGroup.from_list([101e-4, 0.1, 5,
[1, {'vary': False, 'non-negative': False}]])
wanted = ParameterGroup.from_list([101e-3, 0.3, 10,
[1, {'vary': False, 'non-negative': False}]])
time = np.asarray(np.arange(-10, 50, 1.5))
axis = {"time": time, "pixel": np.asarray([0])}
clp = xr.DataArray([[1]], coords=[('pixel', [0]), ('clp_label', ['s1'])])
class OneComponentOneChannelGaussianIrf:
model = KineticImageModel.from_dict({
"initial_concentration": {
"j1": {
"compartments": ["s1"],
"parameters": ["2"]
},
},
"megacomplex": {
"mc1": {
"k_matrix": ["k1"]
},
},
"k_matrix": {
"k1": {
"matrix": {
("s1", "s1"): "1",
}
}
},
"irf": {
"irf1": {
"type": "gaussian",
"center": "2",
"width": "3"
},
},
"dataset": {
"dataset1": {
"initial_concentration": "j1",
"irf": "irf1",
"megacomplex": ["mc1"],
},
},
})
initial_parameters = ParameterGroup.from_list(
[101e-4, 0.1, 1, [1, {
"vary": False,
"non-negative": False
}]])
wanted_parameters = ParameterGroup.from_list([
[101e-3, {
"non-negative": True
}],
[0.2, {
"non-negative": True
}],
[2, {
"non-negative": True
}],
[1, {
"vary": False,
"non-negative": False
}],
])
time = np.asarray(np.arange(-10, 50, 1.5))
axis = {"time": time, "pixel": np.asarray([0])}
clp = xr.DataArray([[1]], coords=[("pixel", [0]), ("clp_label", ["s1"])])
class OneComponentOneChannelMeasuredIrf:
model = KineticImageModel.from_dict({
"initial_concentration": {
"j1": {
"compartments": ["s1"],
"parameters": ["2"]
},
},
"megacomplex": {
"mc1": {
"k_matrix": ["k1"]
},
},
"k_matrix": {
"k1": {
"matrix": {
("s1", "s1"): "1",
}
}
},
"irf": {
"irf1": {
"type": "measured"
},
},
"dataset": {
"dataset1": {
"initial_concentration": "j1",
"irf": "irf1",
"megacomplex": ["mc1"],
},
},
})
initial_parameters = ParameterGroup.from_list(
[101e-4, [1, {
"vary": False,
"non-negative": False
}]])
wanted_parameters = ParameterGroup.from_list(
[101e-3, [1, {
"vary": False,
"non-negative": False
}]])
time = np.asarray(np.arange(-10, 50, 1.5))
axis = {"time": time, "pixel": np.asarray([0])}
center = 0
width = 5
irf = (1 / np.sqrt(2 * np.pi)) * np.exp(-(time - center) *
(time - center) /
(2 * width * width))
model.irf["irf1"].irfdata = irf
clp = xr.DataArray([[1]], coords=[("pixel", [0]), ("clp_label", ["s1"])])
def test_unibranched():
compartments = ['s1', 's2', 's3']
matrix = {
('s2', 's1'): "1",
('s3', 's2'): "2",
('s2', 's2'): "2",
('s3', 's3'): "3",
}
params = ParameterGroup.from_list([3, 4, 5, 1, 0])
mat = KMatrix()
mat.label = ""
mat.matrix = matrix
mat = mat.fill(None, params)
jvec = ["4", "5", "5"]
con = InitialConcentration()
con.label = ""
con.compartments = compartments
con.parameters = jvec
con = con.fill(None, params)
assert not mat.is_unibranched(con)
matrix = {
('s2', 's1'): "1",
('s2', 's2'): "2",
}
compartments = ['s1', 's2']
params = ParameterGroup.from_list([0.55, 0.0404, 1, 0])
mat = KMatrix()
mat.label = ""
mat.matrix = matrix
mat = mat.fill(None, params)
jvec = ["3", "4"]
con = InitialConcentration()
con.label = ""
con.compartments = compartments
con.parameters = jvec
con = con.fill(None, params)
print(mat.reduced(compartments))
assert mat.is_unibranched(con)
wanted_a_matrix = np.asarray([
[1, -1.079278],
[0, 1.079278],
])
print(mat.a_matrix_unibranch(con))
assert np.allclose(mat.a_matrix_unibranch(con), wanted_a_matrix)
def test_unibranched():
compartments = ['s1', 's2', 's3']
matrix = {
('s2', 's1'): "1",
('s3', 's2'): "2",
('s2', 's2'): "2",
('s3', 's3'): "3",
}
params = ParameterGroup.from_list([3, 4, 5, 1, 0])
mat = KMatrix()
mat.label = ""
mat.matrix = matrix
mat = mat.fill(None, params)
jvec = ["4", "5", "5"]
con = InitialConcentration()
con.label = ""
con.compartments = compartments
con.parameters = jvec
con = con.fill(None, params)
assert not mat.is_unibranched(con)
matrix = {
('s2', 's1'): "1",
('s2', 's2'): "2",
}
compartments = ['s1', 's2']
params = ParameterGroup.from_list([0.55, 0.0404, 1, 0])
mat = KMatrix()
mat.label = ""
mat.matrix = matrix
mat = mat.fill(None, params)
jvec = ["3", "4"]
con = InitialConcentration()
con.label = ""
con.compartments = compartments
con.parameters = jvec
con = con.fill(None, params)
print(mat.reduced(compartments))
assert mat.is_unibranched(con)
wanted_a_matrix = np.asarray([
[1, -1.079278],
[0, 1.079278],
])
print(mat.a_matrix_unibranch(con))
assert np.allclose(mat.a_matrix_unibranch(con), wanted_a_matrix)
class ThreeDatasetDecay:
wanted_parameters = ParameterGroup.from_list([101e-4, 201e-3])
initial_parameters = ParameterGroup.from_list([100e-5, 200e-3])
global_axis = np.asarray([1.0])
model_axis = np.arange(0, 150, 1.5)
global_axis2 = np.asarray([1.0, 2.01])
model_axis2 = np.arange(0, 100, 1.5)
global_axis3 = np.asarray([0.99, 3.0])
model_axis3 = np.arange(0, 150, 1.5)
sim_model_dict = {
"megacomplex": {"m1": {"is_index_dependent": False}, "m2": {"type": "global_complex"}},
"dataset": {
"dataset1": {
"initial_concentration": [],
"megacomplex": ["m1"],
"global_megacomplex": ["m2"],
"kinetic": ["1"],
},
"dataset2": {
"initial_concentration": [],
"megacomplex": ["m1"],
"global_megacomplex": ["m2"],
"kinetic": ["1", "2"],
},
"dataset3": {
"initial_concentration": [],
"megacomplex": ["m1"],
"global_megacomplex": ["m2"],
"kinetic": ["2"],
},
},
}
sim_model = DecayModel.from_dict(sim_model_dict)
model_dict = {
"megacomplex": {"m1": {"is_index_dependent": False}},
"dataset": {
"dataset1": {"initial_concentration": [], "megacomplex": ["m1"], "kinetic": ["1"]},
"dataset2": {
"initial_concentration": [],
"megacomplex": ["m1"],
"kinetic": ["1", "2"],
},
"dataset3": {"initial_concentration": [], "megacomplex": ["m1"], "kinetic": ["2"]},
},
}
model = DecayModel.from_dict(model_dict)
def test_single_dataset():
model = MockModel.from_dict(
{"dataset": {
"dataset1": {
"megacomplex": [],
},
}})
model.grouped = lambda: True
print(model.validate())
assert model.valid()
assert model.grouped()
parameters = ParameterGroup.from_list([1, 10])
print(model.validate(parameters))
assert model.valid(parameters)
axis_e = [1, 2, 3]
axis_c = [5, 7, 9, 12]
data = {
"dataset1":
xr.DataArray(np.ones((3, 4)),
coords=[("e", axis_e),
("c", axis_c)]).to_dataset(name="data")
}
scheme = Scheme(model, parameters, data)
problem = Problem(scheme)
bag = problem.bag
datasets = problem.groups
assert len(datasets) == 1
assert len(bag) == 3
assert all(p.data.size == 4 for p in bag)
assert all(p.descriptor[0].label == "dataset1" for p in bag)
assert all(all(p.descriptor[0].axis == axis_c) for p in bag)
assert [p.descriptor[0].index for p in bag] == axis_e
def test_simulate_dataset():
model = MockModel.from_dict({
"dataset": {
"dataset1": {
"megacomplex": [],
},
}
})
print(model.validate())
assert model.valid()
parameter = ParameterGroup.from_list([1, 1])
print(model.validate(parameter))
assert model.valid(parameter)
est_axis = np.asarray([1, 1, 1, 1])
cal_axis = np.asarray([2, 2, 2])
data = simulate(model, 'dataset1', parameter, {'e': est_axis, 'c': cal_axis})
assert np.array_equal(data["c"], cal_axis)
assert np.array_equal(data["e"], est_axis)
assert data.data.shape == (3, 4)
assert np.array_equal(data.data, np.asarray([
[2, 4, 6],
[4, 10, 16],
[6, 16, 26],
[8, 22, 36],
]).T)
def test_single_dataset():
model = MockModel.from_dict({
"dataset": {
"dataset1": {
"megacomplex": [],
},
}
})
print(model.validate())
assert model.valid()
parameter = ParameterGroup.from_list([1, 10])
print(model.validate(parameter))
assert model.valid(parameter)
data = {'dataset1': xr.DataArray(
np.ones((3, 4)),
coords=[('e', [1, 2, 3]), ('c', [5, 7, 9, 12])]
).to_dataset(name="data")}
group = create_group(model, data)
assert len(group) == 3
assert [item[0][0] for _, item in group.items()] == [1, 2, 3]
assert all([item[0][1].label == 'dataset1' for _, item in group.items()])
result = [calculate_group_item(item, model, parameter, data) for item in group.values()]
assert len(result) == 3
print(result[0])
assert result[0][1].shape == (4, 2)
data = create_data_group(model, group, data)
assert len(data) == 3
assert data[1].shape[0] == 4
def test_multi_dataset_overlap():
model = MockModel.from_dict({
"dataset": {
"dataset1": {
"megacomplex": [],
},
"dataset2": {
"megacomplex": [],
},
}
})
model.grouped = lambda: True
print(model.validate())
assert model.valid()
assert model.grouped()
parameters = ParameterGroup.from_list([1, 10])
print(model.validate(parameters))
assert model.valid(parameters)
axis_e_1 = [1, 2, 3, 5]
axis_c_1 = [5, 7]
axis_e_2 = [0, 1.4, 2.4, 3.4, 9]
axis_c_2 = [5, 7, 9, 12]
data = {
"dataset1":
xr.DataArray(np.ones((4, 2)),
coords=[("e", axis_e_1),
("c", axis_c_1)]).to_dataset(name="data"),
"dataset2":
xr.DataArray(np.ones((5, 4)),
coords=[("e", axis_e_2),
("c", axis_c_2)]).to_dataset(name="data"),
}
scheme = Scheme(model, parameters, data, group_tolerance=5e-1)
problem = Problem(scheme)
bag = list(problem.bag)
assert len(problem.groups) == 3
assert "dataset1dataset2" in problem.groups
assert problem.groups["dataset1dataset2"] == ["dataset1", "dataset2"]
assert len(bag) == 6
assert all(p.data.size == 4 for p in bag[:1])
assert all(p.descriptor[0].label == "dataset1" for p in bag[1:5])
assert all(all(p.descriptor[0].axis == axis_c_1) for p in bag[1:5])
assert [p.descriptor[0].index for p in bag[1:5]] == axis_e_1
assert all(p.data.size == 6 for p in bag[1:4])
assert all(p.descriptor[1].label == "dataset2" for p in bag[1:4])
assert all(all(p.descriptor[1].axis == axis_c_2) for p in bag[1:4])
assert [p.descriptor[1].index for p in bag[1:4]] == axis_e_2[1:4]
assert all(p.data.size == 4 for p in bag[5:])
assert bag[4].descriptor[0].label == "dataset1"
assert bag[5].descriptor[0].label == "dataset2"
assert np.array_equal(bag[4].descriptor[0].axis, axis_c_1)
assert np.array_equal(bag[5].descriptor[0].axis, axis_c_2)
assert [p.descriptor[0].index for p in bag[1:4]] == axis_e_1[:-1]
def test_matrix_non_unibranch(matrix):
params = ParameterGroup.from_list(matrix.params)
mat = KMatrix()
mat.label = ""
mat.matrix = matrix.matrix
mat = mat.fill(None, params)
con = InitialConcentration()
con.label = ""
con.compartments = matrix.compartments
con.parameters = matrix.jvec
con = con.fill(None, params)
for comp in matrix.compartments:
assert comp in mat.involved_compartments()
print(mat.reduced(matrix.compartments))
assert np.array_equal(mat.reduced(matrix.compartments), matrix.wanted_array)
print(mat.full(matrix.compartments).T)
assert np.allclose(mat.full(matrix.compartments), matrix.wanted_full)
print(mat.eigen(matrix.compartments)[0])
print(mat.eigen(matrix.compartments)[1])
vals, vec = mat.eigen(matrix.compartments)
assert np.allclose(vals, matrix.wanted_eigen_vals)
assert np.allclose(vec, matrix.wanted_eigen_vec)
print(mat._gamma(vec, con))
assert np.allclose(mat._gamma(vec, con), matrix.wanted_gamma)
print(mat.a_matrix_non_unibranch(con))
assert np.allclose(mat.a_matrix_non_unibranch(con), matrix.wanted_a_matrix)
def test_simulate_dataset():
model = SimpleTestModel.from_dict(
{"dataset": {
"dataset1": {
"megacomplex": [],
},
}})
print(model.validate())
assert model.valid()
parameter = ParameterGroup.from_list([1, 1])
print(model.validate(parameter))
assert model.valid(parameter)
est_axis = np.asarray([1, 1, 1, 1])
cal_axis = np.asarray([2, 2, 2])
data = simulate(model, "dataset1", parameter, {
"e": est_axis,
"c": cal_axis
})
assert np.array_equal(data["c"], cal_axis)
assert np.array_equal(data["e"], est_axis)
assert data.data.shape == (3, 4)
assert np.array_equal(
data.data,
np.asarray([
[2, 4, 6],
[4, 10, 16],
[6, 16, 26],
[8, 22, 36],
]).T,
)
def test_single_dataset():
model = MockModel.from_dict(
{"dataset": {
"dataset1": {
"megacomplex": [],
},
}})
print(model.validate())
assert model.valid()
parameter = ParameterGroup.from_list([1, 10])
print(model.validate(parameter))
assert model.valid(parameter)
axis_e = [1, 2, 3]
axis_c = [5, 7, 9, 12]
data = {
'dataset1':
xr.DataArray(np.ones((3, 4)),
coords=[('e', axis_e),
('c', axis_c)]).to_dataset(name="data")
}
scheme = Scheme(model, parameter, data)
bag, datasets = create_grouped_bag(scheme)
bag = bag.compute()
assert len(datasets) == 0
assert len(bag) == 3
assert all([p.data.size == 4 for p in bag])
assert all([p.descriptor[0].dataset == 'dataset1' for p in bag])
assert all([all(p.descriptor[0].axis == axis_c) for p in bag])
assert [p.descriptor[0].index for p in bag] == axis_e
def test_matrix_non_unibranch(matrix):
params = ParameterGroup.from_list(matrix.params)
mat = KMatrix()
mat.label = ""
mat.matrix = matrix.matrix
mat = mat.fill(None, params)
con = InitialConcentration()
con.label = ""
con.compartments = matrix.compartments
con.parameters = matrix.jvec
con = con.fill(None, params)
for comp in matrix.compartments:
assert comp in mat.involved_compartments()
print(mat.reduced(matrix.compartments))
assert np.array_equal(mat.reduced(matrix.compartments), matrix.wanted_array)
print(mat.full(matrix.compartments).T)
assert np.allclose(mat.full(matrix.compartments), matrix.wanted_full)
print(mat.eigen(matrix.compartments)[0])
print(mat.eigen(matrix.compartments)[1])
vals, vec = mat.eigen(matrix.compartments)
assert np.allclose(vals, matrix.wanted_eigen_vals)
assert np.allclose(vec, matrix.wanted_eigen_vec)
print(mat._gamma(vec, con))
assert np.allclose(mat._gamma(vec, con), matrix.wanted_gamma)
print(mat.a_matrix_non_unibranch(con))
assert np.allclose(mat.a_matrix_non_unibranch(con), matrix.wanted_a_matrix)
def test_coherent_artifact():
model = KineticModel.from_dict({
'initial_concentration': {
'j1': {
'compartments': ['s1'],
'parameters': ['2']
},
},
'megacomplex': {
'mc1': {
'k_matrix': ['k1']
},
},
'k_matrix': {
"k1": {
'matrix': {
("s1", "s1"): '1',
}
}
},
'irf': {
'irf1': {
'type': 'gaussian',
'center': '2',
'width': '3',
'coherent_artifact': True,
'coherent_artifact_order': 3,
},
},
'dataset': {
'dataset1': {
'initial_concentration': 'j1',
'megacomplex': ['mc1'],
'irf': 'irf1',
},
},
})
parameter = ParameterGroup.from_list([
101e-4,
[10, {
'vary': False,
'non-negative': False
}],
[20, {
'vary': False,
'non-negative': False
}],
])
time = np.asarray(np.arange(0, 50, 1.5))
dataset = model.dataset['dataset1'].fill(model, parameter)
compartments, matrix = calculate_kinetic_matrix(dataset, 0, time)
assert len(compartments) == 4
for i in range(1, 4):
assert compartments[i] == f'irf1_coherent_artifact_{i}'
assert matrix.shape == (time.size, 4)
class TwoCompartmentDecay:
wanted_parameters = ParameterGroup.from_list([11e-4, 22e-5])
initial_parameters = ParameterGroup.from_list([10e-4, 20e-5])
e_axis = np.asarray([1.0])
c_axis = np.arange(0, 150, 1.5)
model = DecayModel.from_dict({
"dataset": {
"dataset1": {
"initial_concentration": [],
"megacomplex": [],
"kinetic": ["1", "2"]
}
},
})
sim_model = model
def test_k_matrices(model):
assert "km1" in model.k_matrix
parameter = ParameterGroup.from_list([1, 2, 3, 4, 5, 6, 7])
reduced = model.k_matrix["km1"].fill(model, parameter).reduced(
["s1", "s2", "s3", "s4"])
assert np.array_equal(
reduced,
np.asarray([[1, 3, 5, 7], [2, 0, 0, 0], [4, 0, 0, 0], [6, 0, 0, 0]]))
def test_multi_dataset_overlap():
model = MockModel.from_dict(
{
"dataset": {
"dataset1": {
"megacomplex": [],
},
"dataset2": {
"megacomplex": [],
},
}
}
)
print(model.validate())
assert model.valid()
parameter = ParameterGroup.from_list([1, 10])
print(model.validate(parameter))
assert model.valid(parameter)
axis_e_1 = [1, 2, 3, 5]
axis_c_1 = [5, 7]
axis_e_2 = [0, 1.4, 2.4, 3.4, 9]
axis_c_2 = [5, 7, 9, 12]
data = {
"dataset1": xr.DataArray(
np.ones((4, 2)), coords=[("e", axis_e_1), ("c", axis_c_1)]
).to_dataset(name="data"),
"dataset2": xr.DataArray(
np.ones((5, 4)), coords=[("e", axis_e_2), ("c", axis_c_2)]
).to_dataset(name="data"),
}
scheme = Scheme(model, parameter, data, group_tolerance=5e-1)
bag, datasets = create_grouped_bag(scheme)
bag = bag.compute()
assert len(datasets) == 1
assert "dataset1dataset2" in datasets
assert datasets["dataset1dataset2"] == ["dataset1", "dataset2"]
assert len(bag) == 6
assert all([p.data.size == 4 for p in bag[:1]])
assert all([p.descriptor[0].dataset == "dataset1" for p in bag[1:5]])
assert all([all(p.descriptor[0].axis == axis_c_1) for p in bag[1:5]])
assert [p.descriptor[0].index for p in bag[1:5]] == axis_e_1
assert all([p.data.size == 6 for p in bag[1:4]])
assert all([p.descriptor[1].dataset == "dataset2" for p in bag[1:4]])
assert all([all(p.descriptor[1].axis == axis_c_2) for p in bag[1:4]])
assert [p.descriptor[1].index for p in bag[1:4]] == axis_e_2[1:4]
assert all([p.data.size == 4 for p in bag[5:]])
assert bag[4].descriptor[0].dataset == "dataset1"
assert bag[5].descriptor[0].dataset == "dataset2"
assert np.array_equal(bag[4].descriptor[0].axis, axis_c_1)
assert np.array_equal(bag[5].descriptor[0].axis, axis_c_2)
assert [p.descriptor[0].index for p in bag[1:4]] == axis_e_1[:-1]
class OneCompartmentDecay:
wanted = ParameterGroup.from_list([101e-4])
initial = ParameterGroup.from_list([100e-5])
e_axis = np.asarray([1])
c_axis = np.arange(0, 150, 1.5)
model = DecayModel.from_dict({
'compartment': ["s1"],
'dataset': {
'dataset1': {
'initial_concentration': [],
'megacomplex': [],
'kinetic': ['1']
}
}
})
sim_model = model
class OneCompartmentDecay:
wanted = ParameterGroup.from_list([101e-4])
initial = ParameterGroup.from_list([100e-5])
e_axis = np.asarray([1])
c_axis = np.arange(0, 150, 1.5)
model = DecayModel.from_dict({
"compartment": ["s1"],
"dataset": {
"dataset1": {
"initial_concentration": [],
"megacomplex": [],
"kinetic": ["1"]
}
},
})
sim_model = model
def test_multi_dataset_no_overlap():
model = MockModel.from_dict({
"dataset": {
"dataset1": {
"megacomplex": [],
},
"dataset2": {
"megacomplex": [],
},
}
})
print(model.validate())
assert model.valid()
parameter = ParameterGroup.from_list([1, 10])
print(model.validate(parameter))
assert model.valid(parameter)
data = {
'dataset1': xr.DataArray(
np.ones((3, 2)),
coords=[('e', [1, 2, 3]), ('c', [5, 7])]
).to_dataset(name="data"),
'dataset2': xr.DataArray(
np.ones((3, 3)),
coords=[('e', [4, 5, 6]), ('c', [5, 7, 9])]
).to_dataset(name="data"),
}
group = create_group(model, data)
assert len(group) == 6
assert [item[0][0] for _, item in group.items()] == [1, 2, 3, 4, 5, 6]
assert [item[0][1].label for _, item in group.items()] == \
['dataset1' for _ in range(3)] + ['dataset2' for _ in range(3)]
result = [calculate_group_item(item, model, parameter, data) for item in group.values()]
assert len(result) == 6
print(result[0])
assert result[0][1].shape == (2, 2)
assert result[3][1].shape == (3, 2)
data = create_data_group(model, group, data)
assert len(data) == 6
assert data[1].shape[0] == 2
assert data[4].shape[0] == 3
data = {
'dataset1': xr.DataArray(
np.ones((3, 2)),
coords=[('e', [1, 2, 3]), ('c', [5, 7])]
).to_dataset(name="data"),
'dataset2': xr.DataArray(
np.ones((3, 3)),
coords=[('e', [4, 5, 6]), ('c', [5, 7, 9])]
).to_dataset(name="data"),
}
def test_a_matrix_sequential():
compartments = ["s1", "s2", "s3"]
matrix = {
("s2", "s1"): "1",
("s3", "s2"): "2",
("s2", "s2"): "2",
("s3", "s3"): "3",
}
params = ParameterGroup.from_list([3, 4, 5])
mat = KMatrix()
mat.label = ""
mat.matrix = matrix
mat = mat.fill(None, params)
initial_concentration = [1, 0, 0]
assert not mat.is_sequential(compartments, initial_concentration)
matrix = {
("s2", "s1"): "1",
("s2", "s2"): "2",
}
compartments = ["s1", "s2"]
params = ParameterGroup.from_list([0.55, 0.0404])
mat = KMatrix()
mat.label = ""
mat.matrix = matrix
mat = mat.fill(None, params)
initial_concentration = [1, 0]
print(mat.reduced(compartments))
assert mat.is_sequential(compartments, initial_concentration)
wanted_a_matrix = np.asarray([
[1, -1.079278],
[0, 1.079278],
])
print(mat.a_matrix_sequential(compartments))
assert np.allclose(mat.a_matrix_sequential(compartments), wanted_a_matrix)
class OneComponentOneChannel:
model = KineticImageModel.from_dict({
"initial_concentration": {
"j1": {
"compartments": ["s1"],
"parameters": ["2"]
},
},
"megacomplex": {
"mc1": {
"k_matrix": ["k1"]
},
},
"k_matrix": {
"k1": {
"matrix": {
("s1", "s1"): "1",
}
}
},
"dataset": {
"dataset1": {
"initial_concentration": "j1",
"megacomplex": ["mc1"],
},
},
})
initial = ParameterGroup.from_list(
[101e-4, [1, {
"vary": False,
"non-negative": False
}]])
wanted = ParameterGroup.from_list(
[101e-3, [1, {
"vary": False,
"non-negative": False
}]])
time = np.asarray(np.arange(0, 50, 1.5))
axis = {"time": time, "pixel": np.asarray([0])}
clp = xr.DataArray([[1]], coords=[("pixel", [0]), ("clp_label", ["s1"])])
def parameter():
params = [1, 2,
['foo', 3],
['bar', 4],
['baz', 2],
['scale_1', 2],
['scale_2', 8],
4e2
]
return ParameterGroup.from_list(params)
def test_multi_dataset_overlap():
model = MockModel.from_dict({
"dataset": {
"dataset1": {
"megacomplex": [],
},
"dataset2": {
"megacomplex": [],
},
}
})
print(model.validate())
assert model.valid()
parameter = ParameterGroup.from_list([1, 10])
print(model.validate(parameter))
assert model.valid(parameter)
data = {
'dataset1': xr.DataArray(
np.ones((4, 2)),
coords=[('e', [0, 1, 2, 3]), ('c', [5, 7])]
).to_dataset(name="data"),
'dataset2': xr.DataArray(
np.ones((4, 4)),
coords=[('e', [1.4, 2.4, 3.4, 9]), ('c', [5, 7, 9, 12])]
).to_dataset(name="data"),
}
scheme = Scheme(model, parameter, data, group_tolerance=5e-1)
optimizer = Optimizer(scheme)
group = optimizer._global_problem
assert len(group) == 5
assert group[0][0][1].label == 'dataset1'
assert group[1][0][1].label == 'dataset1'
assert group[1][1][1].label == 'dataset2'
assert group[9][0][1].label == 'dataset2'
optimizer._create_calculate_penalty_job(parameter)
print(optimizer.matrices)
result = [m.compute() for m in optimizer.full_matrices.values()]
assert len(result) == 5
print(result[0])
print(result[1])
assert result[0].shape == (2, 2)
assert result[1].shape == (6, 2)
assert result[4].shape == (4, 2)
data = [d.compute() for d in optimizer._global_data.values()]
assert len(data) == 5
assert data[0].shape[0] == 2
assert data[1].shape[0] == 6
assert data[4].shape[0] == 4
class OneComponentOneChannelMeasuredIrf:
model = KineticImageModel.from_dict({
'initial_concentration': {
'j1': {
'compartments': ['s1'],
'parameters': ['2']
},
},
'megacomplex': {
'mc1': {'k_matrix': ['k1']},
},
'k_matrix': {
"k1": {'matrix': {("s1", "s1"): '1', }}
},
'irf': {
'irf1': {'type': 'measured'},
},
'dataset': {
'dataset1': {
'initial_concentration': 'j1',
'irf': 'irf1',
'megacomplex': ['mc1'],
},
},
})
initial = ParameterGroup.from_list([101e-4, [1, {'vary': False, 'non-negative': False}]])
wanted = ParameterGroup.from_list([101e-3, [1, {'vary': False, 'non-negative': False}]])
time = np.asarray(np.arange(-10, 50, 1.5))
axis = {"time": time, "pixel": np.asarray([0])}
center = 0
width = 5
irf = (1/np.sqrt(2 * np.pi)) * np.exp(-(time-center) * (time-center)
/ (2 * width * width))
model.irf["irf1"].irfdata = irf
clp = xr.DataArray([[1]], coords=[('pixel', [0]), ('clp_label', ['s1'])])
def test_multi_dataset_no_overlap():
model = MockModel.from_dict({
"dataset": {
"dataset1": {
"megacomplex": [],
},
"dataset2": {
"megacomplex": [],
},
}
})
model.grouped = lambda: True
print(model.validate())
assert model.valid()
assert model.grouped()
parameters = ParameterGroup.from_list([1, 10])
print(model.validate(parameters))
assert model.valid(parameters)
axis_e_1 = [1, 2, 3]
axis_c_1 = [5, 7]
axis_e_2 = [4, 5, 6]
axis_c_2 = [5, 7, 9]
data = {
"dataset1":
xr.DataArray(np.ones((3, 2)),
coords=[("e", axis_e_1),
("c", axis_c_1)]).to_dataset(name="data"),
"dataset2":
xr.DataArray(np.ones((3, 3)),
coords=[("e", axis_e_2),
("c", axis_c_2)]).to_dataset(name="data"),
}
scheme = Scheme(model, parameters, data)
problem = Problem(scheme)
bag = list(problem.bag)
assert len(problem.groups) == 2
assert len(bag) == 6
assert all(p.data.size == 2 for p in bag[:3])
assert all(p.descriptor[0].label == "dataset1" for p in bag[:3])
assert all(all(p.descriptor[0].axis == axis_c_1) for p in bag[:3])
assert [p.descriptor[0].index for p in bag[:3]] == axis_e_1
assert all(p.data.size == 3 for p in bag[3:])
assert all(p.descriptor[0].label == "dataset2" for p in bag[3:])
assert all(all(p.descriptor[0].axis == axis_c_2) for p in bag[3:])
assert [p.descriptor[0].index for p in bag[3:]] == axis_e_2
def test_multi_dataset_overlap():
model = MockModel.from_dict({
"dataset": {
"dataset1": {
"megacomplex": [],
},
"dataset2": {
"megacomplex": [],
},
}
})
print(model.validate())
assert model.valid()
parameter = ParameterGroup.from_list([1, 10])
print(model.validate(parameter))
assert model.valid(parameter)
data = {
'dataset1': xr.DataArray(
np.ones((4, 2)),
coords=[('e', [0, 1, 2, 3]), ('c', [5, 7])]
).to_dataset(name="data"),
'dataset2': xr.DataArray(
np.ones((4, 4)),
coords=[('e', [1.4, 2.4, 3.4, 9]), ('c', [5, 7, 9, 12])]
).to_dataset(name="data"),
}
group = create_group(model, data, atol=5e-1)
assert len(group) == 5
assert group[0][0][1].label == 'dataset1'
assert group[1][0][1].label == 'dataset1'
assert group[1][1][1].label == 'dataset2'
assert group[9][0][1].label == 'dataset2'
result = [calculate_group_item(item, model, parameter, data) for item in group.values()]
assert len(result) == 5
print(result[0])
print(result[1])
assert result[0][1].shape == (2, 2)
assert result[1][1].shape == (6, 2)
assert result[4][1].shape == (4, 2)
data = create_data_group(model, group, data)
assert len(data) == 5
assert data[0].shape[0] == 2
assert data[1].shape[0] == 6
assert data[9].shape[0] == 4
def test_baseline():
model = KineticImageModel.from_dict({
'initial_concentration': {
'j1': {
'compartments': ['s1'],
'parameters': ['2']
},
},
'megacomplex': {
'mc1': {
'k_matrix': ['k1']
},
},
'k_matrix': {
"k1": {
'matrix': {
("s1", "s1"): '1',
}
}
},
'dataset': {
'dataset1': {
'initial_concentration': 'j1',
'megacomplex': ['mc1'],
'baseline': True,
},
},
})
parameter = ParameterGroup.from_list([
101e-4,
[1, {
'vary': False,
'non-negative': False
}],
[42, {
'vary': False,
'non-negative': False
}],
])
time = np.asarray(np.arange(0, 50, 1.5))
dataset = model.dataset['dataset1'].fill(model, parameter)
compartments, matrix = kinetic_image_matrix(dataset, time, 0)
assert len(compartments) == 2
assert compartments[1] == 'dataset1_baseline'
assert matrix.shape == (time.size, 2)
assert np.all(matrix[:, 1] == 1)
class OneCompartmentDecay:
scale = 2
wanted_parameters = ParameterGroup.from_list([101e-4])
initial_parameters = ParameterGroup.from_list(
[100e-5, [scale, {
"vary": False
}]])
e_axis = np.asarray([1.0])
c_axis = np.arange(0, 150, 1.5)
model_dict = {
"dataset": {
"dataset1": {
"initial_concentration": [],
"megacomplex": [],
"kinetic": ["1"]
}
},
}
sim_model = DecayModel.from_dict(model_dict)
model_dict["dataset"]["dataset1"]["scale"] = "2"
model = DecayModel.from_dict(model_dict)
def test_single_dataset():
model = SimpleTestModel.from_dict({
"megacomplex": {
"m1": {
"is_index_dependent": False
}
},
"dataset_groups": {
"default": {
"link_clp": True
}
},
"dataset": {
"dataset1": {
"megacomplex": ["m1"],
},
},
})
print(model.validate())
assert model.valid()
parameters = ParameterGroup.from_list([1, 10])
print(model.validate(parameters))
assert model.valid(parameters)
global_axis = [1, 2, 3]
model_axis = [5, 7, 9, 12]
data = {
"dataset1":
xr.DataArray(np.ones((3, 4)),
coords=[("global", global_axis),
("model", model_axis)]).to_dataset(name="data")
}
scheme = Scheme(model, parameters, data)
optimization_group = OptimizationGroup(
scheme,
model.get_dataset_groups()["default"])
bag = optimization_group._calculator.bag
datasets = optimization_group._calculator.groups
assert len(datasets) == 1
assert len(bag) == 3
assert all(p.data.size == 4 for p in bag)
assert all(p.dataset_models[0].label == "dataset1" for p in bag)
assert all(
all(p.dataset_models[0].axis["model"] == model_axis) for p in bag)
assert all(
all(p.dataset_models[0].axis["global"] == global_axis) for p in bag)
assert [p.dataset_models[0].indices["global"] for p in bag] == [0, 1, 2]
def test_multi_dataset_no_overlap():
model = MockModel.from_dict({
"dataset": {
"dataset1": {
"megacomplex": [],
},
"dataset2": {
"megacomplex": [],
},
}
})
print(model.validate())
assert model.valid()
parameter = ParameterGroup.from_list([1, 10])
print(model.validate(parameter))
assert model.valid(parameter)
data = {
'dataset1': xr.DataArray(
np.ones((3, 2)),
coords=[('e', [1, 2, 3]), ('c', [5, 7])]
).to_dataset(name="data"),
'dataset2': xr.DataArray(
np.ones((3, 3)),
coords=[('e', [4, 5, 6]), ('c', [5, 7, 9])]
).to_dataset(name="data"),
}
scheme = Scheme(model, parameter, data)
optimizer = Optimizer(scheme)
group = optimizer._global_problem
assert len(group) == 6
assert [problem[0][0] for problem in group.values()] == [1, 2, 3, 4, 5, 6]
assert [problem[0][1].label for problem in group.values()] == \
['dataset1' for _ in range(3)] + ['dataset2' for _ in range(3)]
optimizer._create_calculate_penalty_job(parameter)
result = [m.compute() for mat in optimizer.matrices.values() for m in mat]
assert len(result) == 6
print(result[0])
assert result[0].shape == (2, 2)
assert result[3].shape == (3, 2)
data = optimizer._global_data
assert len(data) == 6
assert list(data.values())[1].compute().shape[0] == 2
assert list(data.values())[4].compute().shape[0] == 3
def test_multi_dataset_no_overlap():
model = MockModel.from_dict({
"dataset": {
"dataset1": {
"megacomplex": [],
},
"dataset2": {
"megacomplex": [],
},
}
})
print(model.validate())
assert model.valid()
parameter = ParameterGroup.from_list([1, 10])
print(model.validate(parameter))
assert model.valid(parameter)
axis_e_1 = [1, 2, 3]
axis_c_1 = [5, 7]
axis_e_2 = [4, 5, 6]
axis_c_2 = [5, 7, 9]
data = {
'dataset1':
xr.DataArray(np.ones((3, 2)),
coords=[('e', axis_e_1),
('c', axis_c_1)]).to_dataset(name="data"),
'dataset2':
xr.DataArray(np.ones((3, 3)),
coords=[('e', axis_e_2),
('c', axis_c_2)]).to_dataset(name="data"),
}
scheme = Scheme(model, parameter, data)
bag, datasets = create_grouped_bag(scheme)
bag = bag.compute()
assert len(datasets) == 0
assert len(bag) == 6
assert all([p.data.size == 2 for p in bag[:3]])
assert all([p.descriptor[0].dataset == 'dataset1' for p in bag[:3]])
assert all([all(p.descriptor[0].axis == axis_c_1) for p in bag[:3]])
assert [p.descriptor[0].index for p in bag[:3]] == axis_e_1
assert all([p.data.size == 3 for p in bag[3:]])
assert all([p.descriptor[0].dataset == 'dataset2' for p in bag[3:]])
assert all([all(p.descriptor[0].axis == axis_c_2) for p in bag[3:]])
assert [p.descriptor[0].index for p in bag[3:]] == axis_e_2
def test_coherent_artifact():
model = KineticModel.from_dict({
'initial_concentration': {
'j1': {
'compartments': ['s1'],
'parameters': ['2']
},
},
'megacomplex': {
'mc1': {'k_matrix': ['k1']},
},
'k_matrix': {
"k1": {'matrix': {("s1", "s1"): '1', }}
},
'irf': {
'irf1': {
'type': 'gaussian',
'center': '2',
'width': '3',
'coherent_artifact': True,
'coherent_artifact_order': 3,
},
},
'dataset': {
'dataset1': {
'initial_concentration': 'j1',
'megacomplex': ['mc1'],
'irf': 'irf1',
},
},
})
parameter = ParameterGroup.from_list([
101e-4,
[10, {'vary': False, 'non-negative': False}],
[20, {'vary': False, 'non-negative': False}],
])
time = np.asarray(np.arange(0, 50, 1.5))
dataset = model.dataset['dataset1'].fill(model, parameter)
compartments, matrix = calculate_kinetic_matrix(dataset, time, 0)
assert len(compartments) == 4
for i in range(1, 4):
assert compartments[i] == f'irf1_coherent_artifact_{i}'
assert matrix.shape == (time.size, 4)
def test_baseline():
model = KineticModel.from_dict({
'initial_concentration': {
'j1': {
'compartments': ['s1'],
'parameters': ['2']
},
},
'megacomplex': {
'mc1': {'k_matrix': ['k1']},
},
'k_matrix': {
"k1": {'matrix': {("s1", "s1"): '1', }}
},
'dataset': {
'dataset1': {
'initial_concentration': 'j1',
'megacomplex': ['mc1'],
'baseline': True,
},
},
})
parameter = ParameterGroup.from_list([
101e-4,
[1, {'vary': False, 'non-negative': False}],
[42, {'vary': False, 'non-negative': False}],
])
time = np.asarray(np.arange(0, 50, 1.5))
dataset = model.dataset['dataset1'].fill(model, parameter)
compartments, matrix = calculate_kinetic_matrix(dataset, time, 0)
assert len(compartments) == 2
assert compartments[1] == 'dataset1_baseline'
assert matrix.shape == (time.size, 2)
assert np.all(matrix[:, 1] == 1)
def test_single_dataset():
model = MockModel.from_dict({
"dataset": {
"dataset1": {
"megacomplex": [],
},
}
})
print(model.validate())
assert model.valid()
parameter = ParameterGroup.from_list([1, 10])
print(model.validate(parameter))
assert model.valid(parameter)
data = {'dataset1': xr.DataArray(
np.ones((3, 4)),
coords=[('e', [1, 2, 3]), ('c', [5, 7, 9, 12])]
).to_dataset(name="data")}
scheme = Scheme(model, parameter, data)
optimizer = Optimizer(scheme)
group = optimizer._global_problem
assert len(group) == 3
assert list(group.keys()) == [f"dataset1_{i}" for i in [1, 2, 3]]
assert all([p.dataset_descriptor.label == 'dataset1' for p in group.values()])
optimizer._create_calculate_penalty_job(parameter)
result = [m.compute() for m in optimizer.matrices.values()]
assert len(result) == 3
print(result[0])
assert result[0].shape == (4, 2)
data = optimizer._global_data
assert len(data) == 3
assert list(data.values())[1].compute().shape[0] == 4
