def recip_ex(detector_size, pixel_size, calibrated_center, dist_sample,
ub_mat, wavelength, motors, i_stack, H_range, K_range, L_range):
# convert to Q space
q_values = recip.process_to_q(motors, detector_size, pixel_size,
calibrated_center, dist_sample,
wavelength, ub_mat)
# minimum and maximum values of the voxel
q_min = np.array([H_range[0], K_range[0], L_range[0]])
q_max = np.array([H_range[1], K_range[1], L_range[1]])
# no. of bins
dqn = np.array([40, 40, 1])
# process the grid values
(grid_data, grid_occu, std_err,
grid_out, bounds) = grid3d(q_values, i_stack, dqn[0], dqn[1],
dqn[2])
grid = np.mgrid[0:dqn[0], 0:dqn[1], 0:dqn[2]]
r = (q_max - q_min) / dqn
X = grid[0] * r[0] + q_min[0]
Y = grid[1] * r[1] + q_min[1]
Z = grid[2] * r[2] + q_min[2]
# creating a mask
_mask = grid_occu <= 10
grid_mask_data = ma.masked_array(grid_data, _mask)
grid_mask_std_err = ma.masked_array(std_err, _mask)
grid_mask_occu = ma.masked_array(grid_occu, _mask)
return X, Y, Z, grid_mask_data
def test_process_grid_std_err():
size = 10
q_max = np.array([1.0, 1.0, 1.0])
q_min = np.array([-1.0, -1.0, -1.0])
dqn = np.array([size, size, size])
param_dict = {'nx': dqn[0],
'ny': dqn[1],
'nz': dqn[2],
'xmin': q_min[0],
'ymin': q_min[1],
'zmin': q_min[2],
'xmax': q_max[0],
'ymax': q_max[1],
'zmax': q_max[2],
'n_threads': 1}
# slice tricks
# this make a list of slices, the imaginary value in the
# step is interpreted as meaning 'this many values'
slc = [slice(_min + (_max - _min)/(s * 2),
_max - (_max - _min)/(s * 2),
1j * s)
for _min, _max, s in zip(q_min, q_max, dqn)]
# use the numpy slice magic to make X, Y, Z these are dense meshes with
# points in the center of each bin
X, Y, Z = np.mgrid[slc]
# make and ravel the image data (which is all ones)
I = np.hstack([j * np.ones_like(X).ravel() for j in range(1, 6)])
# make input data (N*5x3)
data = np.vstack([np.tile(_, 5)
for _ in (np.ravel(X), np.ravel(Y), np.ravel(Z))]).T
(mean, occupancy,
std_err, oob, bounds) = core.grid3d(data, I, **param_dict)
# check the values are as expected
npt.assert_array_equal(mean,
np.ones_like(X) * np.mean(np.arange(1, 6)))
npt.assert_equal(oob, 0)
npt.assert_array_equal(occupancy, np.ones_like(occupancy)*5)
# need to convert std -> ste (standard error)
# according to wikipedia ste = std/sqrt(n), but experimentally, this is
# implemented as ste = std / srt(n - 1)
npt.assert_array_equal(std_err,
(np.ones_like(occupancy) *
np.std(np.arange(1, 6))/np.sqrt(5 - 1)))
def test_grid3d():
size = 10
q_max = np.array([1.0, 1.0, 1.0])
q_min = np.array([-1.0, -1.0, -1.0])
dqn = np.array([size, size, size])
param_dict = {'nx': dqn[0],
'ny': dqn[1],
'nz': dqn[2],
'xmin': q_min[0],
'ymin': q_min[1],
'zmin': q_min[2],
'xmax': q_max[0],
'ymax': q_max[1],
'zmax': q_max[2]}
# slice tricks
# this make a list of slices, the imaginary value in the
# step is interpreted as meaning 'this many values'
slc = [slice(_min + (_max - _min)/(s * 2),
_max - (_max - _min)/(s * 2),
1j * s)
for _min, _max, s in zip(q_min, q_max, dqn)]
# use the numpy slice magic to make X, Y, Z these are dense meshes with
# points in the center of each bin
X, Y, Z = np.mgrid[slc]
# make and ravel the image data (which is all ones)
I = np.ones_like(X).ravel()
# make input data (Nx3
data = np.array([np.ravel(X),
np.ravel(Y),
np.ravel(Z)]).T
(mean, occupancy,
std_err, oob, bounds) = core.grid3d(data, I, **param_dict)
# check the values are as expected
npt.assert_array_equal(mean.ravel(), I)
npt.assert_equal(oob, 0)
npt.assert_array_equal(occupancy, np.ones_like(occupancy))
npt.assert_array_equal(std_err, 0)
