def get_matching_sites_cart_in_both_h(old_h, new_h):
old_h.reset_atom_i_seqs()
new_h.reset_atom_i_seqs()
fixed_sites = flex.vec3_double()
moving_sites = flex.vec3_double()
isel_for_old = flex.size_t()
isel_for_new = flex.size_t()
if old_h.atoms_size() == new_h.atoms_size():
good = True
for a1, a2 in zip(old_h.atoms(), new_h.atoms()):
if a1.id_str()[:-6] != a2.id_str()[:-6]:
# print "No match: '%s', '%s'" % (a1.id_str()[:-6], a2.id_str()[:-6])
good = False
break
else:
fixed_sites.append(a1.xyz)
moving_sites.append(a2.xyz)
if good:
# print "SHORTCUT DONE"
assert fixed_sites.size() == moving_sites.size()
return fixed_sites, moving_sites
fixed_sites = flex.vec3_double()
moving_sites = flex.vec3_double()
for old_rg, new_rg in zip(old_h.only_chain().residue_groups(), new_h.only_chain().residue_groups()):
for old_ag, new_ag in zip(old_rg.atom_groups(), new_rg.atom_groups()):
for atom in old_ag.atoms():
a = new_ag.get_atom(atom.name.strip())
if a is not None:
fixed_sites.append(atom.xyz)
moving_sites.append(a.xyz)
assert fixed_sites.size() == moving_sites.size()
return fixed_sites, moving_sites
def join(self,data_dict):
"""The join() function closes the database.
"""
# Terminate the consumer process by feeding it a None command and
# wait for it to finish.
self._db_commands_queue.put(None)
self._db_commands_queue.join()
self._db_results_queue.join()
self._semaphore.acquire()
nrows = data_dict["rows"].get_obj()[0]
print "writing observation pickle with %d rows"%nrows
kwargs = dict(
miller_lookup = flex.size_t(data_dict["miller_proxy"].get_obj()[:nrows]),
observed_intensity = flex.double(data_dict["intensity_proxy"].get_obj()[:nrows]),
observed_sigI = flex.double(data_dict["sigma_proxy"].get_obj()[:nrows]),
frame_lookup = flex.size_t(data_dict["frame_proxy"].get_obj()[:nrows]),
original_H = flex.int (data_dict["H_proxy"].get_obj()[:nrows]),
original_K = flex.int (data_dict["K_proxy"].get_obj()[:nrows]),
original_L = flex.int (data_dict["L_proxy"].get_obj()[:nrows]),
)
import cPickle as pickle
pickle.dump(kwargs, open(self.params.output.prefix+"_observation.pickle","wb"),
pickle.HIGHEST_PROTOCOL)
pickle.dump(self.miller, open(self.params.output.prefix+"_miller.pickle","wb"),
pickle.HIGHEST_PROTOCOL)
pickle.dump(data_dict["xtal_proxy"].get_obj().raw.replace('\0','').strip(),
open(self.params.output.prefix+"_frame.pickle","wb"),pickle.HIGHEST_PROTOCOL)
return kwargs
def _add_to_single_size_t(self, x, next_to_i_seq, squeeze_in, mode=1):
tmp_x = []
new_independent_element = None
added = 0
for sel in x:
if(sel < next_to_i_seq):
tmp_x.append(sel)
elif(sel == next_to_i_seq):
tmp_x.append(sel)
if(squeeze_in):
if(mode == 1):
if(x.size() > 1):
tmp_x.append(next_to_i_seq+1)
added = 1
elif(x.size() == 1):
new_independent_element = [next_to_i_seq+1]
added = 1
else: raise RuntimeError
elif(mode == 2):
new_independent_element = [next_to_i_seq+1]
added = 1
else: raise RuntimeError
else:
tmp_x.append(sel+1)
if(new_independent_element is not None):
new_independent_element = flex.size_t(new_independent_element)
return flex.size_t(tmp_x), new_independent_element, added
def discard_symmetry(self):
assert len(self.table())>0
site_sym = self.table()[0]
assert site_sym.is_point_group_1()
return site_symmetry_table(
indices=flex.size_t(self.indices().size(), 0),
table=[site_symmetry_ops(1, site_sym.special_op(), site_sym.matrices())],
special_position_indices=flex.size_t())
def fit_side_chain(self, clusters):
rotamer_iterator = \
mmtbx.refinement.real_space.fit_residue.get_rotamer_iterator(
mon_lib_srv = self.mon_lib_srv,
residue = self.residue)
if(rotamer_iterator is None): return
selection = flex.size_t(flatten(clusters[0].vector))
if(self.target_map is not None):
start_target_value = self.get_target_value(
sites_cart = self.residue.atoms().extract_xyz(),
selection = selection)
sites_cart_start = self.residue.atoms().extract_xyz()
sites_cart_first_rotamer = list(rotamer_iterator)[0][1]
self.residue.atoms().set_xyz(sites_cart_first_rotamer)
axes = []
atr = []
for i, angle in enumerate(self.chi_angles[0]):
cl = clusters[i]
axes.append(flex.size_t(cl.axis))
atr.append(flex.size_t(cl.atoms_to_rotate))
if(self.target_map is not None):
ro = ext.fit(
target_value = start_target_value,
axes = axes,
rotatable_points_indices = atr,
angles_array = self.chi_angles,
density_map = self.target_map,
all_points = self.residue.atoms().extract_xyz(),
unit_cell = self.unit_cell,
selection = selection,
sin_table = self.sin_cos_table.sin_table,
cos_table = self.sin_cos_table.cos_table,
step = self.sin_cos_table.step,
n = self.sin_cos_table.n)
else:
ro = ext.fit(
sites_cart_start = sites_cart_start.deep_copy(),
axes = axes,
rotatable_points_indices = atr,
angles_array = self.chi_angles,
all_points = self.residue.atoms().extract_xyz(),
sin_table = self.sin_cos_table.sin_table,
cos_table = self.sin_cos_table.cos_table,
step = self.sin_cos_table.step,
n = self.sin_cos_table.n)
sites_cart_result = ro.result()
if(sites_cart_result.size()>0):
dist = None
if(self.accept_only_if_max_shift_is_smaller_than is not None):
dist = flex.max(flex.sqrt((sites_cart_start - sites_cart_result).dot()))
if(dist is None):
self.residue.atoms().set_xyz(sites_cart_result)
else:
if(dist is not None and
dist < self.accept_only_if_max_shift_is_smaller_than):
self.residue.atoms().set_xyz(sites_cart_result)
else:
self.residue.atoms().set_xyz(sites_cart_start)
def find_overlaps(self, experiments=None, border=0):
'''
Check for overlapping reflections.
:param experiments: The experiment list
:param tolerance: A positive integer specifying border around shoebox
:return: The overlap list
'''
from dials.algorithms.shoebox import OverlapFinder
from itertools import groupby
from scitbx.array_family import shared
# Expand the bbox if necessary
if border > 0:
x0, x1, y0, y1, z0, z1 = self['bbox'].parts()
x0 -= border
x1 += border
y0 -= border
y1 += border
z0 -= border
z1 += border
bbox = int6(x0,x1,y0,y1,z0,z1)
else:
bbox = self['bbox']
# Get the panel and id
panel = self['panel']
exp_id = self['id']
# Group according to imageset
if experiments is not None:
groups = groupby(
range(len(experiments)),
lambda x: experiments[x].imageset)
# Get the experiment ids we're to treat together
lookup = {}
for j, (key, indices) in enumerate(groups):
for i in indices:
lookup[i] = j
group_id = flex.size_t([lookup[i] for i in self['id']])
elif "imageset_id" in self:
imageset_id = self['imageset_id']
assert imageset_id.all_ge(0)
group_id = flex.size_t(list(imageset_id))
else:
raise RuntimeError('Either need to supply experiments or have imageset_id')
# Create the overlap finder
find_overlapping = OverlapFinder()
# Find the overlaps
overlaps = find_overlapping(group_id, panel, bbox)
assert(overlaps.num_vertices() == len(self))
# Return the overlaps
return overlaps
def __init__(self, asu_index, is_centric, iplus=None, iminus=None):
self._asu_index = asu_index
self._centric = is_centric
if iplus is None:
iplus = flex.size_t()
if iminus is None:
iminus = flex.size_t()
self._iplus = iplus
self._iminus = iminus
def exercise_miller_export_as_shelx_hklf():
s = """\
1 2 -1 23.34 4.56
2 -3 9 12.45 6.12
99999999999999999.9999999.99
-999-999-999-9999.99-9999.99
3 4 5999999.99999999.
3 4 5-99999.9-999999.
"""
ma = hklf.reader(file_object=StringIO(s)).as_miller_arrays()[0]
sio = StringIO()
ma.export_as_shelx_hklf(file_object=sio)
ma2 = hklf.reader(file_object=StringIO(sio.getvalue())).as_miller_arrays()[0]
assert approx_equal(ma.indices(), ma2.indices())
assert approx_equal(ma.data(), ma2.data())
assert approx_equal(ma.sigmas(), ma2.sigmas())
#
ma = ma.select(flex.size_t([0]))
def check(d, s, f):
if (s is not None): s = flex.double([s])
ma2 = ma.array(data=flex.double([d]), sigmas=s)
sio = StringIO()
ma2.export_as_shelx_hklf(sio, normalise_if_format_overflow=True)
assert not show_diff(sio.getvalue(), """\
1 2 -1%s
0 0 0 0.00 0.00
""" % f)
try: ma2.export_as_shelx_hklf(sio)
except RuntimeError: pass
else: raise Exception_expected
check(-12345678, 1, "-999999. 0.08")
check(-12345678, None, "-999999. 0.00")
check(2, -12345678, " 0.16-999999.")
check(123456789, 30, "9999999. 2.43")
check(123456789, None, "9999999. 0.00")
check(40, 123456789, " 3.249999999.")
check(-23456789, 123456789, "-999999.5263153.")
check(123456789, -23456789, "5263153.-999999.")
#
ma = hklf.reader(file_object=StringIO(s)).as_miller_arrays()[0]
ma = ma.select(flex.size_t([0,1]))
ma2 = ma.array(data=flex.double([123456789, -23456789]))
sio = StringIO()
ma2.export_as_shelx_hklf(sio, normalise_if_format_overflow=True)
assert not show_diff(sio.getvalue(), """\
1 2 -15263153. 0.00
2 -3 9-999999. 0.00
0 0 0 0.00 0.00
""")
ma2 = ma.array(data=flex.double([-23456789, 823456789]))
sio = StringIO()
ma2.export_as_shelx_hklf(sio, normalise_if_format_overflow=True)
assert not show_diff(sio.getvalue(), """\
1 2 -1-284858. 0.00
2 -3 99999999. 0.00
0 0 0 0.00 0.00
""")
def __init__(self,obs_arrays,unique_set,d_max,d_min,n_bins):
from cctbx import miller
self.obs_arrays = obs_arrays
extended_indices = unique_set.indices().select(obs_arrays.miller)
self.obs_set = unique_set.customized_copy(indices=extended_indices, data=obs_arrays.frame)
self.obs_set.setup_binner(d_max=d_max,
d_min=d_min,
n_bins=n_bins)
self.n_meas_cache = flex.size_t(n_bins+1)
self.n_neg_cache = flex.size_t(n_bins+1)
def generate_evec(selections,
selections_1d,
xray_structure,
pdb_hierarchy,
filename,
n_modes,
zero_mode_input_flag = False,
zero_mode_flag = True):
global time_generate_evec
t1 = time.time()
atoms = pdb_hierarchy.atoms()
nm_init_manager = nm_init(filename = filename,
n_modes = n_modes,
atoms = atoms,
zero_mode_input_flag = zero_mode_input_flag,
zero_mode_flag = zero_mode_flag)
modes = []
for i in range(n_modes):
modes.append(nm_init_manager.return_modes(i))
if zero_mode_flag == True and zero_mode_input_flag == False:
count = 0
for selection in selections:
# print len(selection)
# selection is size_t array
# print len(selections)
# for selection_ in selection:
# print selection_
bool_selection = flex.bool(xray_structure.sites_cart().size(), False)
bool_selection.set_selected(selection, True)
sites_cart_selected = xray_structure.sites_cart().select(selection)
atomic_weights_selected = xray_structure.atomic_weights().select(selection)
nm_init_manager.gen_zero_modes(sites_cart_selected, atomic_weights_selected, bool_selection)
padd = 6*count
for i in range(6):
selected_zero_modes = nm_init_manager.return_zero_modes(i+padd)
modes[i].set_selected(selection, selected_zero_modes)
count += 1
new_sel_st = flex.size_t()
for i in range(count):
new_bool_selection = nm_init_manager.return_new_selection(i)
new_selection = []
for selection_ in selections[i]:
if new_bool_selection[selection_] != False:
new_selection.append(selection_)
new_selection = flex.size_t(new_selection)
new_sel_st.extend(new_selection)
selections[i] = new_selection
selections_1d = new_sel_st
# selection will be modified in this step, we will only keep those atoms with normal modes being assigned.
nm_init_manager.normalize(n_modes)
t2 = time.time()
time_generate_evec += (t2 - t1)
return modes
def exercise_optimise_shelxl_weights():
def calc_goof(fo2, fc, w, k, n_params):
fc2 = fc.as_intensity_array()
w = w(fo2.data(), fo2.sigmas(), fc2.data(), k)
return math.sqrt(flex.sum(
w * flex.pow2(fo2.data() - k*fc2.data()))/(fo2.size() - n_params))
xs = smtbx.development.sucrose()
k = 0.05 + 10 * flex.random_double()
fc = xs.structure_factors(anomalous_flag=False, d_min=0.7).f_calc()
fo = fc.as_amplitude_array()
fo = fo.customized_copy(data=fo.data()*math.sqrt(k))
fo = fo.customized_copy(sigmas=0.03*fo.data())
sigmas = fo.sigmas()
for i in range(fo.size()):
fo.data()[i] += 2 * scitbx.random.variate(
scitbx.random.normal_distribution(sigma=sigmas[i]))() \
+ 0.5*random.random()
fo2 = fo.as_intensity_array()
fc2 = fc.as_intensity_array()
w = least_squares.mainstream_shelx_weighting(a=0.1)
s = calc_goof(fo2, fc, w, k, xs.n_parameters())
w2 = w.optimise_parameters(fo2, fc2, k, xs.n_parameters())
s2 = calc_goof(fo2, fc, w2, k, xs.n_parameters())
# sort data and setup binning by fc/fc_max
fc_sq = fc.as_intensity_array()
fc_sq_over_fc_sq_max = fc_sq.data()/flex.max(fc_sq.data())
permutation = flex.sort_permutation(fc_sq_over_fc_sq_max)
fc_sq_over_fc_sq_max = fc_sq.customized_copy(
data=fc_sq_over_fc_sq_max).select(permutation)
fc_sq = fc_sq.select(permutation)
fo_sq = fo2.select(permutation)
n_bins = 10
bin_max = 0
bin_limits = flex.size_t(1, 0)
bin_count = flex.size_t()
for i in range(n_bins):
bin_limits.append(int(math.ceil((i+1) * fc_sq.size()/n_bins)))
bin_count.append(bin_limits[i+1] - bin_limits[i])
goofs_w = flex.double()
goofs_w2 = flex.double()
for i_bin in range(n_bins):
sel = flex.size_t_range(bin_limits[i_bin], bin_limits[i_bin+1])
goofs_w2.append(calc_goof(fo_sq.select(sel),
fc_sq.select(sel),
w2, k, xs.n_parameters()))
goofs_w.append(calc_goof(fo_sq.select(sel),
fc_sq.select(sel),
w, k, xs.n_parameters()))
a = flex.mean_and_variance(goofs_w).unweighted_sample_variance()
b = flex.mean_and_variance(goofs_w2).unweighted_sample_variance()
assert a > b or abs(1-s) > abs(1-s2)
assert a > b # flat analysis of variance
assert abs(1-s) > abs(1-s2) # GooF close to 1
def exercise_covariance():
xs = xray.structure(
crystal_symmetry=crystal.symmetry(
(5.01,5.01,5.47,90,90,120), "P6222"),
scatterers=flex.xray_scatterer([
xray.scatterer("Si", (1/2.,1/2.,1/3.)),
xray.scatterer("O", (0.197,-0.197,0.83333))]))
uc = xs.unit_cell()
flags = xs.scatterer_flags()
for f in flags:
f.set_grad_site(True)
xs.set_scatterer_flags(flags)
cov = flex.double((1e-8,1e-9,2e-9,3e-9,4e-9,5e-9,
2e-8,1e-9,2e-9,3e-9,4e-9,
3e-8,1e-9,2e-9,3e-9,
2e-8,1e-9,2e-9,
3e-8,1e-9,
4e-8))
param_map = xs.parameter_map()
assert approx_equal(cov,
covariance.extract_covariance_matrix_for_sites(flex.size_t([0,1]), cov, param_map))
cov_cart = covariance.orthogonalize_covariance_matrix(cov, uc, param_map)
O = matrix.sqr(uc.orthogonalization_matrix())
for i in range(param_map.n_scatterers):
cov_i = covariance.extract_covariance_matrix_for_sites(flex.size_t([i]), cov, param_map)
cov_i_cart = covariance.extract_covariance_matrix_for_sites(flex.size_t([i]), cov_cart, param_map)
assert approx_equal(
O * matrix.sym(sym_mat3=cov_i) * O.transpose(),
matrix.sym(sym_mat3=cov_i_cart).as_mat3())
for f in flags: f.set_grads(False)
flags[0].set_grad_u_aniso(True)
flags[0].set_use_u_aniso(True)
flags[1].set_grad_u_iso(True)
flags[1].set_use_u_iso(True)
xs.set_scatterer_flags(flags)
param_map = xs.parameter_map()
cov = flex.double(7*7, 0)
cov.reshape(flex.grid(7,7))
cov.matrix_diagonal_set_in_place(flex.double([i for i in range(7)]))
cov = cov.matrix_symmetric_as_packed_u()
assert approx_equal([i for i in range(6)],
covariance.extract_covariance_matrix_for_u_aniso(
0, cov, param_map).matrix_packed_u_diagonal())
assert covariance.variance_for_u_iso(1, cov, param_map) == 6
try: covariance.variance_for_u_iso(0, cov, param_map)
except RuntimeError: pass
else: raise Exception_expected
try: covariance.extract_covariance_matrix_for_u_aniso(1, cov, param_map)
except RuntimeError: pass
else: raise Exception_expected
approx_equal(covariance.extract_covariance_matrix_for_sites(
flex.size_t([1]), cov, param_map), (0,0,0,0,0,0))
def exercise_miller_array_data_types():
miller_set = crystal.symmetry(unit_cell=(10, 10, 10, 90, 90, 90), space_group_symbol="P1").miller_set(
indices=flex.miller_index([(1, 2, 3), (4, 5, 6)]), anomalous_flag=False
)
for data in [
flex.bool([False, True]),
flex.int([0, 1]),
flex.size_t([0, 1]),
flex.double([0, 1]),
flex.complex_double([0, 1]),
]:
miller_array = miller_set.array(data=data)
if op.isfile("tmp_iotbx_mtz.mtz"):
os.remove("tmp_iotbx_mtz.mtz")
assert not op.isfile("tmp_iotbx_mtz.mtz")
miller_array.as_mtz_dataset(column_root_label="DATA").mtz_object().write(file_name="tmp_iotbx_mtz.mtz")
assert op.isfile("tmp_iotbx_mtz.mtz")
mtz_obj = mtz.object(file_name="tmp_iotbx_mtz.mtz")
miller_arrays_read_back = mtz_obj.as_miller_arrays()
assert len(miller_arrays_read_back) == 1
miller_array_read_back = miller_arrays_read_back[0]
assert miller_array_read_back.indices().all_eq(miller_array.indices())
if miller_array.is_integer_array() or miller_array.is_bool_array():
assert miller_array_read_back.data().all_eq(flex.int([0, 1]))
elif miller_array.is_real_array():
assert miller_array_read_back.data().all_eq(flex.double([0, 1]))
elif miller_array.is_complex_array():
assert miller_array_read_back.data().all_eq(flex.complex_double([0, 1]))
else:
raise RuntimeError("Programming error.")
def exercise_zeolite_atlas(distance_cutoff=3.5):
atlas_file = libtbx.env.find_in_repositories(
relative_path="phenix_regression/misc/strudat_zeolite_atlas",
test=os.path.isfile)
if (atlas_file is None):
print "Skipping exercise_zeolite_atlas(): input file not available"
return
all_entries = strudat.read_all_entries(open(atlas_file))
for i,entry in enumerate(all_entries.entries):
structure = entry.as_xray_structure()
if ("--full" in sys.argv[1:] or i % 20 == 0):
tst_direct_space_asu.exercise_neighbors_pair_generators(
structure=structure,
verbose="--Verbose" in sys.argv[1:])
asu_mappings = structure.asu_mappings(buffer_thickness=distance_cutoff)
pair_generator = crystal.neighbors_fast_pair_generator(
asu_mappings=asu_mappings,
distance_cutoff=distance_cutoff)
bond_counts = flex.size_t(structure.scatterers().size(), 0)
for pair in pair_generator:
bond_counts[pair.i_seq] += 1
if (pair.j_sym == 0):
bond_counts[pair.j_seq] += 1
for atom,bond_count in zip(entry.atoms, bond_counts):
assert atom.connectivity is not None
assert atom.connectivity == bond_count
def _nonbonded_pair_objects(max_bonded_cutoff=3.,
i_seqs=None,
):
if i_seqs is None:
atoms = self.pdb_hierarchy.atoms()
i_seqs = flex.size_t()
for atom in atoms:
i_seqs.append(atom.i_seq)
if (self.model_indices is not None):
model_indices = self.model_indices.select(i_seqs)
conformer_indices = self.conformer_indices.select(i_seqs)
sym_excl_indices = self.sym_excl_indices.select(i_seqs)
donor_acceptor_excl_groups = self.donor_acceptor_excl_groups.select(i_seqs)
asu_mappings = self.special_position_settings.asu_mappings(
buffer_thickness=max_bonded_cutoff)
sites_cart = self.sites_cart.select(i_seqs)
asu_mappings.process_sites_cart(
original_sites=sites_cart,
site_symmetry_table=self.site_symmetry_table().select(i_seqs))
pair_asu_table = crystal.pair_asu_table(asu_mappings=asu_mappings)
nonbonded_proxies = geometry_restraints.nonbonded_sorted_asu_proxies(
model_indices=model_indices,
conformer_indices=conformer_indices,
sym_excl_indices=sym_excl_indices,
donor_acceptor_excl_groups=donor_acceptor_excl_groups,
nonbonded_params=geometry_restraints.nonbonded_params(
default_distance=1),
nonbonded_types=flex.std_string(conformer_indices.size()),
nonbonded_charges=flex.int(conformer_indices.size(), 0),
nonbonded_distance_cutoff_plus_buffer=max_bonded_cutoff,
min_cubicle_edge=5,
shell_asu_tables=[pair_asu_table])
return nonbonded_proxies, sites_cart, pair_asu_table, asu_mappings, i_seqs
def extract_residues(self, model_i, number_previous_scatters, combine = True):
result = []
model = self.pdb_hierarchy.models()[model_i]
rm = []
for chain in model.chains():
for rg in chain.residue_groups():
rg_i_seqs = []
r_name = None
for ag in rg.atom_groups():
if(r_name is None): r_name = ag.resname
for atom in ag.atoms():
if(self.selection[atom.i_seq - number_previous_scatters]):
rg_i_seqs.append(atom.i_seq - number_previous_scatters)
if(len(rg_i_seqs) != 0):
rm.append(group_args(
selection = flex.size_t(rg_i_seqs),
name = r_name,
model_id = model_i,
resid = rg.resid(),
chain_id = chain.id))
result.append(rm)
if(combine):
r0 = result[0]
for r in result[1:]:
for i, ri in enumerate(r):
r0[i].selection.extend(ri.selection)
assert r0[i].name == ri.name
else:
r0 = result[0]
for r in result[1:]:
r0.extend(r)
return r0
def exclude_outliers_from_reference_restraints_selection(
pdb_hierarchy,
restraints_selection):
from mmtbx.validation.ramalyze import ramalyze
# the import below is SLOW!!!
from mmtbx.rotamer.rotamer_eval import RotamerEval
assert restraints_selection is not None
# ramachandran plot outliers
rama_outlier_selection = ramalyze(pdb_hierarchy=pdb_hierarchy,
outliers_only=False).outlier_selection()
rama_outlier_selection = flex.bool(restraints_selection.size(),
rama_outlier_selection)
# rotamer outliers
rota_outlier_selection = flex.size_t()
rotamer_manager = RotamerEval() # SLOW!!!
for model in pdb_hierarchy.models():
for chain in model.chains():
for residue_group in chain.residue_groups():
conformers = residue_group.conformers()
if(len(conformers)>1): continue
for conformer in residue_group.conformers():
residue = conformer.only_residue()
if(rotamer_manager.evaluate_residue(residue)=="OUTLIER"):
rota_outlier_selection.extend(residue.atoms().extract_i_seq())
rota_outlier_selection = flex.bool(restraints_selection.size(),
rota_outlier_selection)
outlier_selection = rama_outlier_selection | rota_outlier_selection
return restraints_selection & (~outlier_selection)
def map_to_grid(self, sweep, centroids):
b_iso = 200
beam = sweep.get_beam()
wavelength = beam.get_wavelength()
d_min = self.d_min
n_points = self.gridding[0]
rlgrid = 2 / (d_min * n_points)
# real space FFT grid dimensions
cell_lengths = [n_points * d_min/2 for i in range(3)]
self.fft_cell = uctbx.unit_cell(cell_lengths+[90]*3)
self.crystal_symmetry = crystal.symmetry(unit_cell=self.fft_cell,
space_group_symbol="P1")
print "FFT gridding: (%i,%i,%i)" %self.gridding
grid = flex.double(flex.grid(self.gridding), 0)
reflections_used_for_indexing = flex.size_t()
for i_pnt, point in enumerate(centroids):
point = scitbx.matrix.col(point)
spot_resolution = 1/point.length()
if spot_resolution < d_min:
continue
grid_coordinates = [int(round(point[i]/rlgrid)+n_points/2) for i in range(3)]
if max(grid_coordinates) >= n_points: continue # this reflection is outside the grid
if min(grid_coordinates) < 0: continue # this reflection is outside the grid
T = math.exp(b_iso * point.length()**2 / 4)
grid[grid_coordinates] = T
self.reciprocal_space_grid = grid
def show_terms(structure, term_table, coseq_dict=None):
assert len(term_table) == structure.scatterers().size()
for scatterer,terms in zip(structure.scatterers(), term_table):
print scatterer.label, list(terms),
if (coseq_dict is not None):
terms_to_match = list(terms[1:])
have_match = False
tags = coseq_dict.keys()
tags.sort()
for tag in tags:
for coseq_terms in coseq_dict[tag]:
n = min(len(coseq_terms), len(terms_to_match))
if (coseq_terms[:n] == terms_to_match[:n]):
print tag,
have_match = True
if (not have_match):
print "Unknown",
print
sums_terms = flex.double()
multiplicities = flex.double()
for scatterer,terms in zip(structure.scatterers(), term_table):
sums_terms.append(flex.sum(flex.size_t(list(terms))))
multiplicities.append(scatterer.multiplicity())
print "TD%d: %.2f" % (
len(terms)-1, flex.mean_weighted(sums_terms, multiplicities))
def __init__(self,
structure_monitor,
rotamer_manager,
sin_cos_table,
mon_lib_srv,
backbone_sample=True,
log = None):
adopt_init_args(self, locals())
self.unit_cell = self.structure_monitor.xray_structure.unit_cell()
if(self.log is None): self.log = sys.stdout
assert approx_equal(
self.structure_monitor.xray_structure.sites_cart(),
self.structure_monitor.pdb_hierarchy.atoms().extract_xyz())
self.special_position_indices = \
self.structure_monitor.xray_structure.special_position_indices()
self.atom_radius_to_negate_map_within = None
if(self.structure_monitor.target_map_object.miller_array.d_min()>3.5):
self.atom_radius_to_negate_map_within = 2.0
else:
self.atom_radius_to_negate_map_within = 1.5
#
self.selection_good = self.structure_monitor.map_cc_per_atom > 0.8
self.selection_water = self.structure_monitor.pdb_hierarchy.\
atom_selection_cache().selection(string = "water")
self.iselection_backbone=flex.size_t()
for r in self.structure_monitor.residue_monitors:
if(r.selection_backbone is not None):
self.iselection_backbone.extend(r.selection_backbone)
self.loop_over_residues()
def mask(self, solvent_fraction): hist = self.histogram() cutoff = hist.get_cutoff(int(self.map.size()*(1-solvent_fraction))) mask = flex.size_t() mask.resize(self.map.accessor(), 1) mask.set_selected(self.map > cutoff, 0) return mask
def run_call_back(flags, space_group_info):
d_min = 2.0
structure = random_structure.xray_structure(
space_group_info=space_group_info,
elements=["N", "C", "O", "S"]*3 + ["Fe"]*2,
volume_per_atom=100)
if (not space_group_info.group().is_centric()):
fp_fdp_targets = [(-1,2), (-2,6)]
else:
fp_fdp_targets = [(-1,0), (-2,0)]
anomalous_scatterer_groups = [
xray.anomalous_scatterer_group(
iselection=flex.size_t(),
f_prime=fp,
f_double_prime=fdp,
refine=["f_prime", "f_double_prime"]) for fp,fdp in fp_fdp_targets]
for i_seq,scatterer in enumerate(structure.scatterers()):
if (scatterer.scattering_type == "S"):
anomalous_scatterer_groups[0].iselection.append(i_seq)
if (scatterer.scattering_type == "Fe"):
anomalous_scatterer_groups[1].iselection.append(i_seq)
for group in anomalous_scatterer_groups:
group.copy_to_scatterers_in_place(scatterers=structure.scatterers())
if (flags.Verbose):
structure.show_summary().show_scatterers()
f_obs = abs(structure.structure_factors(
d_min=2.0, anomalous_flag=True).f_calc())
if (flags.Verbose):
f_obs.show_comprehensive_summary()
#
for group in anomalous_scatterer_groups:
group.f_prime = 0
group.f_double_prime = 0
group.copy_to_scatterers_in_place(scatterers=structure.scatterers())
sfg_params = mmtbx.f_model.sf_and_grads_accuracy_master_params.extract()
sfg_params.algorithm = "direct"
fmodel = mmtbx.f_model.manager(
xray_structure=structure,
f_obs=f_obs,
r_free_flags=f_obs.generate_r_free_flags(),
sf_and_grads_accuracy_params = sfg_params,
target_name="ls")
#
n_cycles = [0]
def call_back(minimizer):
n_cycles[0] += 1
return True
minimized = mmtbx.refinement.anomalous_scatterer_groups.minimizer(
fmodel=fmodel,
groups=anomalous_scatterer_groups,
call_back_after_minimizer_cycle=call_back,
number_of_finite_difference_tests=3)
assert n_cycles == [3]
#
for group,(fp,fdp) in zip(anomalous_scatterer_groups, fp_fdp_targets):
# Large eps because the minimization doesn't reliably converge.
# We don't want to exercise the minimizer here, the important
# test is the finite difference test embedded in the minimizer.
assert approx_equal(group.f_prime, fp, eps=1)
assert approx_equal(group.f_double_prime, fdp, eps=1)
def set_refinable_parameters(xray_structure, parameters, selections,
enforce_positivity=False):
# XXX PVA: Code below is terribly inefficient and MUST be moved into C++
sz = xray_structure.scatterers().size()
i = 0
for sel in selections:
# pre-check for positivity begin
# spread negative occupancies across i_seqs having positive ones
par_all = flex.double()
par_neg = flex.double()
i_p = i
for sel_ in sel:
p = parameters[i_p]
par_all.append(p)
if(p<0): par_neg.append(p)
i_p += 1
if(enforce_positivity and par_neg.size()>0):
par_all = par_all - flex.min(par_all)
fs = flex.sum(par_all)
if(fs != 0):
par_all = par_all / fs
# pre-check for positivity end
for j, sel_ in enumerate(sel):
sel__b = flex.bool(sz, flex.size_t(sel_))
xray_structure.set_occupancies(par_all[j], sel__b)
i+=1
def _add(self, x, next_to_i_seq, squeeze_in):
if(x is None): return x
elif(self.is_bool(x)):
x_new = []
result = self._add_to_single_size_t(x.iselection(),
next_to_i_seq, squeeze_in)
if(result[1] is None): x_new.extend([result[0]])
else: x_new.extend([result[0], result[1]])
if(result[2] == 0 and squeeze_in):
x_new.extend([flex.size_t([next_to_i_seq+1])])
x_new_new = flex.size_t()
for i_x_new in x_new: x_new_new.extend(i_x_new)
return flex.bool(x.size()+1, x_new_new)
#elif(self.is_size_t(x)): # XXX not testes so disabled
# return self._add_to_single_size_t(x, next_to_i_seq, squeeze_in)
elif(len(x)==0): raise RuntimeError
elif(self.is_size_t(x[0])):
x_new = []
added = 0
for x_ in x:
result = self._add_to_single_size_t(x_, next_to_i_seq, squeeze_in)
added += result[2]
if(result[1] is None): x_new.extend([result[0]])
else: x_new.extend([result[0], result[1]])
if(added == 0 and squeeze_in):
x_new.extend([flex.size_t([next_to_i_seq+1])])
return x_new
elif(self.is_size_t(x[0][0])):
xx_new = []
added = 0
result_1 = None
for xx in x:
x_new = []
for x_ in xx:
result = self._add_to_single_size_t(x_, next_to_i_seq, squeeze_in, 2)
added += result[2]
if(result[1] is None):
x_new.extend([result[0]])
else:
x_new.extend([result[0]])
if(result[1] is not None):
xx_new.append([result[1]])
if(len(x_new) > 0): xx_new.append(x_new)
if(added == 0 and squeeze_in):
xx_new.append([flex.size_t([next_to_i_seq+1])])
return xx_new
else: raise RuntimeError("Bad selection array type.")
def ca(self, x):
if(x is None): return str(0)
elif(self.is_bool(x)): return str(x.count(True))
elif(self.is_size_t(x)): return str(x.size())
elif(len(x)==0): return str(0)
elif(self.is_size_t(x[0])):
return str(flex.sum(flex.size_t([i.size() for i in x])))
else: raise RuntimeError("Bad selection array type.")
def __init__(O, n_reserve, i_calc, use_symmetry):
from cctbx.array_family import flex
O.i_calc = i_calc
O.use_symmetry = use_symmetry
if (use_symmetry):
O.n_indices = O.i_calc.asu.indices().size()
else:
O.n_indices = O.i_calc.p1_anom.indices().size()
O.completeness_history = flex.double()
O.completeness_history.reserve(n_reserve)
O.completeness_history.append(0)
O.min_count_history = flex.size_t()
O.min_count_history.reserve(n_reserve)
O.min_count_history.append(0)
O.counts = flex.size_t(O.n_indices, 0)
O.currently_zero = O.n_indices
O.new_0 = None
def count_occupancies(self, x):
result = flex.size_t()
if(x is not None):
for i in x:
for j in i:
for k in j:
result.append(k)
return str(result.size())
def expand_model_or_conformer_indices(
indices,
x_n_seq,
related_x_i_seqs):
result = flex.size_t(x_n_seq, x_n_seq)
for i_seq,i in enumerate(indices):
result.set_selected(related_x_i_seqs[i_seq], i)
assert result.count(x_n_seq) == 0
return result
def map_statistics_for_atom_selection (
atom_selection,
fmodel=None,
resolution_factor=0.25,
map1=None,
map2=None,
xray_structure=None,
map1_type="2mFo-DFc",
map2_type="Fmodel",
atom_radius=1.5,
exclude_hydrogens=False) :
"""
Simple-but-flexible function to give the model-to-map CC and mean density
values (sigma-scaled, unless pre-calculated maps are provided) for any
arbitrary atom selection.
"""
assert (atom_selection is not None) and (len(atom_selection) > 0)
if (fmodel is not None) :
assert (map1 is None) and (map2 is None) and (xray_structure is None)
edm = fmodel.electron_density_map()
map1_coeffs = edm.map_coefficients(map1_type)
map1 = map1_coeffs.fft_map(
resolution_factor=resolution_factor).apply_sigma_scaling().real_map()
map2_coeffs = edm.map_coefficients(map2_type)
map2 = map2_coeffs.fft_map(
resolution_factor=resolution_factor).apply_sigma_scaling().real_map()
xray_structure = fmodel.xray_structure
else :
assert (not None in [map1, map2, xray_structure])
assert isinstance(map1, flex.double) and isinstance(map2, flex.double)
if (exclude_hydrogens) :
hd_selection = xray_structure.hd_selection()
if (type(atom_selection).__name__ == "size_t") :
atom_selection_new = flex.size_t()
for i_seq in atom_selection :
if (not hd_selection[i_seq]) :
atom_selection_new.append(i_seq)
atom_selection = atom_selection_new
assert (len(atom_selection) > 0)
else :
assert (type(atom_selection).__name__ == "bool")
atom_selection &= ~hd_selection
manager = selection_map_statistics_manager(
atom_selection=atom_selection,
xray_structure=xray_structure,
fft_n_real = map1.focus(),
fft_m_real = map1.all(),
exclude_hydrogens=exclude_hydrogens)
stats = manager.analyze_map(
map=map1,
model_map=map2)
return group_args(
cc=stats.cc,
map1_mean=stats.mean,
map2_mean=stats.model_mean)
def find_similar_matches(self, target, matches, used, overlap_thres):
tmp_a = flex.double(self.set_a.size(), 0.0).set_selected(target[0], 1.0)
result = flex.size_t()
for ii in xrange(len(matches)):
if not used[ii]:
match = matches[ii][0]
tmp_b = flex.double(self.set_a.size(), 0.0).set_selected(match, 1.0)
similar = flex.sum(tmp_a * tmp_b) / flex.sum(tmp_a)
if similar > overlap_thres:
result.append(ii)
return result
def compute_d(self, experiments):
'''
Compute the resolution for each reflection.
:param experiments: The experiment list
:return: The resolution for each reflection
'''
from dials.array_family import flex
uc = flex.unit_cell(len(experiments))
for i, e in enumerate(experiments):
uc[i] = e.crystal.get_unit_cell()
assert self['id'].all_ge(0)
self['d'] = uc.d(self['miller_index'], flex.size_t(list(self['id'])))
return self['d']
def __init__(
self,
target_map,
residue,
vdw_radii,
xray_structure,
mon_lib_srv,
rotamer_manager,
# This is cctbx.geometry_restraints.manager.manager
geometry_restraints_manager,
real_space_gradients_delta,
selection_radius=5,
rms_bonds_limit=0.03, # XXX probably needs to be much lower
rms_angles_limit=3.0, # XXX
backbone_sample_angle=None,
allow_modified_residues=False):
adopt_init_args(self, locals())
# load rotamer manager
self.rotamer_manager = mmtbx.idealized_aa_residues.rotamer_manager.load(
)
# pre-compute sin and cos tables
self.sin_cos_table = scitbx.math.sin_cos_table(n=10000)
self.backbone_atom_names = ["N", "CA", "O", "CB", "C"]
self.residue_iselection = self.residue.atoms().extract_i_seq()
assert (not self.residue_iselection.all_eq(0))
self.residue_selection = flex.bool(xray_structure.scatterers().size(),
self.residue_iselection)
self.residue_backbone_selection = flex.size_t()
for atom in self.residue.atoms():
if (atom.name.strip() in self.backbone_atom_names):
self.residue_backbone_selection.append(atom.i_seq)
self.residue_backbone_selection = flex.bool(
xray_structure.scatterers().size(),
self.residue_backbone_selection)
self.target_map_work = target_map
self.target_map_orig = target_map.deep_copy()
self.fit_backbone()
negate_selection = mmtbx.refinement.real_space.selection_around_to_negate(
xray_structure=self.xray_structure,
selection_within_radius=self.selection_radius,
iselection=self.residue.atoms().extract_i_seq())
self.target_map_work = mmtbx.refinement.real_space.\
negate_map_around_selected_atoms_except_selected_atoms(
xray_structure = self.xray_structure,
map_data = target_map,
negate_selection = negate_selection,
atom_radius = 1.5)
self.fit_rotamers()
def run_fit_rotatable(fmodel,
ref_model,
angular_step,
log=None,
use_h_omit_map=False,
map_type="2mFo-DFc"):
pdb_hierarchy = ref_model.get_hierarchy()
xrs = fmodel.xray_structure
rotatable_h_selection = rotatable(
pdb_hierarchy=pdb_hierarchy,
mon_lib_srv=ref_model.get_mon_lib_srv(),
restraints_manager=ref_model.get_restraints_manager(),
log=log)
rotatable_h_selection_1d = []
for s in rotatable_h_selection:
rotatable_h_selection_1d.extend(s[1])
rotatable_h_selection_1d = flex.size_t(rotatable_h_selection_1d)
rotatable_h_selection_1d_bool = flex.bool(xrs.scatterers().size(),
rotatable_h_selection_1d)
if (log is not None):
print("Real-space grid search fit H (or D) atoms:", file=log)
print(" start: r_work=%6.4f r_free=%6.4f" %
(fmodel.r_work(), fmodel.r_free()),
file=log)
if (use_h_omit_map):
xrs_omit = fmodel.xray_structure.select(~rotatable_h_selection_1d_bool)
fmodel.update_xray_structure(xray_structure=xrs_omit,
update_f_calc=True)
if (log is not None):
print(" H omit: r_work=%6.4f r_free=%6.4f" %
(fmodel.r_work(), fmodel.r_free()),
file=log)
fft_map = fmodel.electron_density_map().fft_map(
resolution_factor=1. / 4.,
map_type=map_type,
symmetry_flags=maptbx.use_space_group_symmetry)
fft_map.apply_sigma_scaling()
map_data = fft_map.real_map_unpadded()
fit_rotatable(pdb_hierarchy=pdb_hierarchy,
xray_structure=xrs,
rotatable_h_selection=rotatable_h_selection,
map_data=map_data)
fmodel.update_xray_structure(xray_structure=xrs, update_f_calc=True)
ref_model.xray_structure = xrs
if (log is not None):
print(" final: r_work=%6.4f r_free=%6.4f" %
(fmodel.r_work(), fmodel.r_free()),
file=log)
def exercise_split_unmerged():
import random
random.seed(42)
flex.set_random_seed(42)
from cctbx import crystal
base_set = miller.build_set(
crystal_symmetry=crystal.symmetry(
unit_cell=(10,10,10,90,90,90), space_group_symbol="P1"),
d_min=1.6,
anomalous_flag=False)
indices = base_set.indices()
assert (len(indices) == 510)
unmerged_hkl = flex.miller_index()
unmerged_data = flex.double()
unmerged_sigmas = flex.double()
redundancies = flex.size_t()
# XXX grossly overengineered, but I wanted to get a realistic CC to make sure
# the reflections are being split properly
for i, hkl in enumerate(indices):
n_obs = min(8, 1 + i % 12)
redundancies.append(n_obs)
intensity_merged = (510 - i) + (510 % 27)
for j in range(n_obs):
unmerged_hkl.append(hkl)
intensity = intensity_merged + 20 * (510 % (7 * (j+1)))
sigma = max(0.5, i % 10)
unmerged_data.append(intensity)
unmerged_sigmas.append(sigma)
assert (unmerged_hkl.size() == 2877)
unmerged_array = miller.set(
crystal_symmetry=base_set,
indices=unmerged_hkl,
anomalous_flag=False).array(data=unmerged_data, sigmas=unmerged_sigmas)
split = miller.split_unmerged(
unmerged_indices=unmerged_hkl,
unmerged_data=unmerged_data,
unmerged_sigmas=unmerged_sigmas)
assert (split.data_1.size() == split.data_2.size() == 467)
cc = miller.compute_cc_one_half(unmerged_array)
assert approx_equal(cc, 0.861, eps=0.001)
unmerged_array.setup_binner(n_bins=10)
unmerged_array.set_observation_type_xray_intensity()
result = unmerged_array.cc_one_half(use_binning=True)
assert approx_equal(
result.data[1:-1],
[0.549, 0.789, 0.843, 0.835, 0.863, 0.860, 0.893, 0.847, 0.875, 0.859],
eps=0.05)
def exercise_1(mon_lib_srv, ener_lib):
pdb_in = simple_pdb()
params = pdb_interpretation.master_params.extract()
processed_pdb_file = pdb_interpretation.process(mon_lib_srv=mon_lib_srv,
ener_lib=ener_lib,
params=params,
pdb_inp=pdb_in,
log=StringIO())
grm = processed_pdb_file.geometry_restraints_manager()
pdb_hierarchy = processed_pdb_file.all_chain_proxies.pdb_hierarchy
sites_cart = pdb_hierarchy.atoms().extract_xyz()
proxies = reference.add_coordinate_restraints(sites_cart=sites_cart)
assert proxies.size() == 29, "expected 29, got %d" % proxies.size()
import boost.python
ext = boost.python.import_ext("mmtbx_reference_coordinate_ext")
grads = flex.vec3_double(sites_cart.size(), (0.0, 0.0, 0.0))
residual = ext.reference_coordinate_residual_sum(sites_cart=sites_cart,
proxies=proxies,
gradient_array=grads)
assert approx_equal(residual, 0.0)
#test selection
ca_selection = pdb_hierarchy.get_peptide_c_alpha_selection()
ca_sites_cart = sites_cart.select(ca_selection)
proxies = reference.add_coordinate_restraints(sites_cart=ca_sites_cart,
selection=ca_selection)
assert proxies.size() == 3, "expected 3, got %d" % proxies.size()
tst_iselection = flex.size_t()
for atom in pdb_hierarchy.atoms():
if atom.name == " CA " or atom.name == " N ":
tst_iselection.append(atom.i_seq)
tst_sites_cart = sites_cart.select(tst_iselection)
proxies = reference.add_coordinate_restraints(sites_cart=tst_sites_cart,
selection=tst_iselection)
assert proxies.size() == 6, "expected 6, got %d" % proxies.size()
#test remove
selection = flex.bool([False] * 29)
proxies = proxies.proxy_remove(selection=selection)
assert proxies.size() == 6, "expected 6, got %d" % proxies.size()
proxies = proxies.proxy_remove(selection=ca_selection)
assert proxies.size() == 3, "expected 3, got %d" % proxies.size()
selection = flex.bool([True] * 29)
proxies = proxies.proxy_remove(selection=selection)
assert proxies.size() == 0, "expected 0, got %d" % proxies.size()
def formatted_distance(self, i_seq, j_seq, distance, rt_mx_ji):
if rt_mx_ji is None: rt_mx_ji = unit_mx
if self.covariance_matrix_cart is not None:
cov = covariance.extract_covariance_matrix_for_sites(
flex.size_t((i_seq,j_seq)),
self.covariance_matrix_cart,
self.parameter_map)
if self.cell_covariance_matrix is not None:
var = distance.variance(
cov, self.cell_covariance_matrix, self.unit_cell, rt_mx_ji)
else:
var = distance.variance(cov, self.unit_cell, rt_mx_ji)
if var > self.eps and not(self.fixed_distances is not None and
((i_seq, j_seq) in self.fixed_distances or
(j_seq, i_seq) in self.fixed_distances)):
return format_float_with_su(distance.distance_model, math.sqrt(var))
return "%.4f" %distance.distance_model
def get_cluster(self):
axis=[]
atoms_to_rotate=[]
use_in_target_selection = flex.size_t()
counter = 0
for atom in self.residue.atoms():
if(atom.name.strip() in ["N", "C"]):
axis.append(counter)
else:
atoms_to_rotate.append(counter)
if(atom.name.strip() in self.backbone_atom_names):
use_in_target_selection.append(counter)
counter += 1
return mmtbx.refinement.real_space.cluster(
axis = axis,
atoms_to_rotate = atoms_to_rotate,
selection = use_in_target_selection)
def formatted_angle(self, i_seq, j_seq, k_seq, angle, rt_mx_ki):
if rt_mx_ki is None: rt_mx_ki = unit_mx
if self.covariance_matrix_cart is not None:
cov = covariance.extract_covariance_matrix_for_sites(
flex.size_t((i_seq,j_seq,k_seq)),
self.covariance_matrix_cart,
self.parameter_map)
if self.cell_covariance_matrix is not None:
var = angle.variance(cov, self.cell_covariance_matrix, self.unit_cell,
(unit_mx, unit_mx, rt_mx_ki))
else:
var = angle.variance(cov, self.unit_cell, (unit_mx, unit_mx, rt_mx_ki))
if var > self.eps and not(self.fixed_angles is not None and
((i_seq, j_seq, k_seq) in self.fixed_angles or
(k_seq, j_seq, i_seq) in self.fixed_angles)):
return format_float_with_su(angle.angle_model, math.sqrt(var))
return "%.1f" %angle.angle_model
def expand_planarity_proxies(planarity_proxies, x_n_seq, related_x_i_seqs):
result = cctbx.geometry_restraints.shared_planarity_proxy()
planarity_proxy_t = cctbx.geometry_restraints.planarity_proxy
for proxy in planarity_proxies:
x_i_seqs_list = [
tuple(related_x_i_seqs[i_seq]) for i_seq in proxy.i_seqs
]
loop_n = [len(x_i_seqs) for x_i_seqs in x_i_seqs_list]
sym_ops = proxy.sym_ops
weights = proxy.weights / matrix.col(loop_n).product()
for loop_i in nested_loop(loop_n):
i_seqs = flex.size_t(
[x_i_seqs[i] for x_i_seqs, i in zip(x_i_seqs_list, loop_i)])
result.append(
planarity_proxy_t(i_seqs=i_seqs,
sym_ops=sym_ops,
weights=weights).sort_i_seqs())
return result
def exclude_H_on_links(self):
origin_ids = linking_class()
rm = self.model.get_restraints_manager()
bond_proxies_simple, asu = rm.geometry.get_all_bond_proxies(
sites_cart = self.model.get_sites_cart())
elements = self.model.get_hierarchy().atoms().extract_element()
exclusion_iseqs = list()
exclusion_dict = dict()
all_proxies = [p for p in bond_proxies_simple]
for proxy in asu:
all_proxies.append(proxy)
# Loop through bond proxies to find links (origin_id != 0)
for proxy in all_proxies:
if( isinstance(proxy, ext.bond_simple_proxy)): i,j=proxy.i_seqs
elif(isinstance(proxy, ext.bond_asu_proxy)): i,j=proxy.i_seq,proxy.j_seq
else: assert 0 # never goes here
if proxy.origin_id != 0:
exclusion_iseqs.extend([i,j])
exclusion_dict[i] = proxy.origin_id
exclusion_dict[j] = proxy.origin_id
sel_remove = flex.size_t()
# Now find H atoms bound to linked atoms
removed_dict = dict()
for proxy in all_proxies:
if( isinstance(proxy, ext.bond_simple_proxy)): i,j=proxy.i_seqs
elif(isinstance(proxy, ext.bond_asu_proxy)): i,j=proxy.i_seq,proxy.j_seq
else: assert 0 # never goes here
if(elements[i] in ["H","D"] and j in exclusion_iseqs):
sel_remove.append(i)
removed_dict[i] = exclusion_dict[j]
if(elements[j] in ["H","D"] and i in exclusion_iseqs):
sel_remove.append(j)
removed_dict[j] = exclusion_dict[i]
#
sl_removed = [(atom.id_str().replace('pdb=','').replace('"',''),
origin_ids.get_origin_key(removed_dict[atom.i_seq]))
for atom in self.model.get_hierarchy().atoms().select(sel_remove)]
# self.site_labels_removed = list(OrderedDict.fromkeys(sl_removed))
self.sl_removed = sl_removed
self.exclusion_iseqs = exclusion_iseqs
#
self.model = self.model.select(~flex.bool(self.model.size(), sel_remove))
def exclude_h_on_coordinated_S(model): # XXX if edits used it should be like in exclude_h_on_SS
rm = model.get_restraints_manager().geometry
els = model.get_hierarchy().atoms().extract_element()
# Find possibly coordinated S
exclusion_list = ["H","D","T","S","O","P","N","C","SE"]
sel_s = []
for proxy in rm.pair_proxies().nonbonded_proxies.simple:
i,j = proxy.i_seqs
if(els[i] == "S" and not els[j] in exclusion_list): sel_s.append(i)
if(els[j] == "S" and not els[i] in exclusion_list): sel_s.append(j)
# Find H attached to possibly coordinated S
bond_proxies_simple, asu = rm.get_all_bond_proxies(
sites_cart = model.get_sites_cart())
sel_remove = flex.size_t()
for proxy in bond_proxies_simple:
i,j = proxy.i_seqs
if(els[i] in ["H","D"] and j in sel_s): sel_remove.append(i)
if(els[j] in ["H","D"] and i in sel_s): sel_remove.append(j)
return model.select(~flex.bool(model.size(), sel_remove))
def exercise_match_indices():
h0 = flex.miller_index(((1,2,3), (-1,-2,-3), (2,3,4), (-2,-3,-4), (3,4,5)))
d0 = flex.double((1,2,3,4,5))
h1 = flex.miller_index(((-1,-2,-3), (-2,-3,-4), (1,2,3), (2,3,4)))
d1 = flex.double((10,20,30,40))
mi = miller.match_indices(h0, h0)
assert mi.have_singles() == 0
assert list(mi.pairs()) == list(zip(range(5), range(5)))
mi = miller.match_indices(h0, h1)
assert tuple(mi.singles(0)) == (4,)
assert tuple(mi.singles(1)) == ()
assert tuple(mi.pairs()) == ((0,2), (1,0), (2,3), (3,1))
assert tuple(mi.pair_selection(0)) == (1, 1, 1, 1, 0)
assert tuple(mi.single_selection(0)) == (0, 0, 0, 0, 1)
assert tuple(mi.pair_selection(1)) == (1, 1, 1, 1)
assert tuple(mi.single_selection(1)) == (0, 0, 0, 0)
assert tuple(mi.paired_miller_indices(0)) \
== tuple(h0.select(mi.pair_selection(0)))
l1 = list(mi.paired_miller_indices(1))
l2 = list(h1.select(mi.pair_selection(1)))
l1.sort()
l2.sort()
assert l1 == l2
assert approx_equal(tuple(mi.plus(d0, d1)), (31, 12, 43, 24))
assert approx_equal(tuple(mi.minus(d0, d1)), (-29,-8,-37,-16))
assert approx_equal(tuple(mi.multiplies(d0, d1)), (30,20,120,80))
assert approx_equal(tuple(mi.divides(d0, d1)), (1/30.,2/10.,3/40.,4/20.))
assert approx_equal(tuple(mi.additive_sigmas(d0, d1)), [
math.sqrt(x*x+y*y) for x,y in ((1,30), (2,10), (3,40), (4,20))])
q = flex.size_t((3,2,0,4,1))
h1 = h0.select(q)
assert tuple(miller.match_indices(h1, h0).permutation()) == tuple(q)
p = miller.match_indices(h0, h1).permutation()
assert tuple(p) == (2,4,1,0,3)
assert tuple(h1.select(p)) == tuple(h0)
cd0 = [ complex(a,b) for (a,b) in ((1,1),(2,0),(3.5,-1.5),(5, -3),(-8,5.4)) ]
cd1 = [ complex(a,b) for (a,b) in ((1,-1),(2,1),(0.5,1.5),(-1, -8),(10,0)) ]
cd2 = flex.complex_double(cd0)
cd3 = flex.complex_double(cd1)
mi = miller.match_indices(h0, h0)
assert approx_equal(tuple(mi.plus(cd2,cd3)),
((2+0j), (4+1j), (4+0j), (4-11j), (2+5.4j)))
def exercise_1():
pdb_in = simple_pdb()
pdb_hierarchy = pdb_in.construct_hierarchy()
sites_cart = pdb_hierarchy.atoms().extract_xyz()
proxies = reference.add_coordinate_restraints(sites_cart=sites_cart)
assert proxies.size() == 29, "expected 29, got %d" % proxies.size()
import boost.python
ext = boost.python.import_ext("mmtbx_reference_coordinate_ext")
grads = flex.vec3_double(sites_cart.size(), (0.0,0.0,0.0))
residual = ext.reference_coordinate_residual_sum(
sites_cart=sites_cart,
proxies=proxies,
gradient_array=grads)
assert approx_equal(residual, 0.0)
#test selection
ca_selection = pdb_hierarchy.get_peptide_c_alpha_selection()
ca_sites_cart = sites_cart.select(ca_selection)
proxies = reference.add_coordinate_restraints(
sites_cart=ca_sites_cart,
selection=ca_selection)
assert proxies.size() == 3, "expected 3, got %d" % proxies.size()
tst_iselection = flex.size_t()
for atom in pdb_hierarchy.atoms():
if atom.name == " CA " or atom.name == " N ":
tst_iselection.append(atom.i_seq)
tst_sites_cart = sites_cart.select(tst_iselection)
proxies = reference.add_coordinate_restraints(
sites_cart=tst_sites_cart,
selection=tst_iselection)
assert proxies.size() == 6, "expected 6, got %d" % proxies.size()
#test remove
selection = flex.bool([False]*29)
proxies = proxies.proxy_remove(selection=selection)
assert proxies.size() == 6, "expected 6, got %d" % proxies.size()
proxies = proxies.proxy_remove(selection=ca_selection)
assert proxies.size() == 3, "expected 3, got %d" % proxies.size()
selection = flex.bool([True]*29)
proxies = proxies.proxy_remove(selection=selection)
assert proxies.size() == 0, "expected 0, got %d" % proxies.size()
def pack_variables(O, xray_structure=None):
if (xray_structure is None):
xray_structure = O.xray_structure
O.x = flex.double()
O.x_info = []
O.gact_indices = flex.size_t()
O.dynamic_shift_limits = []
site_limits = [
0.15 / p for p in xray_structure.unit_cell().parameters()[:3]
]
d_min = O.f_obs.d_min()
i_all = 0
sstab = xray_structure.site_symmetry_table()
for i_sc, sc in enumerate(xray_structure.scatterers()):
assert sc.flags.use_u_iso()
assert not sc.flags.use_u_aniso()
#
site_symmetry = sstab.get(i_sc)
if (site_symmetry.is_point_group_1()):
p = sc.site
l = site_limits
else:
p = site_symmetry.site_constraints().independent_params(
all_params=sc.site)
l = site_symmetry.site_constraints().independent_params(
all_params=site_limits)
O.x.extend(flex.double(p))
O.x_info.extend([(i_sc, "xyz"[i]) for i in xrange(len(p))])
O.dynamic_shift_limits.extend(
[dynamic_shift_limit_site(width=width) for width in l])
for i in xrange(len(p)):
O.gact_indices.append(i_all)
i_all += 1
#
O.x.append(sc.u_iso)
O.x_info.append((i_sc, "u"))
O.dynamic_shift_limits.append(
dynamic_shift_limit_u_iso(d_min=d_min))
O.gact_indices.append(i_all)
i_all += 1
#
i_all += 3 # occ, fp, fdp
def compute_step_using_curvs(O):
if (len(O.xfgc_infos) > 1 and O.params.use_gradient_flips):
prev = O.xfgc_infos[-2]
else:
prev = None
dests = flex.double()
approx_quads = flex.size_t()
if (O.params.try_approx_curvs):
O.approx_curvs()
for ix,dsl,g,c in zip(count(), O.dynamic_shift_limits, O.grads, O.curvs):
limit = dsl.pair(x=O.x[ix]).get(grad=g)
dest = None
if (prev is not None):
prev_g = prev.grads[ix]
if (sign0(g) != sign0(prev_g)):
x = O.x[ix]
prev_x = prev.x[ix]
xm = (g*prev_x - prev_g*x) / (g - prev_g)
dest = xm - x
if (dest > limit): dest = limit
elif (dest < -limit): dest = -limit
if (dest is None):
if (c > 0
and O.params.approx_quad_limit_factor > 0
and abs(g) < O.params.approx_quad_limit_factor * limit * c):
dest = -g / c
approx_quads.append(ix)
else:
dest = -delta_estimation_minus_cos(
limit=limit, grad=g, curv=c)
dests.append(dest)
O.xfgc_infos[-1].approx_quads = approx_quads
O.update_dests_using_bfgs_formula(dests)
O.x_before_line_search = O.xfgc_infos[-1].x
if (O.params.use_line_search):
dest_adj = O.line_search(dests, stpmax=1.0)
print "dest_adj:", dest_adj
if (dest_adj is not None and dest_adj < 1):
dests *= dest_adj
if (O.params.show_dests): O.show_dests(dests)
O.x = O.x_before_line_search + dests
O.update_fgc(is_iterate=True)
def compute_negate_mask(self, residue, radius):
residue_i_selection = residue.atoms().extract_i_seq()
residue_b_selection = flex.bool(self.sites_cart.size(), residue_i_selection)
selection_around_residue = self.special_position_settings.pair_generator(
sites_cart = self.sites_cart,
distance_cutoff = radius
).neighbors_of(primary_selection = residue_b_selection).iselection()
selection_around_residue_minus_residue = flex.size_t(
list(set(selection_around_residue).difference(
set(residue_i_selection)).difference(self.selection_water_as_set)))
sites_cart = self.sites_cart.select(selection_around_residue_minus_residue)
sites_frac_p1 = self.crystal_symmetry.unit_cell().fractionalize(
self.crystal_symmetry.expand_to_p1(sites_cart =
self.sites_cart.select(selection_around_residue_minus_residue)))
return cctbx_maptbx_ext.mask(
sites_frac = sites_frac_p1,
unit_cell = self.crystal_symmetry.cell_equivalent_p1().unit_cell(),
n_real = self.target_map.all(),
mask_value_inside_molecule = -10,
mask_value_outside_molecule = 0,
radii = flex.double(sites_frac_p1.size(), 2.))
def task_a(params):
# add an anchor
sampling_experiments_for_cosym = ExperimentList()
sampling_reflections_for_cosym = []
if params.modify.cosym.anchor:
from xfel.merging.application.model.crystal_model import crystal_model
#P = Timer("construct the anchor reference model")
XM = crystal_model(params=params, purpose="cosym")
model_intensities = XM.run([], [])
#del P
from dxtbx.model import Experiment, Crystal
from scitbx.matrix import sqr
O = sqr(model_intensities.unit_cell().orthogonalization_matrix()
).transpose().elems
real_a = (O[0], O[1], O[2])
real_b = (O[3], O[4], O[5])
real_c = (O[6], O[7], O[8])
nc = Crystal(real_a, real_b, real_c,
model_intensities.space_group())
sampling_experiments_for_cosym.append(
Experiment(crystal=nc)
) # prepends the reference model to the cosym E-list
from dials.array_family import flex
exp_reflections = flex.reflection_table()
exp_reflections['intensity.sum.value'] = model_intensities.data()
exp_reflections['intensity.sum.variance'] = flex.pow(
model_intensities.sigmas(), 2)
exp_reflections['miller_index'] = model_intensities.indices()
exp_reflections[
'miller_index_asymmetric'] = model_intensities.indices()
exp_reflections['flags'] = flex.size_t(
model_intensities.size(),
flex.reflection_table.flags.integrated_sum)
# prepare individual reflection tables for each experiment
cosym.experiment_id_detail(sampling_experiments_for_cosym,
sampling_reflections_for_cosym,
exp_reflections)
return sampling_experiments_for_cosym, sampling_reflections_for_cosym
def exclude_H_on_disulfides(self):
rm = self.model.get_restraints_manager()
bond_proxies_simple, asu = rm.geometry.get_all_bond_proxies(
sites_cart=self.model.get_sites_cart())
elements = self.model.get_hierarchy().atoms().extract_element()
ss_i_seqs = []
all_proxies = [p for p in bond_proxies_simple]
for proxy in asu:
all_proxies.append(proxy)
for proxy in all_proxies:
if (isinstance(proxy, ext.bond_simple_proxy)): i, j = proxy.i_seqs
elif (isinstance(proxy, ext.bond_asu_proxy)):
i, j = proxy.i_seq, proxy.j_seq
else:
assert 0 # never goes here
if ([
elements[i], elements[j]
].count("S") == 2): # XXX may be coordinated if metal edits used
ss_i_seqs.extend([i, j])
sel_remove = flex.size_t()
for proxy in all_proxies:
if (isinstance(proxy, ext.bond_simple_proxy)): i, j = proxy.i_seqs
elif (isinstance(proxy, ext.bond_asu_proxy)):
i, j = proxy.i_seq, proxy.j_seq
else:
assert 0 # never goes here
if (elements[i] in ["H", "D"] and j in ss_i_seqs):
sel_remove.append(i)
if (elements[j] in ["H", "D"] and i in ss_i_seqs):
sel_remove.append(j)
#
sl_disulfides = [
atom.id_str().replace('pdb=', '').replace('"', '')
for atom in self.model.get_hierarchy().atoms().select(sel_remove)
]
self.site_labels_disulfides = list(OrderedDict.fromkeys(sl_disulfides))
self.model = self.model.select(
~flex.bool(self.model.size(), sel_remove))
def map_to_grid(self, sweep, centroids):
b_iso = 200
beam = sweep.get_beam()
wavelength = beam.get_wavelength()
d_min = self.d_min
n_points = self.gridding[0]
rlgrid = 2 / (d_min * n_points)
# real space FFT grid dimensions
cell_lengths = [n_points * d_min / 2 for i in range(3)]
self.fft_cell = uctbx.unit_cell(cell_lengths + [90] * 3)
self.crystal_symmetry = crystal.symmetry(
unit_cell=self.fft_cell, space_group_symbol="P1"
)
print("FFT gridding: (%i,%i,%i)" % self.gridding)
grid = flex.double(flex.grid(self.gridding), 0)
reflections_used_for_indexing = flex.size_t()
for i_pnt, point in enumerate(centroids):
point = scitbx.matrix.col(point)
spot_resolution = 1 / point.length()
if spot_resolution < d_min:
continue
grid_coordinates = [
int(round(point[i] / rlgrid) + n_points / 2) for i in range(3)
]
if max(grid_coordinates) >= n_points:
continue # this reflection is outside the grid
if min(grid_coordinates) < 0:
continue # this reflection is outside the grid
T = math.exp(b_iso * point.length() ** 2 / 4)
grid[grid_coordinates] = T
self.reciprocal_space_grid = grid
def extract_residues(self,
model_i,
number_previous_scatters,
combine=True):
result = []
model = self.pdb_hierarchy.models()[model_i]
rm = []
for chain in model.chains():
for rg in chain.residue_groups():
rg_i_seqs = []
r_name = None
for ag in rg.atom_groups():
if (r_name is None): r_name = ag.resname
for atom in ag.atoms():
if (self.selection[atom.i_seq -
number_previous_scatters]):
rg_i_seqs.append(atom.i_seq -
number_previous_scatters)
if (len(rg_i_seqs) != 0):
rm.append(
group_args(selection=flex.size_t(rg_i_seqs),
name=r_name,
model_id=model_i,
resid=rg.resid(),
chain_id=chain.id))
result.append(rm)
if (combine):
r0 = result[0]
for r in result[1:]:
for i, ri in enumerate(r):
r0[i].selection.extend(ri.selection)
assert r0[i].name == ri.name
else:
r0 = result[0]
for r in result[1:]:
r0.extend(r)
return r0
def fit_c_beta(self, c_beta_rotation_cluster):
selection = flex.size_t(c_beta_rotation_cluster.selection)
sites_cart = self.residue.atoms().extract_xyz()
start_target_value = self.get_target_value(
sites_cart=sites_cart,
selection=selection,
target_map=self.target_map_for_cb)
ro = ext.fit(
target_value=start_target_value,
axes=[c_beta_rotation_cluster.axis],
rotatable_points_indices=[c_beta_rotation_cluster.atoms_to_rotate],
angles_array=[[i * math.pi / 180] for i in range(-20, 21, 1)],
density_map=self.target_map_for_cb,
all_points=sites_cart,
unit_cell=self.unit_cell,
selection=selection,
sin_table=self.sin_cos_table.sin_table,
cos_table=self.sin_cos_table.cos_table,
step=self.sin_cos_table.step,
n=self.sin_cos_table.n)
sites_cart_result = ro.result()
if (sites_cart_result.size() > 0):
self.residue.atoms().set_xyz(sites_cart_result)
def exclude_h_on_SS(model):
rm = model.get_restraints_manager()
bond_proxies_simple, asu = rm.geometry.get_all_bond_proxies(
sites_cart = model.get_sites_cart())
els = model.get_hierarchy().atoms().extract_element()
ss_i_seqs = []
all_proxies = [p for p in bond_proxies_simple]
for proxy in asu:
all_proxies.append(proxy)
for proxy in all_proxies:
if( isinstance(proxy, ext.bond_simple_proxy)): i,j=proxy.i_seqs
elif(isinstance(proxy, ext.bond_asu_proxy)): i,j=proxy.i_seq,proxy.j_seq
else: assert 0 # never goes here
if([els[i],els[j]].count("S")==2): # XXX may be coordinated if metal edits used
ss_i_seqs.extend([i,j])
sel_remove = flex.size_t()
for proxy in all_proxies:
if( isinstance(proxy, ext.bond_simple_proxy)): i,j=proxy.i_seqs
elif(isinstance(proxy, ext.bond_asu_proxy)): i,j=proxy.i_seq,proxy.j_seq
else: assert 0 # never goes here
if(els[i] in ["H","D"] and j in ss_i_seqs): sel_remove.append(i)
if(els[j] in ["H","D"] and i in ss_i_seqs): sel_remove.append(j)
return model.select(~flex.bool(model.size(), sel_remove))
def exercise_zeolite_atlas(distance_cutoff=3.5):
atlas_file = libtbx.env.find_in_repositories(
relative_path="phenix_regression/misc/strudat_zeolite_atlas",
test=os.path.isfile)
if (atlas_file is None):
print("Skipping exercise_zeolite_atlas(): input file not available")
return
all_entries = strudat.read_all_entries(open(atlas_file))
for i, entry in enumerate(all_entries.entries):
structure = entry.as_xray_structure()
if ("--full" in sys.argv[1:] or i % 20 == 0):
tst_direct_space_asu.exercise_neighbors_pair_generators(
structure=structure, verbose="--Verbose" in sys.argv[1:])
asu_mappings = structure.asu_mappings(buffer_thickness=distance_cutoff)
pair_generator = crystal.neighbors_fast_pair_generator(
asu_mappings=asu_mappings, distance_cutoff=distance_cutoff)
bond_counts = flex.size_t(structure.scatterers().size(), 0)
for pair in pair_generator:
bond_counts[pair.i_seq] += 1
if (pair.j_sym == 0):
bond_counts[pair.j_seq] += 1
for atom, bond_count in zip(entry.atoms, bond_counts):
assert atom.connectivity is not None
assert atom.connectivity == bond_count
def optimise_parameters(self, fo_sq, fc_sq,
scale_factor, n_independent_params):
""" Find optimal values of a and b that give a flat analysis of the variance
when binned by Fc/max(Fc), and a goodness of fit close to 1.
This is done in a grid search fashion similar to Shelxl.
self is not modified in place; instead a new instance of the weighting
scheme is returned.
It is intended that f_calc should already contain the contribution from
f_mask (if a solvent mask is used).
"""
assert fc_sq.is_xray_intensity_array()
weighting = ext.mainstream_shelx_weighting(a=self.a, b=self.b)
def compute_chi_sq(fo_sq, fc_sq, a,b):
weighting.a = a
weighting.b = b
weights = weighting(
fo_sq.data(), fo_sq.sigmas(), fc_sq.data(), scale_factor)
return (flex.sum(
weights * flex.pow2(fo_sq.data() - scale_factor * fc_sq.data())))
fo_sq = fo_sq.deep_copy()
fo_sq.data().set_selected(fo_sq.data() < 0, 0)
fo2 = fo_sq.data().deep_copy()
fo2 /= scale_factor
sigmas = fo_sq.sigmas() / scale_factor
sigmas_sq = flex.pow2(sigmas)
fc2 = fc_sq.data()
# determine starting values for a and b, formulae taken from shelxl code
p = (fo2 + 2 * fc2)/3
p_sq = flex.pow2(p)
x = flex.sum((flex.pow2(fo2-fc2)-sigmas) * (p_sq/sigmas_sq))
y = flex.sum( flex.pow2(p_sq)/sigmas_sq)
z = flex.sum(p)
start_a = math.sqrt(max(0.0001, 0.64*x/max(1e-8, y)))
start_b = 0.5 * z * start_a**2 /fo_sq.size()
a_step = 0.2 * start_a
b_step = 0.4 * start_b
# sort data and setup binning by fc/fc_max
fc_sq_over_fc_sq_max = fc_sq.data()/flex.max(fc_sq.data())
permutation = flex.sort_permutation(fc_sq_over_fc_sq_max)
fc_sq_over_fc_sq_max = fc_sq.customized_copy(
data=fc_sq_over_fc_sq_max).select(permutation)
fc_sq = fc_sq.select(permutation)
fo_sq = fo_sq.select(permutation)
n_bins = 10
bin_max = 0
bin_limits = flex.size_t(1, 0)
bin_count = flex.size_t()
for i in range(n_bins):
bin_limits.append(int(math.ceil((i+1) * fc_sq.size()/n_bins)))
bin_count.append(bin_limits[i+1] - bin_limits[i])
n = fo_sq.size()//(fo_sq.size()-n_independent_params)
# search on a 9x9 grid to determine best values of a and b
gridding = flex.grid(9,9)
while (a_step > 1e-4 and b_step > 5e-3):
tmp = flex.double(gridding, 0)
binned_chi_sq = [tmp.deep_copy() for i in range(n_bins)]
start_a = max(start_a, 4*a_step) - 4*a_step
start_b = max(start_b, 4*b_step) - 4*b_step
for i_bin in range(n_bins):
sel = flex.size_t_range(bin_limits[i_bin], bin_limits[i_bin+1])
fc2 = fc_sq.select(sel)
fo2 = fo_sq.select(sel)
b = start_b
for j in range(9):
a = start_a
b += b_step
for k in range(9):
a += a_step
binned_chi_sq[i_bin][j,k] += compute_chi_sq(fo2, fc2, a, b)
min_variance = 9e9
j_min, k_min = (0, 0)
for j in range(9):
for k in range(9):
variance = 0
for i_bin in range(n_bins):
if bin_count[i_bin] == 0: continue
goof = math.sqrt(binned_chi_sq[i_bin][j,k]*n/bin_count[i_bin])
variance += (goof-1)**2
min_variance = min(variance, min_variance)
if variance == min_variance:
j_min = j
k_min = k
start_a += k_min*a_step
start_b += j_min*b_step
if k_min == 8:
a_step *= 2
continue
elif k_min != 0:
a_step /= 4
if j_min == 8:
b_step *= 2
continue
elif j_min != 0:
b_step /=4
if start_a <= 1e-4: a_step /= 4
if start_b <= 1e-3: b_step /= 4
if start_a > 0.2:
start_a = 0.2
start_b = 0
weighting.a = start_a
weighting.b = start_b
return weighting
def exercise():
verbose = "--verbose" in sys.argv[1:]
quick = "--quick" in sys.argv[1:]
list_cif = server.mon_lib_list_cif()
srv = server.server(list_cif=list_cif)
print("srv.root_path:", srv.root_path)
default_switch = "--default_off" not in sys.argv[1:]
if (False or default_switch):
monomers_with_commas = {}
atom_id_counts = dicts.with_default_value(0)
for row_id in list_cif.cif["comp_list"]["_chem_comp.id"]:
if (quick and random.random() < 0.95): continue
if (verbose): print("id:", row_id)
comp_comp_id = srv.get_comp_comp_id_direct(comp_id=row_id)
if (comp_comp_id is None):
print("Could not instantiating comp_comp_id(%s)" % row_id)
else:
has_primes = False
has_commas = False
for atom in comp_comp_id.atom_list:
atom_id_counts[atom.atom_id] += 1
if (atom.atom_id.find("'") >= 0):
has_primes = True
if (atom.atom_id.find(",") >= 0):
has_commas = True
if (has_commas):
monomers_with_commas[
comp_comp_id.chem_comp.id] = has_primes
print(monomers_with_commas)
atom_ids = flex.std_string(list(atom_id_counts.keys()))
counts = flex.size_t(list(atom_id_counts.values()))
perm = flex.sort_permutation(data=counts, reverse=True)
atom_ids = atom_ids.select(perm)
counts = counts.select(perm)
for atom_id, count in zip(atom_ids, counts):
print(atom_id, count)
if (False or default_switch):
for row in list_cif.cif["comp_list"]["_chem_comp"].iterrows():
if (quick and random.random() < 0.95): continue
if (verbose): print("id:", row["_chem_comp.id"])
comp_comp_id = srv.get_comp_comp_id_direct(
comp_id=row["_chem_comp.id"])
check_chem_comp(cif_types.chem_comp(**row), comp_comp_id)
if ("--pickle" in sys.argv[1:]):
easy_pickle.dump("mon_lib.pickle", srv)
if (False or default_switch):
comp = srv.get_comp_comp_id_direct("GLY")
comp.show()
mod = srv.mod_mod_id_dict["COO"]
comp.apply_mod(mod).show()
if (False or default_switch):
comp = srv.get_comp_comp_id_direct("LYS")
comp.show()
mod = srv.mod_mod_id_dict["B2C"]
comp.apply_mod(mod).show()
if (False or default_switch):
for row in list_cif.cif["comp_list"]["_chem_comp"].iterrows():
if (quick and random.random() < 0.95): continue
comp_comp_id = srv.get_comp_comp_id_direct(row["_chem_comp.id"])
if (comp_comp_id is not None):
if (comp_comp_id.classification == "peptide"):
print(comp_comp_id.chem_comp.id,
comp_comp_id.chem_comp.name,
end=' ')
print(row["_chem_comp.group"], end=' ')
grp = row["_chem_comp.group"].lower().strip()
if (grp not in ("l-peptide", "d-peptide", "polymer")):
print("LOOK", end=' ')
#if (not os.path.isdir("look")): os.makedirs("look")
#open("look/%s.cif" % row["_chem_comp.id"], "w").write(
#open(comp_comp_id.file_name).read())
print()
elif (row["_chem_comp.group"].lower().find("peptide") >= 0
or comp_comp_id.chem_comp.group.lower().find("peptide")
>= 0):
print(comp_comp_id.chem_comp.id,
comp_comp_id.chem_comp.name,
end=' ')
print(row["_chem_comp.group"], "MISMATCH")
if (comp_comp_id.classification in ("RNA", "DNA")):
print(comp_comp_id.chem_comp.id,
comp_comp_id.chem_comp.name,
end=' ')
print(row["_chem_comp.group"], end=' ')
if (comp_comp_id.classification !=
row["_chem_comp.group"].strip()):
print(comp_comp_id.classification, "MISMATCH", end=' ')
print()
elif (row["_chem_comp.group"].lower().find("NA") >= 0
or comp_comp_id.chem_comp.group.lower().find("NA") >= 0):
print(comp_comp_id.chem_comp.id,
comp_comp_id.chem_comp.name,
end=' ')
print(row["_chem_comp.group"], "MISMATCH")
if (False or default_switch):
for row in list_cif.cif["comp_list"]["_chem_comp"].iterrows():
if (quick and random.random() < 0.95): continue
comp_comp_id = srv.get_comp_comp_id_direct(row["_chem_comp.id"])
if (comp_comp_id is not None):
planes = comp_comp_id.get_planes()
for plane in planes:
dist_esd_dict = {}
for plane_atom in plane.plane_atoms:
dist_esd_dict[str(plane_atom.dist_esd)] = 0
# FIXME: might break compat for py2/3 because indexing a values call
if (len(dist_esd_dict) != 1
or list(dist_esd_dict.keys())[0] != "0.02"):
print(comp_comp_id.chem_comp.id,
plane.plane_id,
end=' ')
print(list(dist_esd_dict.keys()))
if (False or default_switch):
standard_amino_acids = [
"GLY", "VAL", "ALA", "LEU", "ILE", "PRO", "MET", "PHE", "TRP",
"SER", "THR", "TYR", "CYS", "ASN", "GLN", "ASP", "GLU", "LYS",
"ARG", "HIS"
]
for row in list_cif.cif["comp_list"]["_chem_comp"].iterrows():
is_standard_aa = row["_chem_comp.id"] in standard_amino_acids
if (1 and not is_standard_aa):
continue
comp_comp_id = srv.get_comp_comp_id_direct(row["_chem_comp.id"])
if (is_standard_aa):
assert comp_comp_id is not None
assert comp_comp_id.chem_comp.group.strip() == "L-peptide"
if (comp_comp_id is not None):
print(comp_comp_id.chem_comp.id.strip(), end=' ')
print(comp_comp_id.chem_comp.name.strip(), end=' ')
print(comp_comp_id.chem_comp.group.strip())
for tor in comp_comp_id.tor_list:
print(" tor:", tor.atom_id_1, tor.atom_id_2, end=' ')
print(tor.atom_id_3,
tor.atom_id_4,
tor.value_angle,
end=' ')
print(tor.value_angle_esd, tor.period)
for chir in comp_comp_id.chir_list:
print(" chir:",
chir.atom_id_centre,
chir.atom_id_1,
end=' ')
print(chir.atom_id_2, chir.atom_id_3, chir.volume_sign)
if (False or default_switch):
elib = server.ener_lib()
if (False or default_switch):
for syn in elib.lib_synonym.items():
print(syn)
if (False or default_switch):
for vdw in elib.lib_vdw:
vdw.show()
print("OK")
def scale_frame_detail(self, result, file_name, db_mgr, out):
# If the pickled integration file does not contain a wavelength,
# fall back on the value given on the command line. XXX The
# wavelength parameter should probably be removed from master_phil
# once all pickled integration files contain it.
if ("wavelength" in result):
wavelength = result["wavelength"]
elif (self.params.wavelength is not None):
wavelength = self.params.wavelength
else:
# XXX Give error, or raise exception?
return None
assert (wavelength > 0)
observations = result["observations"][0]
cos_two_polar_angle = result["cos_two_polar_angle"]
assert observations.size() == cos_two_polar_angle.size()
tt_vec = observations.two_theta(wavelength)
#print "mean tt degrees",180.*flex.mean(tt_vec.data())/math.pi
cos_tt_vec = flex.cos(tt_vec.data())
sin_tt_vec = flex.sin(tt_vec.data())
cos_sq_tt_vec = cos_tt_vec * cos_tt_vec
sin_sq_tt_vec = sin_tt_vec * sin_tt_vec
P_nought_vec = 0.5 * (1. + cos_sq_tt_vec)
F_prime = -1.0 # Hard-coded value defines the incident polarization axis
P_prime = 0.5 * F_prime * cos_two_polar_angle * sin_sq_tt_vec
# XXX added as a diagnostic
prange = P_nought_vec - P_prime
other_F_prime = 1.0
otherP_prime = 0.5 * other_F_prime * cos_two_polar_angle * sin_sq_tt_vec
otherprange = P_nought_vec - otherP_prime
diff2 = flex.abs(prange - otherprange)
print "mean diff is", flex.mean(diff2), "range", flex.min(
diff2), flex.max(diff2)
# XXX done
observations = observations / (P_nought_vec - P_prime)
# This corrects observations for polarization assuming 100% polarization on
# one axis (thus the F_prime = -1.0 rather than the perpendicular axis, 1.0)
# Polarization model as described by Kahn, Fourme, Gadet, Janin, Dumas & Andre
# (1982) J. Appl. Cryst. 15, 330-337, equations 13 - 15.
print "Step 3. Correct for polarization."
indexed_cell = observations.unit_cell()
observations_original_index = observations.deep_copy()
if result.get(
"model_partialities", None
) is not None and result["model_partialities"][0] is not None:
# some recordkeeping useful for simulations
partialities_original_index = observations.customized_copy(
crystal_symmetry=self.miller_set.crystal_symmetry(),
data=result["model_partialities"][0]["data"],
sigmas=flex.double(result["model_partialities"][0]
["data"].size()), #dummy value for sigmas
indices=result["model_partialities"][0]["indices"],
).resolution_filter(d_min=self.params.d_min)
assert len(observations_original_index.indices()) == len(
observations.indices())
# Now manipulate the data to conform to unit cell, asu, and space group
# of reference. The resolution will be cut later.
# Only works if there is NOT an indexing ambiguity!
observations = observations.customized_copy(
anomalous_flag=not self.params.merge_anomalous,
crystal_symmetry=self.miller_set.crystal_symmetry()).map_to_asu()
observations_original_index = observations_original_index.customized_copy(
anomalous_flag=not self.params.merge_anomalous,
crystal_symmetry=self.miller_set.crystal_symmetry())
print "Step 4. Filter on global resolution and map to asu"
print >> out, "Data in reference setting:"
#observations.show_summary(f=out, prefix=" ")
show_observations(observations, out=out)
#if self.params.significance_filter.apply is True:
# raise Exception("significance filter not implemented in samosa")
if self.params.significance_filter.apply is True: #------------------------------------
# Apply an I/sigma filter ... accept resolution bins only if they
# have significant signal; tends to screen out higher resolution observations
# if the integration model doesn't quite fit
N_obs_pre_filter = observations.size()
N_bins_small_set = N_obs_pre_filter // self.params.significance_filter.min_ct
N_bins_large_set = N_obs_pre_filter // self.params.significance_filter.max_ct
# Ensure there is at least one bin.
N_bins = max([
min([self.params.significance_filter.n_bins,
N_bins_small_set]), N_bins_large_set, 1
])
print "Total obs %d Choose n bins = %d" % (N_obs_pre_filter,
N_bins)
bin_results = show_observations(observations,
out=out,
n_bins=N_bins)
#show_observations(observations, out=sys.stdout, n_bins=N_bins)
acceptable_resolution_bins = [
bin.mean_I_sigI > self.params.significance_filter.sigma
for bin in bin_results
]
acceptable_nested_bin_sequences = [
i for i in xrange(len(acceptable_resolution_bins))
if False not in acceptable_resolution_bins[:i + 1]
]
if len(acceptable_nested_bin_sequences) == 0:
return null_data(file_name=file_name,
log_out=out.getvalue(),
low_signal=True)
else:
N_acceptable_bins = max(acceptable_nested_bin_sequences) + 1
imposed_res_filter = float(bin_results[N_acceptable_bins -
1].d_range.split()[2])
imposed_res_sel = observations.resolution_filter_selection(
d_min=imposed_res_filter)
observations = observations.select(imposed_res_sel)
observations_original_index = observations_original_index.select(
imposed_res_sel)
print "New resolution filter at %7.2f" % imposed_res_filter, file_name
print "N acceptable bins", N_acceptable_bins
print "Old n_obs: %d, new n_obs: %d" % (N_obs_pre_filter,
observations.size())
print "Step 5. Frame by frame resolution filter"
# Finished applying the binwise I/sigma filter---------------------------------------
if self.params.raw_data.sdfac_auto is True:
raise Exception("sdfac auto not implemented in samosa.")
print "Step 6. Match to reference intensities, filter by correlation, filter out negative intensities."
assert len(observations_original_index.indices()) \
== len(observations.indices())
data = frame_data(self.n_refl, file_name)
data.set_indexed_cell(indexed_cell)
data.d_min = observations.d_min()
# Ensure that match_multi_indices() will return identical results
# when a frame's observations are matched against the
# pre-generated Miller set, self.miller_set, and the reference
# data set, self.i_model. The implication is that the same match
# can be used to map Miller indices to array indices for intensity
# accumulation, and for determination of the correlation
# coefficient in the presence of a scaling reference.
if self.i_model is not None:
assert len(self.i_model.indices()) == len(self.miller_set.indices()) \
and (self.i_model.indices() ==
self.miller_set.indices()).count(False) == 0
matches = miller.match_multi_indices(
miller_indices_unique=self.miller_set.indices(),
miller_indices=observations.indices())
use_weights = False # New facility for getting variance-weighted correlation
if self.params.scaling.algorithm in ['mark1', 'levmar']:
# Because no correlation is computed, the correlation
# coefficient is fixed at zero. Setting slope = 1 means
# intensities are added without applying a scale factor.
sum_x = 0
sum_y = 0
for pair in matches.pairs():
data.n_obs += 1
if not self.params.include_negatives and observations.data()[
pair[1]] <= 0:
data.n_rejected += 1
else:
sum_y += observations.data()[pair[1]]
N = data.n_obs - data.n_rejected
# Early return if there are no positive reflections on the frame.
if data.n_obs <= data.n_rejected:
return null_data(file_name=file_name,
log_out=out.getvalue(),
low_signal=True)
# Update the count for each matched reflection. This counts
# reflections with non-positive intensities, too.
data.completeness += matches.number_of_matches(0).as_int()
data.wavelength = wavelength
if not self.params.scaling.enable: # Do not scale anything
print "Scale factor to an isomorphous reference PDB will NOT be applied."
slope = 1.0
offset = 0.0
observations_original_index_indices = observations_original_index.indices(
)
if db_mgr is None:
return unpack(MINI.x) # special exit for two-color indexing
kwargs = {
'wavelength': wavelength,
'beam_x': result['xbeam'],
'beam_y': result['ybeam'],
'distance': result['distance'],
'unique_file_name': data.file_name
}
ORI = result["current_orientation"][0]
Astar = matrix.sqr(ORI.reciprocal_matrix())
kwargs['res_ori_1'] = Astar[0]
kwargs['res_ori_2'] = Astar[1]
kwargs['res_ori_3'] = Astar[2]
kwargs['res_ori_4'] = Astar[3]
kwargs['res_ori_5'] = Astar[4]
kwargs['res_ori_6'] = Astar[5]
kwargs['res_ori_7'] = Astar[6]
kwargs['res_ori_8'] = Astar[7]
kwargs['res_ori_9'] = Astar[8]
assert self.params.scaling.report_ML is True
kwargs['half_mosaicity_deg'] = result["ML_half_mosaicity_deg"][0]
kwargs['domain_size_ang'] = result["ML_domain_size_ang"][0]
frame_id_0_base = db_mgr.insert_frame(**kwargs)
xypred = result["mapped_predictions"][0]
indices = flex.size_t([pair[1] for pair in matches.pairs()])
sel_observations = flex.intersection(size=observations.data().size(),
iselections=[indices])
set_original_hkl = observations_original_index_indices.select(
flex.intersection(size=observations_original_index_indices.size(),
iselections=[indices]))
set_xypred = xypred.select(
flex.intersection(size=xypred.size(), iselections=[indices]))
kwargs = {
'hkl_id_0_base': [pair[0] for pair in matches.pairs()],
'i': observations.data().select(sel_observations),
'sigi': observations.sigmas().select(sel_observations),
'detector_x': [xy[0] for xy in set_xypred],
'detector_y': [xy[1] for xy in set_xypred],
'frame_id_0_base': [frame_id_0_base] * len(matches.pairs()),
'overload_flag': [0] * len(matches.pairs()),
'original_h': [hkl[0] for hkl in set_original_hkl],
'original_k': [hkl[1] for hkl in set_original_hkl],
'original_l': [hkl[2] for hkl in set_original_hkl]
}
db_mgr.insert_observation(**kwargs)
print >> out, "Lattice: %d reflections" % (data.n_obs -
data.n_rejected)
print >> out, "average obs", sum_y / (data.n_obs - data.n_rejected), \
"average calc", sum_x / (data.n_obs - data.n_rejected)
print >> out, "Rejected %d reflections with negative intensities" % \
data.n_rejected
data.accept = True
for pair in matches.pairs():
if not self.params.include_negatives and (
observations.data()[pair[1]] <= 0):
continue
Intensity = observations.data()[pair[1]]
# Super-rare exception. If saved sigmas instead of I/sigmas in the ISIGI dict, this wouldn't be needed.
if Intensity == 0:
continue
# Add the reflection as a two-tuple of intensity and I/sig(I)
# to the dictionary of observations.
index = self.miller_set.indices()[pair[0]]
isigi = (Intensity, observations.data()[pair[1]] /
observations.sigmas()[pair[1]], 1.0)
if index in data.ISIGI:
data.ISIGI[index].append(isigi)
else:
data.ISIGI[index] = [isigi]
sigma = observations.sigmas()[pair[1]]
variance = sigma * sigma
data.summed_N[pair[0]] += 1
data.summed_wt_I[pair[0]] += Intensity / variance
data.summed_weight[pair[0]] += 1 / variance
data.set_log_out(out.getvalue())
return data
def occupancy_selections(
model,
add_water = False,
other_individual_selection_strings = None,
other_constrained_groups = None,
remove_selection = None,
as_flex_arrays = True,
constrain_correlated_3d_groups = False,
log = None):
# set up defaults
if(other_individual_selection_strings is not None and
len(other_individual_selection_strings) == 0):
other_individual_selection_strings = None
if(other_constrained_groups is not None and
len(other_constrained_groups) == 0):
other_constrained_groups = None
if(remove_selection is not None and len(remove_selection) == 0):
remove_selection = None
result = model.get_hierarchy().occupancy_groups_simple(
common_residue_name_class_only = None,
always_group_adjacent = False,
ignore_hydrogens = False)
exchangable_hd_pairs = mmtbx.utils.combine_hd_exchangable(hierarchy =
model.get_hierarchy())
if(len(exchangable_hd_pairs)==0 and result is not None):
occupancy_regroupping(
pdb_hierarchy = model.get_hierarchy(),
cgs = result)
result = mmtbx.utils.remove_selections(selection = result,
other = exchangable_hd_pairs,
size = model.get_number_of_atoms())
result.extend(exchangable_hd_pairs)
# extract group-[0,1]-constrained atoms withing a residue
pogl = extract_partial_occupancy_selections(hierarchy = model.get_hierarchy())
rm_duplicate_with_pogl = []
for t_ in pogl:
for t__ in t_:
for t___ in t__:
rm_duplicate_with_pogl.append(t___)
result = mmtbx.utils.remove_selections(selection = result, other = pogl,
size = model.get_number_of_atoms())
result.extend(pogl)
# add partial occupancies
occupancies = model.get_xray_structure().scatterers().extract_occupancies()
sel = (occupancies != 1.) & (occupancies != 0.)
result = add_occupancy_selection(
result = result,
size = model.get_number_of_atoms(),
selection = sel,
hd_special = None)
# check user's input
all_sel_strgs = []
if(other_individual_selection_strings is not None):
all_sel_strgs = all_sel_strgs + other_individual_selection_strings
if(other_constrained_groups is not None):
for other_constrained_group in other_constrained_groups:
for other_constrained_group in other_constrained_groups:
if(len(other_constrained_group.selection)>0):
all_sel_strgs = all_sel_strgs + other_constrained_group.selection
if(len(all_sel_strgs) > 0):
for sel_str in all_sel_strgs:
sel_str_sel = get_atom_selections(
model = model,
selection_strings = [sel_str],
iselection = True,
one_selection_array = True)
if(sel_str_sel.size() == 0):
raise Sorry("Empty selection: %s"%sel_str)
#
if([other_individual_selection_strings,
other_constrained_groups].count(None) == 0):
sel1 = get_atom_selections(
model = model,
selection_strings = other_individual_selection_strings,
iselection = True,
one_selection_array = True)
for other_constrained_group in other_constrained_groups:
for other_constrained_group in other_constrained_groups:
for cg_sel_strs in other_constrained_group.selection:
sel2 = get_atom_selections(
model = model,
selection_strings = cg_sel_strs,
iselection = True,
one_selection_array = True)
if(sel1.intersection(sel2).size() > 0):
raise Sorry("Duplicate selection: same atoms selected for individual and group occupancy refinement.")
# check user's input and apply remove_selection to default selection
if(remove_selection is not None):
sel1 = get_atom_selections(
model = model,
selection_strings = remove_selection,
iselection = True,
one_selection_array = True)
if(sel1.size() == 0): # XXX check all and not total.
raise Sorry("Empty selection: remove_selection.")
if(other_individual_selection_strings is not None):
sel2 = get_atom_selections(
model = model,
selection_strings = other_individual_selection_strings,
iselection = True,
one_selection_array = True)
if(sel1.intersection(sel2).size() > 0):
raise Sorry("Duplicate selection: occupancies of same atoms selected to be fixed and to be refined.")
if(other_constrained_groups is not None):
for other_constrained_group in other_constrained_groups:
for cg_sel_strs in other_constrained_group.selection:
sel2 = get_atom_selections(
model = model,
selection_strings = cg_sel_strs,
iselection = True,
one_selection_array = True)
if(sel1.intersection(sel2).size() > 0):
raise Sorry("Duplicate selection: occupancies of same atoms selected to be fixed and to be refined.")
result = mmtbx.utils.remove_selections(selection = result, other = sel1,
size = model.get_number_of_atoms())
#
if(other_individual_selection_strings is not None):
sel = get_atom_selections(
model = model,
selection_strings = other_individual_selection_strings,
iselection = True,
one_selection_array = True)
result = mmtbx.utils.remove_selections(selection = result, other = sel,
size = model.get_number_of_atoms())
result = add_occupancy_selection(
result = result,
size = model.get_number_of_atoms(),
selection = sel,
hd_special = None)
if(other_constrained_groups is not None):
for other_constrained_group in other_constrained_groups:
cg_sel = []
for cg_sel_strs in other_constrained_group.selection:
sel = get_atom_selections(
model = model,
selection_strings = cg_sel_strs,
iselection = True,
one_selection_array = True)
result = mmtbx.utils.remove_selections(selection = result, other = sel,
size = model.get_number_of_atoms())
if(sel.size() > 0):
cg_sel.append(list(sel))
if(len(cg_sel) > 0):
result.append(cg_sel)
if(add_water):
water_selection = get_atom_selections(
model = model,
selection_strings = ['water'],
iselection = True,
allow_empty_selection = True,
one_selection_array = True)
result = add_occupancy_selection(
result = result,
size = model.get_number_of_atoms(),
selection = water_selection,
hd_special = None)
list_3d_as_bool_selection(
list_3d=result, size=model.get_number_of_atoms())
if(len(result) == 0): result = None
if(as_flex_arrays and result is not None):
result_ = []
for gsel in result:
result__ = []
for sel in gsel:
result__.append(flex.size_t(sel))
result_.append(result__)
result = result_
if (constrain_correlated_3d_groups) and (len(result) > 0):
result = assemble_constraint_groups_3d(
xray_structure=model.get_xray_structure(),
pdb_atoms=model.get_atoms(),
constraint_groups=result,
log=log)
return result
def __init__(self, fmodels,
model,
max_number_of_iterations = 25,
number_of_macro_cycles = 3,
occupancy_max = None,
occupancy_min = None,
log = None,
exclude_hd = False):
self.show(fmodels=fmodels, log= log, message="occupancy refinement: start")
fmodels.update_xray_structure(xray_structure = model.get_xray_structure(),
update_f_calc = True)
selections = model.refinement_flags.s_occupancies
# exclude H or D from refinement if requested
if(exclude_hd):
hd_sel = model.get_hd_selection()
tmp_sel = []
for sel in selections:
tmp_sel_ = []
for sel_ in sel:
tmp_sel__ = flex.size_t()
for sel__ in sel_:
if(not hd_sel[sel__]):
tmp_sel__.append(sel__)
if(tmp_sel__.size()>0):
tmp_sel_.append(tmp_sel__)
if(len(tmp_sel_)>0):
tmp_sel.append(tmp_sel_)
selections = tmp_sel
#
if(len(selections)>0):
i_selection = flex.size_t()
for s in selections:
for ss in s:
i_selection.extend(ss)
fmodels.fmodel_xray().xray_structure.scatterers().flags_set_grads(
state=False)
fmodels.fmodel_xray().xray_structure.scatterers().flags_set_grad_occupancy(
iselection = i_selection)
fmodels.fmodel_xray().xray_structure.adjust_occupancy(
occ_max = occupancy_max,
occ_min = occupancy_min,
selection = i_selection)
xray_structure_dc = fmodels.fmodel_xray().xray_structure.\
deep_copy_scatterers()
par_initial = flex.double()
occupancies = xray_structure_dc.scatterers().extract_occupancies()
constrained_groups_selections = []
group_counter = 0
for sel in selections:
ss = []
for sel_ in sel:
ss.append(group_counter)
group_counter += 1
val = flex.mean(occupancies.select(sel_))
par_initial.append(val)
constrained_groups_selections.append(ss)
minimized = None
for macro_cycle in range(number_of_macro_cycles):
if(minimized is not None): par_initial = minimized.par_min
minimized = minimizer(
fmodels = fmodels,
selections = selections,
constrained_groups_selections = constrained_groups_selections,
par_initial = par_initial,
max_number_of_iterations = max_number_of_iterations)
if(minimized is not None): par_initial = minimized.par_min
set_refinable_parameters(
xray_structure = fmodels.fmodel_xray().xray_structure,
parameters = par_initial,
selections = selections,
enforce_positivity = (occupancy_min>=0))
fmodels.fmodel_xray().xray_structure.adjust_occupancy(
occ_max = occupancy_max,
occ_min = occupancy_min,
selection = i_selection)
xray_structure_final = fmodels.fmodel_xray().xray_structure
model.set_xray_structure(xray_structure_final)
fmodels.update_xray_structure(xray_structure = xray_structure_final,
update_f_calc = True)
refined_occ = xray_structure_final.scatterers().extract_occupancies().\
select(i_selection)
assert flex.min(refined_occ) >= occupancy_min
assert flex.max(refined_occ) <= occupancy_max
self.show(fmodels= fmodels, log = log, message="occupancy refinement: end")
def run(args):
from cctbx.array_family import flex
from dials.util.options import OptionParser
from dials.util.options import flatten_reflections
import libtbx.load_env
usage = "%s [options] reflections_1.pickle reflections_2.pickle" % (
libtbx.env.dispatcher_name)
parser = OptionParser(usage=usage,
phil=phil_scope,
read_reflections=True,
epilog=help_message)
params, options, args = parser.parse_args(show_diff_phil=True,
return_unhandled=True)
reflections = flatten_reflections(params.input.reflections)
if flex.max(reflections[0]["id"]) > 0:
reflections = list(reversed(reflections))
assert flex.max(reflections[0]["id"]) == 0
assert len(reflections) == 2
partialities = []
intensities = []
sigmas = []
ids = []
xyz = []
# only want fully-recorded reflections in full dataset
# reflections[0] = reflections[0].select(reflections[0]['partiality'] > 0.99)
print(reflections[0].size())
# only want partial reflections in sliced dataset
# reflections[1] = reflections[1].select(reflections[1]['partiality'] < 0.99)
print(reflections[1].size())
for refl in reflections:
# sel = refl.get_flags(refl.flags.integrated_sum)
sel = refl.get_flags(refl.flags.integrated)
sel &= refl["intensity.sum.value"] > 0
sel &= refl["intensity.sum.variance"] > 0
refl = refl.select(sel)
hkl = refl["miller_index"]
partiality = refl["partiality"]
intensity = refl["intensity.sum.value"]
vari = refl["intensity.sum.variance"]
assert vari.all_gt(0)
sigi = flex.sqrt(vari)
intensities.append(intensity)
partialities.append(partiality)
sigmas.append(sigi)
ids.append(refl["id"])
xyz.append(refl["xyzcal.px"])
from annlib_ext import AnnAdaptor as ann_adaptor
ann = ann_adaptor(xyz[0].as_double().as_1d(), 3)
ann.query(xyz[1].as_double().as_1d())
distances = flex.sqrt(ann.distances)
matches = distances < 2 # pixels
isel0 = flex.size_t(list(ann.nn.select(matches)))
isel1 = flex.size_t(list(matches.iselection()))
p0 = partialities[0].select(isel0)
p1 = partialities[1].select(isel1)
i0 = intensities[0].select(isel0)
i1 = intensities[1].select(isel1)
print((p0 > p1).count(True), (p0 < p1).count(True))
h0 = flex.histogram(p0, data_min=0, data_max=1, n_slots=20)
h1 = flex.histogram(p1, data_min=0, data_max=1, n_slots=20)
h0.show()
h1.show()
from matplotlib import pyplot
perm0 = flex.sort_permutation(p0)
perm1 = flex.sort_permutation(p1)
fig, axes = pyplot.subplots(nrows=2, sharex=True)
axes[0].plot(p0.select(perm0), flex.int_range(p0.size()))
axes[1].plot(p1.select(perm1), flex.int_range(p1.size()))
axes[1].set_xlabel("Partiality")
for ax in axes:
ax.set_ylabel("Cumulative frequency")
for ax in axes:
ax.set_yscale("log")
pyplot.savefig("sorted_partialities.png")
pyplot.clf()
blue = "#3498db"
fig, axes = pyplot.subplots(nrows=2, sharex=True)
axes[0].bar(
h0.slot_centers(),
h0.slots(),
width=h0.slot_width(),
align="center",
color=blue,
edgecolor=blue,
)
axes[1].bar(
h1.slot_centers(),
h1.slots(),
width=h1.slot_width(),
align="center",
color=blue,
edgecolor=blue,
)
axes[1].set_xlabel("Partiality")
for ax in axes:
ax.set_ylabel("Frequency")
for ax in axes:
ax.set_yscale("log")
pyplot.savefig("partiality_histogram.png")
# pyplot.show()
pyplot.clf()
pyplot.scatter(p0, p1, s=5, alpha=0.3, marker="+")
pyplot.xlabel("Partiality (full)")
pyplot.ylabel("Partiality (sliced)")
pyplot.savefig("partiality_full_vs_sliced.png")
pyplot.clf()
pyplot.scatter(i0, i1, s=5, alpha=0.3, marker="+")
pyplot.xlim(flex.min(i0), flex.max(i0))
pyplot.ylim(flex.min(i1), flex.max(i1))
pyplot.xlabel("Intensity (full)")
pyplot.ylabel("Intensity (sliced)")
pyplot.xscale("log")
pyplot.yscale("log")
pyplot.savefig("intensity_full_vs_sliced.png")
pyplot.clf()
i_ratio = i1 / i0
p_ratio = p1 / p0
pyplot.scatter(p_ratio, i_ratio, s=5, alpha=0.3, marker="+")
pyplot.ylim(flex.min(i_ratio), flex.max(i_ratio))
pyplot.yscale("log")
pyplot.xlabel("P(full)/P(sliced)")
pyplot.ylabel("I(full)/I(sliced)")
pyplot.savefig("partiality_ratio_vs_intensity_ratio.png")
pyplot.clf()
def recycle_one_dano(missing, verbose):
assert missing in [None, "+", "-"]
from cctbx import crystal
cs = crystal.symmetry(
unit_cell=(13,17,19,85,95,105),
space_group_symbol="P1")
from cctbx.array_family import flex
mi = flex.miller_index([(1,2,3), (-1,-2,-3)])
fpm = flex.double([2.5, 5.5])
spm = flex.double([0.1, 0.3])
from cctbx import miller
ms = miller.set(crystal_symmetry=cs, indices=mi, anomalous_flag=True)
ma = ms.array(data=fpm, sigmas=spm)
mtz_dataset = ma.as_mtz_dataset(column_root_label="X")
if (missing is not None):
for col in mtz_dataset.columns():
if (col.label() in ["X(%s)" % missing, "SIGX(%s)" % missing]):
col.set_values(
values=flex.float([0]),
selection_valid=flex.bool([False]))
if (missing == "+"): i = 1
else: i = 0
ma = ma.select(flex.size_t([i]))
mtz_obj = mtz_dataset.mtz_object()
from cctbx.xray import observation_types
ma.set_observation_type(observation_types.reconstructed_amplitude())
mtz_obj_reco = ma.as_mtz_dataset(column_root_label="R").mtz_object()
sio = StringIO()
print >> sio, "Resulting mtz from .as_mtz_dataset():"
mtz_obj_reco.show_column_data_human_readable(out=sio)
print >> sio
ma_reco = mtz_obj_reco.as_miller_arrays()[0]
print >> sio, "mtz_obj_reco.as_miller_arrays result:"
ma_reco.show_array(f=sio)
print >> sio
if (verbose):
sys.stdout.write(sio.getvalue())
if (missing is None):
expected = """\
Resulting mtz from .as_mtz_dataset():
Column data:
-------------------------------------------------------------------------------
R SIGR DANOR SIGDANOR
ISYMR
1 2 3 4 0.158114 -3 0.316228
0
-------------------------------------------------------------------------------
mtz_obj_reco.as_miller_arrays result:
(1, 2, 3) 2.5 0.223606796247
(-1, -2, -3) 5.5 0.223606796247
"""
elif (missing == "+"):
expected = """\
Resulting mtz from .as_mtz_dataset():
Column data:
-------------------------------------------------------------------------------
R SIGR DANOR SIGDANOR
ISYMR
1 2 3 5.5 0.3 None None
2
-------------------------------------------------------------------------------
mtz_obj_reco.as_miller_arrays result:
(-1, -2, -3) 5.5 0.300000011921
"""
elif (missing == "-"):
expected = """\
Resulting mtz from .as_mtz_dataset():
Column data:
-------------------------------------------------------------------------------
R SIGR DANOR SIGDANOR
ISYMR
1 2 3 2.5 0.1 None None
1
-------------------------------------------------------------------------------
mtz_obj_reco.as_miller_arrays result:
(1, 2, 3) 2.5 0.10000000149
"""
else:
raise RuntimeError("Unreachable.")
from libtbx.test_utils import show_diff
assert not show_diff(sio.getvalue(), expected)
