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)
def kinetic_spectrum_matrix(dataset_descriptor=None, axis=None, index=None, irf=None):
clp_label, matrix = kinetic_image_matrix(
dataset_descriptor, axis, index, dataset_descriptor.irf
)
if isinstance(dataset_descriptor.irf, IrfGaussianCoherentArtifact):
irf_clp_label, irf_matrix = dataset_descriptor.irf.calculate_coherent_artifact(axis)
if matrix is None:
clp_label = irf_clp_label
matrix = irf_matrix
else:
clp_label += irf_clp_label
matrix = np.concatenate((matrix, irf_matrix), axis=1)
return (clp_label, matrix)
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)
def calculate_doas_matrix(dataset_descriptor=None,
axis=None,
index=None,
irf=None):
oscillations = _collect_oscillations(dataset_descriptor)
matrix = np.zeros((axis.size, len(2 * oscillations)), dtype=np.float64)
labels = [o.label for o in oscillations]
# TODO: improve code reasability further
clp = [
lbl for o in zip([f"{l_cos}_cos" for l_cos in labels],
[f"{l_sin}_sin" for l_sin in labels]) for lbl in o
]
delta = np.abs(axis[1:] - axis[:-1])
delta_min = delta[np.argmin(delta)]
frequency_max = 1 / (2 * 0.03 * delta_min)
frequencies = np.asarray(
[o.frequency * 0.03 * 2 * np.pi for o in oscillations])
frequencies[frequencies >= frequency_max] = np.mod(
frequencies[frequencies >= frequency_max], frequency_max)
rates = np.asarray([o.rate for o in oscillations])
if dataset_descriptor.irf is None:
calculate_doas_matrix_no_irf(matrix, frequencies, rates, axis)
elif isinstance(dataset_descriptor.irf, IrfMultiGaussian):
centers, widths, scales, _, _ = dataset_descriptor.irf.parameter(index)
calculate_doas_matrix_gaussian_irf(matrix, frequencies, rates, axis,
centers, widths, scales)
kinetic_clp, kinetic_matrix = kinetic_image_matrix(dataset_descriptor,
axis, index, irf)
if kinetic_matrix is not None:
clp = clp + kinetic_clp
matrix = np.concatenate((matrix, kinetic_matrix), axis=1)
return (clp, matrix)
def test_spectral_relation():
model = KineticSpectrumModel.from_dict({
'initial_concentration': {
'j1': {
'compartments': ['s1', 's2', 's3', 's4'],
'parameters': ['i.1', 'i.2', 'i.3', 'i.4']
},
},
'megacomplex': {
'mc1': {
'k_matrix': ['k1']
},
},
'k_matrix': {
"k1": {
'matrix': {
("s1", "s1"): 'kinetic.1',
("s2", "s2"): 'kinetic.1',
("s3", "s3"): 'kinetic.1',
("s4", "s4"): 'kinetic.1',
}
}
},
'spectral_relations': [
{
'compartment': 's1',
'target': 's2',
'parameter': 'rel.1',
'interval': [(0, 2)],
},
{
'compartment': 's1',
'target': 's3',
'parameter': 'rel.2',
'interval': [(0, 2)],
},
],
'dataset': {
'dataset1': {
'initial_concentration': 'j1',
'megacomplex': ['mc1'],
},
},
})
print(model)
rel1, rel2 = 10, 20
parameter = ParameterGroup.from_dict({
'kinetic': [1e-4],
'i': [1, 2, 3, 4],
'rel': [rel1, rel2],
})
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) == 4
assert matrix.shape == (time.size, 4)
reduced_compartments, relation_matrix = \
create_spectral_relation_matrix(model, parameter, compartments, matrix, 1)
print(relation_matrix)
assert len(reduced_compartments) == 2
assert relation_matrix.shape == (4, 2)
assert np.array_equal(relation_matrix, [
[1., 0.],
[10., 0.],
[20., 0.],
[0., 1.],
])
reduced_compartments, reduced_matrix = \
model.constrain_matrix_function(parameter, compartments, matrix, 1)
assert reduced_matrix.shape == (time.size, 2)
print(reduced_matrix[0, 0], matrix[0, 0], matrix[0, 1], matrix[0, 2])
assert np.allclose(
reduced_matrix[:, 0],
matrix[:, 0] + rel1 * matrix[:, 1] + rel2 * matrix[:, 2])
clp = xr.DataArray([[1., 10., 20., 1]],
coords=(('spectral', [1]), ('clp_label',
['s1', 's2', 's3', 's4'])))
data = model.simulate('dataset1',
parameter,
clp=clp,
axes={
'time': time,
'spectral': np.array([1])
})
result = model.optimize(parameter, {'dataset1': data}, max_nfev=1)
result_data = result.data['dataset1']
print(result_data.species_associated_spectra)
assert result_data.species_associated_spectra.shape == (1, 4)
assert result_data.species_associated_spectra[0, 1] == \
rel1 * result_data.species_associated_spectra[0, 0]
assert result_data.species_associated_spectra[0, 2] == \
rel2 * result_data.species_associated_spectra[0, 0]
def test_spectral_relation():
model = KineticSpectrumModel.from_dict({
"initial_concentration": {
"j1": {
"compartments": ["s1", "s2", "s3", "s4"],
"parameters": ["i.1", "i.2", "i.3", "i.4"],
},
},
"megacomplex": {
"mc1": {
"k_matrix": ["k1"]
},
},
"k_matrix": {
"k1": {
"matrix": {
("s1", "s1"): "kinetic.1",
("s2", "s2"): "kinetic.1",
("s3", "s3"): "kinetic.1",
("s4", "s4"): "kinetic.1",
}
}
},
"spectral_relations": [
{
"compartment": "s1",
"target": "s2",
"parameter": "rel.1",
"interval": [(0, 2)],
},
{
"compartment": "s1",
"target": "s3",
"parameter": "rel.2",
"interval": [(0, 2)],
},
],
"dataset": {
"dataset1": {
"initial_concentration": "j1",
"megacomplex": ["mc1"],
},
},
})
print(model)
rel1, rel2 = 10, 20
parameter = ParameterGroup.from_dict({
"kinetic": [1e-4],
"i": [1, 2, 3, 4],
"rel": [rel1, rel2],
})
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) == 4
assert matrix.shape == (time.size, 4)
reduced_compartments, relation_matrix = create_spectral_relation_matrix(
model, parameter, compartments, matrix, 1)
print(relation_matrix)
assert len(reduced_compartments) == 2
assert relation_matrix.shape == (4, 2)
assert np.array_equal(
relation_matrix,
[
[1.0, 0.0],
[10.0, 0.0],
[20.0, 0.0],
[0.0, 1.0],
],
)
reduced_compartments, reduced_matrix = model.constrain_matrix_function(
parameter, compartments, matrix, 1)
assert reduced_matrix.shape == (time.size, 2)
print(reduced_matrix[0, 0], matrix[0, 0], matrix[0, 1], matrix[0, 2])
assert np.allclose(
reduced_matrix[:, 0],
matrix[:, 0] + rel1 * matrix[:, 1] + rel2 * matrix[:, 2])
clp = xr.DataArray([[1.0, 10.0, 20.0, 1]],
coords=(("spectral", [1]), ("clp_label",
["s1", "s2", "s3", "s4"])))
data = model.simulate("dataset1",
parameter,
clp=clp,
axes={
"time": time,
"spectral": np.array([1])
})
result = model.optimize(parameter, {"dataset1": data}, max_nfev=1)
result_data = result.data["dataset1"]
print(result_data.species_associated_spectra)
assert result_data.species_associated_spectra.shape == (1, 4)
assert (result_data.species_associated_spectra[0, 1] == rel1 *
result_data.species_associated_spectra[0, 0])
assert (result_data.species_associated_spectra[0, 2] == rel2 *
result_data.species_associated_spectra[0, 0])
def test_spectral_constraint():
model = KineticSpectrumModel.from_dict({
"initial_concentration": {
"j1": {
"compartments": ["s1", "s2"],
"parameters": ["i.1", "i.2"],
},
},
"megacomplex": {
"mc1": {
"k_matrix": ["k1"]
},
},
"k_matrix": {
"k1": {
"matrix": {
("s2", "s1"): "kinetic.1",
("s2", "s2"): "kinetic.2",
}
}
},
"spectral_constraints": [
{
"type": "zero",
"compartment": "s2",
"interval": (float("-inf"), float("inf"))
},
],
"dataset": {
"dataset1": {
"initial_concentration": "j1",
"megacomplex": ["mc1"],
},
},
})
print(model)
wanted_parameters = ParameterGroup.from_dict({
"kinetic": [1e-4, 1e-5],
"i": [1, 2],
})
initial_parameters = ParameterGroup.from_dict({
"kinetic": [2e-4, 2e-5],
"i": [1, 2, {
"vary": False
}],
})
time = np.asarray(np.arange(0, 50, 1.5))
dataset = model.dataset["dataset1"].fill(model, wanted_parameters)
compartments, matrix = kinetic_image_matrix(dataset, time, 0)
assert len(compartments) == 2
assert matrix.shape == (time.size, 2)
reduced_compartments, reduced_matrix = apply_spectral_constraints(
model, compartments, matrix, 1)
print(reduced_matrix)
assert len(reduced_compartments) == 1
assert reduced_matrix.shape == (time.size, 1)
reduced_compartments, reduced_matrix = model.constrain_matrix_function(
"dataset1", wanted_parameters, compartments, matrix, 1)
assert reduced_matrix.shape == (time.size, 1)
clp = xr.DataArray([[1.0, 10.0, 20.0, 1]],
coords=(("spectral", [1]), ("clp_label",
["s1", "s2", "s3", "s4"])))
data = model.simulate("dataset1",
wanted_parameters,
clp=clp,
axes={
"time": time,
"spectral": np.array([1])
})
dataset = {"dataset1": data}
scheme = Scheme(model=model,
parameters=initial_parameters,
data=dataset,
nfev=20)
# the resulting jacobian is singular
with pytest.warns(UserWarning):
result = optimize(scheme)
result_data = result.data["dataset1"]
print(result_data.clp_label)
print(result_data.clp)
# TODO: save reduced clp
# assert result_data.clp.shape == (1, 1)
print(result_data.species_associated_spectra)
assert result_data.species_associated_spectra.shape == (1, 2)
assert result_data.species_associated_spectra[0, 1] == 0
