def _sort_together_data_ccp4(self):
'''Sort together in the right order (rebatching as we go) the sweeps
we want to scale together.'''
max_batches = 0
for epoch in self._sweep_handler.get_epochs():
si = self._sweep_handler.get_sweep_information(epoch)
pname, xname, dname = si.get_project_info()
sname = si.get_sweep_name()
hklin = si.get_reflections()
# limit the reflections - e.g. if we are re-running the scaling step
# on just a subset of the integrated data
hklin = si.get_reflections()
limit_batch_range = None
for sweep in PhilIndex.params.xia2.settings.sweep:
if sweep.id == sname and sweep.range is not None:
limit_batch_range = sweep.range
break
if limit_batch_range is not None:
Debug.write('Limiting batch range for %s: %s' %
(sname, limit_batch_range))
start, end = limit_batch_range
hklout = os.path.splitext(hklin)[0] + '_tmp.mtz'
FileHandler.record_temporary_file(hklout)
rb = self._factory.Pointless()
rb.set_hklin(hklin)
rb.set_hklout(hklout)
rb.limit_batches(start, end)
si.set_reflections(hklout)
si.set_batches(limit_batch_range)
# keep a count of the maximum number of batches in a block -
# this will be used to make rebatch work below.
hklin = si.get_reflections()
batches = MtzUtils.batches_from_mtz(hklin)
if 1 + max(batches) - min(batches) > max_batches:
max_batches = max(batches) - min(batches) + 1
Debug.write('Biggest sweep has %d batches' % max_batches)
max_batches = nifty_power_of_ten(max_batches)
# then rebatch the files, to make sure that the batch numbers are
# in the same order as the epochs of data collection.
counter = 0
for epoch in self._sweep_handler.get_epochs():
si = self._sweep_handler.get_sweep_information(epoch)
hklin = si.get_reflections()
pname, xname, dname = si.get_project_info()
sname = si.get_sweep_name()
hklout = os.path.join(self.get_working_directory(),
'%s_%s_%s_%s_integrated.mtz' % \
(pname, xname, dname, sname))
first_batch = min(si.get_batches())
si.set_batch_offset(counter * max_batches - first_batch + 1)
from xia2.Modules.Scaler.rebatch import rebatch
new_batches = rebatch(hklin,
hklout,
first_batch=counter * max_batches + 1,
pname=pname,
xname=xname,
dname=dname)
# update the "input information"
si.set_reflections(hklout)
si.set_batches(new_batches)
# update the counter & recycle
counter += 1
s = self._factory.Sortmtz()
hklout = os.path.join(self.get_working_directory(),
'%s_%s_sorted.mtz' % \
(self._scalr_pname, self._scalr_xname))
s.set_hklout(hklout)
for epoch in self._sweep_handler.get_epochs():
s.add_hklin(
self._sweep_handler.get_sweep_information(
epoch).get_reflections())
s.sort()
# verify that the measurements are in the correct setting
# choice for the spacegroup
hklin = hklout
hklout = hklin.replace('sorted.mtz', 'temp.mtz')
if not self.get_scaler_reference_reflection_file():
if PhilIndex.params.xia2.settings.symmetry.program == 'dials':
p = self._factory.dials_symmetry()
else:
p = self._factory.Pointless()
FileHandler.record_log_file('%s %s pointless' % \
(self._scalr_pname,
self._scalr_xname),
p.get_log_file())
if len(self._sweep_handler.get_epochs()) > 1:
p.set_hklin(hklin)
else:
# permit the use of pointless preparation...
epoch = self._sweep_handler.get_epochs()[0]
p.set_hklin(
self._prepare_pointless_hklin(
hklin,
self._sweep_handler.get_sweep_information(
epoch).get_integrater().get_phi_width()))
if self._scalr_input_spacegroup:
Debug.write('Assigning user input spacegroup: %s' % \
self._scalr_input_spacegroup)
p.decide_spacegroup()
spacegroup = p.get_spacegroup()
reindex_operator = p.get_spacegroup_reindex_operator()
Debug.write('Pointless thought %s (reindex as %s)' % \
(spacegroup, reindex_operator))
spacegroup = self._scalr_input_spacegroup
reindex_operator = 'h,k,l'
self._spacegroup_reindex_operator = reindex_operator
else:
p.decide_spacegroup()
spacegroup = p.get_spacegroup()
reindex_operator = p.get_spacegroup_reindex_operator()
self._spacegroup_reindex_operator = clean_reindex_operator(
reindex_operator)
Debug.write('Pointless thought %s (reindex as %s)' % \
(spacegroup, reindex_operator))
if self._scalr_input_spacegroup:
self._scalr_likely_spacegroups = [self._scalr_input_spacegroup]
else:
self._scalr_likely_spacegroups = p.get_likely_spacegroups()
Chatter.write('Likely spacegroups:')
for spag in self._scalr_likely_spacegroups:
Chatter.write('%s' % spag)
Chatter.write(
'Reindexing to first spacegroup setting: %s (%s)' % \
(spacegroup, clean_reindex_operator(reindex_operator)))
else:
spacegroup = MtzUtils.space_group_name_from_mtz(
self.get_scaler_reference_reflection_file())
reindex_operator = 'h,k,l'
self._scalr_likely_spacegroups = [spacegroup]
Debug.write('Assigning spacegroup %s from reference' % \
spacegroup)
# then run reindex to set the correct spacegroup
ri = self._factory.Reindex()
ri.set_hklin(hklin)
ri.set_hklout(hklout)
ri.set_spacegroup(spacegroup)
ri.set_operator(reindex_operator)
ri.reindex()
FileHandler.record_temporary_file(hklout)
# then resort the reflections (one last time!)
s = self._factory.Sortmtz()
temp = hklin
hklin = hklout
hklout = temp
s.add_hklin(hklin)
s.set_hklout(hklout)
s.sort()
# done preparing!
self._prepared_reflections = s.get_hklout()
def _sort_together_data_xds_one_sweep(self):
assert len(self._sweep_information) == 1
epoch = self._sweep_information.keys()[0]
hklin = self._sweep_information[epoch]['scaled_reflections']
if self.get_scaler_reference_reflection_file():
spacegroups = [
MtzUtils.space_group_name_from_mtz(
self.get_scaler_reference_reflection_file())
]
reindex_operator = 'h,k,l'
elif self._scalr_input_spacegroup:
Debug.write('Assigning user input spacegroup: %s' % \
self._scalr_input_spacegroup)
spacegroups = [self._scalr_input_spacegroup]
reindex_operator = 'h,k,l'
else:
pointless = self._factory.Pointless()
pointless.set_hklin(hklin)
pointless.decide_spacegroup()
FileHandler.record_log_file('%s %s pointless' % \
(self._scalr_pname,
self._scalr_xname),
pointless.get_log_file())
spacegroups = pointless.get_likely_spacegroups()
reindex_operator = pointless.get_spacegroup_reindex_operator()
self._scalr_likely_spacegroups = spacegroups
spacegroup = self._scalr_likely_spacegroups[0]
self._scalr_reindex_operator = clean_reindex_operator(reindex_operator)
Chatter.write('Likely spacegroups:')
for spag in self._scalr_likely_spacegroups:
Chatter.write('%s' % spag)
Chatter.write(
'Reindexing to first spacegroup setting: %s (%s)' % \
(spacegroup, clean_reindex_operator(reindex_operator)))
hklout = os.path.join(self.get_working_directory(),
'%s_%s_reindex.mtz' % \
(self._scalr_pname, self._scalr_xname))
FileHandler.record_temporary_file(hklout)
if reindex_operator == '[h,k,l]':
# just assign spacegroup
from cctbx import sgtbx
s = sgtbx.space_group(
sgtbx.space_group_symbols(str(spacegroup)).hall())
m = mtz.object(hklin)
m.set_space_group(s).write(hklout)
self._scalr_cell = m.crystals()[-1].unit_cell().parameters()
Debug.write(
'Updating unit cell to %.2f %.2f %.2f %.2f %.2f %.2f' % \
tuple(self._scalr_cell))
del m
del s
else:
ri = self._factory.Reindex()
ri.set_hklin(hklin)
ri.set_hklout(hklout)
ri.set_spacegroup(spacegroup)
ri.set_operator(reindex_operator)
ri.reindex()
Debug.write(
'Updating unit cell to %.2f %.2f %.2f %.2f %.2f %.2f' % \
tuple(ri.get_cell()))
self._scalr_cell = tuple(ri.get_cell())
hklin = hklout
hklout = os.path.join(self.get_working_directory(),
'%s_%s_sorted.mtz' % \
(self._scalr_pname, self._scalr_xname))
s = self._factory.Sortmtz()
s.set_hklin(hklin)
s.set_hklout(hklout)
s.sort(vrset=-99999999.0)
self._prepared_reflections = hklout
def _sort_together_data_xds(self):
if len(self._sweep_information) == 1:
return self._sort_together_data_xds_one_sweep()
max_batches = 0
for epoch in self._sweep_information.keys():
hklin = self._sweep_information[epoch]['scaled_reflections']
if self._sweep_information[epoch]['batches'] == [0, 0]:
Chatter.write('Getting batches from %s' % hklin)
batches = MtzUtils.batches_from_mtz(hklin)
self._sweep_information[epoch]['batches'] = [
min(batches), max(batches)
]
Chatter.write('=> %d to %d' % (min(batches), max(batches)))
batches = self._sweep_information[epoch]['batches']
if 1 + max(batches) - min(batches) > max_batches:
max_batches = max(batches) - min(batches) + 1
Debug.write('Biggest sweep has %d batches' % max_batches)
max_batches = nifty_power_of_ten(max_batches)
epochs = sorted(self._sweep_information.keys())
counter = 0
for epoch in epochs:
hklin = self._sweep_information[epoch]['scaled_reflections']
pname = self._sweep_information[epoch]['pname']
xname = self._sweep_information[epoch]['xname']
dname = self._sweep_information[epoch]['dname']
sname = self._sweep_information[epoch]['sname']
hklout = os.path.join(self.get_working_directory(),
'%s_%s_%s_%d.mtz' % \
(pname, xname, dname, counter))
# we will want to delete this one exit
FileHandler.record_temporary_file(hklout)
# record this for future reference - will be needed in the
# radiation damage analysis...
# hack - reset this as it gets in a muddle...
intgr = self._sweep_information[epoch]['integrater']
self._sweep_information[epoch][
'batches'] = intgr.get_integrater_batches()
first_batch = min(self._sweep_information[epoch]['batches'])
offset = counter * max_batches - first_batch + 1
self._sweep_information[epoch]['batch_offset'] = offset
from xia2.Modules.Scaler.rebatch import rebatch
new_batches = rebatch(hklin,
hklout,
add_batch=offset,
pname=pname,
xname=xname,
dname=dname)
# update the "input information"
self._sweep_information[epoch]['hklin'] = hklout
self._sweep_information[epoch]['batches'] = new_batches
# update the counter & recycle
counter += 1
s = self._factory.Sortmtz()
hklout = os.path.join(self.get_working_directory(),
'%s_%s_sorted.mtz' % \
(self._scalr_pname, self._scalr_xname))
s.set_hklout(hklout)
for epoch in epochs:
s.add_hklin(self._sweep_information[epoch]['hklin'])
s.sort(vrset=-99999999.0)
self._prepared_reflections = hklout
if self.get_scaler_reference_reflection_file():
spacegroups = [
MtzUtils.space_group_name_from_mtz(
self.get_scaler_reference_reflection_file())
]
reindex_operator = 'h,k,l'
else:
pointless = self._factory.Pointless()
pointless.set_hklin(hklout)
pointless.decide_spacegroup()
FileHandler.record_log_file('%s %s pointless' % \
(self._scalr_pname,
self._scalr_xname),
pointless.get_log_file())
spacegroups = pointless.get_likely_spacegroups()
reindex_operator = pointless.get_spacegroup_reindex_operator()
if self._scalr_input_spacegroup:
Debug.write('Assigning user input spacegroup: %s' % \
self._scalr_input_spacegroup)
spacegroups = [self._scalr_input_spacegroup]
reindex_operator = 'h,k,l'
self._scalr_likely_spacegroups = spacegroups
spacegroup = self._scalr_likely_spacegroups[0]
self._scalr_reindex_operator = reindex_operator
Chatter.write('Likely spacegroups:')
for spag in self._scalr_likely_spacegroups:
Chatter.write('%s' % spag)
Chatter.write(
'Reindexing to first spacegroup setting: %s (%s)' % \
(spacegroup, clean_reindex_operator(reindex_operator)))
hklin = self._prepared_reflections
hklout = os.path.join(self.get_working_directory(),
'%s_%s_reindex.mtz' % \
(self._scalr_pname, self._scalr_xname))
FileHandler.record_temporary_file(hklout)
ri = self._factory.Reindex()
ri.set_hklin(hklin)
ri.set_hklout(hklout)
ri.set_spacegroup(spacegroup)
ri.set_operator(reindex_operator)
ri.reindex()
hklin = hklout
hklout = os.path.join(self.get_working_directory(),
'%s_%s_sorted.mtz' % \
(self._scalr_pname, self._scalr_xname))
s = self._factory.Sortmtz()
s.set_hklin(hklin)
s.set_hklout(hklout)
s.sort(vrset=-99999999.0)
self._prepared_reflections = hklout
Debug.write(
'Updating unit cell to %.2f %.2f %.2f %.2f %.2f %.2f' % \
tuple(ri.get_cell()))
self._scalr_cell = tuple(ri.get_cell())
return