def __init__(self, lattice_cell_dict):
"""Initialise myself from a dictionary keyed by crystal lattice
classes (e.g. tP) containing unit cells for these lattices."""
# transform them into a list, then sort the solutions and
# store the sorted version
lattices = [(k, lattice_cell_dict[k]) for k in lattice_cell_dict.keys()]
self._sorted_list = SortLattices(lattices)
def insert(self, lattice, cell):
"""Insert a new solution, e.g. from some postprocessing from
the indexer. N.B. this will be re-sorted."""
lattices = [(lattice, cell)]
for l in self._sorted_list:
lattices.append(l)
self._sorted_list = SortLattices(lattices)
def continue_from_error(self):
# copy the LP file
shutil.copyfile(
os.path.join(self.get_working_directory(), "IDXREF.LP"),
os.path.join(
self.get_working_directory(), "%d_IDXREF.LP" % self.get_xpid()
),
)
# parse the output
lp = open(
os.path.join(self.get_working_directory(), "IDXREF.LP"), "r"
).readlines()
self._fraction_rmsd_rmsphi = _parse_idxref_lp_quality(lp)
self._idxref_data = _parse_idxref_lp(lp)
if not self._idxref_data:
raise RuntimeError("indexing failed")
st = _parse_idxref_lp_subtree(lp)
if 2 in st:
if st[2] > st[1] / 10.0:
Debug.write("Look closely at autoindexing solution!")
self._index_tree_problem = True
for j in sorted(st):
Debug.write("%2d: %5d" % (j, st[j]))
# print out some (perhaps dire) warnings about the beam centre
# if there is really any ambiguity...
origins = _parse_idxref_index_origin(lp)
assert (0, 0, 0) in origins
quality_0 = origins[(0, 0, 0)][0]
alternatives = []
for hkl in origins:
if hkl == (0, 0, 0):
continue
if origins[hkl][0] < 4 * quality_0:
quality, delta, beam_x, beam_y = origins[hkl]
alternatives.append(
(hkl[0], hkl[1], hkl[2], quality, beam_x, beam_y)
)
if alternatives:
Debug.write("Alternative indexing possible:")
for alternative in alternatives:
Debug.write("... %3d %3d %3d %4.1f %6.1f %6.1f" % alternative)
# New algorithm in here - now use iotbx.lattice_symmetry with the
# P1 indexing solution (solution #1) to determine the list of
# allowable solutions - only consider those lattices in this
# allowed list (unless we have user input)
from xia2.Wrappers.Phenix.LatticeSymmetry import LatticeSymmetry
ls = LatticeSymmetry()
ls.set_lattice("aP")
ls.set_cell(tuple(self._idxref_data[44]["cell"]))
ls.generate()
allowed_lattices = ls.get_lattices()
for j in range(1, 45):
if j not in self._idxref_data:
continue
data = self._idxref_data[j]
lattice = data["lattice"]
fit = data["fit"]
cell = data["cell"]
mosaic = data["mosaic"]
if self._symm and self._cell and self._indxr_user_input_lattice:
if (
self._compare_cell(self._cell, cell)
and lattice_to_spacegroup_number(lattice) == self._symm
):
if lattice in self._indexing_solutions:
if self._indexing_solutions[lattice]["goodness"] < fit:
continue
self._indexing_solutions[lattice] = {
"goodness": fit,
"cell": cell,
}
else:
if lattice in allowed_lattices or (self._symm and fit < 200.0):
# bug 2417 - if we have an input lattice then we
# don't want to include anything higher symmetry
# in the results table...
if self._symm:
if lattice_to_spacegroup_number(lattice) > self._symm:
Debug.write(
"Ignoring solution with lattice %s" % lattice
)
continue
if lattice in self._indexing_solutions:
if self._indexing_solutions[lattice]["goodness"] < fit:
continue
self._indexing_solutions[lattice] = {
"goodness": fit,
"cell": cell,
}
# postprocess this list, to remove lattice solutions which are
# lower symmetry but higher penalty than the putative correct
# one, if self._symm is set...
if self._symm:
assert self._indexing_solutions, (
"No remaining indexing solutions (%s, %s)"
% (s2l(self._symm), self._symm)
)
else:
assert self._indexing_solutions, "No remaining indexing solutions"
if self._symm:
max_p = 2.0 * self._indexing_solutions[s2l(self._symm)]["goodness"]
to_remove = []
for lattice in self._indexing_solutions:
if self._indexing_solutions[lattice]["goodness"] > max_p:
to_remove.append(lattice)
for lattice in to_remove:
Debug.write("Ignoring solution with lattice %s" % lattice)
del self._indexing_solutions[lattice]
# get the highest symmetry "acceptable" solution
items = [
(k, self._indexing_solutions[k]["cell"])
for k in self._indexing_solutions
]
# if there was a preassigned cell and symmetry return now
# with everything done, else select the "top" solution and
# reindex, resetting the input cell and symmetry.
if self._cell:
# select the solution which matches the input unit cell
# actually after the changes above this should now be the
# only solution in the table..
Debug.write(
"Target unit cell: %.2f %.2f %.2f %.2f %.2f %.2f" % self._cell
)
for l in items:
if lattice_to_spacegroup_number(l[0]) == self._symm:
# this should be the correct solution...
# check the unit cell...
cell = l[1]
cell_str = "%.2f %.2f %.2f %.2f %.2f %.2f" % cell
Debug.write("Chosen unit cell: %s" % cell_str)
self._indxr_lattice = l[0]
self._indxr_cell = l[1]
self._indxr_mosaic = mosaic
else:
# select the top solution as the input cell and reset the
# "indexing done" flag
sorted_list = SortLattices(items)
# print sorted_list
self._symm = lattice_to_spacegroup_number(sorted_list[0][0])
self._cell = sorted_list[0][1]
return False
# get the refined distance &c.
beam, distance = _parse_idxref_lp_distance_etc(lp)
self._refined_beam = beam
self._refined_distance = distance
# gather the output files
for file in self._output_data_files_list:
self._output_data_files[file] = os.path.join(
self.get_working_directory(), file
)
return True
def __init__(self, lattice_cell_dict):
"""Initialise myself from a dictionary keyed by crystal lattice
classes (e.g. tP) containing unit cells for these lattices."""
self._sorted_list = SortLattices(lattice_cell_dict.items())