def get_cell(self):
'''Compute an average cell.'''
if len(self._cells) < 1:
raise RuntimeError, 'no input unit cell parameters'
# check that the input cells are reasonably uniform -
# be really relaxed and allow 5% variation!
average_cell = [self._cells[0][j] for j in range(6)]
number_cells = 1
for j in range(1, len(self._cells)):
cell = self._cells[j]
for k in range(6):
average = average_cell[k] / number_cells
if math.fabs((cell[k] - average) / average) > 0.05 \
and not Flags.get_relax():
raise RuntimeError, 'incompatible unit cells'
average = average_cell[k] / number_cells
if math.fabs((cell[k] - average) / average) > 0.2:
raise RuntimeError, 'very incompatible unit cells'
# it was ok to remember for later on..
for k in range(6):
average_cell[k] += cell[k]
number_cells += 1
cellparm_inp = open(os.path.join(
self.get_working_directory(), 'CELLPARM.INP'), 'w')
for j in range(len(self._cells)):
cell = self._cells[j]
n_ref = self._n_refs[j]
cellparm_inp.write('UNIT_CELL_CONSTANTS=')
cellparm_inp.write(
'%.3f %.3f %.3f %.3f %.3f %.3f WEIGHT=%d\n' % \
(cell[0], cell[1], cell[2], cell[3], cell[4], cell[5],
n_ref))
cellparm_inp.close()
self.start()
self.close_wait()
# FIXME need to look for errors in here
cellparm_lp = open(os.path.join(
self.get_working_directory(), 'CELLPARM.LP'), 'r')
data = cellparm_lp.readlines()
return map(float, data[-1].split()[:6])
def _index(self):
'''Actually do the autoindexing using the data prepared by the
previous method.'''
images_str = '%d to %d' % tuple(self._indxr_images[0])
for i in self._indxr_images[1:]:
images_str += ', %d to %d' % tuple(i)
cell_str = None
if self._indxr_input_cell:
cell_str = '%.2f %.2f %.2f %.2f %.2f %.2f' % \
self._indxr_input_cell
# then this is a proper autoindexing run - describe this
# to the journal entry
#if len(self._fp_directory) <= 50:
#dirname = self._fp_directory
#else:
#dirname = '...%s' % self._fp_directory[-46:]
dirname = self.get_directory()
Journal.block('autoindexing', self._indxr_sweep_name, 'XDS',
{'images':images_str,
'target cell':cell_str,
'target lattice':self._indxr_input_lattice,
'template':self.get_template(),
'directory':dirname})
idxref = self.Idxref()
self._index_remove_masked_regions()
for file in ['SPOT.XDS']:
idxref.set_input_data_file(file, self._indxr_payload[file])
idxref.set_data_range(self._indxr_images[0][0],
self._indxr_images[0][1])
idxref.set_background_range(self._indxr_images[0][0],
self._indxr_images[0][1])
# set the phi start etc correctly
if self._i_or_ii == None:
self._i_or_ii = self.decide_i_or_ii()
Debug.write('Selecting I or II, chose %s' % self._i_or_ii)
if self._i_or_ii == 'i':
blocks = self._index_select_images_i()
for block in blocks[:1]:
starting_frame = block[0]
dd = Diffdump()
dd.set_image(self.get_image_name(starting_frame))
starting_angle = dd.readheader()['phi_start']
idxref.set_starting_frame(starting_frame)
idxref.set_starting_angle(starting_angle)
idxref.add_spot_range(block[0], block[1])
for block in blocks[1:]:
idxref.add_spot_range(block[0], block[1])
else:
for block in self._indxr_images[:1]:
starting_frame = block[0]
dd = Diffdump()
dd.set_image(self.get_image_name(starting_frame))
starting_angle = dd.readheader()['phi_start']
idxref.set_starting_frame(starting_frame)
idxref.set_starting_angle(starting_angle)
idxref.add_spot_range(block[0], block[1])
for block in self._indxr_images[1:]:
idxref.add_spot_range(block[0], block[1])
# FIXME need to also be able to pass in the known unit
# cell and lattice if already available e.g. from
# the helper... indirectly
if self._indxr_user_input_lattice:
idxref.set_indexer_user_input_lattice(True)
if self._indxr_input_lattice and self._indxr_input_cell:
idxref.set_indexer_input_lattice(self._indxr_input_lattice)
idxref.set_indexer_input_cell(self._indxr_input_cell)
Debug.write('Set lattice: %s' % self._indxr_input_lattice)
Debug.write('Set cell: %f %f %f %f %f %f' % \
self._indxr_input_cell)
original_cell = self._indxr_input_cell
elif self._indxr_input_lattice:
idxref.set_indexer_input_lattice(self._indxr_input_lattice)
original_cell = None
else:
original_cell = None
# FIXED need to set the beam centre here - this needs to come
# from the input .xinfo object or header, and be converted
# to the XDS frame... done.
#mosflm_beam_centre = self.get_beam_centre()
#xds_beam_centre = beam_centre_mosflm_to_xds(
#mosflm_beam_centre[0], mosflm_beam_centre[1], self.get_header())
from dxtbx.serialize.xds import to_xds
converter = to_xds(self.get_imageset())
xds_beam_centre = converter.detector_origin
idxref.set_beam_centre(xds_beam_centre[0],
xds_beam_centre[1])
# fixme need to check if the lattice, cell have been set already,
# and if they have, pass these in as input to the indexing job.
done = False
while not done:
try:
done = idxref.run()
# N.B. in here if the IDXREF step was being run in the first
# pass done is FALSE however there should be a refined
# P1 orientation matrix etc. available - so keep it!
except XDSException, e:
# inspect this - if we have complaints about not
# enough reflections indexed, and we have a target
# unit cell, and they are the same, well ignore it
if 'solution is inaccurate' in str(e):
Debug.write(
'XDS complains solution inaccurate - ignoring')
done = idxref.continue_from_error()
elif ('insufficient percentage (< 70%)' in str(e) or
'insufficient percentage (< 50%)' in str(e)) and \
original_cell:
done = idxref.continue_from_error()
lattice, cell, mosaic = \
idxref.get_indexing_solution()
# compare solutions
for j in range(3):
# allow two percent variation in unit cell length
if math.fabs((cell[j] - original_cell[j]) / \
original_cell[j]) > 0.02 and \
not Flags.get_relax():
Debug.write('XDS unhappy and solution wrong')
raise e
# and two degree difference in angle
if math.fabs(cell[j + 3] - original_cell[j + 3]) \
> 2.0 and not Flags.get_relax():
Debug.write('XDS unhappy and solution wrong')
raise e
Debug.write('XDS unhappy but solution ok')
elif 'insufficient percentage (< 70%)' in str(e) or \
'insufficient percentage (< 50%)' in str(e):
Debug.write('XDS unhappy but solution probably ok')
done = idxref.continue_from_error()
else:
raise e
