def refine_crystal(
experiment,
profile,
refiner_data,
fix_unit_cell=False,
fix_orientation=False,
wavelength_spread_model="delta",
):
"""Do the crystal refinement"""
if (fix_unit_cell is True) and (fix_orientation is True):
return
logger.info("\n" + "=" * 80 + "\nRefining crystal parmameters")
# Create the parameterisation
state = ModelState(
experiment,
profile.parameterisation.parameterisation(),
fix_mosaic_spread=True,
fix_unit_cell=fix_unit_cell,
fix_orientation=fix_orientation,
fix_wavelength_spread=wavelength_spread_model == "delta",
)
# Create the refiner and refine
refiner = ProfileRefiner(state, refiner_data)
refiner.refine()
return refiner
def refine_profile(experiment,
profile,
refiner_data,
wavelength_spread_model="delta"):
"""Do the profile refinement"""
logger.info("\n" + "=" * 80 + "\nRefining profile parmameters")
# Create the parameterisation
state = ModelState(
experiment,
profile.parameterisation.parameterisation(),
fix_orientation=True,
fix_unit_cell=True,
fix_wavelength_spread=wavelength_spread_model == "delta",
)
# Create the refiner and refine
refiner = ProfileRefiner(state, refiner_data)
refiner.refine()
# Set the profile parameters
profile.parameterisation.update_model(state)
# Set the mosaicity
experiment.crystal.mosaicity = profile
return refiner
def check(
parameterisation,
fix_mosaic_spread=True,
fix_orientation=True,
fix_unit_cell=True,
fix_wavelength_spread=True,
):
state = ModelState(
experiment,
parameterisation,
fix_mosaic_spread=fix_mosaic_spread,
fix_orientation=fix_orientation,
fix_unit_cell=fix_unit_cell,
fix_wavelength_spread=fix_wavelength_spread,
)
refiner = Refiner(state, data)
refiner.refine()
print(state.mosaicity_covariance_matrix)
def simple6_model_state(test_experiment):
state = ModelState(test_experiment, Simple6MosaicityParameterisation())
return state
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
def check_reflection_model_state_with_fixed(
experiment,
mosaicity_parameterisation,
wavelength_parameterisation,
fix_mosaic_spread=False,
fix_wavelength_spread=False,
fix_unit_cell=False,
fix_orientation=False,
):
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,
)
model = ReflectionModelState(state, matrix.col(experiment.beam.get_s0()),
matrix.col((1, 1, 1)))
assert list(model.mosaicity_covariance_matrix.flatten()) == list(
mosaicity_parameterisation.sigma().flatten())
assert list(model.get_r().flatten()) == pytest.approx(
np.matmul(state.A_matrix,
np.array([1, 1, 1]).reshape(3, 1))[:, 0].tolist(),
abs=1e-6,
)
if wavelength_parameterisation is not None:
assert model.wavelength_spread == wavelength_parameterisation.sigma()
else:
assert model.wavelength_spread == 0
dS_dp = model.get_dS_dp()
dr_dp = model.get_dr_dp()
dL_dp = model.get_dL_dp()
assert dS_dp.shape[2] == len(state.parameter_labels)
assert dr_dp.shape[1] == len(state.parameter_labels)
assert len(dL_dp) == len(state.parameter_labels)
if not fix_wavelength_spread:
assert dr_dp[:, -1].flatten() == pytest.approx([0, 0, 0], abs=1e-6)
assert dS_dp[:, :, -1].flatten() == pytest.approx(
(0, 0, 0, 0, 0, 0, 0, 0, 0), abs=1e-6)
dr_dp = dr_dp[:, :-1]
dS_dp = dS_dp[:, :, :-1]
dL_dp = dL_dp[:-1]
if not fix_mosaic_spread:
num_params = mosaicity_parameterisation.num_parameters()
for i in range(num_params):
assert dr_dp[:, -(i + 1)] == pytest.approx([0, 0, 0], abs=1e-6)
assert dS_dp[:, :, -(i + 1)] == pytest.approx(
state.dM_dp[-(i + 1), :, :], abs=1e-6)
assert dL_dp[-1] == 0
dr_dp = dr_dp[:, :-num_params]
dS_dp = dS_dp[:, :, :-num_params]
dL_dp = dL_dp[:-num_params]
if not fix_unit_cell:
num_params = state.B_params.size
for i in range(num_params):
assert dS_dp[:, :, -(i + 1)].flatten() == pytest.approx(
(0, 0, 0, 0, 0, 0, 0, 0, 0), abs=1e-6)
assert dL_dp[-(i + 1)] == 0
dr_dp = dr_dp[:, :-num_params]
dS_dp = dS_dp[:, :, :-num_params]
dL_dp = dL_dp[:-num_params]
if not fix_orientation:
num_params = state.U_params.size
for i in range(num_params):
assert dS_dp[:, :, -(i + 1)].flatten() == pytest.approx(
(0, 0, 0, 0, 0, 0, 0, 0, 0), abs=1e-6)
assert dL_dp[-(i + 1)] == 0
dr_dp = dr_dp[:, :-num_params]
dS_dp = dS_dp[:, :, :-num_params]
dL_dp = dL_dp[:-num_params]
def check_model_state_with_fixed(
experiment,
mosaicity_parameterisation,
wavelength_parameterisation,
fix_mosaic_spread=False,
fix_wavelength_spread=False,
fix_unit_cell=False,
fix_orientation=False,
):
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,
)
assert state.is_orientation_fixed == fix_orientation
assert state.is_unit_cell_fixed == fix_unit_cell
assert state.is_mosaic_spread_fixed == fix_mosaic_spread
assert state.is_wavelength_spread_fixed == fix_wavelength_spread
U = state.U_matrix
B = state.B_matrix
A = state.A_matrix
M = state.mosaicity_covariance_matrix
L = state.wavelength_spread
assert U.shape == (3, 3)
assert B.shape == (3, 3)
assert A.shape == (3, 3)
assert M.shape == (3, 3)
if wavelength_parameterisation is not None:
assert len(L) == 1
else:
assert len(L) == 0
assert len(state.U_params) == 3
assert len(state.B_params) == 2
assert len(state.M_params) == mosaicity_parameterisation.num_parameters()
if wavelength_parameterisation is not None:
assert len(state.L_params) == 1
else:
assert len(state.L_params) == 0
dU = state.dU_dp
dB = state.dB_dp
dM = state.dM_dp
dL = state.dL_dp
assert dU.shape[0] == 3
assert dB.shape[0] == 2
assert dM.shape[0] == mosaicity_parameterisation.num_parameters()
if wavelength_parameterisation is not None:
assert len(dL) == 1
else:
assert len(dL) == 0
params = state.active_parameters
expected_len = 0
if not fix_mosaic_spread:
expected_len += mosaicity_parameterisation.num_parameters()
if not fix_wavelength_spread:
if wavelength_parameterisation is not None:
expected_len += wavelength_parameterisation.num_parameters()
if not fix_unit_cell:
expected_len += 2
if not fix_orientation:
expected_len += 3
assert len(params) == expected_len
new_params = params
state.active_parameters = new_params
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)
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