def test_ReflectionModelState(test_experiment):
experiments = [test_experiment]
S1 = Simple1MosaicityParameterisation()
S6 = Simple6MosaicityParameterisation()
W = WavelengthSpreadParameterisation()
check_reflection_model_state_with_fixed(experiments[0],
S1,
None,
fix_wavelength_spread=True)
check_reflection_model_state_with_fixed(experiments[0],
S1,
W,
fix_mosaic_spread=True)
check_reflection_model_state_with_fixed(experiments[0],
S1,
W,
fix_wavelength_spread=True)
check_reflection_model_state_with_fixed(experiments[0],
S1,
W,
fix_unit_cell=True)
check_reflection_model_state_with_fixed(experiments[0],
S1,
W,
fix_orientation=True)
check_reflection_model_state_with_fixed(experiments[0],
S6,
None,
fix_wavelength_spread=True)
check_reflection_model_state_with_fixed(experiments[0],
S6,
W,
fix_mosaic_spread=True)
check_reflection_model_state_with_fixed(experiments[0],
S6,
W,
fix_wavelength_spread=True)
check_reflection_model_state_with_fixed(experiments[0],
S6,
W,
fix_unit_cell=True)
check_reflection_model_state_with_fixed(experiments[0],
S6,
W,
fix_orientation=True)
def test_Simple6MosaicityParameterisation():
params = np.array([1e-3, 2e-3, 3e-3, 4e-3, 5e-3, 6e-3])
p = Simple6MosaicityParameterisation(params=params)
assert p.is_angular() is False
assert p.num_parameters() == 6
assert list(p.parameters) == pytest.approx(list(params))
params = np.array([2e-3, 3e-3, 4e-3, 5e-3, 6e-3, 7e-3])
p.parameters = params
assert list(p.parameters) == pytest.approx(list(params))
b1, b2, b3, b4, b5, b6 = params
assert p.sigma()[0, 0] == pytest.approx(b1**2)
assert p.sigma()[0, 1] == pytest.approx(b1 * b2)
assert p.sigma()[0, 2] == pytest.approx(b1 * b4)
assert p.sigma()[1, 0] == pytest.approx(b1 * b2)
assert p.sigma()[1, 1] == pytest.approx(b2**2 + b3 * b3)
assert p.sigma()[1, 2] == pytest.approx(b2 * b4 + b3 * b5)
assert p.sigma()[2, 0] == pytest.approx(b1 * b4)
assert p.sigma()[2, 1] == pytest.approx(b2 * b4 + b3 * b5)
assert p.sigma()[2, 2] == pytest.approx(b4**2 + b5**2 + b6**2)
dSdb = [
(2 * b1, b2, b4, b2, 0, 0, b4, 0, 0),
(0, b1, 0, b1, 2 * b2, b4, 0, b4, 0),
(0, 0, 0, 0, 2 * b3, b5, 0, b5, 0),
(0, 0, b1, 0, 0, b2, b1, b2, 2 * b4),
(0, 0, 0, 0, 0, b3, 0, b3, 2 * b5),
(0, 0, 0, 0, 0, 0, 0, 0, 2 * b6),
]
d = p.first_derivatives()
assert d.shape[0] == 6
for i in range(d.shape[0]):
a = dSdb[i]
b = d[i, :, :]
for j in range(9):
assert b.flatten()[j] == pytest.approx(a[j], abs=1e-12)
def simple6_model_state(test_experiment):
state = ModelState(test_experiment, Simple6MosaicityParameterisation())
return state
def test_ReflectionModelState_derivatives(testdata):
def check(
mosaicity_parameterisation,
wavelength_parameterisation,
fix_mosaic_spread=False,
fix_wavelength_spread=False,
fix_unit_cell=False,
fix_orientation=False,
):
experiment = testdata.experiment
models = testdata.models
s0 = testdata.s0
h = testdata.h
# ctot = testdata.ctot
# mobs = testdata.mobs
# Sobs = testdata.Sobs
U_params = models[1].get_param_vals()
B_params = models[2].get_param_vals()
M_params = np.array(
models[0][:mosaicity_parameterisation.num_parameters()])
L_params = np.array(models[3])
state = ModelState(
experiment,
mosaicity_parameterisation,
wavelength_parameterisation,
fix_mosaic_spread=fix_mosaic_spread,
fix_wavelength_spread=fix_wavelength_spread,
fix_unit_cell=fix_unit_cell,
fix_orientation=fix_orientation,
)
state.U_params = U_params
state.B_params = B_params
state.M_params = M_params
state.L_params = L_params
model = ReflectionModelState(state, s0, h)
dr_dp = model.get_dr_dp()
dS_dp = model.get_dS_dp()
dL_dp = model.get_dL_dp()
def compute_sigma(parameters):
state.active_parameters = parameters
model = ReflectionModelState(state, s0, h)
return model.mosaicity_covariance_matrix
def compute_r(parameters):
state.active_parameters = parameters
model = ReflectionModelState(state, s0, h)
return model.get_r()
def compute_sigma_lambda(parameters):
state.active_parameters = parameters
model = ReflectionModelState(state, s0, h)
return model.wavelength_spread
step = 1e-6
parameters = copy(state.active_parameters)
dr_num = []
for i in range(len(parameters)):
def f(x):
p = copy(parameters)
p[i] = x
return compute_r(p)
dr_num.append(
first_derivative(f, parameters[i], step).reshape(3, 1))
dr_num = np.concatenate(dr_num, axis=1)
for n, c in zip(dr_num, dr_dp):
for nn, cc in zip(n, c):
print(nn)
print(cc)
assert abs(nn - cc) < 1e-7
ds_num = []
for i in range(len(parameters)):
def f(x):
p = copy(parameters)
p[i] = x
return compute_sigma(p)
fd = first_derivative(f, parameters[i], step)
print(fd)
ds_num.append(fd.reshape(3, 3, 1))
ds_num = np.concatenate(ds_num, axis=2)
for i in range(len(parameters)):
for n, c in zip(ds_num[:, :, i], dS_dp[:, :, i]):
for nn, cc in zip(n.flatten(), c.flatten()):
print(nn)
print(cc)
assert abs(nn - cc) < 1e-5
dl_num = []
for i in range(len(parameters)):
def f(x):
p = copy(parameters)
p[i] = x
return compute_sigma_lambda(p)**2
dl_num.append(first_derivative(f, parameters[i], step))
for n, c in zip(dl_num, dL_dp):
assert abs(n - c) < 1e-7
S1 = Simple1MosaicityParameterisation()
S6 = Simple6MosaicityParameterisation()
W = WavelengthSpreadParameterisation()
check(S1, None, fix_wavelength_spread=True)
check(S1, W, fix_mosaic_spread=True)
check(S1, W, fix_wavelength_spread=True)
check(S1, W, fix_unit_cell=True)
check(S1, W, fix_orientation=True)
check(S6, None, fix_wavelength_spread=True)
check(S6, W, fix_mosaic_spread=True)
check(S6, W, fix_wavelength_spread=True)
check(S6, W, fix_unit_cell=True)
check(S6, W, fix_orientation=True)
def test_ModelState(test_experiment):
experiments = [test_experiment]
S1 = Simple1MosaicityParameterisation()
S6 = Simple6MosaicityParameterisation()
W = WavelengthSpreadParameterisation()
with pytest.raises(AssertionError):
check_model_state_with_fixed(experiments[0],
S1,
None,
fix_mosaic_spread=True)
with pytest.raises(AssertionError):
check_model_state_with_fixed(experiments[0],
S1,
None,
fix_unit_cell=True)
with pytest.raises(AssertionError):
check_model_state_with_fixed(experiments[0],
S1,
None,
fix_orientation=True)
check_model_state_with_fixed(experiments[0],
S1,
None,
fix_wavelength_spread=True)
check_model_state_with_fixed(experiments[0], S1, W, fix_mosaic_spread=True)
check_model_state_with_fixed(experiments[0],
S1,
W,
fix_wavelength_spread=True)
check_model_state_with_fixed(experiments[0], S1, W, fix_unit_cell=True)
check_model_state_with_fixed(experiments[0], S1, W, fix_orientation=True)
with pytest.raises(AssertionError):
check_model_state_with_fixed(experiments[0],
S6,
None,
fix_mosaic_spread=True)
with pytest.raises(AssertionError):
check_model_state_with_fixed(experiments[0],
S6,
None,
fix_unit_cell=True)
with pytest.raises(AssertionError):
check_model_state_with_fixed(experiments[0],
S6,
None,
fix_orientation=True)
check_model_state_with_fixed(experiments[0],
S6,
None,
fix_wavelength_spread=True)
check_model_state_with_fixed(experiments[0], S6, W, fix_mosaic_spread=True)
check_model_state_with_fixed(experiments[0],
S6,
W,
fix_wavelength_spread=True)
check_model_state_with_fixed(experiments[0], S6, W, fix_unit_cell=True)
check_model_state_with_fixed(experiments[0], S6, W, fix_orientation=True)
def test_ReflectionLikelihood(testdata):
def check(
mosaicity_parameterisation,
wavelength_parameterisation,
fix_mosaic_spread=False,
fix_wavelength_spread=False,
fix_unit_cell=False,
fix_orientation=False,
):
experiment = testdata.experiment
models = testdata.models
s0 = np.array(testdata.s0)
sp = np.array(testdata.sp)
h = testdata.h
ctot = testdata.ctot
mobs = testdata.mobs
Sobs = testdata.Sobs
U_params = models[1].get_param_vals()
B_params = models[2].get_param_vals()
M_params = np.array(
models[0][:mosaicity_parameterisation.num_parameters()])
L_params = flex.double(models[3])
state = ModelState(
experiment,
mosaicity_parameterisation,
wavelength_parameterisation,
fix_mosaic_spread=fix_mosaic_spread,
fix_wavelength_spread=fix_wavelength_spread,
fix_unit_cell=fix_unit_cell,
fix_orientation=fix_orientation,
)
state.U_params = U_params
state.B_params = B_params
state.M_params = M_params
state.L_params = L_params
def get_reflection_likelihood(state):
return ReflectionLikelihood(state, s0, sp, h, ctot, mobs, Sobs)
likelihood = get_reflection_likelihood(state)
step = 1e-6
dL_dp = likelihood.first_derivatives()
parameters = state.active_parameters
assert len(dL_dp) == len(parameters)
def compute_likelihood(parameters):
state.active_parameters = parameters
likelihood = get_reflection_likelihood(state)
return likelihood.log_likelihood()
dL_num = []
for i in range(len(parameters)):
def f(x):
p = copy.copy(parameters)
p[i] = x
return compute_likelihood(p)
dL_num.append(first_derivative(f, parameters[i], step))
assert len(dL_num) == len(parameters)
print(dL_num)
print(list(dL_dp))
for n, c in zip(dL_num, dL_dp):
print(n, c)
assert n == pytest.approx(c, abs=1e-4)
S1 = Simple1MosaicityParameterisation()
S6 = Simple6MosaicityParameterisation()
check(S1, None, fix_wavelength_spread=True)
check(S1, None, fix_wavelength_spread=True, fix_mosaic_spread=True)
check(S1, None, fix_wavelength_spread=True, fix_unit_cell=True)
check(S1, None, fix_wavelength_spread=True, fix_orientation=True)
check(S6, None, fix_wavelength_spread=True, fix_mosaic_spread=True)
check(S6, None, fix_wavelength_spread=True, fix_unit_cell=True)
check(S6, None, fix_wavelength_spread=True, fix_orientation=True)
check(S6, None, fix_wavelength_spread=True)
def test_ConditionalDistribution(testdata):
def check(
mosaicity_parameterisation,
wavelength_parameterisation,
fix_mosaic_spread=False,
fix_wavelength_spread=False,
fix_unit_cell=False,
fix_orientation=False,
):
experiment = testdata.experiment
models = testdata.models
h = testdata.h
s0 = np.array(testdata.s0).reshape(3, 1)
sp = np.array(testdata.sp).reshape(3, 1)
# ctot = testdata.ctot
# mobs = testdata.mobs
# Sobs = testdata.Sobs
U_params = models[1].get_param_vals()
B_params = models[2].get_param_vals()
M_params = models[0][:mosaicity_parameterisation.num_parameters()]
L_params = models[3]
state = ModelState(
experiment,
mosaicity_parameterisation,
wavelength_parameterisation,
fix_mosaic_spread=fix_mosaic_spread,
fix_wavelength_spread=fix_wavelength_spread,
fix_unit_cell=fix_unit_cell,
fix_orientation=fix_orientation,
)
state.U_params = np.array(U_params, dtype=np.float64)
state.B_params = np.array(B_params, dtype=np.float64)
state.M_params = np.array(M_params, dtype=np.float64)
state.L_params = L_params
def get_conditional(state):
conditional = ReflectionLikelihood(
state,
s0,
sp,
h,
0,
np.array([0.0, 0.0]),
np.array([0.0, 0.0, 0.0, 0.0]).reshape(2, 2),
).conditional
return conditional
conditional = get_conditional(state)
step = 1e-6
dm_dp = conditional.first_derivatives_of_mean()
dS_dp = conditional.first_derivatives_of_sigma()
parameters = state.active_parameters
def compute_sigma(parameters):
state.active_parameters = parameters
return get_conditional(state).sigma()
def compute_mean(parameters):
state.active_parameters = parameters
return get_conditional(state).mean()
dm_num = []
for i in range(len(parameters)):
def f(x):
p = copy.copy(parameters)
p[i] = x
return compute_mean(p)
dm_num.append(first_derivative(f, parameters[i], step))
for n, c in zip(dm_num, dm_dp):
for nn, cc in zip(n, c):
print(nn)
print(cc)
assert abs(nn - cc) < 1e-7
# assert all(abs(nn - cc) < 1e-7 for nn, cc in zip(n, c))
ds_num = []
for i in range(len(parameters)):
def f(x):
p = copy.copy(parameters)
p[i] = x
return compute_sigma(p)
ds_num.append(first_derivative(f, parameters[i], step))
for n, c in zip(ds_num, dS_dp):
for nn, cc in zip(n.flatten(), c.flatten()):
print(nn)
print(cc)
assert abs(nn - cc) < 1e-7
# assert all(abs(nn - cc) < 1e-7 for nn, cc in zip(n, c))
S1 = Simple1MosaicityParameterisation()
S6 = Simple6MosaicityParameterisation()
check(S1, None, fix_wavelength_spread=True)
check(S1, None, fix_wavelength_spread=True, fix_mosaic_spread=True)
check(S1, None, fix_wavelength_spread=True, fix_unit_cell=True)
check(S1, None, fix_wavelength_spread=True, fix_orientation=True)
check(S6, None, fix_wavelength_spread=True)
check(S6, None, fix_wavelength_spread=True, fix_mosaic_spread=True)
check(S6, None, fix_wavelength_spread=True, fix_unit_cell=True)
check(S6, None, fix_wavelength_spread=True, fix_orientation=True)
def parameterisation(self):
"""
Get the parameterisation
"""
return Simple6MosaicityParameterisation(self.params)