def get_finegrained_SST(self, coarse_sampling_grid=0.005):
d_min = self.params.refinement_protocol.d_min_start
sel = self.reflections["id"] == -1
if d_min is not None:
sel &= 1 / self.reflections["rlp"].norms() > d_min
reciprocal_lattice_points = self.reflections["rlp"].select(sel)
print("Indexing from %i reflections COARSE" %
len(reciprocal_lattice_points))
from rstbx.array_family import flex
from rstbx.dps_core import SimpleSamplerTool
assert self.target_symmetry_primitive is not None
assert self.target_symmetry_primitive.unit_cell() is not None
SST = SimpleSamplerTool(coarse_sampling_grid)
SST.construct_hemisphere_grid(SST.incr)
cell_dimensions = self.target_symmetry_primitive.unit_cell(
).parameters()[:3]
unique_cell_dimensions = set(cell_dimensions)
print("Number of search vectors COARSE: %i" %
(len(SST.angles) * len(unique_cell_dimensions)))
vectors = flex.vec3_double()
function_values = flex.double()
import time
time1 = time.time()
SST_all_angles = flex.Direction()
for i, direction in enumerate(SST.angles):
for l in unique_cell_dimensions:
v = matrix.col(direction.dvec) * l
f = compute_functional(v.elems, reciprocal_lattice_points)
vectors.append(v.elems)
function_values.append(f)
SST_all_angles.append(direction)
time2 = time.time()
print('COARSE GRID SEARCH TIME=', time2 - time1)
perm = flex.sort_permutation(function_values, reverse=True)
vectors = vectors.select(perm)
function_values = function_values.select(perm)
unique_vectors = []
unique_indices = []
i = 0
while len(unique_vectors) < 30:
v = matrix.col(vectors[i])
is_unique = True
if i > 0:
for v_u in unique_vectors:
if v.length() < v_u.length():
if is_approximate_integer_multiple(
v,
v_u,
relative_tolerance=0.2,
angular_tolerance=5.0):
is_unique = False
break
elif is_approximate_integer_multiple(
v_u, v, relative_tolerance=0.2,
angular_tolerance=5.0):
is_unique = False
break
if is_unique:
unique_vectors.append(v)
unique_indices.append(perm[i])
i += 1
# Evaluate which SST angles contributed to the unique vectors
SST_filter = flex.Direction()
for v in unique_indices:
direction = SST.angles[v // len(unique_cell_dimensions)]
SST_filter.append(direction)
SST.construct_hemisphere_grid_finegrained(0.0001, coarse_sampling_grid,
SST_filter)
return SST
