def apply_back_trace_of_overall_exp_scale_matrix(self, xray_structure=None):
k,b=self.overall_isotropic_kb_estimate()
k_total = self.core.k_isotropic * self.core.k_anisotropic * \
self.core.k_isotropic_exp
k,b,r = mmtbx.bulk_solvent.fit_k_exp_b_to_k_total(k_total, self.ss, k, b)
if(r<0.7): self.k_exp_overall,self.b_exp_overall = k,b
if(xray_structure is None): return None
b_adj = 0
if([self.k_exp_overall,self.b_exp_overall].count(None)==0 and k != 0):
bs1 = xray_structure.extract_u_iso_or_u_equiv()*adptbx.u_as_b(1.)
def split(b_trace, xray_structure):
b_min = xray_structure.min_u_cart_eigenvalue()*adptbx.u_as_b(1.)
b_res = min(0, b_min + b_trace+1.e-6)
b_adj = b_trace-b_res
xray_structure.shift_us(b_shift = b_adj)
return b_adj, b_res
b_adj,b_res=split(b_trace=self.b_exp_overall,xray_structure=xray_structure)
k_new = self.k_exp_overall*flex.exp(-self.ss*b_adj)
bs2 = xray_structure.extract_u_iso_or_u_equiv()*adptbx.u_as_b(1.)
diff = bs2-bs1
assert approx_equal(flex.min(diff), flex.max(diff))
assert approx_equal(flex.max(diff), b_adj)
self.core = self.core.update(
k_isotropic = self.core.k_isotropic,
k_isotropic_exp = self.core.k_isotropic_exp/k_new,
k_masks = [m*flex.exp(-self.ss*b_adj) for m in self.core.k_masks])
return group_args(
xray_structure = xray_structure,
k_isotropic = self.k_isotropic(),
k_anisotropic = self.k_anisotropic(),
k_mask = self.k_masks(),
b_adj = b_adj)
def check_adp_set_b_iso(
cmd, xrsp_init, output, selection, selection_str, verbose,
tolerance=1.e-3):
remove_files(output)
run_command(command=cmd, verbose=verbose)
xrsp = xray_structure_plus(file_name = output)
assert approx_equal(xrsp.occ, xrsp_init.occ,tolerance)
assert approx_equal(xrsp.sites_cart, xrsp_init.sites_cart,tolerance)
assert approx_equal(xrsp.use_u_iso, xrsp_init.use_u_iso,tolerance)
assert approx_equal(xrsp.use_u_aniso,xrsp_init.use_u_aniso,tolerance)
assert approx_equal(xrsp.u_iso_not_used, xrsp_init.u_iso_not_used,tolerance)
assert approx_equal(xrsp.u_cart_not_used,xrsp_init.u_cart_not_used,tolerance)
if(selection_str is None):
assert not_approx_equal(xrsp.u_iso_used, xrsp_init.u_iso_used,tolerance)
for ucart in xrsp.u_cart:
b_iso = adptbx.u_as_b(adptbx.u_cart_as_u_iso(ucart))
if b_iso > 0: assert approx_equal(b_iso, 10, 0.005)
else: assert approx_equal(b_iso, -78.956, 0.005)
else:
arg1 = xrsp.u_iso_used.select(selection.select(xrsp.use_u_iso))
arg2 = xrsp_init.u_iso_used.select(selection.select(xrsp_init.use_u_iso))
if(arg1.size() > 0): assert not_approx_equal(arg1, arg2,tolerance)
for ucart in xrsp.u_cart:
b_iso = adptbx.u_as_b(adptbx.u_cart_as_u_iso(ucart))
if b_iso > 0: assert approx_equal(b_iso, 10, 0.005)
else: assert approx_equal(b_iso, -78.956, 0.005)
def __init__(self, xray_structure, k_anisotropic, k_masks, ss):
self.xray_structure = xray_structure
self.k_anisotropic = k_anisotropic
self.k_masks = k_masks
self.ss = ss
#
k_total = self.k_anisotropic
r = scitbx.math.gaussian_fit_1d_analytical(x=flex.sqrt(self.ss), y=k_total)
k,b = r.a, r.b
#
k,b,r = mmtbx.bulk_solvent.fit_k_exp_b_to_k_total(k_total, self.ss, k, b)
k_exp_overall, b_exp_overall = None,None
if(r<0.7): k_exp_overall, b_exp_overall = k,b
if(self.xray_structure is None): return None
b_adj = 0
if([k_exp_overall, b_exp_overall].count(None)==0 and k != 0):
bs1 = self.xray_structure.extract_u_iso_or_u_equiv()*adptbx.u_as_b(1.)
def split(b_trace, xray_structure):
b_min = xray_structure.min_u_cart_eigenvalue()*adptbx.u_as_b(1.)
b_res = min(0, b_min + b_trace+1.e-6)
b_adj = b_trace-b_res
xray_structure.shift_us(b_shift = b_adj)
return b_adj, b_res
b_adj,b_res=split(b_trace=b_exp_overall,xray_structure=self.xray_structure)
k_new = k_exp_overall*flex.exp(-self.ss*b_adj)
bs2 = self.xray_structure.extract_u_iso_or_u_equiv()*adptbx.u_as_b(1.)
diff = bs2-bs1
assert approx_equal(flex.min(diff), flex.max(diff))
assert approx_equal(flex.max(diff), b_adj)
self.k_anisotropic = self.k_anisotropic/k_new
self.k_masks = [m*flex.exp(-self.ss*b_adj) for m in self.k_masks]
def as_pdb_file(self,
remark,
remarks,
fractional_coordinates,
resname,
connect):
if (remark is not None):
remarks.insert(0, remark)
s = StringIO()
for remark in remarks:
print >> s, "REMARK", remark
print >> s, "REMARK Number of scatterers:", self.scatterers().size()
print >> s, "REMARK At special positions:", \
self.special_position_indices().size()
if (fractional_coordinates):
print >> s, "REMARK Fractional coordinates"
else:
print >> s, "REMARK Cartesian coordinates"
print >> s, iotbx.pdb.format_cryst1_record(crystal_symmetry=self)
print >> s, iotbx.pdb.format_scale_records(unit_cell=self.unit_cell())
atom = iotbx.pdb.hierarchy.atom_with_labels()
if (resname is not None):
atom.resname = resname.upper()
serial = 0
for scatterer in self.scatterers():
serial += 1
atom.serial = iotbx.pdb.hy36encode(width=5, value=serial)
if (scatterer.flags.use_u_aniso_only()):
atom.uij = adptbx.u_star_as_u_cart(self.unit_cell(), scatterer.u_star)
atom.b = adptbx.u_as_b(adptbx.u_cart_as_u_iso(atom.uij))
else:
atom.uij_erase()
atom.b = adptbx.u_as_b(scatterer.u_iso)
if (fractional_coordinates):
atom.xyz = scatterer.site
else:
atom.xyz = self.unit_cell().orthogonalize(scatterer.site)
atom.occ = scatterer.occupancy
label = scatterer.label.upper()
atom.name = label[:4]
if (resname is None):
atom.resname = label[:3]
element_symbol = scatterer.element_symbol()
if (element_symbol is None): element_symbol = "Q"
assert len(element_symbol) in (1,2)
atom.element = element_symbol.upper()
atom.resseq = iotbx.pdb.hy36encode(width=4, value=serial)
print >> s, atom.format_atom_record_group()
if (connect is not None):
assert len(connect) == self.scatterers().size()
i = 0
for bonds in connect:
i += 1
l = "CONNECT%5d" % i
for bond in bonds:
l += "%5d" % (bond+1)
print >> s, l
print >> s, "END"
return s.getvalue()
def remove_common_isotropic_adp(self): xrs = self.xray_structure b_iso_min = flex.min(xrs.extract_u_iso_or_u_equiv()*adptbx.u_as_b(1)) self.b_overall = b_iso_min print >> self.log, "Max B subtracted from atoms and used to sharpen map:", b_iso_min xrs.shift_us(b_shift=-b_iso_min) b_iso_min = flex.min(xrs.extract_u_iso_or_u_equiv()*adptbx.u_as_b(1)) assert approx_equal(b_iso_min, 0, 1.e-3)
def run_00():
time_aniso_u_scaler = 0
for symbol in sgtbx.bravais_types.acentric + sgtbx.bravais_types.centric:
#print symbol, "-"*50
space_group_info = sgtbx.space_group_info(symbol = symbol)
xrs = random_structure.xray_structure(
space_group_info = space_group_info,
elements = ["N"]*100,
volume_per_atom = 50.0,
random_u_iso = True)
# XXX ad a method to adptbx to do this
point_group = sgtbx.space_group_info(
symbol=symbol).group().build_derived_point_group()
adp_constraints = sgtbx.tensor_rank_2_constraints(
space_group=point_group,
reciprocal_space=True)
u_star = adptbx.u_cart_as_u_star(xrs.unit_cell(),
adptbx.random_u_cart(u_scale=1,u_min=0.1))
u_indep = adp_constraints.independent_params(all_params=u_star)
u_star = adp_constraints.all_params(independent_params=u_indep)
b_cart_start=adptbx.u_as_b(adptbx.u_star_as_u_cart(xrs.unit_cell(), u_star))
#
tr = (b_cart_start[0]+b_cart_start[1]+b_cart_start[2])/3
b_cart_start = [b_cart_start[0]-tr,b_cart_start[1]-tr,b_cart_start[2]-tr,
b_cart_start[3],b_cart_start[4],b_cart_start[5]]
tr = (b_cart_start[0]+b_cart_start[1]+b_cart_start[2])/3
#
#print "Input b_cart :", " ".join(["%8.4f"%i for i in b_cart_start]), "tr:", tr
F = xrs.structure_factors(d_min = 2.0).f_calc()
u_star = adptbx.u_cart_as_u_star(
F.unit_cell(), adptbx.b_as_u(b_cart_start))
fbc = mmtbx.f_model.ext.k_anisotropic(F.indices(), u_star)
fc = F.structure_factors_from_scatterers(xray_structure=xrs).f_calc()
f_obs = F.customized_copy(data = flex.abs(fc.data()*fbc))
t0 = time.time()
#
obj = bulk_solvent.aniso_u_scaler(
f_model_abs = flex.abs(fc.data()),
f_obs = f_obs.data(),
miller_indices = f_obs.indices(),
adp_constraint_matrix = adp_constraints.gradient_sum_matrix())
time_aniso_u_scaler += (time.time()-t0)
b_cart_final = adptbx.u_as_b(adptbx.u_star_as_u_cart(f_obs.unit_cell(),
adp_constraints.all_params(tuple(obj.u_star_independent))))
#
obj = bulk_solvent.aniso_u_scaler(
f_model_abs = flex.abs(fc.data()),
f_obs = f_obs.data(),
miller_indices = f_obs.indices())
b_cart_final2 = adptbx.u_as_b(adptbx.u_star_as_u_cart(f_obs.unit_cell(),
tuple(obj.u_star)))
#
assert approx_equal(b_cart_final, b_cart_final2)
#print "Output b_cart:", " ".join(["%8.4f"%i for i in b_cart_final])
assert approx_equal(b_cart_start, b_cart_final, 1.e-4)
print "Time (aniso_u_scaler only): %6.4f"%time_aniso_u_scaler
def show_selection(i_ncs, pair):
print >> out, prefix + "NCS selection:", \
show_string(self.group.selection_strings[i_ncs])
print >> out, prefix + " "*(max_label_size+2) \
+ " B-iso NCS ave Difference"
u_isos_current = self.u_isos.select(pair[1])
u_isos_average = self.u_isos_average.select(pair[0])
for i,c,a in zip(pair[1], u_isos_current, u_isos_average):
c = adptbx.u_as_b(c)
a = adptbx.u_as_b(a)
print >> out, prefix + fmt % (site_labels[i], c, a, c-a)
def create_da_xray_structures(xray_structure, params):
def grid(sphere, gap, overlap):
c = flex.double(sphere.center)
x_start, y_start, z_start = c - float(sphere.radius)
x_end, y_end, z_end = c + float(sphere.radius)
x_range = frange(c[0], c[0]+gap, overlap)
y_range = frange(c[1], c[1]+gap, overlap)
z_range = frange(c[2], c[2]+gap, overlap)
return group_args(x_range = x_range, y_range = y_range, z_range = z_range)
grids = []
for sphere in params.sphere:
grids.append(grid(sphere = sphere, gap = params.atom_gap,
overlap = params.overlap_interval))
initial_b_factor = params.initial_b_factor
if(initial_b_factor is None):
initial_b_factor = flex.mean(
xray_structure.extract_u_iso_or_u_equiv()*adptbx.u_as_b(1.))
da_xray_structures = []
counter = 0
for grid, sphere in zip(grids, params.sphere):
cntr_g = 0 # XXX
for x_start in grid.x_range:
for y_start in grid.y_range:
for z_start in grid.z_range:
cntr_g += 1
if(cntr_g>1): continue # XXX
counter += 1
new_center = flex.double([x_start, y_start, z_start])
atom_grid = make_grid(
center = new_center,
radius = sphere.radius,
gap = params.atom_gap,
occupancy = params.initial_occupancy,
b_factor = initial_b_factor,
atom_name = params.atom_name,
scattering_type = params.atom_type,
resname = params.residue_name)
da_xray_structure = pdb_atoms_as_xray_structure(pdb_atoms = atom_grid,
crystal_symmetry = xray_structure.crystal_symmetry())
closest_distances_result = xray_structure.closest_distances(
sites_frac = da_xray_structure.sites_frac(),
distance_cutoff = 5)
selection = closest_distances_result.smallest_distances > 0
selection &= closest_distances_result.smallest_distances < 1
da_xray_structure = da_xray_structure.select(~selection)
#print counter, da_xray_structure.scatterers().size()
if(cntr_g==1): # XXX
da_xray_structures.append(da_xray_structure)
###
result = []
for i, x1 in enumerate(da_xray_structures):
for j, x2 in enumerate(da_xray_structures):
if(x1 is not x2):
closest_distances_result = x1.closest_distances(
sites_frac = x2.sites_frac(),
distance_cutoff = 5) # XXX ???
selection = closest_distances_result.smallest_distances > 0
selection &= closest_distances_result.smallest_distances < params.atom_gap
da_xray_structures[j] = x2.select(~selection)
return da_xray_structures
def show(self, weight = None, prefix = "", show_neutron=True,
print_stats=True):
deltab = self.model.rms_b_iso_or_b_equiv_bonded()
r_work = self.fmodels.fmodel_xray().r_work()*100.
r_free = self.fmodels.fmodel_xray().r_free()*100.
mean_b = flex.mean(
self.model.xray_structure.extract_u_iso_or_u_equiv())*adptbx.u_as_b(1)
if(deltab is None):
print >> self.log, " r_work=%5.2f r_free=%5.2f"%(r_work, r_free)
return None
neutron_r_work = neutron_r_free = None
if (show_neutron) and (self.fmodels.fmodel_neutron() is not None) :
neutron_r_work = self.fmodels.fmodel_neutron().r_work()*100.
neutron_r_free = self.fmodels.fmodel_neutron().r_free()*100.
xrs = self.fmodels.fmodel_xray().xray_structure
result = weight_result(
r_work=r_work,
r_free=r_free,
delta_b=deltab,
mean_b=mean_b,
weight=weight,
xray_target=self.fmodels.fmodel_xray().target_w(),
neutron_r_work=neutron_r_work,
neutron_r_free=neutron_r_free,
u_star=xrs.scatterers().extract_u_star(),
u_iso=xrs.scatterers().extract_u_iso())
if (print_stats) :
result.show(out=self.log)
return result
def debye_waller_factors(self,
miller_index=None,
miller_indices=None,
u_iso=None,
b_iso=None,
u_cart=None,
b_cart=None,
u_cif=None,
u_star=None,
exp_arg_limit=50,
truncate_exp_arg=False):
assert [miller_index, miller_indices].count(None) == 1
assert [u_iso, b_iso, u_cart, b_cart, u_cif, u_star].count(None) == 5
from cctbx import adptbx
h = miller_index
if (h is None): h = miller_indices
if (u_iso is not None):
b_iso = adptbx.u_as_b(u_iso)
if (b_iso is not None):
return adptbx.debye_waller_factor_b_iso(
self.stol_sq(h),
b_iso, exp_arg_limit, truncate_exp_arg)
if (b_cart is not None):
u_cart = adptbx.b_as_u(b_cart)
if (u_cart is not None):
u_star = adptbx.u_cart_as_u_star(self, u_cart)
if (u_cif is not None):
u_star = adptbx.u_cif_as_u_star(self, u_cif)
assert u_star is not None
return adptbx.debye_waller_factor_u_star(
h, u_star, exp_arg_limit, truncate_exp_arg)
def finalize_model (pdb_hierarchy,
xray_structure,
set_b_iso=None,
convert_to_isotropic=None,
selection=None) :
"""
Prepare a rebuilt model for refinement, optionally including B-factor reset.
"""
from cctbx import adptbx
from scitbx.array_family import flex
pdb_atoms = pdb_hierarchy.atoms()
if (selection is None) :
selection = flex.bool(pdb_atoms.size(), True)
elif isinstance(selection, str) :
sel_cache = pdb_hierarchy.atom_selection_cache()
selection = sel_cache.selection(selection)
for i_seq, atom in enumerate(pdb_atoms) :
assert (atom.parent() is not None)
atom.segid = ""
sc = xray_structure.scatterers()[i_seq]
sc.label = atom.id_str()
if (convert_to_isotropic) :
xray_structure.convert_to_isotropic(selection=selection.iselection())
if (set_b_iso is not None) :
if (set_b_iso is Auto) :
u_iso = xray_structure.extract_u_iso_or_u_equiv()
set_b_iso = adptbx.u_as_b(flex.mean(u_iso)) / 2
xray_structure.set_b_iso(value=set_b_iso, selection=selection)
pdb_hierarchy.adopt_xray_structure(xray_structure)
pdb_atoms.reset_serial()
pdb_atoms.reset_i_seq()
pdb_atoms.reset_tmp()
def exercise_01(grid_step = 0.03, d_min = 1.0, wing_cutoff = 1.e-9):
xrs = random_structure.xray_structure(
space_group_info = sgtbx.space_group_info("P 1"),
elements = ["O","N","C","P","S","U","AU"]*1,
random_u_iso = True,
general_positions_only = False)
# avoid excessive_range_error_limit crash
bs = xrs.extract_u_iso_or_u_equiv()*adptbx.u_as_b(1)
sel = bs < 1
bs = bs.set_selected(sel, 1)
xrs.set_b_iso(values = bs)
#
p = xrs.unit_cell().parameters()
timer = user_plus_sys_time()
res = manager(nx = int(p[0]/grid_step),
ny = int(p[1]/grid_step),
nz = int(p[2]/grid_step),
scattering_type_registry = xrs.scattering_type_registry(),
unit_cell = xrs.unit_cell(),
scatterers = xrs.scatterers(),
wing_cutoff = wing_cutoff)
print "time: %10.4f" % (timer.elapsed())
f_calc_dir = xrs.structure_factors(
d_min = d_min,
algorithm = "direct").f_calc()
#
f_calc_den = f_calc_dir.structure_factors_from_map(map = res.density_array,
use_scale = True)
f1 = flex.abs(f_calc_dir.data())
f2 = flex.abs(f_calc_den.data())
r = flex.sum(flex.abs(f1-f2))/flex.sum(f2)
print "r-factor:", r
assert r < 1.e-4, r
def __init__(self,
target_map,
pdb_hierarchy,
atom_radius,
use_adp_restraints,
nproc,
log=None):
adopt_init_args(self, locals())
self.xray_structure = self.pdb_hierarchy.extract_xray_structure(
crystal_symmetry = self.target_map.miller_array.crystal_symmetry())
b_isos = self.xray_structure.extract_u_iso_or_u_equiv()*adptbx.u_as_b(1.)
self.xray_structure = self.xray_structure.set_b_iso(
value = flex.mean(b_isos))
#for rg in self.pdb_hierarchy.residue_groups():
# sel = rg.atoms().extract_i_seq()
# sel = flex.bool(b_isos.size(), sel)
# self.xray_structure = self.xray_structure.set_b_iso(
# value = flex.mean(b_isos.select(sel)),
# selection = sel)
self.pdb_hierarchy.adopt_xray_structure(self.xray_structure)
self.chain_selections = []
for chain in self.pdb_hierarchy.chains():
self.chain_selections.append(chain.atoms().extract_i_seq())
def run(args):
for file_name in args:
print "File name:", file_name
try:
pdb_inp = iotbx.pdb.input(file_name=file_name)
except KeyboardInterrupt: raise
except Exception:
libtbx.utils.format_exception()
isotropic_b_factors = flex.double()
all_eigenvalues = flex.double()
for atom in pdb_inp.atoms():
if (atom.uij == (-1,-1,-1,-1,-1,-1)):
isotropic_b_factors.append(atom.b)
else:
all_eigenvalues.extend(flex.double(adptbx.eigenvalues(atom.uij)))
all_eigenvalues *= adptbx.u_as_b(1)
print "Number of isotropic atoms: ", isotropic_b_factors.size()
print "Number of anisotropic atoms:", all_eigenvalues.size() // 3
if (isotropic_b_factors.size() != 0):
print "Histogram of isotropic B-factors:"
flex.histogram(data=isotropic_b_factors, n_slots=10).show(
prefix=" ", format_cutoffs="%7.2f")
if (all_eigenvalues.size() != 0):
print "Histogram of eigenvalues of anisotropic B-factors:"
flex.histogram(data=all_eigenvalues, n_slots=10).show(
prefix=" ", format_cutoffs="%7.2f")
print
def show_xray_structure_statistics(xray_structure, atom_selections, hd_sel = None):
result = group_args(
all = None,
macromolecule = None,
sidechain = None,
solvent = None,
ligand = None,
backbone = None)
if(hd_sel is not None):
xray_structure = xray_structure.select(~hd_sel)
for key in atom_selections.__dict__.keys():
value = atom_selections.__dict__[key]
if(value.count(True) > 0):
if(hd_sel is not None):
value = value.select(~hd_sel)
xrs = xray_structure.select(value)
atom_counts = xrs.scattering_types_counts_and_occupancy_sums()
atom_counts_strs = []
for ac in atom_counts:
atom_counts_strs.append("%s:%s:%s"%(ac.scattering_type,str(ac.count),
str("%10.2f"%ac.occupancy_sum).strip()))
atom_counts_str = " ".join(atom_counts_strs)
b_isos = xrs.extract_u_iso_or_u_equiv()
n_aniso = xrs.use_u_aniso().count(True)
n_not_positive_definite = xrs.is_positive_definite_u().count(False)
b_mean = format_value("%-6.1f",adptbx.u_as_b(flex.mean(b_isos)))
b_min = format_value("%-6.1f",adptbx.u_as_b(flex.min(b_isos)))
b_max = format_value("%-6.1f",adptbx.u_as_b(flex.max(b_isos)))
n_atoms = format_value("%-8d",xrs.scatterers().size()).strip()
n_npd = format_value("%-8s",n_not_positive_definite).strip()
occ = xrs.scatterers().extract_occupancies()
o_mean = format_value("%-6.2f",flex.mean(occ)).strip()
o_min = format_value("%-6.2f",flex.min(occ)).strip()
o_max = format_value("%-6.2f",flex.max(occ)).strip()
tmp_result = group_args(
n_atoms = n_atoms,
atom_counts_str = atom_counts_str,
b_min = b_min,
b_max = b_max,
b_mean = b_mean,
o_min = o_min,
o_max = o_max,
o_mean = o_mean,
n_aniso = n_aniso,
n_npd = n_npd)
setattr(result,key,tmp_result)
return result
def __init__ (self,
ligand,
pdb_hierarchy,
xray_structure,
two_fofc_map,
fofc_map,
fmodel_map,
reference_ligands=None,
two_fofc_map_cutoff=1.5,
fofc_map_cutoff=-3.0) :
from mmtbx import real_space_correlation
from cctbx import adptbx
from scitbx.array_family import flex
atom_selection = ligand.atoms().extract_i_seq()
assert (len(atom_selection) == 1) or (not atom_selection.all_eq(0))
manager = real_space_correlation.selection_map_statistics_manager(
atom_selection=atom_selection,
xray_structure=xray_structure,
fft_m_real=two_fofc_map.all(),
fft_n_real=two_fofc_map.focus(),
exclude_hydrogens=True)
stats_two_fofc = manager.analyze_map(
map=two_fofc_map,
model_map=fmodel_map,
min=1.5)
stats_fofc = manager.analyze_map(
map=fofc_map,
model_map=fmodel_map,
min=-3.0)
self.atom_selection = manager.atom_selection # XXX non-hydrogens only!
sites_cart = xray_structure.sites_cart().select(self.atom_selection)
self.xyz_center = sites_cart.mean()
self.id_str = ligand.id_str()
self.cc = stats_two_fofc.cc
self.two_fofc_min = stats_two_fofc.min
self.two_fofc_max = stats_two_fofc.max
self.two_fofc_mean = stats_two_fofc.mean
self.fofc_min = stats_fofc.min
self.fofc_max = stats_fofc.max
self.fofc_mean = stats_fofc.mean
self.n_below_two_fofc_cutoff = stats_two_fofc.n_below_min
self.n_below_fofc_cutoff = stats_fofc.n_below_min
u_iso = xray_structure.extract_u_iso_or_u_equiv().select(
self.atom_selection)
u_iso_mean = flex.mean(u_iso)
self.b_iso_mean = adptbx.u_as_b(u_iso_mean)
occ = xray_structure.scatterers().extract_occupancies().select(
self.atom_selection)
self.occupancy_mean = flex.mean(occ)
self.rmsds = self.pbss = None
if (reference_ligands is not None) and (len(reference_ligands) > 0) :
self.rmsds, self.pbss = compare_ligands_impl(ligand=ligand,
reference_ligands=reference_ligands,
max_distance_between_centers_of_mass=8.0,
raise_sorry_if_no_matching_atoms=False,
verbose=False,
quiet=True)
def reset_adps(fmodels, selection, params):
xrs = fmodels.fmodel_xray().xray_structure
b = xrs.extract_u_iso_or_u_equiv()*adptbx.u_as_b(1.)
sel = b > params.filter.b_iso_max
sel &= selection
b = b.set_selected(sel, params.filter.b_iso_max)
sel = b < params.filter.b_iso_min
sel &= selection
b = b.set_selected(sel, params.filter.b_iso_min)
xrs = xrs.set_b_iso(values=b)
fmodels.update_xray_structure(xray_structure = xrs, update_f_calc=True,
update_f_mask=False)
def __init__ (self, pdb_hierarchy, xray_structure, params, out=sys.stdout) :
from cctbx import adptbx
from scitbx.array_family import flex
self.plot_range = params.plot_range
self.chains = []
self.residues = []
b_isos = xray_structure.extract_u_iso_or_u_equiv() * adptbx.u_as_b(1.0)
occ = pdb_hierarchy.atoms().extract_occ()
model = pdb_hierarchy.models()[0]
for chain in model.chains() :
main_conf = chain.conformers()[0]
is_na = main_conf.is_na()
is_protein = main_conf.is_protein()
if (not is_protein) and (not is_na) :
print >> out, "Skipping chain '%s' - not protein or DNA/RNA." %chain.id
continue
self.chains.append(chain.id)
self.residues.append([])
for residue_group in chain.residue_groups() :
n_conformers = len(residue_group.atom_groups())
rg_i_seqs = residue_group.atoms().extract_i_seq()
rg_occ = residue_group.atoms().extract_occ()
if (params.average_b_over == "residue") :
use_i_seqs = rg_i_seqs
elif (params.average_b_over == "mainchain") :
use_i_seqs = []
if (is_protein) :
for j_seq, atom in enumerate(residue_group.atoms()) :
#alab = atom.fetch_labels()
if (atom.name in [" N ", " C ", " CA ", " O "]) :
use_i_seqs.append(rg_i_seqs[j_seq])
else :
raise Sorry("Mainchain-only mode not supported for nucleic acids.")
else :
use_i_seqs = []
if (is_protein) :
for j_seq, atom in enumerate(residue_group.atoms()) :
if (not atom.name in [" N ", " C ", " CA ", " O "]) :
use_i_seqs.append(rg_i_seqs[j_seq])
if (len(use_i_seqs) > 0) :
has_partocc = ((flex.min(occ.select(use_i_seqs)) < 1.0) and
(n_conformers == 1))
res_info = residue_info(
chain_id=chain.id,
resseq=residue_group.resseq_as_int(),
icode=residue_group.icode,
has_altconf=(n_conformers > 1),
has_partocc=has_partocc,
avg_b=flex.mean(b_isos.select(use_i_seqs)))
self.residues[-1].append(res_info)
def apply_back_trace_of_overall_exp_scale_matrix(self, xray_structure=None):
if(xray_structure is None): return None
k_sol, b_sol, b_cart = self.k_sols(), self.b_sols(), self.b_cart()
assert len(k_sol)==1 # XXX Only one mask!
k_sol = k_sol[0]
b_sol = b_sol[0]
#
xrs = xray_structure
if(xrs is None): return
b_min = min(b_sol, xrs.min_u_cart_eigenvalue()*adptbx.u_as_b(1.))
if(b_min < 0): xrs.tidy_us()
b_iso = (b_cart[0]+b_cart[1]+b_cart[2])/3.0
b_test = b_min+b_iso
if(b_test < 0.0): b_adj = b_iso + abs(b_test) + 0.001
else: b_adj = b_iso
b_cart_new = [b_cart[0]-b_adj,b_cart[1]-b_adj,b_cart[2]-b_adj,
b_cart[3], b_cart[4], b_cart[5]]
b_sol_new = b_sol + b_adj
xrs.shift_us(b_shift = b_adj)
b_min = min(b_sol_new, xrs.min_u_cart_eigenvalue()*adptbx.u_as_b(1.))
assert b_min >= 0.0
xrs.tidy_us()
#
assert self.fmodel_kbu
k_masks = [ext.k_mask(self.fmodel_kbu.ss, k_sol, b_sol_new)]
u_star=adptbx.u_cart_as_u_star(
self.fmodel_kbu.f_obs.unit_cell(), adptbx.b_as_u(b_cart_new))
k_anisotropic = ext.k_anisotropic(self.fmodel_kbu.f_obs.indices(), u_star)
self.fmodel_kbu = self.fmodel_kbu.update(
b_sols = [b_sol_new],
b_cart = b_cart_new)
return group_args(
xray_structure = xrs,
b_adj = b_adj,
b_sol = b_sol_new,
b_cart = b_cart_new)
def write_pdb_file(self, out = None):
if (out is None): out = sys.stdout
sites_cart = self.ias_xray_structure.sites_cart()
for i_seq, sc in enumerate(self.ias_xray_structure.scatterers()):
a = pdb.hierarchy.atom_with_labels()
a.hetero = True
a.serial = i_seq+1
a.name = sc.label[:4] # XXX
a.resname = "IAS"
a.resseq = i_seq+1
a.xyz = sites_cart[i_seq]
a.occ = sc.occupancy
a.b = adptbx.u_as_b(sc.u_iso)
a.element = sc.label[:2] # XXX
print >> out, a.format_atom_record_group()
def write_ensemble_pdb(filename,
xrs_list,
ens_pdb_hierarchy):
out = open(filename, 'w')
crystal_symmetry = xrs_list[0].crystal_symmetry()
print >> out, "REMARK 3 TIME-AVERAGED ENSEMBLE REFINEMENT"
print >> out, "REMARK 3 OCCUPANCY = MAP SIGMA LEVEL"
print >> out, pdb.format_cryst1_record(crystal_symmetry = crystal_symmetry)
print >> out, pdb.format_scale_records(unit_cell = crystal_symmetry.unit_cell())
atoms_reset_serial = True
for i_model, xrs in enumerate(xrs_list):
scatterers = xrs.scatterers()
sites_cart = xrs.sites_cart()
u_isos = xrs.extract_u_iso_or_u_equiv()
occupancies = scatterers.extract_occupancies()
u_carts = scatterers.extract_u_cart_plus_u_iso(xrs.unit_cell())
scat_types = scatterers.extract_scattering_types()
i_model_ens_pdb_hierarchy = ens_pdb_hierarchy.models()[i_model]
pdb_atoms = i_model_ens_pdb_hierarchy.atoms()
for j_seq, atom in enumerate(pdb_atoms):
if j_seq < len(sites_cart):
atom.xyz = sites_cart[j_seq]
atom.occ = occupancies[j_seq]
atom.b = adptbx.u_as_b(u_isos[j_seq])
e = scat_types[j_seq]
if (len(e) > 1 and "+-0123456789".find(e[1]) >= 0):
atom.element = "%2s" % e[:1]
atom.charge = "%-2s" % e[1:]
elif (len(e) > 2):
atom.element = "%2s" % e[:2]
atom.charge = "%-2s" % e[2:]
else:
atom.element = "%2s" % e
atom.charge = " "
if (scatterers[j_seq].flags.use_u_aniso()):
atom.uij = u_carts[j_seq]
elif(False):
atom.uij = self.u_cart
else:
atom.uij = (-1,-1,-1,-1,-1,-1)
if (atoms_reset_serial):
atoms_reset_serial_first_value = 1
else:
atoms_reset_serial_first_value = None
out.write(ens_pdb_hierarchy.as_pdb_string(
append_end=False,
atoms_reset_serial_first_value=atoms_reset_serial_first_value))
def get_atom_radius(xray_structure=None, resolution=None, radius=None):
if (radius is not None): return radius
radii = []
if (resolution is not None):
radii.append(resolution)
if (xray_structure is not None and resolution is not None):
b_iso = adptbx.u_as_b(
flex.mean(xray_structure.extract_u_iso_or_u_equiv()))
o = maptbx.atom_curves(scattering_type="C",
scattering_table="electron")
rad_image = o.image(d_min=resolution,
b_iso=b_iso,
radius_max=max(15., resolution),
radius_step=0.01).radius
radii.append(rad_image)
return max(3, min(10, max(radii)))
def _b_cart_minimizer_helper(self, n_macro_cycles = 1):
r_start = self.fmodel_kbu.r_factor()
b_start = self.fmodel_kbu.b_cart()
for u_cycle in xrange(n_macro_cycles):
u_min = k_sol_b_sol_b_cart_minimizer(
fmodel_kbu = self.fmodel_kbu,
params = self.params,
refine_u_star = True).kbu.u_star()
b_cart = adptbx.u_as_b(
adptbx.u_star_as_u_cart(self.fmodel_kbu.f_obs.unit_cell(),u_min))
self.fmodel_kbu.update(b_cart = b_cart)
r_final = self.fmodel_kbu.r_factor()
if(r_final >= r_start):
self.fmodel_kbu.update(b_cart = b_start)
return b_start
else: return b_cart
def exercise_4_f_hydrogens():
for d_min in [1, 2, 3]:
for q in [0, 0.9, 1]:
random.seed(0)
flex.set_random_seed(0)
x = random_structure.xray_structure(
space_group_info=sgtbx.space_group_info("P 4"),
elements=(("O", "N", "C") * 5 + ("H", ) * 95),
volume_per_atom=200,
min_distance=1.5,
general_positions_only=True,
random_u_iso=True,
random_occupancy=False)
hd_sel = x.hd_selection()
b_isos = x.select(
~hd_sel).extract_u_iso_or_u_equiv() * adptbx.u_as_b(1.)
mmm = b_isos.min_max_mean().as_tuple()
b_mean = int(mmm[2])
x = x.set_b_iso(value=b_mean, selection=hd_sel)
x.scattering_type_registry(table="wk1995")
x.set_occupancies(value=q, selection=hd_sel)
fc = x.structure_factors(d_min=d_min, algorithm="direct").f_calc()
f_obs = abs(fc)
x = x.deep_copy_scatterers()
x.set_occupancies(value=0.0, selection=x.hd_selection())
sfg_params = mmtbx.f_model.sf_and_grads_accuracy_master_params.extract(
)
sfg_params.algorithm = "direct"
r_free_flags = f_obs.generate_r_free_flags(fraction=0.1)
fmodel = mmtbx.f_model.manager(
xray_structure=x,
f_obs=f_obs,
r_free_flags=r_free_flags,
sf_and_grads_accuracy_params=sfg_params)
if (q == 0):
assert approx_equal(fmodel.r_work(), 0)
else:
assert fmodel.r_work() > 0.05, fmodel.r_work()
params = bss.master_params.extract()
params.bulk_solvent = False
params.anisotropic_scaling = False
o = fmodel.update_all_scales(fast=False, params=params)
assert approx_equal(o.k_sol[0], 0)
assert approx_equal(o.b_sol[0], 0)
assert approx_equal(o.b_cart, [0, 0, 0, 0, 0, 0])
assert approx_equal(o.k_h, q)
assert approx_equal(fmodel.r_work(), 0)
def filter_da(fmodels, selection, da_sel_refinable, params):
xrs = fmodels.fmodel_xray().xray_structure
xrs_d = xrs.select(selection)
xrs_m = xrs.select(~selection)
#
occ = xrs_d.scatterers().extract_occupancies()
adp = xrs_d.extract_u_iso_or_u_equiv()*adptbx.u_as_b(1.)
sel = occ < params.filter.occupancy_max
sel &= occ > params.filter.occupancy_min
sel &= adp < params.filter.b_iso_max
sel &= adp > params.filter.b_iso_min
uc = xrs_d.unit_cell()
sphere_defined = True
if(len(params.sphere)==0): sphere_defined = False
for sphere in params.sphere:
if([sphere.center, sphere.radius].count(None) != 0): sphere_defined = False
for i_seq, site_frac_d in enumerate(xrs_d.sites_frac()):
if(sphere_defined):
inside = False
for sphere in params.sphere:
if([sphere.center, sphere.radius].count(None)==0):
dist = uc.distance(site_frac_d, uc.fractionalize(sphere.center))
if(dist <= sphere.radius*params.filter.inside_sphere_scale):
inside = True
break
if(not inside): sel[i_seq] = False
for site_frac_m in xrs_m.sites_frac():
dist = uc.distance(site_frac_d, site_frac_m)
if(dist < params.filter.da_model_min_dist):
sel[i_seq] = False
break
#
sel_all = flex.bool(xrs_m.scatterers().size(),True)
sel_all.extend(sel)
da_sel_refinable = da_sel_refinable.select(sel_all)
#
xrs_d = xrs_d.select(sel)
xrs = xrs_m.concatenate(xrs_d)
selection = flex.bool(xrs_m.scatterers().size(), False)
selection.extend(flex.bool(xrs_d.scatterers().size(), True))
fmodels.update_xray_structure(xray_structure = xrs, update_f_calc=True,
update_f_mask=False)
assert selection.size() == da_sel_refinable.size()
#XXXX
da_sel_refinable = selection
#XXXX
return fmodels, selection, da_sel_refinable
def filter_da(fmodels, selection, da_sel_refinable, params):
xrs = fmodels.fmodel_xray().xray_structure
xrs_d = xrs.select(selection)
xrs_m = xrs.select(~selection)
#
occ = xrs_d.scatterers().extract_occupancies()
adp = xrs_d.extract_u_iso_or_u_equiv()*adptbx.u_as_b(1.)
sel = occ < params.filter.occupancy_max
sel &= occ > params.filter.occupancy_min
sel &= adp < params.filter.b_iso_max
sel &= adp > params.filter.b_iso_min
uc = xrs_d.unit_cell()
sphere_defined = True
if(len(params.sphere)==0): sphere_defined = False
for sphere in params.sphere:
if([sphere.center, sphere.radius].count(None) != 0): sphere_defined = False
for i_seq, site_frac_d in enumerate(xrs_d.sites_frac()):
if(sphere_defined):
inside = False
for sphere in params.sphere:
if([sphere.center, sphere.radius].count(None)==0):
dist = uc.distance(site_frac_d, uc.fractionalize(sphere.center))
if(dist <= sphere.radius*params.filter.inside_sphere_scale):
inside = True
break
if(not inside): sel[i_seq] = False
for site_frac_m in xrs_m.sites_frac():
dist = uc.distance(site_frac_d, site_frac_m)
if(dist < params.filter.da_model_min_dist):
sel[i_seq] = False
break
#
sel_all = flex.bool(xrs_m.scatterers().size(),True)
sel_all.extend(sel)
da_sel_refinable = da_sel_refinable.select(sel_all)
#
xrs_d = xrs_d.select(sel)
xrs = xrs_m.concatenate(xrs_d)
selection = flex.bool(xrs_m.scatterers().size(), False)
selection.extend(flex.bool(xrs_d.scatterers().size(), True))
fmodels.update_xray_structure(xray_structure = xrs, update_f_calc=True,
update_f_mask=False)
assert selection.size() == da_sel_refinable.size()
#XXXX
da_sel_refinable = selection
#XXXX
return fmodels, selection, da_sel_refinable
def quality_factor_from_any(d_min=None,
grid_resolution_factor=None,
quality_factor=None,
u_base=None,
b_base=None):
assert [quality_factor, u_base, b_base].count(None) >= 2
if (u_base is not None):
b_base = adptbx.u_as_b(u_base)
if (b_base is not None):
assert [d_min, grid_resolution_factor].count(None) == 0
assert d_min > 0
sigma = 1 / (2. * grid_resolution_factor)
log_quality_factor = b_base * sigma * (sigma - 1) / (d_min * d_min)
quality_factor = 10**log_quality_factor
elif (quality_factor is None):
quality_factor = 100
return quality_factor
def structure_from_inp(inp, status, special_position_settings):
wyckoff_table = special_position_settings.space_group_info().wyckoff_table()
print "</pre><table border=2 cellpadding=2>"
status.in_table = True
print "<tr>"
print "<th>Label"
print "<th>Scattering<br>factor<br>label"
print "<th>Multiplicty"
print "<th>Wyckoff<br>position"
print "<th>Site<br>symmetry"
print "<th colspan=3>Fractional coordinates"
print "<th>Occupancy<br>factor"
print "<th>Biso"
print "<tr>"
structure = xray.structure(special_position_settings)
print
for line in inp.coordinates:
scatterer = read_scatterer(line.split())
if inp.coor_type != "Fractional":
scatterer.site = structure.unit_cell().fractionalize(scatterer.site)
structure.add_scatterer(scatterer)
site_symmetry = structure.site_symmetry(scatterer.site)
wyckoff_mapping = wyckoff_table.mapping(site_symmetry)
wyckoff_position = wyckoff_mapping.position()
print "<tr>"
print (
"<td>%s<td>%s"
+ "<td align=center>%d<td align=center>%s<td align=center>%s"
+ "<td><tt>%.6g</tt><td><tt>%.6g</tt><td><tt>%.6g</tt>"
+ "<td align=center><tt>%.6g</tt>"
+ "<td align=center><tt>%.6g</tt>"
) % (
(
scatterer.label,
scatterer.scattering_type,
wyckoff_position.multiplicity(),
wyckoff_position.letter(),
site_symmetry.point_group_type(),
)
+ scatterer.site
+ (scatterer.occupancy, adptbx.u_as_b(scatterer.u_iso))
)
print "</table><pre>"
status.in_table = False
print
return structure
def quality_factor_from_any(d_min=None,
grid_resolution_factor=None,
quality_factor=None,
u_base=None,
b_base=None):
assert [quality_factor, u_base, b_base].count(None) >= 2
if (u_base is not None):
b_base = adptbx.u_as_b(u_base)
if (b_base is not None):
assert [d_min, grid_resolution_factor].count(None) == 0
assert d_min > 0
sigma = 1 / (2. * grid_resolution_factor)
log_quality_factor = b_base * sigma * (sigma - 1) / (d_min * d_min)
quality_factor = 10**log_quality_factor
elif (quality_factor is None):
quality_factor = 100
return quality_factor
def exercise_4_f_hydrogens():
for d_min in [1,2,3]:
for q in [0, 0.9, 1]:
random.seed(0)
flex.set_random_seed(0)
x = random_structure.xray_structure(
space_group_info = sgtbx.space_group_info("P 4"),
elements =(("O","N","C")*5 + ("H",)*95),
volume_per_atom = 200,
min_distance = 1.5,
general_positions_only = True,
random_u_iso = True,
random_occupancy = False)
hd_sel = x.hd_selection()
b_isos = x.select(~hd_sel).extract_u_iso_or_u_equiv()*adptbx.u_as_b(1.)
mmm = b_isos.min_max_mean().as_tuple()
b_mean = int(mmm[2])
x = x.set_b_iso(value=b_mean, selection = hd_sel)
x.scattering_type_registry(table="wk1995")
x.set_occupancies(value=q, selection = hd_sel)
fc = x.structure_factors(d_min = d_min, algorithm="direct").f_calc()
f_obs = abs(fc)
x = x.deep_copy_scatterers()
x.set_occupancies(value=0.0, selection = x.hd_selection())
sfg_params = mmtbx.f_model.sf_and_grads_accuracy_master_params.extract()
sfg_params.algorithm = "direct"
r_free_flags = f_obs.generate_r_free_flags(fraction = 0.1)
fmodel = mmtbx.f_model.manager(
xray_structure = x,
f_obs = f_obs,
r_free_flags = r_free_flags,
sf_and_grads_accuracy_params = sfg_params)
if(q==0):
assert approx_equal(fmodel.r_work(), 0)
else:
assert fmodel.r_work() > 0.05, fmodel.r_work()
params = bss.master_params.extract()
params.bulk_solvent=False
params.anisotropic_scaling=False
o = fmodel.update_all_scales(fast=False, params=params)
assert approx_equal(o.k_sol[0],0)
assert approx_equal(o.b_sol[0],0)
assert approx_equal(o.b_cart,[0,0,0,0,0,0])
assert approx_equal(o.k_h, q)
assert approx_equal(fmodel.r_work(), 0)
def _b_cart_minimizer_helper(self, n_macro_cycles=1):
r_start = self.fmodel_kbu.r_factor()
b_start = self.fmodel_kbu.b_cart()
for u_cycle in range(n_macro_cycles):
u_min = k_sol_b_sol_b_cart_minimizer(
fmodel_kbu=self.fmodel_kbu,
params=self.params,
refine_u_star=True).kbu.u_star()
b_cart = adptbx.u_as_b(
adptbx.u_star_as_u_cart(self.fmodel_kbu.f_obs.unit_cell(),
u_min))
self.fmodel_kbu.update(b_cart=b_cart)
r_final = self.fmodel_kbu.r_factor()
if (r_final >= r_start):
self.fmodel_kbu.update(b_cart=b_start)
return b_start
else:
return b_cart
def refine(self):
b_isos = self.xray_structure.extract_u_iso_or_u_equiv()*adptbx.u_as_b(1.)
if(self.nproc==1):
for sel in self.chain_selections:
b_isos_refined = self.refine_box_with_selected(selection=sel)
b_isos = b_isos.set_selected(sel, b_isos_refined)
else:
stdout_and_results = easy_mp.pool_map(
processes = self.nproc,
fixed_func = self.refine_box_with_selected,
args = self.chain_selections,
func_wrapper = "buffer_stdout_stderr")
for i, it in enumerate(stdout_and_results):
so, b_isos_refined = it
b_isos = b_isos.set_selected(self.chain_selections[i], b_isos_refined)
print >> self.log, so
self.xray_structure = self.xray_structure.set_b_iso(values = b_isos)
self.pdb_hierarchy.adopt_xray_structure(self.xray_structure)
def loop_2(params, xray_structure, pdb_hierarchy, restraints_manager, root):
print("model:")
amp = params.f_obs.f_calc.atomic_model
grm = restraints_manager
xrs = xray_structure.deep_copy_scatterers()
show(xrs=xrs, xrs_start=xrs, grm=grm, prefix="start:")
xrs_sh = xrs.deep_copy_scatterers()
if (amp.shake_sites_rmsd is not None):
xrs_sh.shake_sites_in_place(rms_difference=amp.shake_sites_rmsd)
if (amp.apply_cartesian_dynamics):
cd(xray_structure=xrs_sh, restraints_manager=grm, params=amp)
show(xrs=xrs_sh, xrs_start=xrs, grm=grm, prefix="cd: ")
if ([
amp.regularize_geometry.rmsd_bonds_target,
amp.regularize_geometry.rmsd_angles_target
].count(None) == 0):
xrs_sh = regularize_geometry(xray_structure=xrs_sh,
restraints_manager=grm,
params=amp.regularize_geometry)
show(xrs=xrs_sh, xrs_start=xrs, grm=grm, prefix="min: ")
if (amp.ladp_angle is not None):
xrs_sh = set_ladp(xray_structure=xrs_sh,
pdb_hierarchy=pdb_hierarchy,
angle=amp.ladp_angle)
if ([amp.tls.max_tl, amp.tls.min_tl].count(None) == 0):
xrs_sh = apply_tls(xray_structure=xrs_sh, params=amp.tls)
if ([
amp.rigid_body_shift.rotation_angle,
amp.rigid_body_shift.translation_length
].count(None) == 0):
xrs_sh = apply_rigid_body_shift(xray_structure=xrs_sh,
params=amp.rigid_body_shift)
show(xrs=xrs_sh, xrs_start=xrs, grm=grm, prefix="rb: ")
#
h = pdb_hierarchy.deep_copy()
h.atoms().reset_i_seq() # XXX
h.atoms().set_xyz(xrs_sh.sites_cart().deep_copy())
h.atoms().set_uij(xrs_sh.scatterers().extract_u_cart(xrs_sh.unit_cell()))
h.atoms().set_b(xrs_sh.extract_u_iso_or_u_equiv() * adptbx.u_as_b(1.))
m = h.models()[0].detached_copy()
m.id = str(None)
root.append_model(m)
def refine(self):
b_isos = self.xray_structure.extract_u_iso_or_u_equiv(
) * adptbx.u_as_b(1.)
if (self.nproc == 1):
for sel in self.chain_selections:
b_isos_refined = self.refine_box_with_selected(selection=sel)
b_isos = b_isos.set_selected(sel, b_isos_refined)
else:
stdout_and_results = easy_mp.pool_map(
processes=self.nproc,
fixed_func=self.refine_box_with_selected,
args=self.chain_selections,
func_wrapper="buffer_stdout_stderr")
for i, it in enumerate(stdout_and_results):
so, b_isos_refined = it
b_isos = b_isos.set_selected(self.chain_selections[i],
b_isos_refined)
print >> self.log, so
self.xray_structure = self.xray_structure.set_b_iso(values=b_isos)
self.pdb_hierarchy.adopt_xray_structure(self.xray_structure)
def write_scatterer(s, running_index, scatterer,
action=None, segid=None, group=None):
if (action is None): action = "refine"
if (segid is None): segid = "SITE"
if (group is None): group = ""
assert running_index > 0
assert scatterer.flags.use_u_iso_only()
assert action in ("refine", "fix", "ignore")
i = running_index
print >> s, """\
{+ choice: "refine" "fix" "ignore" +}
{===>} site.action_%d="%s";
{===>} site.segid_%d="%s"; site.type_%d="%s";
{===>} site.x_%d=%.6g; site.y_%d=%.6g; site.z_%d=%.6g;
{===>} site.b_%d=%.6g; site.q_%d=%.6g; site.g_%d="%s";
""" % (i,action,
i,segid, i,scatterer.scattering_type,
i,scatterer.site[0],
i,scatterer.site[1],
i,scatterer.site[2],
i,adptbx.u_as_b(scatterer.u_iso), i,scatterer.occupancy, i,group)
def structure_from_inp(inp, status, special_position_settings):
wyckoff_table = special_position_settings.space_group_info().wyckoff_table(
)
print "</pre><table border=2 cellpadding=2>"
status.in_table = True
print "<tr>"
print "<th>Label"
print "<th>Scattering<br>factor<br>label"
print "<th>Multiplicty"
print "<th>Wyckoff<br>position"
print "<th>Site<br>symmetry"
print "<th colspan=3>Fractional coordinates"
print "<th>Occupancy<br>factor"
print "<th>Biso"
print "<tr>"
structure = xray.structure(special_position_settings)
print
for line in inp.coordinates:
scatterer = read_scatterer(line.split())
if (inp.coor_type != "Fractional"):
scatterer.site = structure.unit_cell().fractionalize(
scatterer.site)
structure.add_scatterer(scatterer)
site_symmetry = structure.site_symmetry(scatterer.site)
wyckoff_mapping = wyckoff_table.mapping(site_symmetry)
wyckoff_position = wyckoff_mapping.position()
print "<tr>"
print("<td>%s<td>%s" +
"<td align=center>%d<td align=center>%s<td align=center>%s" +
"<td><tt>%.6g</tt><td><tt>%.6g</tt><td><tt>%.6g</tt>" +
"<td align=center><tt>%.6g</tt>" +
"<td align=center><tt>%.6g</tt>") % (
(scatterer.label, scatterer.scattering_type,
wyckoff_position.multiplicity(), wyckoff_position.letter(),
site_symmetry.point_group_type()) + scatterer.site +
(scatterer.occupancy, adptbx.u_as_b(scatterer.u_iso)))
print "</table><pre>"
status.in_table = False
print
return structure
def write_scatterer(s,
running_index,
scatterer,
action=None,
segid=None,
group=None):
if (action is None): action = "refine"
if (segid is None): segid = "SITE"
if (group is None): group = ""
assert running_index > 0
assert scatterer.flags.use_u_iso_only()
assert action in ("refine", "fix", "ignore")
i = running_index
print >> s, """\
{+ choice: "refine" "fix" "ignore" +}
{===>} site.action_%d="%s";
{===>} site.segid_%d="%s"; site.type_%d="%s";
{===>} site.x_%d=%.6g; site.y_%d=%.6g; site.z_%d=%.6g;
{===>} site.b_%d=%.6g; site.q_%d=%.6g; site.g_%d="%s";
""" % (i, action, i, segid, i, scatterer.scattering_type, i, scatterer.site[0],
i, scatterer.site[1], i, scatterer.site[2], i,
adptbx.u_as_b(scatterer.u_iso), i, scatterer.occupancy, i, group)
def get_adps(self):
#print('Extracting ADPs', file=self.log)
if self._adps is None:
b_isos = self._xrs.extract_u_iso_or_u_equiv() * adptbx.u_as_b(1.)
n_iso = self._xrs.use_u_iso().count(True)
n_aniso = self._xrs.use_u_aniso().count(True)
n_zero = (b_isos < 0.01).count(True)
# TODO: what number as cutoff?
n_above_100 = (b_isos > 100).count(True)
isel_above_100 = (b_isos > 100).iselection()
b_min, b_max, b_mean = b_isos.min_max_mean().as_tuple()
# TODO: Get adp from surrounding residues
self._adps = group_args(n_iso=n_iso,
n_aniso=n_aniso,
n_zero=n_zero,
n_above_100=n_above_100,
isel_above_100=isel_above_100,
b_min=b_min,
b_max=b_max,
b_mean=b_mean)
return self._adps
def get_atom_radius(xray_structure=None, d_min=None, map_data=None,
crystal_symmetry=None, radius=None):
if(radius is not None): return radius
radii = []
if(d_min is not None):
radii.append(d_min)
if([xray_structure, crystal_symmetry].count(None)==0):
assert crystal_symmetry.is_similar_symmetry(
xray_structure.crystal_symmetry())
if([map_data, crystal_symmetry].count(None)==0):
d99 = maptbx.d99(
map = map_data,
crystal_symmetry = crystal_symmetry).result.d99
radii.append(d99)
if(xray_structure is not None and d_min is not None):
b_iso = adptbx.u_as_b(
flex.mean(xray_structure.extract_u_iso_or_u_equiv()))
o = maptbx.atom_curves(scattering_type="C", scattering_table="electron")
rad_image = o.image(d_min=d_min, b_iso=b_iso,
radius_max=max(15.,d_min), radius_step=0.01).radius
radii.append(rad_image)
return max(3, min(10, max(radii)))
def refine_box_with_selected(self, selection=None):
if (selection is None):
selections = self.xray_structure.all_selection()
ph_box = self.pdb_hierarchy.select(selection)
ph_box.atoms().reset_i_seq()
box = mmtbx.utils.extract_box_around_model_and_map(
xray_structure=self.xray_structure.select(selection),
map_data=self.target_map.map_data,
box_cushion=self.atom_radius,
mask_atoms=True,
mask_atoms_atom_radius=self.atom_radius)
ph_box.adopt_xray_structure(box.xray_structure_box)
group_adp_sel = []
for rg in ph_box.residue_groups():
group_adp_sel.append(rg.atoms().extract_i_seq())
f_obs_box = abs(box.box_map_coefficients(d_min=self.target_map.d_min))
fmodel = mmtbx.f_model.manager(f_obs=f_obs_box,
xray_structure=box.xray_structure_box)
#XXX
fmodel.update_all_scales(update_f_part1=False, apply_back_trace=True)
#XXX
fmodel.update(target_name="ls_wunit_k1")
if (self.nproc > 1): log = None
else: log = self.log
group_b_manager = mmtbx.refinement.group.manager(
fmodel=fmodel,
selections=group_adp_sel,
convergence_test=False,
max_number_of_iterations=50,
number_of_macro_cycles=3,
run_finite_differences_test=False,
use_restraints=self.use_adp_restraints,
refine_adp=True,
log=log)
return fmodel.xray_structure.extract_u_iso_or_u_equiv(
) * adptbx.u_as_b(1.)
def show_refinement_update(fmodels, selection, da_sel_refinable, prefix):
fmt1 = "%s Rwork= %8.6f Rfree= %8.6f Number of: non-DA= %d DA= %d all= %d"
print(fmt1%(prefix, fmodels.fmodel_xray().r_work(),
fmodels.fmodel_xray().r_free(),
selection.count(False),selection.count(True),
fmodels.fmodel_xray().xray_structure.scatterers().size()))
occ = fmodels.fmodel_xray().xray_structure.scatterers().extract_occupancies()
occ_da = occ.select(selection)
if(occ_da.size()>0):
occ_ma = occ.select(~selection)
print(" non-da: occ(min,max,mean)= %6.3f %6.3f %6.3f"%(
flex.min(occ_ma),flex.max(occ_ma),flex.mean(occ_ma)))
print(" da: occ(min,max,mean)= %6.3f %6.3f %6.3f"%(
flex.min(occ_da),flex.max(occ_da),flex.mean(occ_da)))
b = fmodels.fmodel_xray().xray_structure.extract_u_iso_or_u_equiv()*\
adptbx.u_as_b(1.)
b_da = b.select(selection)
b_ma = b.select(~selection)
print(" non-da: ADP(min,max,mean)= %7.2f %7.2f %7.2f"%(
flex.min(b_ma),flex.max(b_ma),flex.mean(b_ma)))
print(" da: ADP(min,max,mean)= %7.2f %7.2f %7.2f"%(
flex.min(b_da),flex.max(b_da),flex.mean(b_da)))
print("da_sel_refinable:", da_sel_refinable.size(), da_sel_refinable.count(True))
def show_refinement_update(fmodels, selection, da_sel_refinable, prefix):
fmt1 = "%s Rwork= %8.6f Rfree= %8.6f Number of: non-DA= %d DA= %d all= %d"
print fmt1%(prefix, fmodels.fmodel_xray().r_work(),
fmodels.fmodel_xray().r_free(),
selection.count(False),selection.count(True),
fmodels.fmodel_xray().xray_structure.scatterers().size())
occ = fmodels.fmodel_xray().xray_structure.scatterers().extract_occupancies()
occ_da = occ.select(selection)
if(occ_da.size()>0):
occ_ma = occ.select(~selection)
print " non-da: occ(min,max,mean)= %6.3f %6.3f %6.3f"%(
flex.min(occ_ma),flex.max(occ_ma),flex.mean(occ_ma))
print " da: occ(min,max,mean)= %6.3f %6.3f %6.3f"%(
flex.min(occ_da),flex.max(occ_da),flex.mean(occ_da))
b = fmodels.fmodel_xray().xray_structure.extract_u_iso_or_u_equiv()*\
adptbx.u_as_b(1.)
b_da = b.select(selection)
b_ma = b.select(~selection)
print " non-da: ADP(min,max,mean)= %7.2f %7.2f %7.2f"%(
flex.min(b_ma),flex.max(b_ma),flex.mean(b_ma))
print " da: ADP(min,max,mean)= %7.2f %7.2f %7.2f"%(
flex.min(b_da),flex.max(b_da),flex.mean(b_da))
print "da_sel_refinable:", da_sel_refinable.size(), da_sel_refinable.count(True)
def refine_box_with_selected(self, selection=None):
if(selection is None): selections = self.xray_structure.all_selection()
ph_box = self.pdb_hierarchy.select(selection)
ph_box.atoms().reset_i_seq()
box = mmtbx.utils.extract_box_around_model_and_map(
xray_structure = self.xray_structure.select(selection),
map_data = self.target_map.map_data,
box_cushion = self.atom_radius,
mask_atoms = True,
mask_atoms_atom_radius = self.atom_radius)
ph_box.adopt_xray_structure(box.xray_structure_box)
group_adp_sel = []
for rg in ph_box.residue_groups():
group_adp_sel.append(rg.atoms().extract_i_seq())
f_obs_box = abs(box.box_map_coefficients(d_min = self.target_map.d_min))
fmodel = mmtbx.f_model.manager(
f_obs = f_obs_box,
xray_structure = box.xray_structure_box)
#XXX
fmodel.update_all_scales(update_f_part1=False, apply_back_trace=True)
#XXX
fmodel.update(target_name="ls_wunit_k1")
if(self.nproc>1): log = None
else: log = self.log
group_b_manager = mmtbx.refinement.group.manager(
fmodel = fmodel,
selections = group_adp_sel,
convergence_test = False,
max_number_of_iterations = 50,
number_of_macro_cycles = 3,
run_finite_differences_test = False,
use_restraints = self.use_adp_restraints,
refine_adp = True,
log = log)
return fmodel.xray_structure.extract_u_iso_or_u_equiv()*adptbx.u_as_b(1.)
def coordinates(scatterers, xyz_only=False):
cns_input = []
a = cns_input.append
resid = 1
for scatterer in scatterers:
x = scatterer.site
q = scatterer.occupancy
assert scatterer.flags.use_u_iso_only()
b = adptbx.u_as_b(scatterer.u_iso)
gaussian = eltbx.xray_scattering.it1992(scatterer.scattering_type).fetch()
fp = scatterer.fp
fdp = scatterer.fdp
for i in range(3):
a("do (%s=%.12g) (resid=%d)" % ("xyz"[i], x[i], resid))
if (not xyz_only):
a("do (q=%.12g) (resid=%d)" % (q, resid))
a("do (b=%.12g) (resid=%d)" % (b, resid))
a("xray")
a(" scatter (chemical=%s)" % scatterer.label.replace(" ","")[-4:])
for i in range(4):
a(" %.6g %.6g" %
(gaussian.array_of_a()[i], gaussian.array_of_b()[i]))
a(" %.6g" % (gaussian.c(),))
a("end")
a("do (scatter_fp=%.12g) (resid=%d)" % (fp, resid))
a("do (scatter_fdp=%.12g) (resid=%d)" % (fdp, resid))
a("")
resid += 1
a("coordinates orthogonalize end")
a("show (name) (all)")
a("show (chemical) (all)")
if (not xyz_only):
a("show (scatter_fp) (all)")
a("show (scatter_fdp) (all)")
a("")
return cns_input
def run_test(self):
# Refinement
params = mmtbx.f_model.sf_and_grads_accuracy_master_params.extract()
params.algorithm = "direct"
# Get the xray_structure of the shaken ASU
xrs_shaken_asu, dummy, transform_info, ph, ph2 = step_1(
file_name="one_ncs_in_asu_shaken.pdb",
crystal_symmetry=self.xrs_one_ncs.crystal_symmetry(),
write_name='asu_shaken.pdb')
tr_obj = iotbx.ncs.input(
hierarchy = ph,
transform_info = transform_info,
exclude_selection=None)
self.ncs_restraints_group_list = tr_obj.get_ncs_restraints_group_list()
# refine both ncs related and not related atoms
self.refine_selection = flex.size_t(range(tr_obj.total_asu_length))
self.extended_ncs_selection = nu.get_extended_ncs_selection(
ncs_restraints_group_list=tr_obj.get_ncs_restraints_group_list(),
refine_selection=self.refine_selection)
assert self.refine_selection.size() == 21, self.refine_selection.size()
self.fmodel = mmtbx.f_model.manager(
f_obs = self.f_obs,
r_free_flags = self.r_free_flags,
xray_structure = xrs_shaken_asu,
sf_and_grads_accuracy_params = params,
target_name = "ls_wunit_k1")
r_start = self.fmodel.r_work()
assert r_start > 0.1, r_start
print "start r_factor: %6.4f" % r_start
for macro_cycle in xrange(self.n_macro_cycle):
data_weight = None
if(self.use_geometry_restraints):
self.transformations=False
data_weight = nu.get_weight(minimized_obj=self)
target_and_grads_object = mmtbx.refinement.minimization_ncs_constraints.\
target_function_and_grads_reciprocal_space(
fmodel = self.fmodel,
ncs_restraints_group_list = self.ncs_restraints_group_list,
refine_selection = self.refine_selection,
restraints_manager = self.grm,
data_weight = data_weight,
refine_sites = self.sites,
refine_u_iso = self.u_iso,
iso_restraints = self.iso_restraints)
minimized = mmtbx.refinement.minimization_ncs_constraints.lbfgs(
target_and_grads_object = target_and_grads_object,
xray_structure = self.fmodel.xray_structure,
ncs_restraints_group_list = self.ncs_restraints_group_list,
refine_selection = self.refine_selection,
finite_grad_differences_test = self.finite_grad_differences_test,
max_iterations = 100,
refine_sites = self.sites,
refine_u_iso = self.u_iso)
refine_type = 'adp'*self.u_iso + 'sites'*self.sites
outstr = " macro_cycle {0:3} ({1}) r_factor: {2:6.4f} " + \
self.finite_grad_differences_test * \
"finite_grad_difference_val: {3:.4f}"
print outstr.format(
macro_cycle, refine_type,self.fmodel.r_work(),
minimized.finite_grad_difference_val)
assert (minimized.finite_grad_difference_val < 1.0e-3)
assert approx_equal(self.fmodel.r_work(), target_and_grads_object.fmodel.r_work())
# break test if r_work is very small
if target_and_grads_object.fmodel.r_work() < 1.0e-6: break
# check results
if(self.u_iso):
assert approx_equal(self.fmodel.r_work(), 0, 1.e-5)
elif(self.sites):
if(self.use_geometry_restraints):
assert approx_equal(self.fmodel.r_work(), 0, 0.00018)
else:
assert approx_equal(self.fmodel.r_work(), 0, 3.e-4)
else: assert 0
# output refined model
xrs_refined = self.fmodel.xray_structure
output_file_name = "refined_u_iso%s_sites%s.pdb"%(str(self.u_iso),
str(self.sites))
assert ph2.atoms().size() == self.fmodel.xray_structure.scatterers().size()
ph2.atoms().set_xyz(self.fmodel.xray_structure.sites_cart())
ph2.atoms().set_b(
self.fmodel.xray_structure.extract_u_iso_or_u_equiv()*adptbx.u_as_b(1.))
ph2.write_pdb_file(file_name = output_file_name,
crystal_symmetry=self.fmodel.xray_structure.crystal_symmetry())
self.test_files_names.append(output_file_name)
# check final model
if(not self.use_geometry_restraints):
# XXX fix later for case self.use_geometry_restraints=True
pdb_inp_answer = iotbx.pdb.input(source_info=None, lines=ncs_1_copy)
pdb_inp_refined = iotbx.pdb.input(file_name=output_file_name)
xrs1 = pdb_inp_answer.xray_structure_simple(
crystal_symmetry=self.fmodel.xray_structure.crystal_symmetry())
xrs2 = pdb_inp_refined.xray_structure_simple().select(
minimized.extended_ncs_selection)
print xrs1.crystal_symmetry().unit_cell().parameters()
print xrs2.crystal_symmetry().unit_cell().parameters()
mmtbx.utils.assert_xray_structures_equal(
x1 = xrs1,
x2 = xrs2,
sites = False)
delta = flex.vec3_double([xrs1.center_of_mass()]*xrs2.scatterers().size())-\
flex.vec3_double([xrs2.center_of_mass()]*xrs2.scatterers().size())
xrs2.set_sites_cart(sites_cart = xrs2.sites_cart()+delta)
mmtbx.utils.assert_xray_structures_equal(
x1 = xrs1,
x2 = xrs2,
eps=1.e-4)
def __init__(self,
pdb_hierarchy,
xray_structure,
fmodel,
distance_cutoff=4.0,
collect_all=True,
molprobity_map_params=None):
validation.__init__(self)
from mmtbx.real_space_correlation import extract_map_stats_for_single_atoms
from cctbx import adptbx
from scitbx.matrix import col
self.n_bad = 0
self.n_heavy = 0
pdb_atoms = pdb_hierarchy.atoms()
if (len(pdb_atoms) > 1):
assert (not pdb_atoms.extract_i_seq().all_eq(0))
unit_cell = xray_structure.unit_cell()
pair_asu_table = xray_structure.pair_asu_table(
distance_cutoff=distance_cutoff)
asu_mappings = pair_asu_table.asu_mappings()
asu_table = pair_asu_table.table()
u_isos = xray_structure.extract_u_iso_or_u_equiv()
occupancies = xray_structure.scatterers().extract_occupancies()
sites_frac = xray_structure.sites_frac()
sel_cache = pdb_hierarchy.atom_selection_cache()
water_sel = sel_cache.selection("water")
if (molprobity_map_params is not None):
# assume parameters have been validated (symmetry of pdb and map matches)
two_fofc_map = None
fc_map = None
d_min = None
crystal_gridding = None
# read two_fofc_map
if (molprobity_map_params.map_file_name is not None):
f = any_file(molprobity_map_params.map_file_name)
two_fofc_map = f.file_object.map_data()
d_min = molprobity_map_params.d_min
crystal_gridding = maptbx.crystal_gridding(
f.file_object.unit_cell(),
space_group_info=space_group_info(
f.file_object.space_group_number),
pre_determined_n_real=f.file_object.unit_cell_grid)
pdb_atoms = pdb_hierarchy.atoms()
xray_structure = pdb_hierarchy.extract_xray_structure(
crystal_symmetry=f.crystal_symmetry())
unit_cell = xray_structure.unit_cell()
# check for origin shift
# ---------------------------------------------------------------------
soin = maptbx.shift_origin_if_needed(
map_data=two_fofc_map,
sites_cart=xray_structure.sites_cart(),
crystal_symmetry=xray_structure.crystal_symmetry())
two_fofc_map = soin.map_data
xray_structure.set_sites_cart(soin.sites_cart)
# ---------------------------------------------------------------------
pair_asu_table = xray_structure.pair_asu_table(
distance_cutoff=distance_cutoff)
asu_mappings = pair_asu_table.asu_mappings()
asu_table = pair_asu_table.table()
u_isos = xray_structure.extract_u_iso_or_u_equiv()
occupancies = xray_structure.scatterers().extract_occupancies()
sites_frac = xray_structure.sites_frac()
sel_cache = pdb_hierarchy.atom_selection_cache()
water_sel = sel_cache.selection("water")
elif (molprobity_map_params.map_coefficients_file_name
is not None):
f = any_file(molprobity_map_params.map_coefficients_file_name)
fourier_coefficients = f.file_server.get_miller_array(
molprobity_map_params.map_coefficients_label)
crystal_symmetry = fourier_coefficients.crystal_symmetry()
d_min = fourier_coefficients.d_min()
crystal_gridding = maptbx.crystal_gridding(
crystal_symmetry.unit_cell(),
d_min,
resolution_factor=0.25,
space_group_info=crystal_symmetry.space_group_info())
two_fofc_map = miller.fft_map(
crystal_gridding=crystal_gridding,
fourier_coefficients=fourier_coefficients).apply_sigma_scaling().\
real_map_unpadded()
# calculate fc_map
assert ((d_min is not None) and (crystal_gridding is not None))
f_calc = xray_structure.structure_factors(d_min=d_min).f_calc()
fc_map = miller.fft_map(crystal_gridding=crystal_gridding,
fourier_coefficients=f_calc)
fc_map = fc_map.apply_sigma_scaling().real_map_unpadded()
map_stats = extract_map_stats_for_single_atoms(
pdb_atoms=pdb_atoms,
xray_structure=xray_structure,
fmodel=None,
selection=water_sel,
fc_map=fc_map,
two_fofc_map=two_fofc_map)
else:
map_stats = extract_map_stats_for_single_atoms(
pdb_atoms=pdb_atoms,
xray_structure=xray_structure,
fmodel=fmodel,
selection=water_sel)
waters = []
for i_seq, atom in enumerate(pdb_atoms):
if (water_sel[i_seq]):
rt_mx_i_inv = asu_mappings.get_rt_mx(i_seq, 0).inverse()
self.n_total += 1
asu_dict = asu_table[i_seq]
nearest_atom = nearest_contact = None
for j_seq, j_sym_groups in asu_dict.items():
atom_j = pdb_atoms[j_seq]
site_j = sites_frac[j_seq]
# Filter out hydrogens
if atom_j.element.upper().strip() in ["H", "D"]:
continue
for j_sym_group in j_sym_groups:
rt_mx = rt_mx_i_inv.multiply(
asu_mappings.get_rt_mx(j_seq, j_sym_group[0]))
site_ji = rt_mx * site_j
site_ji_cart = xray_structure.unit_cell(
).orthogonalize(site_ji)
vec_i = col(atom.xyz)
vec_ji = col(site_ji_cart)
dxyz = abs(vec_i - vec_ji)
if (nearest_contact is None) or (dxyz <
nearest_contact):
nearest_contact = dxyz
nearest_atom = atom_info(pdb_atom=atom_j,
symop=rt_mx)
w = water(pdb_atom=atom,
b_iso=adptbx.u_as_b(u_isos[i_seq]),
occupancy=occupancies[i_seq],
nearest_contact=nearest_contact,
nearest_atom=nearest_atom,
score=map_stats.two_fofc_ccs[i_seq],
fmodel=map_stats.fmodel_values[i_seq],
two_fofc=map_stats.two_fofc_values[i_seq],
fofc=map_stats.fofc_values[i_seq],
anom=map_stats.anom_values[i_seq],
n_hbonds=None) # TODO
if (w.is_bad_water()):
w.outlier = True
self.n_bad += 1
elif (w.is_heavy_atom()):
w.outlier = True
self.n_heavy += 1
if (w.outlier) or (collect_all):
self.results.append(w)
self.n_outliers = len(self.results)
def residual_contribution(u_isos_current, u_isos_average):
diff = u_isos_current - u_isos_average
self.rms_with_respect_to_average.append(
adptbx.u_as_b(flex.mean_sq(diff)**0.5))
self.number_of_restraints += diff.size()
def map_coefficients(self,
map_type,
acentrics_scale = 2.0,
centrics_pre_scale = 1.0,
exclude_free_r_reflections=False,
fill_missing=False,
fill_missing_method="f_model",
isotropize=True,
sharp=False,
pdb_hierarchy=None, # XXX required for map_type=llg
merge_anomalous=None,
use_shelx_weight=False,
shelx_weight_parameter=1.5):
map_name_manager = mmtbx.map_names(map_name_string = map_type)
# Special case #1: anomalous map
if(map_name_manager.anomalous):
if(self.anom_diff is not None):
# Formula from page 141 in "The Bijvoet-Difference Fourier Synthesis",
# Jeffrey Roach, METHODS IN ENZYMOLOGY, VOL. 374
return miller.array(miller_set = self.anom_diff,
data = self.anom_diff.data()/(2j))
else: return None
# Special case #2: anomalous residual map
elif (map_name_manager.anomalous_residual):
if (self.anom_diff is not None):
return anomalous_residual_map_coefficients(
fmodel=self.fmodel,
exclude_free_r_reflections=exclude_free_r_reflections)
else : return None
# Special case #3: Phaser SAD LLG map
elif (map_name_manager.phaser_sad_llg):
if (pdb_hierarchy is None):
raise RuntimeError("pdb_hierarchy must not be None when a Phaser SAD "+
"LLG map is requested.")
if (self.anom_diff is not None):
return get_phaser_sad_llg_map_coefficients(
fmodel=self.fmodel,
pdb_hierarchy=pdb_hierarchy)
else :
return None
# Special case #4: Fcalc map
mnm = mmtbx.map_names(map_name_string = map_type)
if(mnm.k==0 and abs(mnm.n)==1):
if(fill_missing):
return self.fmodel.xray_structure.structure_factors(
d_min = self.fmodel.f_obs().d_min()).f_calc()
else:
return self.fmodel.f_obs().structure_factors_from_scatterers(
xray_structure = self.fmodel.xray_structure).f_calc()
#
if(self.mch is None):
self.mch = self.fmodel.map_calculation_helper()
ffs = fo_fc_scales(
fmodel = self.fmodel,
map_type_str = map_type,
acentrics_scale = acentrics_scale,
centrics_scale = centrics_pre_scale)
fo_scale, fc_scale = ffs.fo_scale, ffs.fc_scale
coeffs = combine(
fmodel = self.fmodel,
map_type_str = map_type,
fo_scale = fo_scale,
fc_scale = fc_scale,
map_calculation_helper = self.mch,
use_shelx_weight = use_shelx_weight,
shelx_weight_parameter = shelx_weight_parameter).map_coefficients()
r_free_flags = None
# XXX the default scale array (used for the isotropize option) needs to be
# calculated and processed now to avoid array size errors
scale_default = 1. / (self.fmodel.k_isotropic()*self.fmodel.k_anisotropic())
scale_array = coeffs.customized_copy(data=scale_default)
if (exclude_free_r_reflections):
if (coeffs.anomalous_flag()):
coeffs = coeffs.average_bijvoet_mates()
r_free_flags = self.fmodel.r_free_flags()
if (r_free_flags.anomalous_flag()):
r_free_flags = r_free_flags.average_bijvoet_mates()
scale_array = scale_array.average_bijvoet_mates()
coeffs = coeffs.select(~r_free_flags.data())
scale_array = scale_array.select(~r_free_flags.data())
scale=None
if(isotropize):
if(scale is None):
if (scale_array.anomalous_flag()) and (not coeffs.anomalous_flag()):
scale_array = scale_array.average_bijvoet_mates()
scale = scale_array.data()
coeffs = coeffs.customized_copy(data = coeffs.data()*scale)
if(fill_missing):
if(coeffs.anomalous_flag()):
coeffs = coeffs.average_bijvoet_mates()
coeffs = fill_missing_f_obs(
coeffs = coeffs,
fmodel = self.fmodel,
method = fill_missing_method)
if(sharp):
ss = 1./flex.pow2(coeffs.d_spacings().data()) / 4.
from cctbx import adptbx
b = flex.mean(self.fmodel.xray_structure.extract_u_iso_or_u_equiv() *
adptbx.u_as_b(1))/2
k_sharp = 1./flex.exp(-ss * b)
coeffs = coeffs.customized_copy(data = coeffs.data()*k_sharp)
if (merge_anomalous) and (coeffs.anomalous_flag()):
return coeffs.average_bijvoet_mates()
return coeffs
def create_da_xray_structures(xray_structure, params):
def grid(sphere, gap, overlap):
c = flex.double(sphere.center)
x_start, y_start, z_start = c - float(sphere.radius)
x_end, y_end, z_end = c + float(sphere.radius)
x_range = frange(c[0], c[0] + gap, overlap)
y_range = frange(c[1], c[1] + gap, overlap)
z_range = frange(c[2], c[2] + gap, overlap)
return group_args(x_range=x_range, y_range=y_range, z_range=z_range)
grids = []
for sphere in params.sphere:
grids.append(
grid(sphere=sphere,
gap=params.atom_gap,
overlap=params.overlap_interval))
initial_b_factor = params.initial_b_factor
if (initial_b_factor is None):
initial_b_factor = flex.mean(
xray_structure.extract_u_iso_or_u_equiv() * adptbx.u_as_b(1.))
da_xray_structures = []
counter = 0
for grid, sphere in zip(grids, params.sphere):
cntr_g = 0 # XXX
for x_start in grid.x_range:
for y_start in grid.y_range:
for z_start in grid.z_range:
cntr_g += 1
if (cntr_g > 1): continue # XXX
counter += 1
new_center = flex.double([x_start, y_start, z_start])
atom_grid = make_grid(center=new_center,
radius=sphere.radius,
gap=params.atom_gap,
occupancy=params.initial_occupancy,
b_factor=initial_b_factor,
atom_name=params.atom_name,
scattering_type=params.atom_type,
resname=params.residue_name)
da_xray_structure = pdb_atoms_as_xray_structure(
pdb_atoms=atom_grid,
crystal_symmetry=xray_structure.crystal_symmetry())
closest_distances_result = xray_structure.closest_distances(
sites_frac=da_xray_structure.sites_frac(),
distance_cutoff=5)
selection = closest_distances_result.smallest_distances > 0
selection &= closest_distances_result.smallest_distances < 1
da_xray_structure = da_xray_structure.select(~selection)
#print counter, da_xray_structure.scatterers().size()
if (cntr_g == 1): # XXX
da_xray_structures.append(da_xray_structure)
###
result = []
for i, x1 in enumerate(da_xray_structures):
for j, x2 in enumerate(da_xray_structures):
if (x1 is not x2):
closest_distances_result = x1.closest_distances(
sites_frac=x2.sites_frac(), distance_cutoff=5) # XXX ???
selection = closest_distances_result.smallest_distances > 0
selection &= closest_distances_result.smallest_distances < params.atom_gap
da_xray_structures[j] = x2.select(~selection)
return da_xray_structures
def update_solvent_and_scale_2(self, fast, params, apply_back_trace,
refine_hd_scattering, log):
if (params is None): params = bss.master_params.extract()
if (self.xray_structure is not None):
# Figure out Fcalc and Fmask based on presence of H
hd_selection = self.xray_structure.hd_selection()
xrs_no_h = self.xray_structure.select(~hd_selection)
xrs_h = self.xray_structure.select(hd_selection)
# Create data container for scalers. If H scattering is refined then it is
# assumed that self.f_calc() does not contain H contribution at all.
fmodel_kbu = mmtbx.f_model.manager_kbu(f_obs=self.f_obs(),
f_calc=self.f_calc(),
f_masks=self.f_masks(),
ss=self.ss)
# Compute k_total and k_mask using one of the two methods (anal or min).
# Note: this intentionally ignores previously existing f_part1 and f_part2.
#
k_sol, b_sol, b_cart, b_adj = [
None,
] * 4
if (fast): # analytical
assert len(fmodel_kbu.f_masks) == 1
result = mmtbx.bulk_solvent.scaler.run_simple(
fmodel_kbu=fmodel_kbu,
r_free_flags=self.r_free_flags(),
bulk_solvent=params.bulk_solvent,
bin_selections=self.bin_selections)
r_all_from_scaler = result.r_all(
) # must be here, before apply_back_trace
else: # using minimization: exp solvent and scale model (k_sol,b_sol,b_cart)
result = bss.bulk_solvent_and_scales(fmodel_kbu=fmodel_kbu,
params=params)
k_sol, b_sol, b_cart = result.k_sols(), result.b_sols(
), result.b_cart()
r_all_from_scaler = result.r_all(
) # must be here, before apply_back_trace
if (apply_back_trace and len(fmodel_kbu.f_masks) == 1
and self.xray_structure is not None):
o = result.apply_back_trace_of_overall_exp_scale_matrix(
xray_structure=self.xray_structure)
b_adj = o.b_adj
if (not fast): b_sol, b_cart = [o.b_sol], o.b_cart
self.update_xray_structure(xray_structure=o.xray_structure,
update_f_calc=True)
fmodel_kbu = fmodel_kbu.update(f_calc=self.f_calc())
self.show(prefix="overall B=%s to atoms" %
str("%7.2f" % o.b_adj).strip(),
log=log)
# Update self with new arrays so that H correction knows current R factor.
# If no H to account for, then this is the final result.
k_masks = result.k_masks()
k_anisotropic = result.k_anisotropic()
k_isotropic = result.k_isotropic()
self.update_core(k_mask=k_masks,
k_anisotropic=k_anisotropic,
k_isotropic=k_isotropic)
self.show(prefix="bulk-solvent and scaling", log=log)
# Consistency check
if (not apply_back_trace):
assert approx_equal(self.r_all(), r_all_from_scaler)
# Add contribution from H (if present and riding). This goes to f_part2.
kh, bh = 0, 0
if (refine_hd_scattering
and self.need_to_refine_hd_scattering_contribution()):
# Obsolete previous contribution f_part2
f_part2 = fmodel_kbu.f_calc.array(data=fmodel_kbu.f_calc.data() *
0)
self.update_core(f_part2=f_part2)
xrs_h = xrs_h.set_occupancies(value=1).set_b_iso(value=0)
f_h = self.compute_f_calc(xray_structure=xrs_h)
# Accumulate all mask contributions: Fcalc_atoms+Fbulk_1+...+Fbulk_N
data = fmodel_kbu.f_calc.data()
for k_mask_, f_mask_ in zip(k_masks, fmodel_kbu.f_masks):
data = data + k_mask_ * f_mask_.data()
f_calc_plus_f_bulk_no_scales = fmodel_kbu.f_calc.array(data=data)
# Consistency check
assert approx_equal(
self.f_model().data(),
f_calc_plus_f_bulk_no_scales.data() * k_isotropic *
k_anisotropic)
assert approx_equal(self.f_model_no_scales().data(),
f_calc_plus_f_bulk_no_scales.data())
#
# Compute contribution from H (F_H)
#
# Coarse sampling
b_mean = flex.mean(
xrs_no_h.extract_u_iso_or_u_equiv()) * adptbx.u_as_b(1.)
b_min = int(max(0, b_mean) * 0.5)
b_max = int(b_mean * 1.5)
sc = 1000.
kr = [
i / sc for i in range(ifloor(0 * sc),
iceil(1.5 * sc) + 1, int(0.1 * sc))
]
br = [
i / sc for i in range(ifloor(b_min * sc),
iceil(b_max * sc) + 1, int(5. * sc))
]
o = bulk_solvent.k_sol_b_sol_k_anisotropic_scaler_twin(
f_obs=fmodel_kbu.f_obs.data(),
f_calc=f_calc_plus_f_bulk_no_scales.data(),
f_mask=f_h.data(),
k_total=k_isotropic * k_anisotropic,
ss=fmodel_kbu.ss,
k_sol_range=flex.double(kr),
b_sol_range=flex.double(br),
r_ref=self.r_work())
if (o.updated()):
f_part2 = f_h.array(data=o.k_mask() * f_h.data())
kh, bh = o.k_sol(), o.b_sol()
self.show(prefix="add H (%4.2f, %6.2f)" % (kh, bh),
log=log,
r=o.r())
# Fine sampling
k_min = max(0, o.k_sol() - 0.1)
k_max = o.k_sol() + 0.1
b_min = max(0, o.b_sol() - 5.)
b_max = o.b_sol() + 5.
kr = [
i / sc for i in range(ifloor(k_min * sc),
iceil(k_max * sc) + 1, int(0.01 * sc))
]
br = [
i / sc for i in range(ifloor(b_min * sc),
iceil(b_max * sc) + 1, int(1. * sc))
]
o = bulk_solvent.k_sol_b_sol_k_anisotropic_scaler_twin(
f_obs=fmodel_kbu.f_obs.data(),
f_calc=f_calc_plus_f_bulk_no_scales.data(),
f_mask=f_h.data(),
k_total=k_isotropic * k_anisotropic,
ss=fmodel_kbu.ss,
k_sol_range=flex.double(kr),
b_sol_range=flex.double(br),
r_ref=o.r())
if (o.updated()):
f_part2 = f_h.array(data=o.k_mask() * f_h.data())
kh, bh = o.k_sol(), o.b_sol()
self.show(prefix="add H (%4.2f, %6.2f)" % (kh, bh),
log=log,
r=o.r())
# THIS HELPS if fast=true is used, see how it works in reality
#
if (fast):
fmodel_kbu_ = mmtbx.f_model.manager_kbu(
f_obs=self.f_obs(),
f_calc=f_calc_plus_f_bulk_no_scales,
f_masks=[f_part2],
ss=self.ss)
result = mmtbx.bulk_solvent.scaler.run_simple(
fmodel_kbu=fmodel_kbu_,
r_free_flags=self.r_free_flags(),
bulk_solvent=params.bulk_solvent,
bin_selections=self.bin_selections)
f_part2 = f_part2.array(data=result.core.k_mask() *
f_part2.data())
k_isotropic = result.core.k_isotropic * result.core.k_isotropic_exp
k_anisotropic = result.core.k_anisotropic
# Update self with final scales
self.update_core(k_mask=k_masks,
k_anisotropic=k_anisotropic,
k_isotropic=k_isotropic,
f_part2=f_part2)
# Make sure what came out of scaling matches what self thinks it really is
# It must match at least up to 1.e-6.
self.show(prefix="add H (%4.2f, %6.2f)" % (kh, bh), log=log)
if (fast):
assert approx_equal(result.r_work(), self.r_work(), 1.e-4)
else:
assert approx_equal(self.r_all(), o.r()), [self.r_all(), o.r()]
return group_args(k_sol=k_sol,
b_sol=b_sol,
b_cart=b_cart,
k_h=kh,
b_h=bh,
b_adj=b_adj)
def anisotropic_scaling(self, r_start):
r_expanal, r_poly, r_expmin = None, None, None
k_anisotropic_expanal, k_anisotropic_poly, \
k_anisotropic_expmin = None, None, None
scale_matrix_expanal, scale_matrix_poly, scale_matrix_expmin = None, None, None
sel = self.selection_work.data()
f_model_abs = flex.abs(
self.core.f_model_no_aniso_scale.data().select(sel))
f_obs = self.f_obs.data().select(sel)
mi = self.f_obs.indices().select(sel)
uc = self.f_obs.unit_cell()
mi_all = self.f_obs.indices()
# try exp_anal
if (self.try_expanal):
obj = bulk_solvent.aniso_u_scaler(
f_model_abs=f_model_abs,
f_obs=f_obs,
miller_indices=mi,
adp_constraint_matrix=self.adp_constraints.gradient_sum_matrix(
))
u_star = self.adp_constraints.all_params(
tuple(obj.u_star_independent))
scale_matrix_expanal = adptbx.u_as_b(
adptbx.u_star_as_u_cart(uc, u_star))
k_anisotropic_expanal = ext.k_anisotropic(mi_all, u_star)
r_expanal = self.try_scale(k_anisotropic=k_anisotropic_expanal)
if (self.verbose):
print >> self.log, " r_expanal: %6.4f" % r_expanal
# try poly
if (self.try_poly):
obj = bulk_solvent.aniso_u_scaler(f_model_abs=f_model_abs,
f_obs=f_obs,
miller_indices=mi,
unit_cell=uc)
scale_matrix_poly = obj.a
k_anisotropic_poly = ext.k_anisotropic(mi_all, obj.a, uc)
r_poly = self.try_scale(k_anisotropic=k_anisotropic_poly)
if (self.verbose):
print >> self.log, " r_poly : %6.4f" % r_poly
# pre-analyze
force_to_use_expmin = False
if (k_anisotropic_poly is not None and self.auto and r_poly < r_expanal
and (k_anisotropic_poly <= 0).count(True) > 0):
force_to_use_expmin = True
self.try_expmin = True
# try expmin
if (self.try_expmin):
zero = self.f_obs.select(sel).customized_copy(
data=flex.complex_double(f_obs.size(), 0))
fm = mmtbx.f_model.manager_kbu(
f_obs=self.f_obs.select(sel),
f_calc=self.core.f_model_no_aniso_scale.select(sel),
f_masks=[zero],
f_part1=zero,
f_part2=zero,
ss=self.ss)
obj = kbu_refinery.tgc(
f_obs=self.f_obs.select(sel),
f_calc=self.core.f_model_no_aniso_scale.select(sel),
f_masks=[zero],
ss=self.ss,
k_sols=[
0,
],
b_sols=[
0,
],
u_star=[0, 0, 0, 0, 0, 0])
obj.minimize_u()
u_star = obj.kbu.u_star()
scale_matrix_expmin = adptbx.u_as_b(
adptbx.u_star_as_u_cart(uc, u_star))
k_anisotropic_expmin = ext.k_anisotropic(mi_all, u_star)
r_expmin = self.try_scale(k_anisotropic=k_anisotropic_expmin)
if (self.verbose):
print >> self.log, " r_expmin : %6.4f" % r_expmin
if (force_to_use_expmin):
self.core = self.core.update(
k_anisotropic=k_anisotropic_expmin)
if (self.verbose):
self.format_scale_matrix(m=scale_matrix_expmin)
return
# select best
r = [(r_expanal, k_anisotropic_expanal, scale_matrix_expanal),
(r_poly, k_anisotropic_poly, scale_matrix_poly),
(r_expmin, k_anisotropic_expmin, scale_matrix_expmin)]
r_best = r_start
k_anisotropic_best = None
scale_matrix_best = None
for result in r:
r_factor, k_anisotropic, scale_matrix = result
if (r_factor is not None and r_factor < r_best):
r_best = r_factor
k_anisotropic_best = k_anisotropic.deep_copy()
scale_matrix_best = scale_matrix[:]
if (scale_matrix_best is None):
if (self.verbose):
print >> self.log, " result rejected due to r-factor increase"
else:
self.scale_matrices = scale_matrix_best
self.core = self.core.update(k_anisotropic=k_anisotropic_best)
r_aniso = self.r_factor()
if (self.verbose):
self.format_scale_matrix()
print >> self.log, " r_final : %6.4f" % r_aniso
def update_solvent_and_scale_twin(self, refine_hd_scattering, log):
if (not self.twinned()): return
assert len(self.f_masks()) == 1
# Re-set all scales to unit or zero
self.show(prefix="update scales twin start", log=log)
self.reset_all_scales()
self.show(prefix="reset f_part, k_(total,mask)", log=log)
f_calc_data = self.f_calc().data()
f_calc_data_twin = self.f_calc_twin().data()
# Initial trial set
sc = 1000.
ksr = [
i / sc for i in range(ifloor(0 * sc),
iceil(0.6 * sc) + 1, int(0.05 * sc))
]
bsr = [
i / sc for i in range(ifloor(0 * sc),
iceil(150. * sc) + 1, int(10. * sc))
]
o_kbu_sol = bulk_solvent.k_sol_b_sol_k_anisotropic_scaler_twin(
f_obs=self.f_obs().data(),
f_calc_1=f_calc_data,
f_calc_2=f_calc_data_twin,
f_mask_1=self.arrays.core.f_masks[0].data(),
f_mask_2=self.arrays.core_twin.f_masks[0].data(),
ss=self.ss,
twin_fraction=self.twin_fraction,
k_sol_range=flex.double(ksr),
b_sol_range=flex.double(bsr),
miller_indices=self.f_obs().indices(
), #XXX ??? What about twin-related?
unit_cell=self.f_obs().unit_cell(),
r_ref=self.r_all())
if (o_kbu_sol.updated()):
self.update(k_mask=o_kbu_sol.k_mask(),
k_anisotropic=o_kbu_sol.k_anisotropic())
# Second (finer) trial set
k_min = max(o_kbu_sol.k_sol() - 0.05, 0)
k_max = min(o_kbu_sol.k_sol() + 0.05, 0.6)
ksr = [
i / sc for i in range(ifloor(k_min * sc),
iceil(k_max * sc) + 1, int(0.01 * sc))
]
b_min = max(o_kbu_sol.b_sol() - 10, 0)
b_max = min(o_kbu_sol.b_sol() + 10, 150)
bsr = [
i / sc for i in range(ifloor(b_min * sc),
iceil(b_max * sc) + 1, int(1. * sc))
]
o_kbu_sol = bulk_solvent.k_sol_b_sol_k_anisotropic_scaler_twin(
f_obs=self.f_obs().data(),
f_calc_1=f_calc_data,
f_calc_2=f_calc_data_twin,
f_mask_1=self.arrays.core.f_masks[0].data(),
f_mask_2=self.arrays.core_twin.f_masks[0].data(),
ss=self.ss,
twin_fraction=self.twin_fraction,
k_sol_range=flex.double(ksr),
b_sol_range=flex.double(bsr),
miller_indices=self.f_obs().indices(
), #XXX ??? What about twin-related?
unit_cell=self.f_obs().unit_cell(),
r_ref=o_kbu_sol.r())
if (o_kbu_sol.updated()):
self.update(k_mask=o_kbu_sol.k_mask(),
k_anisotropic=o_kbu_sol.k_anisotropic())
# Disable due to rare failures. Technically they should always match. But
# since different routines are used tiny disagreements are possible.
# See examples in : /net/anaconda/raid1/afonine/work/bugs/twin_refinement
#assert approx_equal(self.r_all(), o_kbu_sol.r(), 1.e-5)
##############
# use apply_back_trace in if below
if (self.xray_structure is not None):
o = mmtbx.bulk_solvent.scaler.tmp(
xray_structure=self.xray_structure,
k_anisotropic=o_kbu_sol.k_anisotropic(),
k_masks=[o_kbu_sol.k_mask()],
ss=self.ss)
self.update_xray_structure(xray_structure=o.xray_structure,
update_f_calc=True)
#############
self.update(k_mask=o.k_masks, k_anisotropic=o.k_anisotropic)
self.show(prefix="bulk-solvent and scaling", log=log)
#
# Add contribution from H (if present and riding). This goes to f_part2.
#
kh, bh = 0, 0
if (refine_hd_scattering
and self.need_to_refine_hd_scattering_contribution()):
hd_selection = self.xray_structure.hd_selection()
xrs_no_h = self.xray_structure.select(~hd_selection)
xrs_h = self.xray_structure.select(hd_selection)
# Accumulate all mask contributions: Fcalc_atoms+Fbulk_1+...+Fbulk_N
data = self.f_calc().data(
) + self.f_masks()[0].data() * self.k_masks()[0]
f_calc_plus_f_bulk_no_scales = self.f_calc().array(data=data)
data = self.f_calc_twin().data()+\
self.f_masks_twin()[0].data()*self.k_masks_twin()[0]
f_calc_plus_f_bulk_no_scales_twin = self.f_calc_twin().array(
data=data)
# Initial FH contribution
xrs_h = xrs_h.set_occupancies(value=1).set_b_iso(value=0)
f_h = self.compute_f_calc(xray_structure=xrs_h)
f_h_twin = self.compute_f_calc(xray_structure=xrs_h,
miller_array=self.f_calc_twin())
# Coarse sampling
b_mean = flex.mean(
xrs_no_h.extract_u_iso_or_u_equiv()) * adptbx.u_as_b(1.)
b_min = int(max(0, b_mean) * 0.5)
b_max = int(b_mean * 1.5)
sc = 1000.
kr = [
i / sc for i in range(ifloor(0 * sc),
iceil(1.5 * sc) + 1, int(0.1 * sc))
]
br = [
i / sc for i in range(ifloor(b_min * sc),
iceil(b_max * sc) + 1, int(5. * sc))
]
obj = bulk_solvent.k_sol_b_sol_k_anisotropic_scaler_twin(
f_obs=self.f_obs().data(),
f_calc_1=f_calc_plus_f_bulk_no_scales.data(),
f_calc_2=f_calc_plus_f_bulk_no_scales_twin.data(),
f_mask_1=f_h.data(),
f_mask_2=f_h_twin.data(),
ss=self.ss,
twin_fraction=self.twin_fraction,
k_sol_range=flex.double(kr),
b_sol_range=flex.double(br),
miller_indices=self.f_obs().indices(
), # XXX What about twin-related?
unit_cell=self.f_obs().unit_cell(),
r_ref=self.r_work())
if (obj.updated()):
f_part2 = f_h.array(data=obj.k_mask() * f_h.data())
f_part2_twin = f_h_twin.array(data=obj.k_mask() *
f_h_twin.data())
kh, bh = obj.k_sol(), obj.b_sol()
# Fine sampling
k_min = max(0, obj.k_sol() - 0.1)
k_max = obj.k_sol() + 0.1
b_min = max(0, obj.b_sol() - 5.)
b_max = obj.b_sol() + 5.
kr = [
i / sc for i in range(ifloor(k_min * sc),
iceil(k_max * sc) + 1, int(0.01 * sc))
]
br = [
i / sc for i in range(ifloor(b_min * sc),
iceil(b_max * sc) + 1, int(5. * sc))
]
obj = bulk_solvent.k_sol_b_sol_k_anisotropic_scaler_twin(
f_obs=self.f_obs().data(),
f_calc_1=f_calc_plus_f_bulk_no_scales.data(),
f_calc_2=f_calc_plus_f_bulk_no_scales_twin.data(),
f_mask_1=f_h.data(),
f_mask_2=f_h_twin.data(),
ss=self.ss,
twin_fraction=self.twin_fraction,
k_sol_range=flex.double(kr),
b_sol_range=flex.double(br),
miller_indices=self.f_obs().indices(
), # XXX What about twin-related?
unit_cell=self.f_obs().unit_cell(),
r_ref=obj.r())
if (obj.updated()):
f_part2 = f_h.array(data=obj.k_mask() * f_h.data())
f_part2_twin = f_h_twin.array(data=obj.k_mask() *
f_h_twin.data())
kh, bh = obj.k_sol(), obj.b_sol()
self.update_core(f_part2=f_part2,
f_part2_twin=f_part2_twin,
k_anisotropic=obj.k_anisotropic())
self.show(prefix="add H (%4.2f, %6.2f)" % (kh, bh), log=log)
b_cart = adptbx.u_as_b(
adptbx.u_star_as_u_cart(self.f_obs().unit_cell(),
o_kbu_sol.u_star()))
return group_args(k_sol=o_kbu_sol.k_sol(),
b_sol=o_kbu_sol.b_sol(),
b_cart=b_cart,
k_h=kh,
b_h=bh)
def __init__(self,
miller_array,
n_residues=None,
n_bases=None,
asu_contents=None,
prot_frac=1.0,
nuc_frac=0.0):
""" Maximum likelihood anisotropic wilson scaling"""
#Checking input
if (n_residues is None):
if (n_bases is None):
assert asu_contents is not None
assert (type(asu_contents) == type({}))
if asu_contents is None:
assert ((n_residues is not None) or (n_bases is not None))
assert (prot_frac + nuc_frac <= 1.0)
assert (miller_array.is_real_array())
self.info = miller_array.info()
if (miller_array.is_xray_intensity_array()):
miller_array = miller_array.f_sq_as_f()
work_array = miller_array.resolution_filter(
d_max=1.0 / math.sqrt(scaling.get_d_star_sq_low_limit()),
d_min=1.0 / math.sqrt(scaling.get_d_star_sq_high_limit()))
work_array = work_array.select(work_array.data() > 0)
self.d_star_sq = work_array.d_star_sq().data()
self.scat_info = None
if asu_contents is None:
self.scat_info = scattering_information(n_residues=n_residues,
n_bases=n_bases)
else:
self.scat_info = scattering_information(asu_contents=asu_contents,
fraction_protein=prot_frac,
fraction_nucleic=nuc_frac)
self.scat_info.scat_data(self.d_star_sq)
self.b_cart = None
if (work_array.size() > 0):
self.hkl = work_array.indices()
self.f_obs = work_array.data()
self.unit_cell = uctbx.unit_cell(
miller_array.unit_cell().parameters())
## Make sure sigma's are used when available
if (work_array.sigmas() is not None):
self.sigma_f_obs = work_array.sigmas()
else:
self.sigma_f_obs = flex.double(self.f_obs.size(), 0.0)
if (flex.min(self.sigma_f_obs) < 0):
self.sigma_f_obs = self.sigma_f_obs * 0.0
## multiplicities
self.epsilon = work_array.epsilons().data().as_double()
## Determine Wilson parameters
self.gamma_prot = self.scat_info.gamma_tot
self.sigma_prot_sq = self.scat_info.sigma_tot_sq
## centric flags
self.centric = flex.bool(work_array.centric_flags().data())
## Symmetry stuff
self.sg = work_array.space_group()
self.adp_constraints = self.sg.adp_constraints()
self.dim_u = self.adp_constraints.n_independent_params()
## Setup number of parameters
assert self.dim_u <= 6
## Optimisation stuff
self.x = flex.double(self.dim_u + 1,
0.0) ## B-values and scale factor!
exception_handling_params = scitbx.lbfgs.exception_handling_parameters(
ignore_line_search_failed_step_at_lower_bound=False,
ignore_line_search_failed_step_at_upper_bound=False,
ignore_line_search_failed_maxfev=False)
term_parameters = scitbx.lbfgs.termination_parameters(
max_iterations=50)
minimizer = scitbx.lbfgs.run(
target_evaluator=self,
termination_params=term_parameters,
exception_handling_params=exception_handling_params)
## Done refining
Vrwgk = math.pow(self.unit_cell.volume(), 2.0 / 3.0)
self.p_scale = self.x[0]
self.u_star = self.unpack()
self.u_star = list(flex.double(self.u_star) / Vrwgk)
self.b_cart = adptbx.u_as_b(
adptbx.u_star_as_u_cart(self.unit_cell, self.u_star))
self.u_cif = adptbx.u_star_as_u_cif(self.unit_cell, self.u_star)
#get eigenvalues of B-cart
eigen = eigensystem.real_symmetric(self.b_cart)
self.eigen_values = eigen.values()
self.eigen_vectors = eigen.vectors()
self.work_array = work_array # i need this for further analyses
self.analyze_aniso_correction()
# FIXME see 3ihm:IOBS4,SIGIOBS4
if (self.eigen_values[0] != 0):
self.anirat = (
abs(self.eigen_values[0] - self.eigen_values[2]) /
self.eigen_values[0])
else:
self.anirat = None
del self.x
del self.f_obs
del self.sigma_f_obs
del self.epsilon
del self.gamma_prot
del self.sigma_prot_sq
del self.centric
del self.hkl
del self.d_star_sq
del self.adp_constraints
def __init__(
self,
model,
fmodels,
target_weights,
individual_adp_params,
adp_restraints_params,
h_params,
log,
all_params,
nproc=None):
adopt_init_args(self, locals())
d_min = fmodels.fmodel_xray().f_obs().d_min()
# initialize with defaults...
if(target_weights is not None):
import mmtbx.refinement.weights_params
wcp = mmtbx.refinement.weights_params.tw_customizations_params.extract()
for w_s_c in wcp.weight_selection_criteria:
if(d_min >= w_s_c.d_min and d_min < w_s_c.d_max):
r_free_range_width = w_s_c.r_free_range_width
r_free_r_work_gap = w_s_c.r_free_minus_r_work
mean_diff_b_iso_bonded_fraction = w_s_c.mean_diff_b_iso_bonded_fraction
min_diff_b_iso_bonded = w_s_c.min_diff_b_iso_bonded
break
# ...then customize
wsc = all_params.target_weights.weight_selection_criteria
if(wsc.r_free_minus_r_work is not None):
r_free_r_work_gap = wsc.r_free_minus_r_work
if(wsc.r_free_range_width is not None):
r_free_range_width = wsc.r_free_range_width
if(wsc.mean_diff_b_iso_bonded_fraction is not None):
mean_diff_b_iso_bonded_fraction = wsc.mean_diff_b_iso_bonded_fraction
if(wsc.min_diff_b_iso_bonded is not None):
min_diff_b_iso_bonded = wsc.min_diff_b_iso_bonded
#
print_statistics.make_sub_header(text="Individual ADP refinement", out = log)
assert fmodels.fmodel_xray().xray_structure is model.get_xray_structure()
#
fmodels.create_target_functors()
assert approx_equal(self.fmodels.fmodel_xray().target_w(),
self.fmodels.target_functor_result_xray(
compute_gradients=False).target_work())
rw = flex.double()
rf = flex.double()
rfrw = flex.double()
deltab = flex.double()
w = flex.double()
if(self.target_weights is not None):
fmth =" R-FACTORS <Bi-Bj> <B> WEIGHT TARGETS"
print(fmth, file=self.log)
print(" work free delta data restr", file=self.log)
else:
print("Unresrained refinement...", file=self.log)
self.save_scatterers = self.fmodels.fmodel_xray().xray_structure.\
deep_copy_scatterers().scatterers()
if(self.target_weights is not None):
default_weight = self.target_weights.adp_weights_result.wx*\
self.target_weights.adp_weights_result.wx_scale
if(self.target_weights.twp.optimize_adp_weight):
wx_scale = [0.03,0.125,0.5,1.,1.5,2.,2.5,3.,3.5,4.,4.5,5.]
trial_weights = list( flex.double(wx_scale)*self.target_weights.adp_weights_result.wx )
self.wx_scale = 1
else:
trial_weights = [self.target_weights.adp_weights_result.wx]
self.wx_scale = self.target_weights.adp_weights_result.wx_scale
else:
default_weight = 1
trial_weights = [1]
self.wx_scale = 1
self.show(weight=default_weight)
trial_results = []
if nproc is None:
nproc = all_params.main.nproc
parallel = False
if (len(trial_weights) > 1) and ((nproc is Auto) or (nproc > 1)):
parallel = True
from libtbx import easy_mp
stdout_and_results = easy_mp.pool_map(
processes=nproc,
fixed_func=self.try_weight,
args=trial_weights,
func_wrapper="buffer_stdout_stderr") # XXX safer for phenix GUI
trial_results = [ r for so, r in stdout_and_results ]
else :
for weight in trial_weights:
result = self.try_weight(weight, print_stats=True)
trial_results.append(result)
for result in trial_results :
if(result is not None) and (result.r_work is not None):
if (parallel):
result.show(out=self.log)
rw .append(result.r_work)
rf .append(result.r_free)
rfrw .append(result.r_gap)
deltab .append(result.delta_b)
w .append(result.weight)
#
if(len(trial_weights)>1 and rw.size()>0):
# filter by rfree-rwork
rw,rf,rfrw,deltab,w = self.score(rw=rw,rf=rf,rfrw=rfrw,deltab=deltab,w=w,
score_target=rfrw,score_target_value=r_free_r_work_gap,
secondary_target=deltab)
# filter by rfree
rw,rf,rfrw,deltab,w = self.score(rw=rw,rf=rf,rfrw=rfrw,deltab=deltab,w=w,
score_target=rf,score_target_value=flex.min(rf)+r_free_range_width)
# filter by <Bi-Bj>
delta_b_target = max(min_diff_b_iso_bonded, flex.mean(self.fmodels.
fmodel_xray().xray_structure.extract_u_iso_or_u_equiv()*
adptbx.u_as_b(1))*mean_diff_b_iso_bonded_fraction)
print(" max suggested <Bi-Bj> for this run: %7.2f"%delta_b_target, file=log)
print(" max allowed Rfree-Rwork gap: %5.1f"%r_free_r_work_gap, file=log)
print(" range of equivalent Rfree: %5.1f"%r_free_range_width, file=log)
rw,rf,rfrw,deltab,w = self.score(rw=rw,rf=rf,rfrw=rfrw,deltab=deltab,w=w,
score_target=deltab,score_target_value=delta_b_target)
# select the result with lowest rfree
sel = flex.sort_permutation(rf)
rw,rf,rfrw,deltab,w= self.select(
rw=rw,rf=rf,rfrw=rfrw,deltab=deltab,w=w,sel=sel)
#
w_best = w[0]
rw_best = rw[0]
print("Best ADP weight: %8.3f"%w_best, file=self.log)
#
self.target_weights.adp_weights_result.wx = w_best
self.target_weights.adp_weights_result.wx_scale = 1
best_u_star = None
best_u_iso = None
for result in trial_results :
if(abs(result.weight-w_best)<=1.e-8):
best_u_star = result.u_star
best_u_iso = result.u_iso
break
if(best_u_iso is None) : # XXX this probably shouldn't happen...
self.fmodels.fmodel_xray().xray_structure.replace_scatterers(
self.save_scatterers.deep_copy())
else :
assert (best_u_star is not None)
xrs = self.fmodels.fmodel_xray().xray_structure
xrs.set_u_iso(values=best_u_iso)
xrs.scatterers().set_u_star(best_u_star)
new_u_iso = xrs.scatterers().extract_u_iso()
assert (new_u_iso.all_eq(best_u_iso))
self.fmodels.update_xray_structure(
xray_structure = self.fmodels.fmodel_xray().xray_structure,
update_f_calc = True)
print("Accepted refinement result:", file=self.log)
# reset alpha/beta parameters - if this is not done, the assertion
# below will fail
fmodels.create_target_functors()
if(self.fmodels.fmodel_neutron() is None):
assert approx_equal(self.fmodels.fmodel_xray().r_work()*100, rw_best,
eps=0.001)
# this needs to be done again again, just in case
fmodels.create_target_functors()
self.show(weight=w_best)
self.fmodels.fmodel_xray().xray_structure.tidy_us()
self.fmodels.update_xray_structure(
xray_structure = self.fmodels.fmodel_xray().xray_structure,
update_f_calc = True)
fmodels.create_target_functors()
assert approx_equal(self.fmodels.fmodel_xray().target_w(),
self.fmodels.target_functor_result_xray(
compute_gradients=False).target_work())
self.model.set_xray_structure(self.fmodels.fmodel_xray().xray_structure)
def __init__(self,
pdb_hierarchy,
xray_structure,
ignore_hd=True,
collect_outliers=True):
for name in self.__slots__:
setattr(self, name, None)
validation.__init__(self)
assert len(xray_structure.scatterers()) != 0
from cctbx import adptbx
from scitbx.array_family import flex
xrs = xray_structure
self.n_total = xrs.scatterers().size() # always include H/D
self.results = None
pdb_atoms = pdb_hierarchy.atoms()
pdb_atoms.reset_i_seq()
hd_selection = xrs.hd_selection()
subtract_hd = True
self.n_all = hd_selection.size()
self.n_hd = hd_selection.count(True)
if (ignore_hd) and (0 < self.n_hd < self.n_all):
xrs = xrs.select(~hd_selection)
subtract_hd = False
u_isos = xrs.extract_u_iso_or_u_equiv()
occ = xrs.scatterers().extract_occupancies()
self.n_atoms = xrs.scatterers().size()
self.n_non_hd = self.n_all - self.n_hd
self.n_aniso = xrs.use_u_aniso().count(True)
self.n_aniso_h = (xray_structure.use_u_aniso()
& hd_selection).count(True)
self.n_npd = xrs.is_positive_definite_u().count(False)
self.n_zero_b = (u_isos == 0).count(True)
self.n_zero_occ = (occ == 0).count(True)
u_cutoff_high = sys.maxsize
u_cutoff_low = 0
u_non_zero = u_isos.select(u_isos > 0)
if (len(u_non_zero) > 1):
mv = flex.mean_and_variance(u_non_zero)
sigma = mv.unweighted_sample_standard_deviation()
u_cutoff_high = mv.mean() + (4.0 * sigma)
u_cutoff_low = mv.mean() - (4.0 * sigma)
self.b_mean = adptbx.u_as_b(flex.mean(u_isos))
self.b_min = adptbx.u_as_b(flex.min(u_isos))
self.b_max = adptbx.u_as_b(flex.max(u_isos))
self.o_mean = flex.mean(occ)
self.o_min = flex.min(occ)
self.o_max = flex.max(occ)
self.n_outliers = self.n_aniso_h + self.n_npd
self.zero_occ = []
self.partial_occ = []
self.different_occ = []
self.bad_adps = []
self.b_histogram = None # TODO
def is_u_iso_outlier(u):
return (u < u_cutoff_low) or (u > u_cutoff_high) or (u <= 0)
# these statistics cover all atoms!
occupancies = xray_structure.scatterers().extract_occupancies()
u_isos = xray_structure.extract_u_iso_or_u_equiv()
collected = flex.bool(occupancies.size(), False)
if (collect_outliers):
for i_seq, occ in enumerate(occupancies):
if (hd_selection[i_seq] and ignore_hd) or collected[i_seq]:
continue
pdb_atom = pdb_atoms[i_seq]
parent = pdb_atom.parent()
if (occ <= 0):
group_atoms = parent.atoms()
labels = pdb_atom.fetch_labels()
if (len(group_atoms) >
1) and (group_atoms.extract_occ().all_eq(0)):
i_seqs = group_atoms.extract_i_seq()
b_mean = adptbx.u_as_b(flex.mean(
u_isos.select(i_seqs)))
outlier = residue_occupancy(
chain_id=labels.chain_id,
resseq=labels.resseq,
icode=labels.icode,
altloc=labels.altloc,
resname=labels.resname,
occupancy=occ,
outlier=True,
xyz=group_atoms.extract_xyz().mean(),
b_iso=b_mean)
self.zero_occ.append(outlier)
self.n_outliers += 1
collected.set_selected(i_seqs, True)
else:
assert (pdb_atom.occ == occ), "%s: %s <--> %s" % (
pdb_atom.id_str(), pdb_atom.occ, occ)
outlier = atom_occupancy(pdb_atom=pdb_atom,
occupancy=occ,
b_iso=adptbx.u_as_b(
u_isos[i_seq]),
xyz=pdb_atom.xyz,
outlier=True)
self.zero_occ.append(outlier)
self.n_outliers += 1
elif is_u_iso_outlier(u_isos[i_seq]):
# zero displacements will always be recorded on a per-atom basis
if (u_isos[i_seq] <= 0):
outlier = atom_bfactor(pdb_atom=pdb_atom,
occupancy=occ,
b_iso=adptbx.u_as_b(
u_isos[i_seq]),
xyz=pdb_atom.xyz,
outlier=True)
self.bad_adps.append(outlier)
self.n_outliers += 1
else:
# if the average displacement for the entire residue falls outside
# the cutoffs, save as a single residue outlier
group_atoms = parent.atoms()
i_seqs = group_atoms.extract_i_seq()
u_mean = flex.mean(u_isos.select(i_seqs))
if is_u_iso_outlier(u_mean):
labels = pdb_atom.fetch_labels()
outlier = residue_bfactor(
chain_id=labels.chain_id,
resseq=labels.resseq,
icode=labels.icode,
altloc=labels.altloc,
resname=labels.resname,
occupancy=occ,
outlier=True,
xyz=group_atoms.extract_xyz().mean(),
b_iso=adptbx.u_as_b(u_mean))
self.bad_adps.append(outlier)
self.n_outliers += 1
collected.set_selected(i_seqs, True)
# otherwise, just save this atom
else:
outlier = atom_bfactor(pdb_atom=pdb_atom,
occupancy=occ,
b_iso=adptbx.u_as_b(
u_isos[i_seq]),
xyz=pdb_atom.xyz,
outlier=True)
self.bad_adps.append(outlier)
self.n_outliers += 1
# analyze occupancies for first model
model = pdb_hierarchy.models()[0]
for chain in model.chains():
residue_groups = chain.residue_groups()
for residue_group in chain.residue_groups():
# get unique set of atom names
atom_names = set()
for atom in residue_group.atoms():
atom_names.add(atom.name.strip())
# check total occupancy for each atom
for name in atom_names:
occupancy = 0.0
atoms = list()
for atom_group in residue_group.atom_groups():
atom = atom_group.get_atom(name)
if (atom is not None):
occupancy += atom.occ
atoms.append(atom)
if (not approx_equal(
occupancy, 1.0, out=None, eps=1.0e-3)):
for atom in atoms:
outlier = atom_occupancy(pdb_atom=atom,
occupancy=atom.occ,
b_iso=adptbx.u_as_b(
atom.b),
xyz=atom.xyz,
outlier=True)
self.partial_occ.append(outlier)
self.n_outliers += 1
# check that atoms in an atom group have the same occupancy
for atom_group in residue_group.atom_groups():
residue_is_okay = True
base_occupancy = atom_group.atoms()[0].occ
for atom in atom_group.atoms():
if (not approx_equal(
base_occupancy, atom.occ, out=None,
eps=1.0e-3)):
labels = atom.fetch_labels()
i_seqs = atom_group.atoms().extract_i_seq()
b_mean = adptbx.u_as_b(
flex.mean(u_isos.select(i_seqs)))
outlier = residue_occupancy(
chain_id=labels.chain_id,
resseq=labels.resseq,
icode=labels.icode,
altloc=labels.altloc,
resname=labels.resname,
occupancy=occ,
outlier=True,
xyz=atom_group.atoms().extract_xyz().mean(
),
b_iso=b_mean)
self.different_occ.append(outlier)
self.n_outliers += 1
residue_is_okay = False
break
if (not residue_is_okay):
break
def from_pdb(self):
out = self.out
params = self.params
pdb_hierarchy = self.pdb_hierarchy
pdb_sg, pdb_uc = None, None
pdb_symm = self.pdb_in.crystal_symmetry()
if (pdb_symm is not None):
pdb_sg = pdb_symm.space_group_info()
pdb_uc = pdb_symm.unit_cell()
apply_sg = pdb_sg
apply_uc = pdb_uc
if (params.crystal_symmetry.space_group is not None):
apply_sg = params.crystal_symmetry.space_group
else:
params.crystal_symmetry.space_group = pdb_sg
if (params.crystal_symmetry.unit_cell is not None):
apply_uc = params.crystal_symmetry.unit_cell
else:
params.crystal_symmetry.unit_cell = pdb_uc
if (apply_sg is None) or (apply_uc is None):
raise Sorry(
"Incomplete symmetry information - please specify a space " +
"group and unit cell for this structure.")
from cctbx import crystal, adptbx
from scitbx.array_family import flex
apply_symm = crystal.symmetry(unit_cell=apply_uc,
space_group_info=apply_sg)
if (params.modify_pdb.remove_waters):
print(" Removing solvent atoms...", file=out)
for model in pdb_hierarchy.models():
for chain in model.chains():
for residue_group in chain.residue_groups():
for atom_group in residue_group.atom_groups():
if (atom_group.resname in ["HOH", "WAT"]):
residue_group.remove_atom_group(
atom_group=atom_group)
if (len(residue_group.atom_groups()) == 0):
chain.remove_residue_group(
residue_group=residue_group)
if (len(chain.atoms()) == 0):
model.remove_chain(chain=chain)
if (params.modify_pdb.remove_alt_confs):
print(
" Removing all alternate conformations and resetting occupancies...",
file=out)
from mmtbx import pdbtools
pdbtools.remove_alt_confs(hierarchy=pdb_hierarchy)
xray_structure = self.pdb_in.xray_structure_simple(
crystal_symmetry=apply_symm)
sctr_keys = xray_structure.scattering_type_registry().type_count_dict()
hd_selection = xray_structure.hd_selection()
if (not (("H" in sctr_keys) or ("D" in sctr_keys))):
print(" WARNING: this model does not contain hydrogen atoms!",
file=out)
print(" strongly recommend running phenix.ready_set or",
file=out)
print(" equivalent to ensure realistic simulated data.",
file=out)
print("", file=out)
if (params.modify_pdb.convert_to_isotropic):
xray_structure.convert_to_isotropic()
set_b = None
if (params.modify_pdb.set_mean_b_iso is not None):
assert (not params.modify_pdb.set_wilson_b)
print(" Scaling B-factors to have mean of %.2f" % \
params.modify_pdb.set_mean_b_iso, file=out)
assert (params.modify_pdb.set_mean_b_iso > 0)
set_b = params.modify_pdb.set_mean_b_iso
elif (params.modify_pdb.set_wilson_b):
print(
" Scaling B-factors to match mean Wilson B for this resolution",
file=out)
set_b = get_mean_statistic_for_resolution(d_min=params.d_min,
stat_type="wilson_b")
print("", file=out)
if (set_b is not None):
u_iso = xray_structure.extract_u_iso_or_u_equiv()
u_iso = u_iso.select(~hd_selection)
u_mean = flex.mean(u_iso)
b_mean = adptbx.u_as_b(u_mean)
scale = set_b / b_mean
xray_structure.scale_adps(scale)
pdb_hierarchy.atoms().set_adps_from_scatterers(
scatterers=xray_structure.scatterers(),
unit_cell=xray_structure.unit_cell())
import mmtbx.command_line.fmodel
from mmtbx import utils
fmodel_params = mmtbx.command_line.fmodel.fmodel_from_xray_structure_master_params.extract(
)
fmodel_params.high_resolution = params.d_min
fake_data = params.fake_data_from_fmodel
fmodel_params.fmodel = fake_data.fmodel
if (fmodel_params.fmodel.b_sol == 0):
print(" b_sol is zero - will use mean value for d_min +/- 0.2A",
file=out)
print(" (this is not strongly correlated with resolution, but",
file=out)
print(
" it is preferrable to use a real value instead of leaving",
file=out)
print(" it set to 0)", file=out)
fmodel_params.fmodel.b_sol = 46.0
print("", file=out)
if (fmodel_params.fmodel.k_sol == 0):
print(" k_sol is zero - will use mean value for d_min +/- 0.2A",
file=out)
print(" (this is not strongly correlated with resolution, but",
file=out)
print(
" it is preferrable to use a real value instead of leaving",
file=out)
print(" it set to 0)", file=out)
fmodel_params.fmodel.k_sol = 0.35
print("", file=out)
fmodel_params.structure_factors_accuracy = fake_data.structure_factors_accuracy
fmodel_params.mask = fake_data.mask
fmodel_params.r_free_flags_fraction = params.r_free_flags.fraction
fmodel_params.add_sigmas = False
fmodel_params.output.type = "real"
fmodel_ = utils.fmodel_from_xray_structure(
xray_structure=xray_structure, params=fmodel_params)
f_model = fmodel_.f_model
r_free_flags = fmodel_.r_free_flags
return (f_model, r_free_flags)
def run_01():
time_aniso_u_scaler = 0
for symbol in sgtbx.bravais_types.acentric + sgtbx.bravais_types.centric:
#print symbol, "-"*50
space_group_info = sgtbx.space_group_info(symbol=symbol)
xrs = random_structure.xray_structure(
space_group_info=space_group_info,
elements=["N"] * 100,
volume_per_atom=50.0,
random_u_iso=True)
# XXX ad a method to adptbx to do this
point_group = sgtbx.space_group_info(
symbol=symbol).group().build_derived_point_group()
adp_constraints = sgtbx.tensor_rank_2_constraints(
space_group=point_group, reciprocal_space=True)
u_star = adptbx.u_cart_as_u_star(
xrs.unit_cell(), adptbx.random_u_cart(u_scale=1, u_min=0.1))
u_indep = adp_constraints.independent_params(all_params=u_star)
u_star = adp_constraints.all_params(independent_params=u_indep)
b_cart_start = adptbx.u_as_b(
adptbx.u_star_as_u_cart(xrs.unit_cell(), u_star))
#
tr = (b_cart_start[0] + b_cart_start[1] + b_cart_start[2]) / 3
b_cart_start = [
b_cart_start[0] - tr, b_cart_start[1] - tr, b_cart_start[2] - tr,
b_cart_start[3], b_cart_start[4], b_cart_start[5]
]
tr = (b_cart_start[0] + b_cart_start[1] + b_cart_start[2]) / 3
#
#print "Input b_cart :", " ".join(["%8.4f"%i for i in b_cart_start]), "tr:", tr
F = xrs.structure_factors(d_min=2.0).f_calc()
F = xrs.structure_factors(d_min=2.0).f_calc()
u_star = adptbx.u_cart_as_u_star(F.unit_cell(),
adptbx.b_as_u(b_cart_start))
fbc = mmtbx.f_model.ext.k_anisotropic(F.indices(), u_star)
fc = F.structure_factors_from_scatterers(xray_structure=xrs).f_calc()
f_obs = F.customized_copy(data=flex.abs(fc.data() * fbc))
#print bulk_solvent.r_factor(f_obs.data(), fmodel.f_model().data())
obj = bulk_solvent.aniso_u_scaler(f_model_abs=flex.abs(fc.data()),
f_obs=f_obs.data(),
miller_indices=f_obs.indices(),
unit_cell=f_obs.unit_cell())
a = obj.a
####
#print "Input a :", " ".join(["%7.3f"%i for i in a])
overall_anisotropic_scale = mmtbx.f_model.ext.k_anisotropic(
f_obs.indices(), a, f_obs.unit_cell())
#print bulk_solvent.r_factor(f_obs.data(), fmodel.f_model().data()*overall_anisotropic_scale)
f_obs = abs(fc)
f_obs = f_obs.customized_copy(data=f_obs.data() *
overall_anisotropic_scale)
#print bulk_solvent.r_factor(f_obs.data(), fmodel.f_model().data())
#print bulk_solvent.r_factor(f_obs.data(), fmodel.f_model().data())
t0 = time.time()
obj = bulk_solvent.aniso_u_scaler(f_model_abs=flex.abs(fc.data()),
f_obs=f_obs.data(),
miller_indices=f_obs.indices(),
unit_cell=f_obs.unit_cell())
time_aniso_u_scaler += (time.time() - t0)
overall_anisotropic_scale = mmtbx.f_model.ext.k_anisotropic(
f_obs.indices(), obj.a, f_obs.unit_cell())
assert approx_equal(
bulk_solvent.r_factor(f_obs.data(),
fc.data() * overall_anisotropic_scale), 0.0,
1.e-2) # XXX seems to be low
#print "Output a:", " ".join(["%7.3f"%i for i in obj.a])
assert approx_equal(a, obj.a, 1.e-3) # XXX can it be smaller?
print("Time (aniso_u_scaler only): %6.4f" % time_aniso_u_scaler)
def _atom_radius(self):
b_iso = adptbx.u_as_b(
flex.mean(self.xray_structure.extract_u_iso_or_u_equiv()))
o = maptbx.atom_curves(scattering_type="C", scattering_table="electron")
return o.image(d_min=self.d_min, b_iso=b_iso,
radius_max=max(15.,self.d_min), radius_step=0.01).radius
def prepare_for_minimization(self):
rso = self.refine_sad_object
rso.refine_variance_terms()
self.refined_overall_b_iso = adptbx.u_as_b(
rso.refine_sad_instance.get_refined_scaleU())
rso.refine_sad_instance.set_scaleU(0.)
def find_and_build_ions(manager,
fmodels,
model,
wavelength,
params,
nproc=1,
elements=Auto,
out=None,
run_ordered_solvent=False,
occupancy_strategy_enabled=False,
group_anomalous_strategy_enabled=False,
use_svm=None):
"""
Analyzes the water molecules in a structure and re-labels them as ions if
they scatter and bind environments that we expect of that ion.
Parameters
----------
manager : mmtbx.ions.identity.manager
fmodels : mmtbx.fmodels
model : mmtbx.model.manager
wavelength : float
params : libtbx.phil.scope_extract
nproc : int, optional
elements : list of str, optional
out : file, optional
run_ordered_solvent : bool, optional
occupancy_strategy_enabled : bool, optional
group_anomalous_strategy_enabled : bool, optional
use_svm : bool, optional
See Also
--------
mmtbx.ions.identify.manager.analyze_waters
"""
import mmtbx.refinement.minimization
from mmtbx.refinement.anomalous_scatterer_groups import \
get_single_atom_selection_string
from mmtbx.refinement import anomalous_scatterer_groups
import mmtbx.ions.identify
import mmtbx.ions.svm
from cctbx.eltbx import sasaki
from cctbx import crystal
from cctbx import adptbx
from cctbx import xray
from scitbx.array_family import flex
import scitbx.lbfgs
if (use_svm is None):
use_svm = getattr(params, "use_svm", False)
assert (1.0 >= params.initial_occupancy >= 0)
fmodel = fmodels.fmodel_xray()
anomalous_flag = fmodel.f_obs().anomalous_flag()
if (out is None): out = sys.stdout
model.set_xray_structure(fmodel.xray_structure)
model.get_xray_structure().tidy_us()
pdb_hierarchy = model.get_hierarchy()
pdb_atoms = pdb_hierarchy.atoms()
pdb_atoms.reset_i_seq()
# FIXME why does B for anisotropic waters end up negative?
u_iso = model.get_xray_structure().extract_u_iso_or_u_equiv()
for i_seq, atom in enumerate(pdb_atoms):
labels = atom.fetch_labels()
if (labels.resname == "HOH") and (atom.b < 0):
assert (u_iso[i_seq] >= 0)
atom.b = adptbx.u_as_b(u_iso[i_seq])
if (manager is None):
manager_class = None
if (use_svm):
manager_class = mmtbx.ions.svm.manager
if params.svm.svm_name == "merged_high_res":
params.find_anomalous_substructure = False
params.use_phaser = False
manager = mmtbx.ions.identify.create_manager(
pdb_hierarchy=pdb_hierarchy,
geometry_restraints_manager=model.restraints_manager.geometry,
fmodel=fmodel,
wavelength=wavelength,
params=params,
nproc=nproc,
verbose=params.debug,
log=out,
manager_class=manager_class)
else:
grm = model.get_restraints_manager().geometry
connectivity = grm.shell_sym_tables[0].full_simple_connectivity()
manager.update_structure(pdb_hierarchy=pdb_hierarchy,
xray_structure=fmodel.xray_structure,
connectivity=connectivity,
log=out)
manager.update_maps()
model.update_anomalous_groups(out=out)
make_sub_header("Analyzing water molecules", out=out)
manager.show_current_scattering_statistics(out=out)
anomalous_groups = []
# XXX somehow comma-separation of phil strings fields doesn't work
if (isinstance(elements, list)) and (len(elements) == 1):
elements = elements[0].split(",")
water_ion_candidates = manager.analyze_waters(out=out, candidates=elements)
modified_iselection = flex.size_t()
default_b_iso = manager.get_initial_b_iso()
# Build in the identified ions
for_building = []
if (use_svm):
for result in water_ion_candidates:
for_building.append((result.i_seq, result.final_choice))
else:
for i_seq, final_choices, two_fofc in water_ion_candidates:
if (len(final_choices) == 1):
for_building.append((i_seq, final_choices[0]))
skipped = []
if (len(for_building) > 0):
make_sub_header("Adding %d ions to model" % len(for_building), out)
for k, (i_seq, final_choice) in enumerate(for_building):
atom = manager.pdb_atoms[i_seq]
skip = False
for other_i_seq, other_ion in for_building[:k]:
if (other_i_seq in skipped): continue
if (((other_ion.charge > 0) and (final_choice.charge > 0)) or
((other_ion.charge < 0) and (final_choice.charge < 0))):
other_atom = manager.pdb_atoms[other_i_seq]
dxyz = atom.distance(other_atom)
if (dxyz < params.max_distance_between_like_charges):
print(" %s (%s%+d) is only %.3fA from %s (%s%+d), skipping for now" %\
(atom.id_str(), final_choice.element, final_choice.charge, dxyz,
other_atom.id_str(), other_ion.element, other_ion.charge), file=out)
skipped.append(i_seq)
skip = True
break
if (skip): continue
print(" %s becomes %s%+d" % \
(atom.id_str(), final_choice.element, final_choice.charge), file=out)
refine_adp = params.refine_ion_adp
if (refine_adp == "Auto"):
if (fmodel.f_obs().d_min() <= 1.5):
refine_adp = "anisotropic"
elif (fmodel.f_obs().d_min() < 2.5):
atomic_number = sasaki.table(
final_choice.element).atomic_number()
if (atomic_number >= 19):
refine_adp = "anisotropic"
# Modify the atom object - this is clumsy but they will be grouped into
# a single chain at the end of refinement
initial_b_iso = params.initial_b_iso
if (initial_b_iso is Auto):
initial_b_iso = manager.guess_b_iso_real(i_seq)
element = final_choice.element
if (element == "IOD"): # FIXME
element = "I"
modified_atom = model.convert_atom(
i_seq=i_seq,
scattering_type=final_choice.scattering_type(),
atom_name=element,
element=element,
charge=final_choice.charge,
residue_name=final_choice.element,
initial_occupancy=params.initial_occupancy,
initial_b_iso=initial_b_iso,
chain_id=params.ion_chain_id,
segid="ION",
refine_adp=refine_adp,
refine_occupancies=False) #params.refine_ion_occupancies)
if (params.refine_anomalous) and (anomalous_flag):
scatterer = model.get_xray_structure().scatterers()[i_seq]
if (wavelength is not None):
fp_fdp_info = sasaki.table(
final_choice.element).at_angstrom(wavelength)
scatterer.fp = fp_fdp_info.fp()
scatterer.fdp = fp_fdp_info.fdp()
print(" setting f'=%g, f''=%g" %
(scatterer.fp, scatterer.fdp),
file=out)
group = xray.anomalous_scatterer_group(
iselection=flex.size_t([i_seq]),
f_prime=scatterer.fp,
f_double_prime=scatterer.fdp,
refine=["f_prime", "f_double_prime"],
selection_string=get_single_atom_selection_string(
modified_atom),
update_from_selection=True)
anomalous_groups.append(group)
modified_iselection.append(i_seq)
if (len(modified_iselection) > 0):
scatterers = model.get_xray_structure().scatterers()
# FIXME not sure this is actually working as desired...
site_symmetry_table = model.get_xray_structure().site_symmetry_table()
for i_seq in site_symmetry_table.special_position_indices():
scatterers[i_seq].site = crystal.correct_special_position(
crystal_symmetry=model.get_xray_structure(),
special_op=site_symmetry_table.get(i_seq).special_op(),
site_frac=scatterers[i_seq].site,
site_label=scatterers[i_seq].label,
tolerance=1.0)
model.get_xray_structure().replace_scatterers(scatterers=scatterers)
model.set_xray_structure(model.get_xray_structure())
def show_r_factors():
return "r_work=%6.4f r_free=%6.4f" % (fmodel.r_work(),
fmodel.r_free())
fmodel.update_xray_structure(xray_structure=model.get_xray_structure(),
update_f_calc=True,
update_f_mask=True)
n_anom = len(anomalous_groups)
refine_anomalous = anomalous_flag and params.refine_anomalous and n_anom > 0
refine_occupancies = (
(params.refine_ion_occupancies or refine_anomalous)
and ((not occupancy_strategy_enabled) or
(model.refinement_flags.s_occupancies is None) or
(len(model.refinement_flags.s_occupancies) == 0)))
if (refine_anomalous):
if (model.have_anomalous_scatterer_groups()
and (group_anomalous_strategy_enabled)):
model.set_anomalous_scatterer_groups(
model.get_anomalous_scatterer_groups() + anomalous_groups)
refine_anomalous = False
if (refine_occupancies) or (refine_anomalous):
print("", file=out)
print(" occupancy refinement (new ions only): start %s" % \
show_r_factors(), file=out)
fmodel.xray_structure.scatterers().flags_set_grads(state=False)
fmodel.xray_structure.scatterers().flags_set_grad_occupancy(
iselection=modified_iselection)
lbfgs_termination_params = scitbx.lbfgs.termination_parameters(
max_iterations=25)
minimized = mmtbx.refinement.minimization.lbfgs(
restraints_manager=None,
fmodels=fmodels,
model=model,
is_neutron_scat_table=False,
lbfgs_termination_params=lbfgs_termination_params)
fmodel.xray_structure.adjust_occupancy(
occ_max=1.0, occ_min=0, selection=modified_iselection)
zero_occ = []
for i_seq in modified_iselection:
occ = fmodel.xray_structure.scatterers()[i_seq].occupancy
if (occ == 0):
zero_occ.append(i_seq)
fmodel.update_xray_structure(update_f_calc=True,
update_f_mask=True)
print(" final %s" % \
show_r_factors(), file=out)
if (len(zero_occ) > 0):
print(" WARNING: occupancy dropped to zero for %d atoms:",
file=out)
atoms = model.get_atoms()
for i_seq in zero_occ:
print(" %s" % atoms[i_seq].id_str(suppress_segid=True),
file=out)
print("", file=out)
if (refine_anomalous):
assert fmodel.f_obs().anomalous_flag()
print(" anomalous refinement (new ions only): start %s" % \
show_r_factors(), file=out)
fmodel.update(target_name="ls")
anomalous_scatterer_groups.minimizer(fmodel=fmodel,
groups=anomalous_groups)
fmodel.update(target_name="ml")
print(" final %s" % \
show_r_factors(), file=out)
print("", file=out)
return manager
