def ml_normalisation(self, aniso=False):
# estimate number of residues per unit cell
mr = matthews.matthews_rupp(self.intensities.crystal_symmetry())
n_residues = mr.n_residues
# estimate B-factor and scale factors for normalisation
if aniso:
normalisation = absolute_scaling.ml_aniso_absolute_scaling(
self.intensities, n_residues=n_residues)
u_star = normalisation.u_star
else:
normalisation = absolute_scaling.ml_iso_absolute_scaling(
self.intensities, n_residues=n_residues)
u_star = adptbx.b_as_u(
adptbx.u_iso_as_u_star(
self.intensities.unit_cell(), normalisation.b_wilson))
# apply scales
self.intensities = self.intensities.customized_copy(
data=scaling.ml_normalise_aniso(
self.intensities.indices(), self.intensities.data(),
normalisation.p_scale, self.intensities.unit_cell(),
u_star),
sigmas=scaling.ml_normalise_aniso(
self.intensities.indices(), self.intensities.sigmas(),
normalisation.p_scale, self.intensities.unit_cell(),
u_star)).set_info(self.intensities.info())
# record output in log file
s = StringIO()
mr.show(out=s)
normalisation.show(out=s)
logger.info(s.getvalue())
def _ml_normalisation(intensities, aniso):
# estimate number of residues per unit cell
mr = matthews.matthews_rupp(intensities.crystal_symmetry())
n_residues = mr.n_residues
# estimate B-factor and scale factors for normalisation
if aniso:
normalisation = absolute_scaling.ml_aniso_absolute_scaling(
intensities, n_residues=n_residues
)
u_star = normalisation.u_star
else:
normalisation = absolute_scaling.ml_iso_absolute_scaling(
intensities, n_residues=n_residues
)
u_star = adptbx.b_as_u(
adptbx.u_iso_as_u_star(intensities.unit_cell(), normalisation.b_wilson)
)
# record output in log file
if aniso:
b_cart = normalisation.b_cart
logger.info("ML estimate of overall B_cart value:")
logger.info(
"""\
%5.2f, %5.2f, %5.2f
%12.2f, %5.2f
%19.2f"""
% (b_cart[0], b_cart[3], b_cart[4], b_cart[1], b_cart[5], b_cart[2])
)
else:
logger.info("ML estimate of overall B value:")
logger.info(" %5.2f A**2" % normalisation.b_wilson)
logger.info("ML estimate of -log of scale factor:")
logger.info(" %5.2f" % (normalisation.p_scale))
s = StringIO()
mr.show(out=s)
normalisation.show(out=s)
logger.debug(s.getvalue())
# apply scales
return intensities.customized_copy(
data=scaling.ml_normalise_aniso(
intensities.indices(),
intensities.data(),
normalisation.p_scale,
intensities.unit_cell(),
u_star,
),
sigmas=scaling.ml_normalise_aniso(
intensities.indices(),
intensities.sigmas(),
normalisation.p_scale,
intensities.unit_cell(),
u_star,
),
)
def dummy_structure(space_group_info, volume, n_scatterers):
structure = xray.structure(
special_position_settings=crystal.special_position_settings(
crystal_symmetry=crystal.symmetry(
unit_cell=space_group_info.any_compatible_unit_cell(volume=volume),
space_group_info=space_group_info)))
b_iso = 20
u_iso = adptbx.b_as_u(b_iso)
u_star = adptbx.u_iso_as_u_star(structure.unit_cell(), u_iso)
scatterer = xray.scatterer(label="C", site=(0.123,0.234,0.345), u=u_star)
for i in xrange(n_scatterers):
structure.add_scatterer(scatterer)
return structure
def add_new_solvent(self):
if (self.params.b_iso is None):
sol_sel = self.model.solvent_selection()
xrs_mac_h = self.model.get_xray_structure().select(~sol_sel)
hd_mac = self.model.get_hd_selection().select(~sol_sel)
xrs_mac = xrs_mac_h.select(~hd_mac)
b = xrs_mac.extract_u_iso_or_u_equiv() * math.pi**2 * 8
b_solv = flex.mean_default(b, None)
if (b_solv is not None and b_solv < self.params.b_iso_min
or b_solv > self.params.b_iso_max):
b_solv = (self.params.b_iso_min + self.params.b_iso_max) / 2.
else:
b_solv = self.params.b_iso
if (self.params.new_solvent == "isotropic"):
new_scatterers = flex.xray_scatterer(
self.sites.size(),
xray.scatterer(occupancy=self.params.occupancy,
b=b_solv,
scattering_type=self.params.scattering_type))
elif (self.params.new_solvent == "anisotropic"):
u_star = adptbx.u_iso_as_u_star(
self.model.get_xray_structure().unit_cell(),
adptbx.b_as_u(b_solv))
new_scatterers = flex.xray_scatterer(
self.sites.size(),
xray.scatterer(occupancy=self.params.occupancy,
u=u_star,
scattering_type=self.params.scattering_type))
else:
raise RuntimeError
new_scatterers.set_sites(self.sites)
solvent_xray_structure = xray.structure(
special_position_settings=self.model.get_xray_structure(),
scatterers=new_scatterers)
xrs_sol = self.model.get_xray_structure().select(
self.model.solvent_selection())
xrs_mac = self.model.get_xray_structure().select(
~self.model.solvent_selection())
xrs_sol = xrs_sol.concatenate(other=solvent_xray_structure)
sol_sel = flex.bool(xrs_mac.scatterers().size(), False)
sol_sel.extend(flex.bool(xrs_sol.scatterers().size(), True))
self.model.add_solvent(
solvent_xray_structure=solvent_xray_structure,
residue_name=self.params.output_residue_name,
atom_name=self.params.output_atom_name,
chain_id=self.params.output_chain_id,
refine_occupancies=self.params.refine_occupancies,
refine_adp=self.params.new_solvent)
self.fmodel.update_xray_structure(
xray_structure=self.model.get_xray_structure(), update_f_calc=True)
def add_new_solvent(self):
if(self.params.b_iso is None):
sol_sel = self.model.solvent_selection()
xrs_mac_h = self.model.xray_structure.select(~sol_sel)
hd_mac = self.model.xray_structure.hd_selection().select(~sol_sel)
xrs_mac = xrs_mac_h.select(~hd_mac)
b = xrs_mac.extract_u_iso_or_u_equiv() * math.pi**2*8
b_solv = flex.mean_default(b, None)
if(b_solv is not None and b_solv < self.params.b_iso_min or
b_solv > self.params.b_iso_max):
b_solv = (self.params.b_iso_min + self.params.b_iso_max) / 2.
else:
b_solv = self.params.b_iso
if(self.params.new_solvent == "isotropic"):
new_scatterers = flex.xray_scatterer(
self.sites.size(),
xray.scatterer(occupancy = self.params.occupancy,
b = b_solv,
scattering_type = self.params.scattering_type))
elif(self.params.new_solvent == "anisotropic"):
u_star = adptbx.u_iso_as_u_star(self.model.xray_structure.unit_cell(),
adptbx.b_as_u(b_solv))
new_scatterers = flex.xray_scatterer(
self.sites.size(),
xray.scatterer(
occupancy = self.params.occupancy,
u = u_star,
scattering_type = self.params.scattering_type))
else: raise RuntimeError
new_scatterers.set_sites(self.sites)
solvent_xray_structure = xray.structure(
special_position_settings = self.model.xray_structure,
scatterers = new_scatterers)
xrs_sol = self.model.xray_structure.select(self.model.solvent_selection())
xrs_mac = self.model.xray_structure.select(~self.model.solvent_selection())
xrs_sol = xrs_sol.concatenate(other = solvent_xray_structure)
sol_sel = flex.bool(xrs_mac.scatterers().size(), False)
sol_sel.extend( flex.bool(xrs_sol.scatterers().size(), True) )
self.model.add_solvent(
solvent_xray_structure = solvent_xray_structure,
residue_name = self.params.output_residue_name,
atom_name = self.params.output_atom_name,
chain_id = self.params.output_chain_id,
refine_occupancies = self.params.refine_occupancies,
refine_adp = self.params.new_solvent)
self.fmodel.update_xray_structure(
xray_structure = self.model.xray_structure,
update_f_calc = True)
def split_u(xray_structure, tls_selections, offset):
global time_split_u
timer = user_plus_sys_time()
uc = xray_structure.unit_cell()
u_iso = xray_structure.scatterers().extract_u_iso()
u_eq_1 = xray_structure.extract_u_iso_or_u_equiv()
for tls_selection in tls_selections:
u_iso_sel = u_iso.select(tls_selection)
u_iso_min = flex.min(u_iso_sel)
if (offset):
offset_ = adptbx.b_as_u(5.0)
else:
offset_ = 0.0
if u_iso_min >= offset_:
u_iso_min = u_iso_min - offset_
t = adptbx.u_iso_as_u_star(uc, u_iso_min)
for i_seq in tls_selection:
sc = xray_structure.scatterers()[i_seq]
assert sc.u_iso == u_iso[i_seq]
u_iso_new = sc.u_iso - u_iso_min
assert u_iso_new >= 0.0
sc.u_iso = u_iso_new
assert sc.flags.use_u_aniso()
assert sc.flags.use_u_iso()
if (sc.u_star == (-1.0, -1.0, -1.0, -1.0, -1.0, -1.0)):
sc.u_star = t
else:
x = flex.double(sc.u_star)
y = flex.double(t)
z = list(x + y)
sc.u_star = z
u_iso = xray_structure.scatterers().extract_u_iso().select(
xray_structure.use_u_iso())
assert (u_iso < 0.0).count(True) == 0
u_eq_2 = xray_structure.extract_u_iso_or_u_equiv()
assert approx_equal(u_eq_1, u_eq_2)
time_split_u += timer.elapsed()
def split_u(xray_structure, tls_selections, offset):
global time_split_u
timer = user_plus_sys_time()
uc = xray_structure.unit_cell()
u_iso = xray_structure.scatterers().extract_u_iso()
u_eq_1 = xray_structure.extract_u_iso_or_u_equiv()
for tls_selection in tls_selections:
u_iso_sel = u_iso.select(tls_selection)
u_iso_min = flex.min(u_iso_sel)
if(offset):
offset_ = adptbx.b_as_u(5.0)
else: offset_ = 0.0
if u_iso_min >= offset_:
u_iso_min = u_iso_min - offset_
t = adptbx.u_iso_as_u_star(uc, u_iso_min)
for i_seq in tls_selection:
sc = xray_structure.scatterers()[i_seq]
assert sc.u_iso == u_iso[i_seq]
u_iso_new = sc.u_iso - u_iso_min
assert u_iso_new >= 0.0
sc.u_iso = u_iso_new
assert sc.flags.use_u_aniso()
assert sc.flags.use_u_iso()
if(sc.u_star == (-1.0,-1.0,-1.0,-1.0,-1.0,-1.0)):
sc.u_star = t
else:
x = flex.double(sc.u_star)
y = flex.double(t)
z = list(x + y)
sc.u_star = z
u_iso = xray_structure.scatterers().extract_u_iso().select(
xray_structure.use_u_iso())
assert (u_iso < 0.0).count(True) == 0
u_eq_2 = xray_structure.extract_u_iso_or_u_equiv()
assert approx_equal(u_eq_1, u_eq_2)
time_split_u += timer.elapsed()
def __init__ (self, residue_group, xray_structure, ignore_hydrogens=True) :
from cctbx import adptbx
from scitbx.array_family import flex
from scitbx.matrix import col
self.sites = []
self.u_isos = []
self.u_stars = []
self.atom_names = []
self.id_str = residue_group.id_str()
unit_cell = xray_structure.unit_cell()
atom_name_dict = {}
for atom_group in residue_group.atom_groups() :
b_isos = atom_group.atoms().extract_b()
if (len(b_isos) > 1) and (b_isos.all_eq(b_isos[0])) :
raise RuntimeError("B-factors for atom_group '%s' are identical" %
atom_group.id_str())
for atom in atom_group.atoms() :
if (atom.element.strip() in ["H", "D"]) and (ignore_hydrogens) :
continue
if (not atom.name in atom_name_dict) :
atom_name_dict[atom.name] = []
atom_name_dict[atom.name].append(atom)
self.n_confs = 1
for atom_name in sorted(atom_name_dict.keys()) :
n_atom_confs = len(atom_name_dict[atom_name])
if (n_atom_confs > 1) :
if (self.n_confs > 1) :
if (self.n_confs != n_atom_confs) :
raise RuntimeError(("Inconsistent conformers for '%s': atom %s "+
"has %d confs but previously %d conformations were seen") %
(self.id_str, atom_name, n_atom_confs, self.n_confs))
else :
self.n_confs = n_atom_confs
for n in range(n_atom_confs) :
self.sites.append(flex.vec3_double())
self.u_isos.append(flex.double())
self.u_stars.append([])
self.atom_names.append(atom_name)
for i_conf in range(n_atom_confs) :
atom = atom_name_dict[atom_name][i_conf]
scatterer = xray_structure.scatterers()[atom.i_seq]
assert scatterer.label == atom.id_str()
self.sites[i_conf].append(atom.xyz)
if (scatterer.flags.use_u_aniso()) :
self.u_isos[i_conf].append(adptbx.b_as_u(atom.b))
self.u_stars[i_conf].append(scatterer.u_star)
else :
self.u_isos[i_conf].append(scatterer.u_iso)
self.u_stars[i_conf].append(
adptbx.u_iso_as_u_star(unit_cell, scatterer.u_iso))
self.max_rmsd = 0
self.max_distance_over_u = 0
self.dxyz_save = self.u_iso_save = self.atom_name_save = None
for i_conf, sites in enumerate(self.sites) :
if (i_conf < self.n_confs - 1) :
for j_conf in range(i_conf+1, self.n_confs) :
sites_next = self.sites[j_conf]
rmsd = sites.rms_difference(sites_next)
if (rmsd > self.max_rmsd) :
self.max_rmsd = rmsd
for k_site, (site1, site2) in enumerate(zip(sites, sites_next)) :
distance = abs(col(site1) - col(site2))
#u = max(self.u_isos[i_conf][k_site], self.u_isos[j_conf][k_site])
proj_sum = adptbx.projection_sum(
ustar1=self.u_stars[i_conf][k_site],
ustar2=self.u_stars[j_conf][k_site],
site1=site1,
site2=site2,
unit_cell=unit_cell)
u_proj = max(proj_sum.z_12(), proj_sum.z_21())
if (u_proj <= 0) :
continue
ratio = distance / u_proj
if (ratio > self.max_distance_over_u) :
self.max_distance_over_u = ratio
self.dxyz_save = distance
self.u_iso_save = u_proj
self.atom_name_save = self.atom_names[k_site]
