def generate_cif(crystal, refiner, filename):
logger.info("Saving CIF information to %s", filename)
from cctbx import miller
import iotbx.cif.model
block = iotbx.cif.model.block()
block["_audit_creation_method"] = dials_version()
block["_audit_creation_date"] = datetime.date.today().isoformat()
# block["_publ_section_references"] = '' # once there is a reference...
for cell, esd, cifname in zip(
crystal.get_unit_cell().parameters(),
crystal.get_cell_parameter_sd(),
[
"length_a",
"length_b",
"length_c",
"angle_alpha",
"angle_beta",
"angle_gamma",
],
):
block["_cell_%s" % cifname] = format_float_with_standard_uncertainty(
cell, esd
)
block["_cell_volume"] = format_float_with_standard_uncertainty(
crystal.get_unit_cell().volume(), crystal.get_cell_volume_sd()
)
used_reflections = refiner.get_matches()
block["_cell_measurement_reflns_used"] = len(used_reflections)
block["_cell_measurement_theta_min"] = (
flex.min(used_reflections["2theta_obs.rad"]) * 180 / math.pi / 2
)
block["_cell_measurement_theta_max"] = (
flex.max(used_reflections["2theta_obs.rad"]) * 180 / math.pi / 2
)
block["_diffrn_reflns_number"] = len(used_reflections)
miller_span = miller.index_span(used_reflections["miller_index"])
min_h, min_k, min_l = miller_span.min()
max_h, max_k, max_l = miller_span.max()
block["_diffrn_reflns_limit_h_min"] = min_h
block["_diffrn_reflns_limit_h_max"] = max_h
block["_diffrn_reflns_limit_k_min"] = min_k
block["_diffrn_reflns_limit_k_max"] = max_k
block["_diffrn_reflns_limit_l_min"] = min_l
block["_diffrn_reflns_limit_l_max"] = max_l
block["_diffrn_reflns_theta_min"] = (
flex.min(used_reflections["2theta_obs.rad"]) * 180 / math.pi / 2
)
block["_diffrn_reflns_theta_max"] = (
flex.max(used_reflections["2theta_obs.rad"]) * 180 / math.pi / 2
)
cif = iotbx.cif.model.cif()
cif["two_theta_refine"] = block
with open(filename, "w") as fh:
cif.show(out=fh)
def format_cc_with_standard_error(cc, se, decimal_places=3):
if math.isnan(se):
return "?"
minimum = pow(0.1, decimal_places)
if se >= minimum:
cc_str = format_float_with_standard_uncertainty(cc, se, minimum=1.0e-3)
else:
cc_str = "{val:0.{dp}f}".format(val=cc, dp=decimal_places)
return cc_str
def generate_cif(crystal, refiner, file):
logger.info('Saving CIF information to %s' % file)
from cctbx import miller
import datetime
import iotbx.cif.model
import math
block = iotbx.cif.model.block()
block["_audit_creation_method"] = dials_version()
block["_audit_creation_date"] = datetime.date.today().isoformat()
# block["_publ_section_references"] = '' # once there is a reference...
for cell, esd, cifname in zip(crystal.get_unit_cell().parameters(),
crystal.get_cell_parameter_sd(),
['length_a', 'length_b', 'length_c', 'angle_alpha', 'angle_beta', 'angle_gamma']):
block['_cell_%s' % cifname] = format_float_with_standard_uncertainty(cell, esd)
block['_cell_volume'] = format_float_with_standard_uncertainty(crystal.get_unit_cell().volume(), crystal.get_cell_volume_sd())
used_reflections = refiner.get_matches()
block['_cell_measurement_reflns_used'] = len(used_reflections)
block['_cell_measurement_theta_min'] = flex.min(used_reflections['2theta_obs.rad']) * 180 / math.pi / 2
block['_cell_measurement_theta_max'] = flex.max(used_reflections['2theta_obs.rad']) * 180 / math.pi / 2
block['_diffrn_reflns_number'] = len(used_reflections)
miller_span = miller.index_span(used_reflections['miller_index'])
min_h, min_k, min_l = miller_span.min()
max_h, max_k, max_l = miller_span.max()
block['_diffrn_reflns_limit_h_min'] = min_h
block['_diffrn_reflns_limit_h_max'] = max_h
block['_diffrn_reflns_limit_k_min'] = min_k
block['_diffrn_reflns_limit_k_max'] = max_k
block['_diffrn_reflns_limit_l_min'] = min_l
block['_diffrn_reflns_limit_l_max'] = max_l
block['_diffrn_reflns_theta_min'] = flex.min(used_reflections['2theta_obs.rad']) * 180 / math.pi / 2
block['_diffrn_reflns_theta_max'] = flex.max(used_reflections['2theta_obs.rad']) * 180 / math.pi / 2
cif = iotbx.cif.model.cif()
cif['two_theta_refine'] = block
with open(file, 'w') as fh:
cif.show(out=fh)
def get_output(self):
result = "Crystal: %s\n" % self._name
if self._aa_sequence:
result += "Sequence: %s\n" % self._aa_sequence.get_sequence()
for wavelength in self._wavelengths.keys():
result += self._wavelengths[wavelength].get_output()
scaler = self._get_scaler()
if scaler.get_scaler_finish_done():
for wname, xwav in self._wavelengths.iteritems():
for xsweep in xwav.get_sweeps():
idxr = xsweep._get_indexer()
if PhilIndex.params.xia2.settings.show_template:
result += "%s\n" % banner(
"Autoindexing %s (%s)" %
(idxr.get_indexer_sweep_name(),
idxr.get_template()))
else:
result += "%s\n" % banner(
"Autoindexing %s" % idxr.get_indexer_sweep_name())
result += "%s\n" % idxr.show_indexer_solutions()
intgr = xsweep._get_integrater()
if PhilIndex.params.xia2.settings.show_template:
result += "%s\n" % banner(
"Integrating %s (%s)" %
(intgr.get_integrater_sweep_name(),
intgr.get_template()))
else:
result += "%s\n" % banner(
"Integrating %s" %
intgr.get_integrater_sweep_name())
result += "%s\n" % intgr.show_per_image_statistics()
result += "%s\n" % banner("Scaling %s" % self.get_name())
for (
(dname, sname),
(limit, suggested),
) in scaler.get_scaler_resolution_limits().iteritems():
if suggested is None or limit == suggested:
result += "Resolution limit for %s/%s: %5.2f\n" % (
dname,
sname,
limit,
)
else:
result += (
"Resolution limit for %s/%s: %5.2f (%5.2f suggested)\n"
% (dname, sname, limit, suggested))
# this is now deprecated - be explicit in what you are
# asking for...
reflections_all = self.get_scaled_merged_reflections()
statistics_all = self._get_scaler().get_scaler_statistics()
# print some of these statistics, perhaps?
for key in statistics_all.keys():
result += format_statistics(statistics_all[key],
caption="For %s/%s/%s" % key)
# then print out some "derived" information based on the
# scaling - this is presented through the Scaler interface
# explicitly...
cell = self._get_scaler().get_scaler_cell()
cell_esd = self._get_scaler().get_scaler_cell_esd()
spacegroups = self._get_scaler().get_scaler_likely_spacegroups()
spacegroup = spacegroups[0]
resolution = self._get_scaler().get_scaler_highest_resolution()
from cctbx import sgtbx
sg = sgtbx.space_group_type(str(spacegroup))
spacegroup = sg.lookup_symbol()
CIF.set_spacegroup(sg)
mmCIF.set_spacegroup(sg)
if len(self._wavelengths) == 1:
CIF.set_wavelengths(
[w.get_wavelength() for w in self._wavelengths.itervalues()])
mmCIF.set_wavelengths(
[w.get_wavelength() for w in self._wavelengths.itervalues()])
else:
for wavelength in self._wavelengths.keys():
full_wave_name = "%s_%s_%s" % (
self._project._name,
self._name,
wavelength,
)
CIF.get_block(full_wave_name)[
"_diffrn_radiation_wavelength"] = self._wavelengths[
wavelength].get_wavelength()
mmCIF.get_block(full_wave_name)[
"_diffrn_radiation_wavelength"] = self._wavelengths[
wavelength].get_wavelength()
CIF.set_wavelengths({
name: wave.get_wavelength()
for name, wave in self._wavelengths.iteritems()
})
mmCIF.set_wavelengths({
name: wave.get_wavelength()
for name, wave in self._wavelengths.iteritems()
})
result += "Assuming spacegroup: %s\n" % spacegroup
if len(spacegroups) > 1:
result += "Other likely alternatives are:\n"
for sg in spacegroups[1:]:
result += "%s\n" % sg
if cell_esd:
from libtbx.utils import format_float_with_standard_uncertainty
def match_formatting(dimA, dimB):
def conditional_split(s):
return ((s[:s.index(".")],
s[s.index("."):]) if "." in s else (s, ""))
A, B = conditional_split(dimA), conditional_split(dimB)
maxlen = (max(len(A[0]), len(B[0])), max(len(A[1]), len(B[1])))
return (
A[0].rjust(maxlen[0]) + A[1].ljust(maxlen[1]),
B[0].rjust(maxlen[0]) + B[1].ljust(maxlen[1]),
)
formatted_cell_esds = tuple(
format_float_with_standard_uncertainty(v, sd)
for v, sd in zip(cell, cell_esd))
formatted_rows = (formatted_cell_esds[0:3],
formatted_cell_esds[3:6])
formatted_rows = zip(*(match_formatting(l, a)
for l, a in zip(*formatted_rows)))
result += "Unit cell (with estimated std devs):\n"
result += "%s %s %s\n%s %s %s\n" % (formatted_rows[0] +
formatted_rows[1])
else:
result += "Unit cell:\n"
result += "%7.3f %7.3f %7.3f\n%7.3f %7.3f %7.3f\n" % tuple(cell)
# now, use this information and the sequence (if provided)
# and also matthews_coef (should I be using this directly, here?)
# to compute a likely number of molecules in the ASU and also
# the solvent content...
if self._aa_sequence:
residues = self._aa_sequence.get_sequence()
if residues:
nres = len(residues)
# first compute the number of molecules using the K&R
# method
nmol = compute_nmol(
cell[0],
cell[1],
cell[2],
cell[3],
cell[4],
cell[5],
spacegroup,
resolution,
nres,
)
# then compute the solvent fraction
solvent = compute_solvent(
cell[0],
cell[1],
cell[2],
cell[3],
cell[4],
cell[5],
spacegroup,
nmol,
nres,
)
result += "Likely number of molecules in ASU: %d\n" % nmol
result += "Giving solvent fraction: %4.2f\n" % solvent
self._nmol = nmol
if isinstance(reflections_all, type({})):
for format in reflections_all.keys():
result += "%s format:\n" % format
reflections = reflections_all[format]
if isinstance(reflections, type({})):
for wavelength in reflections.keys():
target = FileHandler.get_data_file(
reflections[wavelength])
result += "Scaled reflections (%s): %s\n" % (
wavelength, target)
else:
target = FileHandler.get_data_file(reflections)
result += "Scaled reflections: %s\n" % target
CIF.write_cif()
mmCIF.write_cif()
return result
def _show(self, show_scan_varying=False, out=None):
from scitbx import matrix
if out is None:
import sys
out = sys.stdout
uc = self.get_unit_cell().parameters()
uc_sd = self.get_cell_parameter_sd()
sg = str(self.get_space_group().info())
umat = matrix.sqr(self.get_U()).mathematica_form(
format="% 5.4f", one_row_per_line=True).splitlines()
bmat = matrix.sqr(self.get_B()).mathematica_form(
format="% 5.4f", one_row_per_line=True).splitlines()
amat = (matrix.sqr(self.get_U()) *
matrix.sqr(self.get_B())).mathematica_form(
format="% 5.4f", one_row_per_line=True).splitlines()
msg = ["Crystal:"]
from libtbx.utils import format_float_with_standard_uncertainty
if len(uc_sd) != 0:
cell_str = [
format_float_with_standard_uncertainty(v, e, minimum=1.e-5)
for (v, e) in zip(uc, uc_sd)
]
msg.append(" Unit cell: (" + ", ".join(cell_str) + ")")
else:
msg.append(" Unit cell: " +
"(%5.3f, %5.3f, %5.3f, %5.3f, %5.3f, %5.3f)" % uc)
msg.append(" Space group: " + sg)
msg.append(" U matrix: " + umat[0])
msg.append(" " + umat[1])
msg.append(" " + umat[2])
msg.append(" B matrix: " + bmat[0])
msg.append(" " + bmat[1])
msg.append(" " + bmat[2])
msg.append(" A = UB: " + amat[0])
msg.append(" " + amat[1])
msg.append(" " + amat[2])
if self.num_scan_points > 0:
msg.append(" A sampled at " + str(self.num_scan_points) \
+ " scan points")
if show_scan_varying:
for i in range(self.num_scan_points):
A = matrix.sqr(self.get_A_at_scan_point(i))
B = matrix.sqr(self.get_B_at_scan_point(i))
U = matrix.sqr(self.get_U_at_scan_point(i))
uc = self.get_unit_cell_at_scan_point(i).parameters()
umat = U.mathematica_form(
format="% 5.4f", one_row_per_line=True).splitlines()
bmat = B.mathematica_form(
format="% 5.4f", one_row_per_line=True).splitlines()
amat = A.mathematica_form(
format="% 5.4f", one_row_per_line=True).splitlines()
msg.append(" Scan point #%i:" % (i + 1))
msg.append(" Unit cell: " +
"(%5.3f, %5.3f, %5.3f, %5.3f, %5.3f, %5.3f)" %
uc)
msg.append(" U matrix: " + umat[0])
msg.append(" " + umat[1])
msg.append(" " + umat[2])
msg.append(" B matrix: " + bmat[0])
msg.append(" " + bmat[1])
msg.append(" " + bmat[2])
msg.append(" A = UB: " + amat[0])
msg.append(" " + amat[1])
msg.append(" " + amat[2])
print >> out, "\n".join(msg)
def get_output(self):
result = 'Crystal: %s\n' % self._name
if self._aa_sequence:
result += 'Sequence: %s\n' % self._aa_sequence.get_sequence()
for wavelength in self._wavelengths.keys():
result += self._wavelengths[wavelength].get_output()
scaler = self._get_scaler()
if scaler.get_scaler_finish_done():
for wname, xwav in self._wavelengths.iteritems():
for xsweep in xwav.get_sweeps():
idxr = xsweep._get_indexer()
if PhilIndex.params.xia2.settings.show_template:
result += '%s\n' %banner('Autoindexing %s (%s)' %(
idxr.get_indexer_sweep_name(), idxr.get_template()))
else:
result += '%s\n' %banner(
'Autoindexing %s' %idxr.get_indexer_sweep_name())
result += '%s\n' %idxr.show_indexer_solutions()
intgr = xsweep._get_integrater()
if PhilIndex.params.xia2.settings.show_template:
result += '%s\n' %banner('Integrating %s (%s)' %(
intgr.get_integrater_sweep_name(), intgr.get_template()))
else:
result += '%s\n' %banner(
'Integrating %s' %intgr.get_integrater_sweep_name())
result += '%s\n' % intgr.show_per_image_statistics()
result += '%s\n' %banner('Scaling %s' %self.get_name())
for (dname, sname), (limit, suggested) in scaler.get_scaler_resolution_limits().iteritems():
if suggested is None or limit == suggested:
result += 'Resolution limit for %s/%s: %5.2f\n' %(dname, sname, limit)
else:
result += 'Resolution limit for %s/%s: %5.2f (%5.2f suggested)\n' %(dname, sname, limit, suggested)
# this is now deprecated - be explicit in what you are
# asking for...
reflections_all = self.get_scaled_merged_reflections()
statistics_all = self._get_scaler().get_scaler_statistics()
# print some of these statistics, perhaps?
for key in statistics_all.keys():
result += format_statistics(statistics_all[key], caption='For %s/%s/%s' % key)
# then print out some "derived" information based on the
# scaling - this is presented through the Scaler interface
# explicitly...
cell = self._get_scaler().get_scaler_cell()
cell_esd = self._get_scaler().get_scaler_cell_esd()
spacegroups = self._get_scaler().get_scaler_likely_spacegroups()
spacegroup = spacegroups[0]
resolution = self._get_scaler().get_scaler_highest_resolution()
from cctbx import sgtbx
sg = sgtbx.space_group_type(str(spacegroup))
spacegroup = sg.lookup_symbol()
CIF.set_spacegroup(sg)
mmCIF.set_spacegroup(sg)
if len(self._wavelengths) == 1:
CIF.set_wavelengths([w.get_wavelength() for w in self._wavelengths.itervalues()])
mmCIF.set_wavelengths([w.get_wavelength() for w in self._wavelengths.itervalues()])
else:
for wavelength in self._wavelengths.keys():
full_wave_name = '%s_%s_%s' % (self._project._name, self._name, wavelength)
CIF.get_block(full_wave_name)['_diffrn_radiation_wavelength'] = \
self._wavelengths[wavelength].get_wavelength()
mmCIF.get_block(full_wave_name)['_diffrn_radiation_wavelength'] = \
self._wavelengths[wavelength].get_wavelength()
CIF.set_wavelengths({name: wave.get_wavelength() for name, wave in self._wavelengths.iteritems()})
mmCIF.set_wavelengths({name: wave.get_wavelength() for name, wave in self._wavelengths.iteritems()})
result += 'Assuming spacegroup: %s\n' % spacegroup
if len(spacegroups) > 1:
result += 'Other likely alternatives are:\n'
for sg in spacegroups[1:]:
result += '%s\n' % sg
if cell_esd:
from libtbx.utils import format_float_with_standard_uncertainty
def match_formatting(dimA, dimB):
def conditional_split(s):
return (s[:s.index('.')],s[s.index('.'):]) if '.' in s else (s, '')
A, B = conditional_split(dimA), conditional_split(dimB)
maxlen = (max(len(A[0]), len(B[0])), max(len(A[1]), len(B[1])))
return (
A[0].rjust(maxlen[0])+A[1].ljust(maxlen[1]),
B[0].rjust(maxlen[0])+B[1].ljust(maxlen[1])
)
formatted_cell_esds = tuple(format_float_with_standard_uncertainty(v, sd) for v, sd in zip(cell, cell_esd))
formatted_rows = (formatted_cell_esds[0:3], formatted_cell_esds[3:6])
formatted_rows = zip(*(match_formatting(l, a) for l, a in zip(*formatted_rows)))
result += 'Unit cell (with estimated std devs):\n'
result += '%s %s %s\n%s %s %s\n' % (formatted_rows[0] + formatted_rows[1])
else:
result += 'Unit cell:\n'
result += '%7.3f %7.3f %7.3f\n%7.3f %7.3f %7.3f\n' % tuple(cell)
# now, use this information and the sequence (if provided)
# and also matthews_coef (should I be using this directly, here?)
# to compute a likely number of molecules in the ASU and also
# the solvent content...
if self._aa_sequence:
residues = self._aa_sequence.get_sequence()
if residues:
nres = len(residues)
# first compute the number of molecules using the K&R
# method
nmol = compute_nmol(cell[0], cell[1], cell[2],
cell[3], cell[4], cell[5],
spacegroup, resolution, nres)
# then compute the solvent fraction
solvent = compute_solvent(cell[0], cell[1], cell[2],
cell[3], cell[4], cell[5],
spacegroup, nmol, nres)
result += 'Likely number of molecules in ASU: %d\n' % nmol
result += 'Giving solvent fraction: %4.2f\n' % solvent
self._nmol = nmol
if type(reflections_all) == type({}):
for format in reflections_all.keys():
result += '%s format:\n' % format
reflections = reflections_all[format]
if type(reflections) == type({}):
for wavelength in reflections.keys():
target = FileHandler.get_data_file(
reflections[wavelength])
result += 'Scaled reflections (%s): %s\n' % \
(wavelength, target)
else:
target = FileHandler.get_data_file(
reflections)
result += 'Scaled reflections: %s\n' % target
CIF.write_cif()
mmCIF.write_cif()
return result
