def calc_partiality_anisotropy_set(self, my_uc, rotx, roty, miller_indices,
ry, rz, r0, re, nu,
bragg_angle_set, alpha_angle_set, wavelength, crystal_init_orientation,
spot_pred_x_mm_set, spot_pred_y_mm_set, detector_distance_mm,
partiality_model, flag_beam_divergence):
#use III.4 in Winkler et al 1979 (A35; P901) for set of miller indices
O = sqr(my_uc.orthogonalization_matrix()).transpose()
R = sqr(crystal_init_orientation.crystal_rotation_matrix()).transpose()
CO = crystal_orientation(O*R, basis_type.direct)
CO_rotate = CO.rotate_thru((1,0,0), rotx
).rotate_thru((0,1,0), roty)
A_star = sqr(CO_rotate.reciprocal_matrix())
S0 = -1*col((0,0,1./wavelength))
#caculate rs
rs_set = r0 + (re * flex.tan(bragg_angle_set))
if flag_beam_divergence:
rs_set += ((ry * flex.cos(alpha_angle_set))**2 + (rz * flex.sin(alpha_angle_set))**2)**(1/2)
#calculate rh
x = A_star.elems * miller_indices.as_vec3_double()
sd_array = x + S0.elems
rh_set = sd_array.norms() - (1/wavelength)
#calculate partiality
if partiality_model == "Lorentzian":
partiality_set = ((rs_set**2)/((2*(rh_set**2))+(rs_set**2)))
elif partiality_model == "Voigt":
partiality_set = self.voigt(rh_set, rs_set, nu)
elif partiality_model == "Lognormal":
partiality_set = self.lognpdf(rh_set, rs_set, nu)
#calculate delta_xy
d_ratio = -detector_distance_mm/sd_array.parts()[2]
calc_xy_array = flex.vec3_double(sd_array.parts()[0]*d_ratio, \
sd_array.parts()[1]*d_ratio, flex.double([0]*len(d_ratio)))
pred_xy_array = flex.vec3_double(spot_pred_x_mm_set, spot_pred_y_mm_set, flex.double([0]*len(d_ratio)))
delta_xy_set = (pred_xy_array - calc_xy_array).norms()
return partiality_set, delta_xy_set, rs_set, rh_set
def fit_rotatable(
pdb_hierarchy,
xray_structure,
map_data,
rotatable_h_selection):
unit_cell = xray_structure.unit_cell()
sites_cart = xray_structure.sites_cart()
scatterers = xray_structure.scatterers()
for sel_ in rotatable_h_selection:
ed_val = -1
angle = 0.
angular_step = 1
axis = sel_[0]
points_i_seqs = sel_[1]
sites_frac_best = flex.vec3_double(len(points_i_seqs))
while angle <= 360:
sites_frac_tmp = flex.vec3_double(len(points_i_seqs))
ed_val_ = 0
for i_seq, point_i_seq in enumerate(points_i_seqs):
site_cart_new = rotate_point_around_axis(
axis_point_1 = sites_cart[axis[0]],
axis_point_2 = sites_cart[axis[1]],
point = sites_cart[point_i_seq],
angle = angle,
deg = True)
site_frac_new = unit_cell.fractionalize(site_cart_new)
ed_val_ += abs(maptbx.eight_point_interpolation(map_data,site_frac_new))
sites_frac_tmp[i_seq] = site_frac_new
if(ed_val_ > ed_val):
ed_val = ed_val_
sites_frac_best = sites_frac_tmp.deep_copy()
angle += angular_step
for i_seq, point_i_seq in enumerate(points_i_seqs):
scatterers[point_i_seq].site = sites_frac_best[i_seq]
pdb_hierarchy.adopt_xray_structure(xray_structure)
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 compute_functional_and_gradients(O):
if (O.number_of_function_evaluations == 0):
O.number_of_function_evaluations += 1
return O.f_start, O.g_start
O.number_of_function_evaluations += 1
O.sites_cart_variable = flex.vec3_double(O.x)
if (O.real_space_target_weight == 0):
rs_f = 0.
rs_g = flex.vec3_double(O.sites_cart_variable.size(), (0,0,0))
else:
if (O.local_standard_deviations_radius is None):
rs_f = maptbx.real_space_target_simple(
unit_cell = O.unit_cell,
density_map = O.density_map,
sites_cart = O.sites_cart_variable,
selection = O.selection_variable_real_space)
rs_g = maptbx.real_space_gradients_simple(
unit_cell = O.unit_cell,
density_map = O.density_map,
sites_cart = O.sites_cart_variable,
delta = O.real_space_gradients_delta,
selection = O.selection_variable_real_space)
else:
rs_f = local_standard_deviations_target(
unit_cell=O.unit_cell,
density_map=O.density_map,
weight_map=O.weight_map,
weight_map_scale_factor=O.weight_map_scale_factor,
sites_cart=O.sites_cart_variable,
site_radii=O.site_radii)
rs_g = local_standard_deviations_gradients(
unit_cell=O.unit_cell,
density_map=O.density_map,
weight_map=O.weight_map,
weight_map_scale_factor=O.weight_map_scale_factor,
sites_cart=O.sites_cart_variable,
site_radii=O.site_radii,
delta=O.real_space_gradients_delta)
rs_f *= -O.real_space_target_weight
rs_g *= -O.real_space_target_weight
if (O.geometry_restraints_manager is None):
f = rs_f
g = rs_g
else:
if (O.selection_variable is None):
O.sites_cart = O.sites_cart_variable
else:
O.sites_cart.set_selected(O.selection_variable, O.sites_cart_variable)
if(O.states_collector is not None):
O.states_collector.add(sites_cart = O.sites_cart)
gr_e = O.geometry_restraints_manager.energies_sites(
sites_cart=O.sites_cart,
compute_gradients=True)
gr_e_gradients = gr_e.gradients
if (O.selection_variable is not None):
gr_e_gradients = gr_e.gradients.select(O.selection_variable)
f = rs_f + gr_e.target
g = rs_g + gr_e_gradients
return f, g.as_double()
def center_of_mass_info(self):
self.rcm = self.structure.center_of_mass()
result = dynamics.center_of_mass_info(self.rcm, self.structure.sites_cart(), self.vxyz, self.weights)
self.vcm = flex.vec3_double()
self.acm = flex.vec3_double()
self.vcm.append(result.vcm())
self.acm.append(result.acm())
self.ekcm = result.ekcm()
def zipper(self, initial_rms, level):
matches = []
for jj in xrange(1, self.n - 1):
ii = jj - 1
kk = jj + 1
# make triplets of sequence related sites
xi = self.set_a[ii]
xpi = self.set_b[ii]
xj = self.set_a[jj]
xpj = self.set_b[jj]
xk = self.set_a[kk]
xpk = self.set_b[kk]
# get the lsq matrix
ref = flex.vec3_double([xi, xj, xk])
mov = flex.vec3_double([xpi, xpj, xpk])
lsq = superpose.least_squares_fit(ref, mov)
# here we have the rotation and translation operators
r = lsq.r
t = lsq.t
rmsd = 10.0
# we would like to know the rmsd on the coords used for superposition
new_sites = lsq.other_sites_best_fit()
deltas = ref - new_sites
rmsd = deltas.rms_length()
if rmsd < initial_rms:
# please apply this rotation to the full set
converged = False
count = 0
match_size = 0
previous_match_size = 0
tmp_a = None
tmp_b = None
select = flex.bool()
while not converged:
previous_match_size = match_size
tmp_a, tmp_b, select = self.pair_sites(r, t, level)
# print count, tmp_a.size()
match_size = tmp_a.size()
if match_size <= previous_match_size:
converged = True
break
if count > self.max_iter:
converged = True
break
if tmp_b.size() > 0:
lsq = superpose.least_squares_fit(tmp_a, tmp_b)
tmp_sites = lsq.other_sites_best_fit()
rmsd = tmp_a.rms_difference(tmp_sites)
r = lsq.r
t = lsq.t
count += 1
if converged:
matches.append(
[select.deep_copy().iselection(), r, t, rmsd, select.deep_copy().iselection().size()]
)
return matches
def run():
for site in ([0,0,0], [0.1,0.1,0.1], [6,6,6], [3,3,3], [-0.1,0.1,-0.1],
[6,-6,6], [3,-3,3]):
exercise_1(grid_step = 0.1,
radius = 1.0,
shell = 0.0,
a = 6.0,
b = 3.0,
site_cart = flex.vec3_double([site]),
buffer_layer = 3.)
for volume_per_atom in range(100,550,100)*10:
exercise_2(grid_step = 0.08,
radius = 1.0,
shell = 0.0,
a = 6.0,
b = 3.0,
volume_per_atom = volume_per_atom)
for site in ([0,0,0], [0.1,0.1,0.1], [6,6,6], [3,3,3], [-0.1,0.1,-0.1],
[6,-6,6], [3,-3,3]):
exercise_3(grid_step = 0.1,
radius = 0.9,
shell = 0.0,
a = 6.0,
b = 3.0,
d_min = 0.08,
site_cart = flex.vec3_double([site]),
buffer_layer = 3.)
for volume_per_atom in range(100,550,100)*5:
exercise_4(grid_step = 0.1,
radius = 0.9,
shell = 0.0,
a = 6.0,
b = 3.0,
d_min = 0.08,
volume_per_atom = volume_per_atom,
use_weights = False,
optimize_cutoff_radius = True)
for use_weights, optimize_cutoff_radius in zip([True,False], [True,True]):
exercise_4(grid_step = 0.1,
radius = 0.9,
shell = 0.0,
a = 6.0,
b = 3.0,
d_min = 0.08,
volume_per_atom = 300,
use_weights = use_weights,
optimize_cutoff_radius = optimize_cutoff_radius)
for site in ([0,0,0], [0.1,0.1,0.1], [6,6,6], [3,3,3], [-0.1,0.1,-0.1],
[6,-6,6], [3,-3,3]):
exercise_5(grid_step = 0.1,
radius = 0.9,
shell = 0.0,
a = 6.0,
b = 3.0,
d_min = 0.08,
site_cart = flex.vec3_double([site]),
buffer_layer = 3.)
def main(xparm_file, spot_file):
import dxtbx
from dxtbx.serialize.xds import to_crystal
models = dxtbx.load(xparm_file)
crystal_model = to_crystal(xparm_file)
from dxtbx.model.experiment.experiment_list import Experiment, ExperimentList
experiment = Experiment(beam=models.get_beam(),
detector=models.get_detector(),
goniometer=models.get_goniometer(),
scan=models.get_scan(),
crystal=crystal_model)
detector = experiment.detector
beam = experiment.beam
goniometer = experiment.goniometer
scan = experiment.scan
from iotbx.xds import spot_xds
spot_xds_handle = spot_xds.reader()
spot_xds_handle.read_file(spot_file)
from cctbx.array_family import flex
centroids_px = flex.vec3_double(spot_xds_handle.centroid)
miller_indices = flex.miller_index(spot_xds_handle.miller_index)
# only those reflections that were actually indexed
centroids_px = centroids_px.select(miller_indices != (0,0,0))
miller_indices = miller_indices.select(miller_indices != (0,0,0))
ub = crystal_model.get_A()
d_spacings = [1.0 / (ub * mi).length() for mi in miller_indices]
print max(d_spacings)
# Convert Pixel coordinate into mm/rad
x, y, z = centroids_px.parts()
x_mm, y_mm = detector[0].pixel_to_millimeter(flex.vec2_double(x, y)).parts()
z_rad = scan.get_angle_from_array_index(z, deg=False)
centroids_mm = flex.vec3_double(x_mm, y_mm, z_rad)
# then convert detector position to reciprocal space position
# based on code in dials/algorithms/indexing/indexer2.py
s1 = detector[0].get_lab_coord(flex.vec2_double(x_mm, y_mm))
s1 = s1/s1.norms() * (1/beam.get_wavelength())
S = s1 - beam.get_s0()
reciprocal_space_points = S.rotate_around_origin(
goniometer.get_rotation_axis(),
-z_rad)
d_spacings = 1/reciprocal_space_points.norms()
dmax = flex.max(d_spacings)
print dmax
def compute_functional_and_gradients(self):
sites_cart = flex.vec3_double(self.x)
f = 0
g = flex.vec3_double(sites_cart.size(), (0, 0, 0))
for sorted_asu_proxies in [self.conservative_pair_proxies.bond, self.conservative_pair_proxies.angle]:
if sorted_asu_proxies is None:
continue
f += geometry_restraints.bond_residual_sum(
sites_cart=sites_cart, sorted_asu_proxies=sorted_asu_proxies, gradient_array=g
)
return f, g.as_double()
def side_chain_placement(ag_to_place, current_reference_ag, rotamer_manager):
"""
Works with poly_gly truncated hierarchy.
Also used in fix_rama_outliers.
"""
resname = current_reference_ag.resname.upper()
c = one_three.get(resname, None)
if c is None:
msg = "Only standard protein residues are currently supported.\n"
msg += "The residue %s (chain %s, resid %s) chain is not standard." % (
resname,
current_reference_ag.parent().parent().id,
current_reference_ag.parent().resid())
raise Sorry(msg)
ag_to_place.resname = three_one[c]
if c == 'G':
return
# align residue from ideal_res_dict to just placed ALA (ag_to_place)
# or from pdb_hierarchy_template
fixed_sites = flex.vec3_double()
moving_sites = flex.vec3_double()
reper_atoms = ["C","CA", "N"]
for (ag, arr) in [(ag_to_place, fixed_sites),
(current_reference_ag, moving_sites)]:
for a in ag.atoms():
if a.name.strip() in reper_atoms:
arr.append(a.xyz)
assert len(fixed_sites) == 3
if len(moving_sites) < 3:
error_msg = "C, CA or N atoms are absent in secondary structure element." +\
"\nPlease add them to the model and try again."
raise Sorry(error_msg)
assert len(moving_sites) == 3
lsq_fit_obj = superpose.least_squares_fit(reference_sites = fixed_sites,
other_sites = moving_sites)
ideal_correct_ag = current_reference_ag.detached_copy()
ideal_correct_ag.atoms().set_xyz(
lsq_fit_obj.r.elems*ideal_correct_ag.atoms().extract_xyz()+\
lsq_fit_obj.t.elems)
ideal_correct_ag.atoms().set_xyz(
rotamer_manager.nearest_rotamer_sites_cart(ideal_correct_ag))
if len(ideal_correct_ag.atoms()) > 4:
ag_to_place.pre_allocate_atoms(number_of_additional_atoms=\
len(ideal_correct_ag.atoms())-4)
for a in ideal_correct_ag.atoms():
if a.name.strip() not in ["N","CA","C","O"]:
at = a.detached_copy()
at.uij_erase()
ag_to_place.append_atom(atom=at)
else:
# This means something wrong with input model, e.g. only 3 atoms in
# the residue and they happened to be N, CA, C
pass
def get_cc(mc1, mc2, xrs):
crystal_gridding = mc1.crystal_gridding(
d_min = mc1.d_min(),
symmetry_flags = maptbx.use_space_group_symmetry,
resolution_factor = 0.25)
fft_map = miller.fft_map(
crystal_gridding = crystal_gridding,
fourier_coefficients = mc1)
fft_map.apply_sigma_scaling()
m1 = fft_map.real_map_unpadded()
fft_map = miller.fft_map(
crystal_gridding = crystal_gridding,
fourier_coefficients = mc2)
fft_map.apply_sigma_scaling()
m2 = fft_map.real_map_unpadded()
assert m1.focus()==m2.focus()
assert m1.all()==m2.all()
sel = maptbx.grid_indices_around_sites(
unit_cell = mc1.unit_cell(),
fft_n_real = m1.focus(),
fft_m_real = m1.all(),
sites_cart = flex.vec3_double(xrs.sites_cart()),
site_radii = flex.double([1.5]*xrs.scatterers().size()))
cc = flex.linear_correlation(x=m1.select(sel), y=m2.select(sel)).coefficient()
def md(m, xrs):
r = flex.double()
for sf in xrs.sites_frac():
r.append(m.eight_point_interpolation(sf))
return flex.mean(r)
return cc, md(m=m1, xrs=xrs), md(m=m2, xrs=xrs)
def __init__(O, f_obs, i_obs, i_sig, i_calc=None, f_calc=None, wa=0.1, wb=0):
assert [i_calc, f_calc].count(None) == 1
if (i_calc is None):
from cctbx.array_family import flex
i_calc = flex.norm(f_calc)
from cctbx import xray
raw = xray.targets_shelxl_wght_ls_kwt_b_dv(
f_obs=f_obs,
i_obs=i_obs,
i_sig=i_sig,
ic=i_calc,
wa=wa,
wb=wb)
assert len(raw) == 5
O.scale_factor, \
O.weights, \
O.target, \
O.i_gradients, \
O.i_curvatures = raw
if (f_calc is None):
O.f_gradients = None
O.f_hessians = None
else:
g = O.i_gradients
c = O.i_curvatures
O.f_gradients = 2 * g * f_calc
a = flex.real(f_calc)
b = flex.imag(f_calc)
aa = 2 * g + 4 * a * a * c
bb = 2 * g + 4 * b * b * c
ab = 4 * a * b * c
O.f_hessians = flex.vec3_double(aa, bb, ab)
def __init__(self,map_data,unit_cell,label,site_cart_1,site_cart_2,step=0.005):
x1,y1,z1 = site_cart_1
x2,y2,z2 = site_cart_2
self.one_dim_point = None
self.peak_value = None
self.peak_site_cart = None
self.status = None
self.bond_length = math.sqrt((x1-x2)**2+(y1-y2)**2+(z1-z2)**2)
alp = 0
self.data = flex.double()
self.dist = flex.double()
self.peak_sites = flex.vec3_double()
i_seq = 0
while alp <= 1.0+1.e-6:
xp = x1+alp*(x2-x1)
yp = y1+alp*(y2-y1)
zp = z1+alp*(z2-z1)
site_frac = unit_cell.fractionalize((xp,yp,zp))
ed_ = maptbx.eight_point_interpolation(map_data, site_frac)
self.dist.append( math.sqrt((x1-xp)**2+(y1-yp)**2+(z1-zp)**2) )
self.data.append(ed_)
self.peak_sites.append(unit_cell.orthogonalize(site_frac))
alp += step
i_seq += 1
i_seq_left, i_seq_right, max_peak_i_seq = self.find_peak()
self.b_estimated, self.q_estimated = None, None
self.a, self.b = None, None
self.peak_data, self.peak_dist = None, None
if([i_seq_left, i_seq_right].count(None) == 0):
self.one_dim_point = self.dist[max_peak_i_seq]
self.peak_value = self.data[max_peak_i_seq]
self.peak_site_cart = self.peak_sites[max_peak_i_seq]
self.peak_data = self.data[i_seq_left:i_seq_right+1]
self.peak_dist = self.dist[i_seq_left:i_seq_right+1]
assert (self.peak_data < 0.0).count(True) == 0
origin = self.dist[max_peak_i_seq]
dist = (self.peak_dist - origin).deep_copy()
sel = self.peak_data > 0.0
data = self.peak_data.select(sel)
dist = dist.select(sel)
if(data.size() > 0):
approx_obj = maptbx.one_gaussian_peak_approximation(
data_at_grid_points = data,
distances = dist,
use_weights = False,
optimize_cutoff_radius = False)
a_real = approx_obj.a_real_space()
b_real = approx_obj.b_real_space()
gof = approx_obj.gof()
self.a = ias_scattering_dict[label].array_of_a()[0]
self.b = ias_scattering_dict[label].array_of_b()[0]
self.b_estimated = approx_obj.b_reciprocal_space()-self.b
self.q_estimated = approx_obj.a_reciprocal_space()/self.a
#print "%.2f %.2f"%(self.q_estimated, self.b_estimated)
if(self.b_estimated <= 0.0):
self.b_estimated = self.b
if(self.q_estimated <= 0.0):
self.q_estimated = self.a
self.set_status()
def finite_differences_site(cartesian_flag, target_ftor, structure,
delta=0.00001):
unit_cell = structure.unit_cell()
abc = unit_cell.parameters()[:3]
derivatives = flex.vec3_double()
for i_scatterer in xrange(structure.scatterers().size()):
d_target_d_site = [0,0,0]
for ix in xrange(3):
target_values = []
for d_sign in (-1, 1):
modified_structure = structure.deep_copy_scatterers()
ms = modified_structure.scatterers()[i_scatterer]
site = list(ms.site)
if (not cartesian_flag):
site[ix] += d_sign * delta / abc[ix]
else:
site_cart = list(unit_cell.orthogonalize(site))
site_cart[ix] += d_sign * delta
site = unit_cell.fractionalize(site_cart)
ms.site = site
f_calc = target_ftor.f_obs().structure_factors_from_scatterers(
xray_structure=modified_structure,
algorithm="direct").f_calc()
target_result = target_ftor(f_calc, compute_derivatives=False)
target_values.append(target_result.target())
derivative = (target_values[1] - target_values[0]) / (2 * delta)
if (not cartesian_flag): derivative *= abc[ix]
d_target_d_site[ix] = derivative
derivatives.append(d_target_d_site)
return derivatives
def _accumulate_significant(self, site, height, site_symmetry, equiv_sites):
unit_cell = self.special_position_settings().unit_cell()
orth = unit_cell.orthogonalize
frac = unit_cell.fractionalize
sum_w_sites = matrix.col(orth(site)) * height
sum_w = height
height_cutoff = height * self._cluster_height_fraction
for i in xrange(self._peak_list_index, self._peak_list.size()):
if (self._is_processed[i]): continue
other_height = self._peak_list.heights()[i]
if (other_height < height_cutoff): break
other_site = self._peak_list.sites()[i]
other_site_symmetry = self._special_position_settings.site_symmetry(
other_site)
if ( self._general_positions_only
and not other_site_symmetry.is_point_group_1()):
self._is_processed[i] = True
continue
other_site = other_site_symmetry.exact_site()
dist_info = sgtbx.min_sym_equiv_distance_info(equiv_sites, other_site)
dist = dist_info.dist()
if (dist < self._min_cross_distance):
self._is_processed[i] = True
close_site = dist_info.apply(flex.vec3_double([other_site]))[0]
close_site = site_symmetry.special_op() * close_site
sum_w_sites += matrix.col(orth(close_site)) * other_height
sum_w += other_height
return frac(sum_w_sites / sum_w), height
def d_target_d_site_cart(self):
manager = self.manager
xray.set_scatterer_grad_flags(
scatterers=manager.xray_structure.scatterers(),
site=True)
return flex.vec3_double(
self.gradients_wrt_atomic_parameters().packed())
def map_peak_filter(sites_frac, obs_map, cutoff):
result = flex.vec3_double()
for site_frac in sites_frac:
val = obs_map.eight_point_interpolation(site_frac)
if val>cutoff:
result.append(site_frac)
return result
def minimum_covering_sphere(self, epsilon=None):
if (epsilon is None): epsilon = 1.e-3
points = flex.vec3_double()
orth = self.unit_cell.orthogonalize
for vertex in self.shape_vertices():
points.append(orth([float(e) for e in vertex]))
return minimum_covering_sphere(points=points, epsilon=epsilon)
def gradients(self, xray_structure, force_update_mask=False):
factor = 1.0
sites_cart = xray_structure.sites_cart()
if(self.fmodel is not None):
max_shift = flex.max(flex.sqrt((self.sites_cart - sites_cart).dot()))
if(max_shift > self.update_gradient_threshold):
self.fmodel.update_xray_structure(
xray_structure = xray_structure,
update_f_calc = True,
update_f_mask = False)
self.gx = flex.vec3_double(self.x_target_functor(compute_gradients=True).\
gradients_wrt_atomic_parameters(site=True).packed())
self.sites_cart = sites_cart
if(self.restraints_manager is not None):
c = self.restraints_manager.energies_sites(sites_cart = sites_cart,
compute_gradients=True)
self.gc = c.gradients
factor *= self.wc
if(c.normalization_factor is not None): factor *= c.normalization_factor
result = None
if(self.wx is not None):
result = self.wx * self.gx
if(self.wc is not None):
gcw = self.wc * self.gc
if(result is None): result = gcw
else: result = result + gcw
if(factor != 1.0): result *= 1.0 / factor
#print "norms:", self.gc.norm(), self.gx.norm(), result.norm()
return result
def __init__(self, centers_of_mass,
sites_cart,
target_functor,
rot_objs,
selections,
suppress_gradients):
t_r = target_functor(compute_gradients=not suppress_gradients)
self.f = t_r.target_work()
if (suppress_gradients):
self.grads_wrt_r = None
self.grads_wrt_t = None
return
target_grads_wrt_xyz = t_r.gradients_wrt_atomic_parameters(site=True)
self.grads_wrt_r = []
self.grads_wrt_t = []
target_grads_wrt_xyz = flex.vec3_double(target_grads_wrt_xyz.packed())
for sel,rot_obj, cm in zip(selections, rot_objs, centers_of_mass):
sites_cart_cm = sites_cart.select(sel) - cm
target_grads_wrt_xyz_sel = target_grads_wrt_xyz.select(sel)
target_grads_wrt_r = matrix.sqr(
sites_cart_cm.transpose_multiply(target_grads_wrt_xyz_sel))
self.grads_wrt_t.append(flex.double(target_grads_wrt_xyz_sel.sum()))
g_phi = (rot_obj.r_phi() * target_grads_wrt_r).trace()
g_psi = (rot_obj.r_psi() * target_grads_wrt_r).trace()
g_the = (rot_obj.r_the() * target_grads_wrt_r).trace()
self.grads_wrt_r.append(flex.double([g_phi, g_psi, g_the]))
def compute_zeta_multi(self, experiments):
'''
Compute zeta for each reflection.
:param experiments: The list of experiments
:return: Zeta for each reflection
'''
from dials.algorithms.profile_model.gaussian_rs import zeta_factor
m2 = flex.vec3_double(len(experiments))
s0 = flex.vec3_double(len(experiments))
for i, e in enumerate(experiments):
m2[i] = e.goniometer.get_rotation_axis()
s0[i] = e.beam.get_s0()
self['zeta'] = zeta_factor(m2, s0, self['s1'], self['id'])
return self['zeta']
def check_f_derivs():
g_ana = trg.f_gradients
c_ana = trg.f_hessians
eps = 1e-6
g_fin = flex.complex_double()
c_fin = flex.vec3_double()
for ih in xrange(i_calc.size()):
c_orig = f_calc[ih]
g_fin_ab = []
c_fin_ab = []
for iab in [0,1]:
fs = []
gs = []
for signed_eps in [eps, -eps]:
if (iab == 0):
f_calc[ih] = complex(c_orig.real + signed_eps, c_orig.imag)
else:
f_calc[ih] = complex(c_orig.real, c_orig.imag + signed_eps)
trg_eps = kwt2(
f_obs=f_obs, i_obs=i_obs, i_sig=i_sig,
f_calc=f_calc, i_calc=None, wa=wa, wb=wb)
fs.append(trg_eps.target)
gs.append(trg_eps.f_gradients[ih])
g_fin_ab.append((fs[0]-fs[1])/(2*eps))
c_fin_ab.append((gs[0]-gs[1])/(2*eps))
g_fin.append(complex(*g_fin_ab))
assert approx_equal(c_fin_ab[0].imag, c_fin_ab[1].real)
c_fin.append((c_fin_ab[0].real, c_fin_ab[1].imag, c_fin_ab[0].imag))
f_calc[ih] = c_orig
assert approx_equal(g_ana, g_fin)
assert approx_equal(c_ana, c_fin)
def testing_function_for_rsfit(basic_map,delta_h,xray_structure,out):
for i_trial in xrange(100):
sites_cart = flex.vec3_double((flex.random_double(size=3)-0.5)*1)
tmp_sites_cart = sites_cart.deep_copy()
for i in xrange(3):
ref = lbfgs(
basic_map=basic_map,
sites_cart=tmp_sites_cart,
delta_h=delta_h)
temp = flex.double(ref.sites_cart[0])-flex.double((0,0,0))
temp = math.sqrt(temp.dot(temp))
if temp <= 2*delta_h:
break
print >> out, "recycling:", ref.sites_cart[0]
tmp_sites_cart = ref.sites_cart
for site,sitec in zip(ref.sites_cart,xray_structure.sites_cart()):
print >> out, i_trial
print >> out, sitec
print >> out, sites_cart[0]
print >> out, site
temp = flex.double(site)-flex.double(sitec)
temp = math.sqrt(temp.dot(temp))
print >> out, temp, delta_h
assert temp <= delta_h*2
print >> out
def cluster_analysis_dbscan(self, vectors):
import numpy as np
from sklearn.cluster import DBSCAN
from sklearn.preprocessing import StandardScaler
vectors = flex.vec3_double(vectors)
X = np.array(vectors)
# scale the data - is this necessary/does it help or hinder?
X = StandardScaler().fit_transform(X)
# Compute DBSCAN
params = self.params.multiple_lattice_search.cluster_analysis.dbscan
db = DBSCAN(eps=params.eps, min_samples=params.min_samples).fit(X)
core_samples = db.core_sample_indices_
# core_samples is a list of numpy.int64 objects
core_samples = flex.int([int(i) for i in core_samples])
labels = flex.int(db.labels_.astype(np.int32))
# Number of clusters in labels, ignoring noise if present.
n_clusters_ = len(set(labels)) - (1 if -1 in labels else 0)
logger.info('Estimated number of clusters: %d' % n_clusters_)
return labels
def collect_map_values (map, get_selections=False) :
values = []
selections = []
if (map is None) :
assert (not get_selections)
return [ None ] * len(pdb_atoms)
for i_seq, atom in enumerate(pdb_atoms) :
if (selection[i_seq]) :
site_frac = sites_frac[i_seq]
values.append(map.eight_point_interpolation(site_frac))
if (get_selections) :
sel = maptbx.grid_indices_around_sites(
unit_cell = unit_cell,
fft_n_real = map.focus(),
fft_m_real = map.all(),
sites_cart = flex.vec3_double([sites_cart[i_seq]]),
site_radii = flex.double([1.5]))
selections.append(map.select(sel))
else :
values.append(None)
selections.append(None)
if (get_selections) :
return values, selections
else :
return values
def change_residue_rotamer_in_place(self,sites_cart, residue,
m_chis, r_chis, mon_lib_srv):
assert m_chis.count(None) == 0
assert r_chis.count(None) == 0
axis_and_atoms_to_rotate= \
rotatable_bonds.axes_and_atoms_aa_specific(
residue=residue,
mon_lib_srv=mon_lib_srv,
remove_clusters_with_all_h=True,
log=None)
if axis_and_atoms_to_rotate is None:
return
assert len(m_chis) == len(axis_and_atoms_to_rotate)
assert len(r_chis) >= len(m_chis)
counter = 0
residue_iselection = residue.atoms().extract_i_seq()
sites_cart_residue = sites_cart.select(residue_iselection)
for aa in axis_and_atoms_to_rotate:
axis = aa[0]
atoms = aa[1]
residue.atoms().set_xyz(new_xyz=sites_cart_residue)
new_xyz = flex.vec3_double()
angle_deg = r_chis[counter] - m_chis[counter]
if angle_deg < 0:
angle_deg += 360.0
for atom in atoms:
new_xyz = rotate_point_around_axis(
axis_point_1=sites_cart_residue[axis[0]],
axis_point_2=sites_cart_residue[axis[1]],
point=sites_cart_residue[atom],
angle=angle_deg, deg=True)
sites_cart_residue[atom] = new_xyz
sites_cart = sites_cart.set_selected(
residue_iselection, sites_cart_residue)
counter += 1
def exercise_flood_fill():
uc = uctbx.unit_cell('10 10 10 90 90 90')
for uc in (uctbx.unit_cell('10 10 10 90 90 90'),
uctbx.unit_cell('9 10 11 87 91 95')):
gridding = maptbx.crystal_gridding(
unit_cell=uc,
pre_determined_n_real=(5,5,5))
corner_cube = (0,4,20,24,100,104,120,124) # cube across all 8 corners
channel = (12,37,38,39,42,43,62,63,67,68,87,112)
data = flex.int(flex.grid(gridding.n_real()))
for i in (corner_cube + channel): data[i] = 1
flood_fill = masks.flood_fill(data, uc)
assert data.count(0) == 105
for i in corner_cube: assert data[i] == 2
for i in channel: assert data[i] == 3
assert approx_equal(flood_fill.centres_of_mass(),
((-0.5, -0.5, -0.5), (-2.5, 7/3, 2.5)))
assert approx_equal(flood_fill.centres_of_mass_frac(),
((-0.1, -0.1, -0.1), (-0.5, 7/15, 0.5)))
assert approx_equal(flood_fill.centres_of_mass_cart(),
uc.orthogonalize(flood_fill.centres_of_mass_frac()))
assert flood_fill.n_voids() == 2
assert approx_equal(flood_fill.grid_points_per_void(), (8, 12))
if 0:
from crys3d import wx_map_viewer
wx_map_viewer.display(raw_map=data.as_double(), unit_cell=uc, wires=False)
#
gridding = maptbx.crystal_gridding(
unit_cell=uc,
pre_determined_n_real=(10,10,10))
data = flex.int(flex.grid(gridding.n_real()))
# parallelogram
points = [(2,4,5),(3,4,5),(4,4,5),(5,4,5),(6,4,5),
(3,5,5),(4,5,5),(5,5,5),(6,5,5),(7,5,5),
(4,6,5),(5,6,5),(6,6,5),(7,6,5),(8,6,5)]
points_frac = flex.vec3_double()
for p in points:
data[p] = 1
points_frac.append([p[i]/gridding.n_real()[i] for i in range(3)])
points_cart = uc.orthogonalize(points_frac)
flood_fill = masks.flood_fill(data, uc)
assert data.count(2) == 15
assert approx_equal(flood_fill.centres_of_mass_frac(), ((0.5,0.5,0.5),))
pai_cart = math.principal_axes_of_inertia(
points=points_cart, weights=flex.double(points_cart.size(),1.0))
F = matrix.sqr(uc.fractionalization_matrix())
O = matrix.sqr(uc.orthogonalization_matrix())
assert approx_equal(
pai_cart.center_of_mass(), flood_fill.centres_of_mass_cart()[0])
assert approx_equal(
flood_fill.covariance_matrices_cart()[0],
(F.transpose() * matrix.sym(
sym_mat3=flood_fill.covariance_matrices_frac()[0]) * F).as_sym_mat3())
assert approx_equal(
pai_cart.inertia_tensor(), flood_fill.inertia_tensors_cart()[0])
assert approx_equal(pai_cart.eigensystem().vectors(),
flood_fill.eigensystems_cart()[0].vectors())
assert approx_equal(pai_cart.eigensystem().values(),
flood_fill.eigensystems_cart()[0].values())
return
def compute_functional_and_gradients(O):
if (O.number_of_function_evaluations == 0):
O.number_of_function_evaluations += 1
return O.f_start, O.g_start
O.number_of_function_evaluations += 1
O.sites_cart_residue = flex.vec3_double(O.x)
rs_f = maptbx.real_space_target_simple(
unit_cell=O.unit_cell,
density_map=O.density_map,
sites_cart=O.sites_cart_residue,
selection=flex.bool(O.sites_cart_residue.size(),True))
O.real_space_target = rs_f
rs_g = maptbx.real_space_gradients_simple(
unit_cell=O.unit_cell,
density_map=O.density_map,
sites_cart=O.sites_cart_residue,
delta=O.real_space_gradients_delta,
selection=flex.bool(O.sites_cart_residue.size(),True))
O.rs_f = rs_f
rs_f *= -O.real_space_target_weight
rs_g *= -O.real_space_target_weight
if (O.geometry_restraints_manager is None):
f = rs_f
g = rs_g
else:
O.sites_cart_all.set_selected(O.residue_i_seqs, O.sites_cart_residue)
gr_e = O.geometry_restraints_manager.energies_sites(
sites_cart=O.sites_cart_all, compute_gradients=True)
f = rs_f + gr_e.target
g = rs_g + gr_e.gradients.select(indices=O.residue_i_seqs)
return f, g.as_double()
def compute_functional_and_gradients(self):
sites_cart = flex.vec3_double(self.x)
tmp = self.restraints_manager.energies_sites(sites_cart = sites_cart,
compute_gradients=True)
f = tmp.target
g = tmp.gradients
return f, g.as_double()
def exercise_crystallographic():
crystal_symmetry = crystal.symmetry(
unit_cell=(10, 10, 10, 90, 90, 90),
space_group_symbol="P 1 1 2")
sites_frac = flex.vec3_double([
(0.1, 0.1, 0.0),
(0.9, 0.1, 0.0)])
for distance_cutoff in [1,2]:
pair_asu_table = \
crystal_symmetry.special_position_settings().pair_asu_table(
distance_cutoff=distance_cutoff,
sites_frac=sites_frac)
for strictly_in_asu in [True, False]:
cluster = crystal.asu_clusters(
pair_asu_table=pair_asu_table,
strictly_in_asu=strictly_in_asu).sort_index_groups_by_size()
cluster_sizes = [cluster.size() for cluster in cluster.index_groups]
if (distance_cutoff == 1 or strictly_in_asu):
assert cluster_sizes == [1, 1]
else:
assert cluster_sizes == [2]
sites_frac = flex.vec3_double([
(0.1, 0.1, 0.0),
(0.2, 0.2, 0.0),
(0.1, 0.3, 0.0),
(0.9, 0.1, 0.0),
(0.8, 0.2, 0.0)])
for i_trial in xrange(10):
if (i_trial > 0):
sites_frac = sites_frac.select(
flex.random_permutation(size=sites_frac.size()))
for distance_cutoff in [1.5,2]:
asu_mappings = crystal_symmetry.asu_mappings(
buffer_thickness=distance_cutoff).process_sites_frac(
original_sites=sites_frac)
pair_asu_table = crystal.pair_asu_table(
asu_mappings=asu_mappings).add_all_pairs(
distance_cutoff=distance_cutoff)
for strictly_in_asu in [True, False]:
cluster = crystal.asu_clusters(
pair_asu_table=pair_asu_table,
strictly_in_asu=strictly_in_asu).sort_index_groups_by_size()
cluster_sizes = [cluster.size() for cluster in cluster.index_groups]
if (distance_cutoff == 1.5 or strictly_in_asu):
assert cluster_sizes == [3, 2]
else:
assert cluster_sizes == [5]
def exercise(file_name, out=sys.stdout):
# Set up source data
if not os.path.isfile(file_name):
raise Sorry("Missing the file: %s" % (file_name) + "\n")
print("Reading from %s" % (file_name))
from iotbx.map_manager import map_manager
m = map_manager(file_name)
print("Header information from %s:" % (file_name))
m.show_summary(out=out)
map_data = m.map_data().deep_copy()
crystal_symmetry = m.crystal_symmetry()
unit_cell_parameters = m.crystal_symmetry().unit_cell().parameters()
print("\nMap origin: %s Extent %s" % (map_data.origin(), map_data.all()))
print("Original unit cell, not just unit cell of part in this file): %s" %
(str(unit_cell_parameters)))
grid_point = (1, 2, 3)
if map_data.origin() != (0, 0, 0): # make sure it is inside
from scitbx.matrix import col
grid_point = tuple(col(grid_point) + col(map_data.origin()))
print("\nValue of map_data at grid point %s: %.3f" %
(str(grid_point), map_data[grid_point]))
print("Map data is %s" % (type(map_data)))
random_position = (10, 5, 7.9)
point_frac = crystal_symmetry.unit_cell().fractionalize(random_position)
value_at_point_frac = map_data.eight_point_interpolation(point_frac)
print("Value of map_data at coordinates %s: %.3f" %
(str(random_position), value_at_point_frac))
map_data_as_float = map_data.as_float()
print("Map data as float is %s" % (type(map_data_as_float)))
# make a little model
sites_cart = flex.vec3_double(((8, 10, 12), (14, 15, 16)))
model = model_manager.from_sites_cart(atom_name=' CA ',
resname='ALA',
chain_id='A',
b_iso=30.,
occ=1.,
scatterer='C',
sites_cart=sites_cart,
crystal_symmetry=crystal_symmetry)
# Move map and a model to place origin at (0, 0, 0)
# map data is new copy but model is shifted in place.
from iotbx.map_model_manager import map_model_manager
mam = map_model_manager(
map_manager=m,
model=model.deep_copy(),
)
print("ORIGINALZZ", mam)
mam.box_all_maps_around_model_and_shift_origin()
print("boxedORIGINALZZ", mam)
shifted_crystal_symmetry = mam.model().crystal_symmetry()
shifted_model = mam.model()
shifted_map_data = mam.map_data()
print("\nOriginal map origin (grid units):", map_data.origin())
print("Original model:\n", model.model_as_pdb())
print("Shifted map origin:", shifted_map_data.origin())
print("Shifted model:\n", shifted_model.model_as_pdb())
# Save the map_model manager
mam_dc = mam.deep_copy()
print("dc", mam)
print("dc mam_dc", mam_dc)
# Mask map around atoms
mam = mam_dc.deep_copy()
print("dc mam_dc dc", mam_dc)
print(mam)
mam.mask_all_maps_around_atoms(mask_atoms_atom_radius=3,
set_outside_to_mean_inside=True,
soft_mask=False)
print("Mean before masking", mam.map_data().as_1d().min_max_mean().mean)
assert approx_equal(mam.map_data().as_1d().min_max_mean().mean,
-0.0585683621466)
print("Max before masking", mam.map_data().as_1d().min_max_mean().max)
assert approx_equal(mam.map_data().as_1d().min_max_mean().max,
-0.0585683621466)
# Mask map around atoms, with soft mask
mam = mam_dc.deep_copy()
mam.mask_all_maps_around_atoms(mask_atoms_atom_radius=3,
soft_mask=True,
soft_mask_radius=5,
set_outside_to_mean_inside=True)
print("Mean after first masking",
mam.map_data().as_1d().min_max_mean().mean)
assert approx_equal(mam.map_data().as_1d().min_max_mean().mean,
-0.00177661714805)
print("Max after first masking", mam.map_data().as_1d().min_max_mean().max)
assert approx_equal(mam.map_data().as_1d().min_max_mean().max,
0.236853733659)
# Mask map around atoms again
mam.mask_all_maps_around_atoms(mask_atoms_atom_radius=3,
set_outside_to_mean_inside=True,
soft_mask=False)
print("Mean after second masking",
mam.map_data().as_1d().min_max_mean().mean)
assert approx_equal(mam.map_data().as_1d().min_max_mean().mean,
-0.0585683621466)
print("Max after second masking",
mam.map_data().as_1d().min_max_mean().max)
assert approx_equal(mam.map_data().as_1d().min_max_mean().max,
-0.0585683621466)
# Mask around edges
mam = mam_dc.deep_copy()
mam.mask_all_maps_around_edges(soft_mask_radius=3)
print("Mean after masking edges",
mam.map_data().as_1d().min_max_mean().mean)
assert approx_equal(mam.map_data().as_1d().min_max_mean().mean,
0.0155055604192)
print("Max after masking edges", mam.map_data().as_1d().min_max_mean().max)
assert approx_equal(mam.map_data().as_1d().min_max_mean().max,
0.249827131629)
print(
"\nWriting map_data and model in shifted position (origin at 0, 0, 0)")
output_file_name = 'shifted_map.ccp4'
print("Writing to %s" % (output_file_name))
mrcfile.write_ccp4_map(
file_name=output_file_name,
crystal_symmetry=shifted_crystal_symmetry,
map_data=shifted_map_data,
)
output_file_name = 'shifted_model.pdb'
f = open(output_file_name, 'w')
print(shifted_model.model_as_pdb(), file=f)
f.close()
print("\nWriting map_data and model in original position (origin at %s)" %
(str(mam.map_manager().origin_shift_grid_units)))
output_file_name = 'new_map_original_position.ccp4'
print("Writing to %s" % (output_file_name))
mrcfile.write_ccp4_map(
file_name=output_file_name,
crystal_symmetry=shifted_crystal_symmetry,
map_data=shifted_map_data,
origin_shift_grid_units=mam.map_manager().origin_shift_grid_units)
print(shifted_model.model_as_pdb())
output_pdb_file_name = 'new_model_original_position.pdb'
f = open(output_pdb_file_name, 'w')
print(shifted_model.model_as_pdb(), file=f)
f.close()
# Write as mmcif
output_cif_file_name = 'new_model_original_position.cif'
f = open(output_cif_file_name, 'w')
print(shifted_model.model_as_mmcif(), file=f)
f.close()
# Read the new map and model
import iotbx.pdb
new_model = model_manager(model_input=iotbx.pdb.input(
source_info=None,
lines=flex.split_lines(open(output_pdb_file_name).read())),
crystal_symmetry=crystal_symmetry)
assert new_model.model_as_pdb() == model.model_as_pdb()
new_model_from_cif = model_manager(model_input=iotbx.pdb.input(
source_info=None,
lines=flex.split_lines(open(output_cif_file_name).read())),
crystal_symmetry=crystal_symmetry)
assert new_model_from_cif.model_as_pdb() == model.model_as_pdb()
# Read and box the original file again in case we modified m in any
# previous tests
m = map_manager(file_name)
mam = map_model_manager(model=model.deep_copy(), map_manager=m)
mam.box_all_maps_around_model_and_shift_origin()
file_name = output_file_name
print("Reading from %s" % (file_name))
new_map = iotbx.mrcfile.map_reader(file_name=file_name, verbose=False)
new_map.data = new_map.data.shift_origin()
print("Header information from %s:" % (file_name))
new_map.show_summary(out=out)
assert new_map.map_data().origin() == mam.map_manager().map_data().origin()
assert new_map.crystal_symmetry().is_similar_symmetry(
mam.map_manager().crystal_symmetry())
# make a map_model_manager with lots of maps and model and ncs
from mmtbx.ncs.ncs import ncs
ncs_object = ncs()
ncs_object.set_unit_ncs()
mam = map_model_manager(
map_manager=m,
ncs_object=ncs_object,
map_manager_1=m.deep_copy(),
map_manager_2=m.deep_copy(),
extra_model_list=[model.deep_copy(),
model.deep_copy()],
extra_model_id_list=["model_1", "model_2"],
extra_map_manager_list=[m.deep_copy(), m.deep_copy()],
extra_map_manager_id_list=["extra_1", "extra_2"],
model=model.deep_copy(),
)
# make a map_model_manager with lots of maps and model and ncs and run
# with wrapping and ignore_symmetry_conflicts on
from mmtbx.ncs.ncs import ncs
ncs_object = ncs()
ncs_object.set_unit_ncs()
m.set_ncs_object(ncs_object.deep_copy())
mam2 = map_model_manager(
map_manager=m.deep_copy(),
ncs_object=ncs_object.deep_copy(),
map_manager_1=m.deep_copy(),
map_manager_2=m.deep_copy(),
extra_model_list=[model.deep_copy(),
model.deep_copy()],
extra_model_id_list=["model_1", "model_2"],
extra_map_manager_list=[m.deep_copy(), m.deep_copy()],
extra_map_manager_id_list=["extra_1", "extra_2"],
model=model.deep_copy(),
ignore_symmetry_conflicts=True,
wrapping=m.wrapping(),
)
assert mam.map_manager().is_similar(mam2.map_manager())
assert mam.map_manager().is_similar(mam2.map_manager_1())
for m in mam2.map_managers():
assert mam.map_manager().is_similar(m)
assert mam.model().shift_cart() == mam2.model().shift_cart()
assert mam.model().shift_cart() == mam2.get_model_by_id(
'model_2').shift_cart()
print("OK")
def hcp_fill_box(cb_op_original_to_sampling,
float_asu,
continuous_shift_flags,
point_distance,
buffer_thickness=-1,
all_twelve_neighbors=False,
exercise_cpp=True):
if (exercise_cpp):
cpp = close_packing.hexagonal_sampling_generator(
cb_op_original_to_sampling=cb_op_original_to_sampling,
float_asu=float_asu,
continuous_shift_flags=continuous_shift_flags,
point_distance=point_distance,
buffer_thickness=buffer_thickness,
all_twelve_neighbors=all_twelve_neighbors)
assert point_distance > 0
if (buffer_thickness < 0):
buffer_thickness = point_distance * (2 / 3. * (.5 * math.sqrt(3)))
if (exercise_cpp):
assert cpp.cb_op_original_to_sampling().c(
) == cb_op_original_to_sampling.c()
assert cpp.float_asu().unit_cell().is_similar_to(float_asu.unit_cell())
assert cpp.continuous_shift_flags() == continuous_shift_flags
assert approx_equal(cpp.point_distance(), point_distance)
assert approx_equal(cpp.buffer_thickness(), buffer_thickness)
assert cpp.all_twelve_neighbors() == all_twelve_neighbors
float_asu_buffer = float_asu.add_buffer(thickness=buffer_thickness)
hex_cell = hexagonal_sampling_cell(point_distance=point_distance)
hex_box = hexagonal_box(
hex_cell=hex_cell,
vertices_cart=float_asu.shape_vertices(cartesian=True))
hex_box_buffer = hexagonal_box(
hex_cell=hex_cell,
vertices_cart=float_asu_buffer.shape_vertices(cartesian=True))
box_lower = []
box_upper = []
for i in xrange(3):
if (continuous_shift_flags[i]):
box_lower.append(0)
box_upper.append(0)
else:
n = iceil(abs(hex_box.max[i] - hex_box.pivot[i]))
box_lower.append(
min(-2, ifloor(hex_box_buffer.min[i] - hex_box.pivot[i])))
box_upper.append(
n + max(2, iceil(hex_box_buffer.max[i] - hex_box.max[i])))
if (exercise_cpp):
assert list(cpp.box_lower()) == box_lower
assert list(cpp.box_upper()) == box_upper
hex_to_frac_matrix = (
matrix.sqr(float_asu.unit_cell().fractionalization_matrix()) *
matrix.sqr(hex_cell.orthogonalization_matrix()))
sites_frac = flex.vec3_double()
for point in flex.nested_loop(begin=box_lower,
end=box_upper,
open_range=False):
site_hex = matrix.col(hex_box.pivot) \
+ matrix.col(hex_indices_as_site(point))
site_frac = hex_to_frac_matrix * site_hex
if (float_asu_buffer.is_inside(site_frac)):
sites_frac.append(site_frac)
elif (all_twelve_neighbors):
for offset in [(1, 0, 0), (1, 1, 0), (0, 1, 0), (-1, 0, 0),
(-1, -1, 0), (0, -1, 0), (0, 0, 1), (-1, -1, 1),
(0, -1, 1), (0, 0, -1), (-1, -1, -1), (0, -1, -1)]:
offset_hex = hex_indices_as_site(offset, layer=point[2])
offset_frac = hex_to_frac_matrix * matrix.col(offset_hex)
other_site_frac = site_frac + offset_frac
if (float_asu.is_inside(other_site_frac)):
sites_frac.append(site_frac)
break
assert sites_frac.size() > 0
rt = cb_op_original_to_sampling.c_inv().as_double_array()
sites_frac = rt[:9] * sites_frac
sites_frac += rt[9:]
if (exercise_cpp):
assert not cpp.at_end()
cpp_sites_frac = cpp.all_sites_frac()
assert cpp.at_end()
assert cpp_sites_frac.size() == sites_frac.size()
assert approx_equal(cpp_sites_frac, sites_frac)
cpp.restart()
assert not cpp.at_end()
assert approx_equal(cpp.next_site_frac(), sites_frac[0])
assert cpp.count_sites() == sites_frac.size() - 1
assert cpp.at_end()
cpp.restart()
n = 0
for site in cpp:
n += 1
assert n == sites_frac.size()
return sites_frac
def exercise_real_space_gradients_simple(timing):
uc = uctbx.unit_cell((11,13,17))
def check():
map = flex.double(flex.grid(22,26,36).set_focus(22,26,34))
site_frac = [i/n for i,n in zip(grid_point, map.focus())]
sites_cart = flex.vec3_double([uc.orthogonalize(site_frac)])
target = maptbx.real_space_target_simple(
unit_cell=uc, density_map=map, sites_cart=sites_cart,
selection=flex.bool(sites_cart.size(), True))
assert approx_equal(target, 0)
terms = maptbx.real_space_target_simple_per_site(
unit_cell=uc, density_map=map, sites_cart=sites_cart)
assert approx_equal(terms, [0])
grads = maptbx.real_space_gradients_simple(
unit_cell=uc, density_map=map, sites_cart=sites_cart, delta=0.1,
selection=flex.bool(sites_cart.size(), True))
assert approx_equal(grads, [(0,0,0)])
grid_point_mod = [i%n for i,n in zip(grid_point, map.focus())]
map[grid_point_mod] = 1
target = maptbx.real_space_target_simple(
unit_cell=uc, density_map=map, sites_cart=sites_cart,
selection=flex.bool(sites_cart.size(), True))
assert approx_equal(target, 1)
terms = maptbx.real_space_target_simple_per_site(
unit_cell=uc, density_map=map, sites_cart=sites_cart)
assert approx_equal(terms, [1])
grads = maptbx.real_space_gradients_simple(
unit_cell=uc, density_map=map, sites_cart=sites_cart, delta=0.1,
selection=flex.bool(sites_cart.size(), True))
assert approx_equal(grads, [(0,0,0)])
i,j,k = grid_point_mod
u,v,w = map.focus()
map[((i+1)%u,j,k)] = 0.3
map[(i,(j+1)%v,k)] = 0.5
map[(i,j,(k+1)%w)] = 0.7
target = maptbx.real_space_target_simple(
unit_cell=uc, density_map=map, sites_cart=sites_cart,
selection=flex.bool(sites_cart.size(), True))
assert approx_equal(target, 1)
for delta in [0.1, 0.2]:
grads = maptbx.real_space_gradients_simple(
unit_cell=uc, density_map=map, sites_cart=sites_cart, delta=delta,
selection=flex.bool(sites_cart.size(), True))
assert approx_equal(grads, [(0.3,0.5,0.7)])
for grid_point in [(0,0,0), (3,4,5), (-3,15,20)]:
check()
for i_trial in range(10):
grid_point = [random.randrange(-100,100) for i in [0,1,2]]
check()
if (timing): n = 1000000
else: n = 10
sites_cart = flex.vec3_double(flex.random_double(size=n*3)*40-20)
map = flex.double(flex.grid(22,26,36).set_focus(22,26,34), 1)
target = maptbx.real_space_target_simple(
unit_cell=uc, density_map=map, sites_cart=sites_cart,
selection=flex.bool(sites_cart.size(), True))
assert approx_equal(target, n)
t0 = time.time()
maptbx.real_space_gradients_simple(
unit_cell=uc, density_map=map, sites_cart=sites_cart, delta=0.1,
selection=flex.bool(sites_cart.size(), True))
tm = time.time() - t0
msg = "real_space_gradients_simple: %.2f s / %d sites" % (tm, n)
if (tm >= 0.01): msg += ", %.0f sites / s" % (n / tm)
if (timing): print(msg)
def find_peaks_clean(self):
import omptbx
# doesn't seem to be any benefit to using more than say 8 threads
num_threads = min(8, omptbx.omp_get_num_procs(), self.params.nproc)
omptbx.omp_set_num_threads(num_threads)
d_min = self.params.fft3d.reciprocal_space_grid.d_min
rlgrid = 2 / (d_min * self.gridding[0])
frame_number = self.reflections['xyzobs.px.value'].parts()[2]
scan_range_min = max(int(math.floor(flex.min(frame_number))),
self.imagesets[0].get_array_range()
[0]) # XXX what about multiple imagesets?
scan_range_max = min(int(math.ceil(flex.max(frame_number))),
self.imagesets[0].get_array_range()
[1]) # XXX what about multiple imagesets?
scan_range = self.params.scan_range
if not len(scan_range):
scan_range = [[scan_range_min, scan_range_max]]
scan = self.imagesets[0].get_scan(
) # XXX what about multiple imagesets?
angle_ranges = [[
scan.get_angle_from_array_index(i, deg=False) for i in range_
] for range_ in scan_range]
grid = flex.double(flex.grid(self.gridding), 0)
sampling_volume_map(
grid, flex.vec2_double(angle_ranges),
self.imagesets[0].get_beam().get_s0(),
self.imagesets[0].get_goniometer().get_rotation_axis(), rlgrid,
d_min, self.params.b_iso)
fft = fftpack.complex_to_complex_3d(self.gridding)
grid_complex = flex.complex_double(reals=grid,
imags=flex.double(grid.size(), 0))
grid_transformed = fft.forward(grid_complex)
grid_real = flex.pow2(flex.real(grid_transformed))
gamma = 1
peaks = flex.vec3_double()
#n_peaks = 200
n_peaks = 100 # XXX how many do we need?
dirty_beam = grid_real
dirty_map = self.grid_real.deep_copy()
import time
t0 = time.time()
peaks = clean_3d(dirty_beam, dirty_map, n_peaks, gamma=gamma)
t1 = time.time()
#print "clean_3d took %.2f s" %(t1-t0)
reciprocal_lattice_points = self.reflections['rlp'].select(
self.reflections_used_for_indexing)
peaks = self.optimise_peaks(peaks, reciprocal_lattice_points)
peaks_frac = flex.vec3_double()
for p in peaks:
peaks_frac.append(
(p[0] / self.gridding[0], p[1] / self.gridding[1],
p[2] / self.gridding[2]))
#print p, peaks_frac[-1]
if self.params.debug:
self.debug_write_ccp4_map(grid, "sampling_volume.map")
self.debug_write_ccp4_map(grid_real, "sampling_volume_FFT.map")
self.debug_write_ccp4_map(dirty_map, "clean.map")
self.sites = peaks_frac
# we don't really know the "volume"" of the peaks, but this method should
# find the peaks in order of their intensity (strongest first)
self.volumes = flex.double(range(len(self.sites), 0, -1))
return
def __call__(self, reflections, experiments, d_min=None):
from scitbx import matrix
from libtbx.math_utils import nearest_integer as nint
reciprocal_lattice_points = reflections["rlp"]
if "miller_index" not in reflections:
reflections["miller_index"] = flex.miller_index(len(reflections))
if d_min is not None:
d_spacings = 1 / reciprocal_lattice_points.norms()
inside_resolution_limit = d_spacings > d_min
else:
inside_resolution_limit = flex.bool(
reciprocal_lattice_points.size(), True)
sel = inside_resolution_limit & (reflections["id"] == -1)
isel = sel.iselection()
rlps = reciprocal_lattice_points.select(isel)
refs = reflections.select(isel)
phi = refs["xyzobs.mm.value"].parts()[2]
if len(rlps) <= self._nearest_neighbours:
raise DialsIndexError(
"index_assignment.local.nearest_neighbour must be smaller than the number of accepted reflections (%d)"
% len(rlps))
UB_matrices = flex.mat3_double(
[cm.get_A() for cm in experiments.crystals()])
result = ext.AssignIndicesLocal(
rlps,
phi,
UB_matrices,
epsilon=self._epsilon,
delta=self._delta,
l_min=self._l_min,
nearest_neighbours=self._nearest_neighbours,
)
miller_indices = result.miller_indices()
crystal_ids = result.crystal_ids()
hkl = miller_indices.as_vec3_double().iround()
assert miller_indices.select(crystal_ids < 0).all_eq((0, 0, 0))
for i_cryst in set(crystal_ids):
if i_cryst < 0:
continue
A = matrix.sqr(experiments[i_cryst].crystal.get_A())
A_inv = A.inverse()
cryst_sel = crystal_ids == i_cryst
rlp_sel = rlps.select(cryst_sel)
hkl_sel = hkl.select(cryst_sel).as_vec3_double()
d_sel = 1 / rlp_sel.norms()
d_perm = flex.sort_permutation(d_sel, reverse=True)
hf_0 = A_inv * rlp_sel[d_perm[0]]
h_0 = matrix.col([nint(j) for j in hf_0.elems])
offset = h_0 - matrix.col(hkl_sel[d_perm[0]])
# print "offset:", offset.elems
h = hkl_sel + flex.vec3_double(hkl_sel.size(), offset.elems)
refs["miller_index"].set_selected(
cryst_sel, flex.miller_index(list(h.iround())))
refs["id"].set_selected(cryst_sel, i_cryst)
crystal_ids.set_selected(crystal_ids < 0, -1)
refs["id"] = crystal_ids
refs["miller_index"].set_selected(crystal_ids < 0, (0, 0, 0))
reflections["miller_index"].set_selected(isel, refs["miller_index"])
reflections["id"].set_selected(isel, refs["id"])
reflections.set_flags(reflections["miller_index"] != (0, 0, 0),
reflections.flags.indexed)
def exercise(file_name=None,
pdb_file_name=None,
map_file_name=None,
split_pdb_file_name=None,
out=sys.stdout):
# Set up source data
if not os.path.isfile(file_name):
raise Sorry("Missing the file: %s" % (file_name) + "\n")
print("Reading from %s" % (file_name))
from iotbx.map_manager import map_manager
m = map_manager(file_name)
print("Header information from %s:" % (file_name))
m.show_summary(out=out)
map_data = m.map_data().deep_copy()
crystal_symmetry = m.crystal_symmetry()
unit_cell_parameters = m.crystal_symmetry().unit_cell().parameters()
print("\nMap origin: %s Extent %s" % (map_data.origin(), map_data.all()))
print("Original unit cell, not just unit cell of part in this file): %s" %
(str(unit_cell_parameters)))
grid_point = (1, 2, 3)
if map_data.origin() != (0, 0, 0): # make sure it is inside
from scitbx.matrix import col
grid_point = tuple(col(grid_point) + col(map_data.origin()))
print("\nValue of map_data at grid point %s: %.3f" %
(str(grid_point), map_data[grid_point]))
print("Map data is %s" % (type(map_data)))
random_position = (10, 5, 7.9)
point_frac = crystal_symmetry.unit_cell().fractionalize(random_position)
value_at_point_frac = map_data.eight_point_interpolation(point_frac)
print("Value of map_data at coordinates %s: %.3f" %
(str(random_position), value_at_point_frac))
map_data_as_float = map_data.as_float()
print("Map data as float is %s" % (type(map_data_as_float)))
# make a little model
sites_cart = flex.vec3_double(((8, 10, 12), (14, 15, 16)))
model = model_manager.from_sites_cart(atom_name=' CA ',
resname='ALA',
chain_id='A',
b_iso=30.,
occ=1.,
scatterer='C',
sites_cart=sites_cart,
crystal_symmetry=crystal_symmetry)
# Move map and a model to place origin at (0, 0, 0)
# map data is new copy but model is shifted in place.
from iotbx.map_model_manager import map_model_manager
mam = map_model_manager(
map_manager=m,
model=model.deep_copy(),
)
# Read in map and model and split up
dm = DataManager()
aa = dm.get_map_model_manager(model_file=pdb_file_name,
map_files=map_file_name)
bb = dm.get_map_model_manager(model_file=split_pdb_file_name,
map_files=map_file_name)
for selection_method in [
'by_chain', 'by_segment', 'supplied_selections', 'boxes'
]:
if selection_method == 'boxes':
choices = [True, False]
else:
choices = [True]
if selection_method == 'by_chain':
mask_choices = [True, False]
else:
mask_choices = [False]
for select_final_boxes_based_on_model in choices:
for skip_empty_boxes in choices:
for mask_choice in mask_choices:
if mask_choice: # use split model
a = bb.deep_copy()
else: # usual
a = aa.deep_copy()
print("\nRunning split_up_map_and_model with \n" +
"select_final_boxes_based_on_model=" +
"%s skip_empty_boxes=%s selection_method=%s" %
(select_final_boxes_based_on_model, skip_empty_boxes,
selection_method))
if selection_method == 'by_chain':
print("Mask around unused atoms: %s" % (mask_choice))
box_info = a.split_up_map_and_model_by_chain(
mask_around_unselected_atoms=mask_choice)
elif selection_method == 'by_segment':
box_info = a.split_up_map_and_model_by_segment()
elif selection_method == 'supplied_selections':
selection = a.model().selection('all')
box_info = a.split_up_map_and_model_by_supplied_selections(
selection_list=[selection])
elif selection_method == 'boxes':
box_info = a.split_up_map_and_model_by_boxes(
skip_empty_boxes=skip_empty_boxes,
select_final_boxes_based_on_model=
select_final_boxes_based_on_model)
print(selection_method, skip_empty_boxes,
len(box_info.selection_list),
box_info.selection_list[0].count(True))
assert (selection_method, skip_empty_boxes,
len(box_info.selection_list),
box_info.selection_list[0].count(True)) in [
('by_chain', True, 3, 19),
(
"by_chain",
True,
1,
86,
),
(
"by_segment",
True,
1,
86,
),
(
"supplied_selections",
True,
1,
86,
),
("boxes", True, 7, 9),
(
"boxes",
False,
12,
0,
),
(
"boxes",
True,
13,
1,
),
(
"boxes",
False,
36,
0,
),
], 'failed to find %s %s %s %s' % (
selection_method, skip_empty_boxes,
len(box_info.selection_list),
box_info.selection_list[0].count(True))
# Change the coordinates in one box
small_model = box_info.mmm_list[0].model()
small_sites_cart = small_model.get_sites_cart()
from scitbx.matrix import col
small_sites_cart += col((1, 0, 0))
small_model.set_crystal_symmetry_and_sites_cart(
sites_cart=small_sites_cart,
crystal_symmetry=small_model.crystal_symmetry())
# Put everything back together
a.merge_split_maps_and_models(box_info=box_info)
mam.box_all_maps_around_model_and_shift_origin()
shifted_crystal_symmetry = mam.model().crystal_symmetry()
shifted_model = mam.model()
shifted_map_data = mam.map_data()
print("\nOriginal map origin (grid units):", map_data.origin())
print("Original model:\n", model.model_as_pdb())
print("Shifted map origin:", shifted_map_data.origin())
print("Shifted model:\n", shifted_model.model_as_pdb())
# Save the map_model manager
mam_dc = mam.deep_copy()
print("dc", mam)
print("dc mam_dc", mam_dc)
# Mask map around atoms
mam = mam_dc.deep_copy()
print("dc mam_dc dc", mam_dc)
print(mam)
mam.mask_all_maps_around_atoms(mask_atoms_atom_radius=3,
set_outside_to_mean_inside=True,
soft_mask=False)
print("Mean before masking", mam.map_data().as_1d().min_max_mean().mean)
assert approx_equal(mam.map_data().as_1d().min_max_mean().mean,
-0.0585683621466)
print("Max before masking", mam.map_data().as_1d().min_max_mean().max)
assert approx_equal(mam.map_data().as_1d().min_max_mean().max,
-0.0585683621466)
# Mask map around atoms, with soft mask
mam = mam_dc.deep_copy()
mam.mask_all_maps_around_atoms(mask_atoms_atom_radius=3,
soft_mask=True,
soft_mask_radius=5,
set_outside_to_mean_inside=True)
print("Mean after first masking",
mam.map_data().as_1d().min_max_mean().mean)
assert approx_equal(mam.map_data().as_1d().min_max_mean().mean,
0,
eps=0.05)
print("Max after first masking", mam.map_data().as_1d().min_max_mean().max)
assert approx_equal(mam.map_data().as_1d().min_max_mean().max,
0.10,
eps=0.05)
# Mask map around atoms again
mam.mask_all_maps_around_atoms(mask_atoms_atom_radius=3,
set_outside_to_mean_inside=True,
soft_mask=False)
print("Mean after second masking",
mam.map_data().as_1d().min_max_mean().mean)
assert approx_equal(mam.map_data().as_1d().min_max_mean().mean, 0, eps=0.1)
print("Max after second masking",
mam.map_data().as_1d().min_max_mean().max)
assert approx_equal(mam.map_data().as_1d().min_max_mean().max, 0, eps=0.1)
# Mask around edges
mam = mam_dc.deep_copy()
mam.mask_all_maps_around_edges(soft_mask_radius=3)
print("Mean after masking edges",
mam.map_data().as_1d().min_max_mean().mean)
assert approx_equal(mam.map_data().as_1d().min_max_mean().mean,
0,
eps=0.05)
print("Max after masking edges", mam.map_data().as_1d().min_max_mean().max)
assert approx_equal(mam.map_data().as_1d().min_max_mean().max,
0.20,
eps=0.05)
print(
"\nWriting map_data and model in shifted position (origin at 0, 0, 0)")
output_file_name = 'shifted_map.ccp4'
print("Writing to %s" % (output_file_name))
mrcfile.write_ccp4_map(
file_name=output_file_name,
crystal_symmetry=shifted_crystal_symmetry,
map_data=shifted_map_data,
)
output_file_name = 'shifted_model.pdb'
f = open(output_file_name, 'w')
print(shifted_model.model_as_pdb(), file=f)
f.close()
print("\nWriting map_data and model in original position (origin at %s)" %
(str(mam.map_manager().origin_shift_grid_units)))
output_file_name = 'new_map_original_position.ccp4'
print("Writing to %s" % (output_file_name))
mrcfile.write_ccp4_map(
file_name=output_file_name,
crystal_symmetry=shifted_crystal_symmetry,
map_data=shifted_map_data,
origin_shift_grid_units=mam.map_manager().origin_shift_grid_units)
print(shifted_model.model_as_pdb())
output_pdb_file_name = 'new_model_original_position.pdb'
f = open(output_pdb_file_name, 'w')
print(shifted_model.model_as_pdb(), file=f)
f.close()
# Write as mmcif
output_cif_file_name = 'new_model_original_position.cif'
f = open(output_cif_file_name, 'w')
print(shifted_model.model_as_mmcif(), file=f)
f.close()
# Read the new map and model
import iotbx.pdb
new_model = model_manager(model_input=iotbx.pdb.input(
source_info=None,
lines=flex.split_lines(open(output_pdb_file_name).read())),
crystal_symmetry=crystal_symmetry)
assert new_model.model_as_pdb() == model.model_as_pdb()
new_model_from_cif = model_manager(model_input=iotbx.pdb.input(
source_info=None,
lines=flex.split_lines(open(output_cif_file_name).read())),
crystal_symmetry=crystal_symmetry)
assert new_model_from_cif.model_as_pdb() == model.model_as_pdb()
# Read and box the original file again in case we modified m in any
# previous tests
m = map_manager(file_name)
mam = map_model_manager(model=model.deep_copy(), map_manager=m)
mam.box_all_maps_around_model_and_shift_origin()
file_name = output_file_name
print("Reading from %s" % (file_name))
new_map = iotbx.mrcfile.map_reader(file_name=file_name, verbose=False)
new_map.data = new_map.data.shift_origin()
print("Header information from %s:" % (file_name))
new_map.show_summary(out=out)
assert new_map.map_data().origin() == mam.map_manager().map_data().origin()
assert new_map.crystal_symmetry().is_similar_symmetry(
mam.map_manager().crystal_symmetry())
# make a map_model_manager with lots of maps and model and ncs
from mmtbx.ncs.ncs import ncs
ncs_object = ncs()
ncs_object.set_unit_ncs()
mam = map_model_manager(
map_manager=m,
ncs_object=ncs_object,
map_manager_1=m.deep_copy(),
map_manager_2=m.deep_copy(),
extra_model_list=[model.deep_copy(),
model.deep_copy()],
extra_model_id_list=["model_1", "model_2"],
extra_map_manager_list=[m.deep_copy(), m.deep_copy()],
extra_map_manager_id_list=["extra_1", "extra_2"],
model=model.deep_copy(),
)
# make a map_model_manager with lots of maps and model and ncs and run
# with wrapping and ignore_symmetry_conflicts on
from mmtbx.ncs.ncs import ncs
ncs_object = ncs()
ncs_object.set_unit_ncs()
m.set_ncs_object(ncs_object.deep_copy())
mam2 = map_model_manager(
map_manager=m.deep_copy(),
ncs_object=ncs_object.deep_copy(),
map_manager_1=m.deep_copy(),
map_manager_2=m.deep_copy(),
extra_model_list=[model.deep_copy(),
model.deep_copy()],
extra_model_id_list=["model_1", "model_2"],
extra_map_manager_list=[m.deep_copy(), m.deep_copy()],
extra_map_manager_id_list=["extra_1", "extra_2"],
model=model.deep_copy(),
ignore_symmetry_conflicts=True,
wrapping=m.wrapping(),
)
assert mam.map_manager().is_similar(mam2.map_manager())
assert mam.map_manager().is_similar(mam2.map_manager_1())
for m in mam2.map_managers():
assert mam.map_manager().is_similar(m)
assert mam.model().shift_cart() == mam2.model().shift_cart()
assert mam.model().shift_cart() == mam2.get_model_by_id(
'model_2').shift_cart()
print("OK")
def find_basis_vector_combinations_cluster_analysis(self):
self.fft()
# hijack the xray.structure class to facilitate calculation of distances
xs = xray.structure(crystal_symmetry=self.crystal_symmetry)
for i, site in enumerate(self.sites):
xs.add_scatterer(xray.scatterer("C%i" % i, site=site))
xs = xs.sites_mod_short()
xs = xs.select(xs.sites_frac().norms() < 0.45)
cell_multiplier = 10
xs1 = xs.customized_copy(unit_cell=uctbx.unit_cell(
[xs.unit_cell().parameters()[0] * cell_multiplier] * 3))
xs1.set_sites_cart(xs.sites_cart())
xs = xs1
sites_cart = xs.sites_cart()
lengths = flex.double([matrix.col(sc).length() for sc in sites_cart])
xs = xs.select(flex.sort_permutation(lengths))
if self.params.debug:
with open('peaks.pdb', 'wb') as f:
print >> f, xs.as_pdb_file()
vector_heights = flex.double()
sites_frac = xs.sites_frac()
pair_asu_table = xs.pair_asu_table(
distance_cutoff=self.params.max_cell)
asu_mappings = pair_asu_table.asu_mappings()
distances = crystal.calculate_distances(pair_asu_table, sites_frac)
vectors = []
difference_vectors = []
pairs = []
for di in distances:
if di.distance < self.params.min_cell: continue
i_seq, j_seq = di.i_seq, di.j_seq
if i_seq > j_seq: continue
pairs.append((i_seq, j_seq))
rt_mx_ji = di.rt_mx_ji
site_frac_ji = rt_mx_ji * sites_frac[j_seq]
site_cart_ji = xs.unit_cell().orthogonalize(site_frac_ji)
site_cart_i = xs.unit_cell().orthogonalize(sites_frac[i_seq])
vectors.append(matrix.col(site_cart_ji))
diff_vec = matrix.col(site_cart_i) - matrix.col(site_cart_ji)
if diff_vec[0] < 0:
# only one hemisphere of difference vector space
diff_vec = -diff_vec
difference_vectors.append(diff_vec)
params = self.params.multiple_lattice_search.cluster_analysis
if params.method == 'dbscan':
i_cluster = self.cluster_analysis_dbscan(difference_vectors)
min_cluster_size = 1
elif params.method == 'hcluster':
i_cluster = self.cluster_analysis_hcluster(difference_vectors)
i_cluster -= 1 # hcluster starts counting at 1
min_cluster_size = params.min_cluster_size
if self.params.debug_plots:
self.debug_plot_clusters(difference_vectors,
i_cluster,
min_cluster_size=min_cluster_size)
clusters = []
min_cluster_size = params.min_cluster_size
for i in range(max(i_cluster) + 1):
isel = (i_cluster == i).iselection()
if len(isel) < min_cluster_size:
continue
clusters.append(isel)
cluster_point_sets = []
centroids = []
cluster_sizes = flex.int()
difference_vectors = flex.vec3_double(difference_vectors)
from libtbx.utils import flat_list
for cluster in clusters:
points = flat_list([pairs[i] for i in cluster])
cluster_point_sets.append(set(points))
d_vectors = difference_vectors.select(cluster)
cluster_sizes.append(len(d_vectors))
centroids.append(d_vectors.mean())
# build a graph where each node is a centroid from the difference vector
# cluster analysis above, and an edge is defined when there is a
# significant overlap between the sets of peaks in the FFT map that
# contributed to the difference vectors in two clusters
import networkx as nx
G = nx.Graph()
G.add_nodes_from(range(len(cluster_point_sets)))
cutoff_frac = 0.25
for i in range(len(cluster_point_sets)):
for j in range(i + 1, len(cluster_point_sets)):
intersection_ij = cluster_point_sets[i].intersection(
cluster_point_sets[j])
union_ij = cluster_point_sets[i].union(cluster_point_sets[j])
frac_connected = len(intersection_ij) / len(union_ij)
if frac_connected > cutoff_frac:
G.add_edge(i, j)
# iteratively find the maximum cliques in the graph
# break from the loop if there are no cliques remaining or there are
# fewer than 3 vectors in the remaining maximum clique
# Allow 1 basis vector to be shared between two cliques, to allow for
# cases where two lattices share one basis vectors (e.g. two plate
# crystals exactly aligned in one direction, but not in the other two)
distinct_cliques = []
cliques = list(nx.find_cliques(G))
cliques = sorted(cliques, key=len, reverse=True)
for i, clique in enumerate(cliques):
clique = set(clique)
if len(clique) < 3:
break
is_distinct = True
for c in distinct_cliques:
if len(c.intersection(clique)) > 1:
is_distinct = False
break
if is_distinct:
distinct_cliques.append(clique)
this_set = set()
for i_cluster in clique:
this_set = this_set.union(cluster_point_sets[i_cluster])
logger.info("Clique %i: %i lattice points" %
(i + 1, len(this_set)))
assert len(distinct_cliques) > 0
logger.info("Estimated number of lattices: %i" % len(distinct_cliques))
self.candidate_basis_vectors = []
self.candidate_crystal_models = []
for clique in distinct_cliques:
sel = flex.size_t(list(clique))
vectors = flex.vec3_double(centroids).select(sel)
perm = flex.sort_permutation(vectors.norms())
vectors = [matrix.col(vectors[p]) for p in perm]
# exclude vectors that are (approximately) integer multiples of a shorter
# vector
unique_vectors = []
for v in vectors:
is_unique = True
for v_u in unique_vectors:
if is_approximate_integer_multiple(v_u,
v,
relative_tolerance=0.01,
angular_tolerance=0.5):
is_unique = False
break
if is_unique:
unique_vectors.append(v)
vectors = unique_vectors
self.candidate_basis_vectors.extend(vectors)
candidate_orientation_matrices \
= self.find_candidate_orientation_matrices(vectors)
if len(candidate_orientation_matrices) == 0:
continue
crystal_model, n_indexed = self.choose_best_orientation_matrix(
candidate_orientation_matrices)
if crystal_model is None: continue
# map to minimum reduced cell
crystal_symmetry = crystal.symmetry(
unit_cell=crystal_model.get_unit_cell(),
space_group=crystal_model.get_space_group())
cb_op = crystal_symmetry.change_of_basis_op_to_minimum_cell()
crystal_model = crystal_model.change_basis(cb_op)
self.candidate_crystal_models.append(crystal_model)
if self.params.debug:
file_name = "vectors.pdb"
a = self.params.max_cell
cs = crystal.symmetry(unit_cell=(a, a, a, 90, 90, 90),
space_group="P1")
xs = xray.structure(crystal_symmetry=cs)
for v in difference_vectors:
v = matrix.col(v)
xs.add_scatterer(xray.scatterer("C", site=v / (a / 10)))
xs.sites_mod_short()
with open(file_name, 'wb') as f:
print >> f, xs.as_pdb_file()
for crystal_model in self.candidate_crystal_models:
logger.debug(crystal_model)
def __init__(self,
map_data,
unit_cell,
label,
site_cart_1,
site_cart_2,
step=0.005):
x1, y1, z1 = site_cart_1
x2, y2, z2 = site_cart_2
self.one_dim_point = None
self.peak_value = None
self.peak_site_cart = None
self.status = None
self.bond_length = math.sqrt((x1 - x2)**2 + (y1 - y2)**2 +
(z1 - z2)**2)
alp = 0
self.data = flex.double()
self.dist = flex.double()
self.peak_sites = flex.vec3_double()
i_seq = 0
while alp <= 1.0 + 1.e-6:
xp = x1 + alp * (x2 - x1)
yp = y1 + alp * (y2 - y1)
zp = z1 + alp * (z2 - z1)
site_frac = unit_cell.fractionalize((xp, yp, zp))
ed_ = maptbx.eight_point_interpolation(map_data, site_frac)
self.dist.append(
math.sqrt((x1 - xp)**2 + (y1 - yp)**2 + (z1 - zp)**2))
self.data.append(ed_)
self.peak_sites.append(unit_cell.orthogonalize(site_frac))
alp += step
i_seq += 1
i_seq_left, i_seq_right, max_peak_i_seq = self.find_peak()
self.b_estimated, self.q_estimated = None, None
self.a, self.b = None, None
self.peak_data, self.peak_dist = None, None
if ([i_seq_left, i_seq_right].count(None) == 0):
self.one_dim_point = self.dist[max_peak_i_seq]
self.peak_value = self.data[max_peak_i_seq]
self.peak_site_cart = self.peak_sites[max_peak_i_seq]
self.peak_data = self.data[i_seq_left:i_seq_right + 1]
self.peak_dist = self.dist[i_seq_left:i_seq_right + 1]
assert (self.peak_data < 0.0).count(True) == 0
origin = self.dist[max_peak_i_seq]
dist = (self.peak_dist - origin).deep_copy()
sel = self.peak_data > 0.0
data = self.peak_data.select(sel)
dist = dist.select(sel)
if (data.size() > 0):
approx_obj = maptbx.one_gaussian_peak_approximation(
data_at_grid_points=data,
distances=dist,
use_weights=False,
optimize_cutoff_radius=False)
a_real = approx_obj.a_real_space()
b_real = approx_obj.b_real_space()
gof = approx_obj.gof()
self.a = ias_scattering_dict[label].array_of_a()[0]
self.b = ias_scattering_dict[label].array_of_b()[0]
self.b_estimated = approx_obj.b_reciprocal_space() - self.b
self.q_estimated = approx_obj.a_reciprocal_space() / self.a
#print "%.2f %.2f"%(self.q_estimated, self.b_estimated)
if (self.b_estimated <= 0.0):
self.b_estimated = self.b
if (self.q_estimated <= 0.0):
self.q_estimated = self.a
self.set_status()
def check_with_grid_tags(inp_symmetry, symmetry_flags, sites_cart,
point_distance, strictly_inside, flag_write_pdb,
verbose):
cb_op_inp_ref = inp_symmetry.change_of_basis_op_to_reference_setting()
if (verbose):
print "cb_op_inp_ref.c():", cb_op_inp_ref.c()
ref_symmetry = inp_symmetry.change_basis(cb_op_inp_ref)
search_symmetry = sgtbx.search_symmetry(
flags=symmetry_flags,
space_group_type=ref_symmetry.space_group_info().type(),
seminvariant=ref_symmetry.space_group_info().structure_seminvariants())
assert search_symmetry.continuous_shifts_are_principal()
continuous_shift_flags = search_symmetry.continuous_shift_flags()
if (flag_write_pdb):
tag_sites_frac = flex.vec3_double()
else:
tag_sites_frac = None
if (strictly_inside):
inp_tags = inp_symmetry.gridding(step=point_distance * .7,
symmetry_flags=symmetry_flags).tags()
if (tag_sites_frac is not None):
for point in flex.nested_loop(inp_tags.n_real()):
if (inp_tags.tags().tag_array()[point] < 0):
point_frac_inp = [
float(n) / d for n, d in zip(point, inp_tags.n_real())
]
tag_sites_frac.append(point_frac_inp)
if (inp_tags.tags().n_independent() < sites_cart.size()):
print "FAIL:", inp_symmetry.space_group_info(), \
inp_tags.tags().n_independent(), sites_cart.size()
raise AssertionError
else:
inp_tags = inp_symmetry.gridding(step=point_distance / 2.,
symmetry_flags=symmetry_flags).tags()
sites_frac_inp = inp_symmetry.unit_cell().fractionalize(
sites_cart=sites_cart)
rt = cb_op_inp_ref.c().as_double_array()
sites_frac_ref = rt[:9] * sites_frac_inp
sites_frac_ref += rt[9:]
max_distance = 2 * ((.5 * math.sqrt(3) * point_distance) * 2 / 3.)
if (verbose):
print "max_distance:", max_distance
for point in flex.nested_loop(inp_tags.n_real()):
if (inp_tags.tags().tag_array()[point] < 0):
point_frac_inp = [
float(n) / d for n, d in zip(point, inp_tags.n_real())
]
if (tag_sites_frac is not None):
tag_sites_frac.append(point_frac_inp)
point_frac_ref = cb_op_inp_ref.c() * point_frac_inp
equiv_points = sgtbx.sym_equiv_sites(
unit_cell=ref_symmetry.unit_cell(),
space_group=search_symmetry.subgroup(),
original_site=point_frac_ref,
minimum_distance=2.e-6,
tolerance=1.e-6)
min_dist = sgtbx.min_sym_equiv_distance_info(
reference_sites=equiv_points,
others=sites_frac_ref,
principal_continuous_allowed_origin_shift_flags=
continuous_shift_flags).dist()
if (min_dist > max_distance):
print "FAIL:", inp_symmetry.space_group_info(), \
point_frac_ref, min_dist
raise AssertionError
if (inp_tags.tags().n_independent() + 10 < sites_cart.size()):
print "FAIL:", inp_symmetry.space_group_info(), \
inp_tags.tags().n_independent(), sites_cart.size()
raise AssertionError
if (tag_sites_frac is not None):
dump_pdb(file_name="tag_sites.pdb",
crystal_symmetry=inp_symmetry,
sites_cart=inp_symmetry.unit_cell().orthogonalize(
sites_frac=tag_sites_frac))
def __init__(self,
sites_cart,
unit_cell=None,
bond_proxies=None,
nonbonded_proxies=None,
nonbonded_function=None,
angle_proxies=None,
dihedral_proxies=None,
reference_coordinate_proxies=None,
reference_dihedral_manager=None,
ncs_dihedral_manager=None,
den_manager=None,
chirality_proxies=None,
planarity_proxies=None,
parallelity_proxies=None,
bond_similarity_proxies=None,
ramachandran_manager=None,
external_energy_function=None,
compute_gradients=True,
gradients=None,
disable_asu_cache=False,
normalization=False,
extension_objects=[]):
# runsnaked away...
#adopt_init_args(self, locals())
#for local in sorted(locals()):
# print " self.%(local)s=%(local)s" % locals()
#assert 0
#
self.angle_proxies = angle_proxies
self.bond_proxies = bond_proxies
self.bond_similarity_proxies = bond_similarity_proxies
self.chirality_proxies = chirality_proxies
self.compute_gradients = compute_gradients
self.den_manager = den_manager
self.dihedral_proxies = dihedral_proxies
self.disable_asu_cache = disable_asu_cache
self.extension_objects = extension_objects
self.external_energy_function = external_energy_function
self.gradients = gradients
# self.ncs_dihedral_manager=ncs_dihedral_manager
self.nonbonded_function = nonbonded_function
self.nonbonded_proxies = nonbonded_proxies
self.normalization = normalization
self.parallelity_proxies = parallelity_proxies
self.planarity_proxies = planarity_proxies
self.ramachandran_manager = ramachandran_manager
self.reference_coordinate_proxies = reference_coordinate_proxies
self.reference_dihedral_manager = reference_dihedral_manager
self.sites_cart = sites_cart
self.unit_cell = unit_cell
#
scitbx.restraints.energies.__init__(
self,
compute_gradients=compute_gradients,
gradients=gradients,
gradients_size=sites_cart.size(),
gradients_factory=flex.vec3_double,
normalization=normalization)
self.n_dihedral_restraints = None
self.dihedral_restraints_residual_sum = 0
if (nonbonded_proxies is not None):
assert nonbonded_function is not None
if (compute_gradients):
if (self.gradients is None):
self.gradients = flex.vec3_double(sites_cart.size(), [0, 0, 0])
else:
assert self.gradients.size() == sites_cart.size()
if (bond_proxies is None):
self.n_bond_proxies = None
self.bond_residual_sum = 0
else:
self.n_bond_proxies = bond_proxies.n_total()
self.bond_residual_sum = geometry_restraints.bond_residual_sum(
sites_cart=sites_cart,
sorted_asu_proxies=bond_proxies,
gradient_array=self.gradients,
disable_cache=disable_asu_cache)
self.number_of_restraints += self.n_bond_proxies
self.residual_sum += self.bond_residual_sum
if (nonbonded_proxies is None):
self.n_nonbonded_proxies = None
self.nonbonded_residual_sum = 0
else:
self.n_nonbonded_proxies = nonbonded_proxies.n_total()
self.nonbonded_residual_sum = geometry_restraints.nonbonded_residual_sum(
sites_cart=sites_cart,
sorted_asu_proxies=nonbonded_proxies,
gradient_array=self.gradients,
function=nonbonded_function,
disable_cache=False)
self.number_of_restraints += self.n_nonbonded_proxies
self.residual_sum += self.nonbonded_residual_sum
# ====================================================================
# Unit cell dependent
# ====================================================================
# name, parameter, function to call
for name, proxies, residual_sum_function in [
("angle", angle_proxies, geometry_restraints.angle_residual_sum),
("dihedral", dihedral_proxies,
geometry_restraints.dihedral_residual_sum),
("planarity", planarity_proxies,
geometry_restraints.planarity_residual_sum),
("parallelity", parallelity_proxies,
geometry_restraints.parallelity_residual_sum),
("bond_similarity", bond_similarity_proxies,
geometry_restraints.bond_similarity_residual_sum)
]:
setattr(self, "n_%s_proxies" % name, None)
setattr(self, "%s_residual_sum" % name, 0)
if proxies is not None:
n_proxies = proxies.size()
# setattr(self, "n_%s_proxies" % name, proxies.size())
if unit_cell is None:
res_sum = residual_sum_function(
sites_cart=sites_cart,
proxies=proxies,
gradient_array=self.gradients)
else:
res_sum = residual_sum_function(
unit_cell=unit_cell,
sites_cart=sites_cart,
proxies=proxies,
gradient_array=self.gradients)
self.number_of_restraints += n_proxies
self.residual_sum += res_sum
setattr(self, "n_%s_proxies" % name, n_proxies)
setattr(self, "%s_residual_sum" % name, res_sum)
# ====================================================================
# Managers
# ====================================================================
for name, manager in [("reference_dihedral",
reference_dihedral_manager),
("ncs_dihedral", ncs_dihedral_manager),
("den", den_manager),
("ramachandran", ramachandran_manager)]:
setattr(self, "n_%s_proxies" % name, None)
setattr(self, "%s_residual_sum" % name, 0)
if manager is not None:
n_proxies = manager.get_n_proxies()
res_sum = manager.target_and_gradients(
unit_cell=unit_cell,
sites_cart=sites_cart,
gradient_array=self.gradients)
self.number_of_restraints += n_proxies
self.residual_sum += res_sum
setattr(self, "n_%s_proxies" % name, n_proxies)
setattr(self, "%s_residual_sum" % name, res_sum)
# ====================================================================
# The rest (not yet unified)
# ====================================================================
if reference_coordinate_proxies is None:
self.n_reference_coordinate_proxies = None
self.reference_coordinate_residual_sum = 0
else:
import boost.python
ext = boost.python.import_ext("mmtbx_reference_coordinate_ext")
self.n_reference_coordinate_proxies = reference_coordinate_proxies.size(
)
self.reference_coordinate_residual_sum = \
ext.reference_coordinate_residual_sum(
sites_cart=sites_cart,
proxies=reference_coordinate_proxies,
gradient_array=self.gradients)
self.number_of_restraints += self.n_reference_coordinate_proxies
self.residual_sum += self.reference_coordinate_residual_sum
if (chirality_proxies is None):
self.n_chirality_proxies = None
self.chirality_residual_sum = 0
else:
self.n_chirality_proxies = len(chirality_proxies)
self.chirality_residual_sum = geometry_restraints.chirality_residual_sum(
sites_cart=sites_cart,
proxies=chirality_proxies,
gradient_array=self.gradients)
self.number_of_restraints += self.n_chirality_proxies
self.residual_sum += self.chirality_residual_sum
if (external_energy_function is not None):
self.external_energy = external_energy_function(
sites_cart=sites_cart, gradient_array=self.gradients)
self.residual_sum += self.external_energy
else:
self.external_energy = 0
for extension_obj in self.extension_objects:
extension_obj.energies_add(energies_obj=self)
self.finalize_target_and_gradients()
def exercise_grid_indices_around_sites():
unit_cell = uctbx.unit_cell((5,5,5))
fft_n_real = (5,5,5)
fft_m_real = (5,5,5)
site_radii = flex.double([0.5*3**0.5+1e-6])
def get():
grid_indices = maptbx.grid_indices_around_sites(
unit_cell=unit_cell, fft_n_real=fft_n_real, fft_m_real=fft_m_real,
sites_cart=sites_cart, site_radii=site_radii)
return list(grid_indices)
sites_cart = flex.vec3_double([(0.5,0.5,0.5)])
assert get() == [0, 1, 5, 6, 25, 26, 30, 31]
sites_cart = flex.vec3_double([(1.5,1.5,1.5)])
assert get() == [31, 32, 36, 37, 56, 57, 61, 62]
def sample():
for i in range(-2,7):
for j in range(-2,7):
for k in range(-2,7):
sites_cart = flex.vec3_double([(i+.5,j+.5,k+.5)])
assert len(get()) == 8
sample()
#
unit_cell = uctbx.unit_cell((5,6,7))
fft_n_real = (5,6,7)
fft_m_real = (5,6,7)
sites_cart = flex.vec3_double([(0.5,0.5,0.5)])
assert get() == [0, 1, 7, 8, 42, 43, 49, 50]
fft_m_real = (5,6,8)
assert get() == [0, 1, 8, 9, 48, 49, 56, 57]
fft_m_real = (5,7,8)
assert get() == [0, 1, 8, 9, 56, 57, 64, 65]
sample()
#
site_radii = flex.double([2])
assert len(get()) == 8 + 6*4
site_radii = flex.double([1000])
assert len(get()) == 5*6*7
#
unit_cell = uctbx.unit_cell((18,26,27))
fft_n_real = (18,26,27)
fft_m_real = (18,27,28)
for ish in range(5):
x = 2*ish+.5
sites_cart = flex.vec3_double([[x]*3])
sh = 3**0.5*(ish+0.5)
site_radii = flex.double([sh-1e-6])
s1 = set(get())
site_radii = flex.double([sh+1e-6])
s2 = set(get())
for gi in sorted(s2-s1):
i,j,k = n_dim_index_from_one_dim(gi, fft_m_real)
assert approx_equal(abs(matrix.col((i-x,j-x,k-x))), sh)
assert len(s1) == [0, 56, 304, 912, 1904][ish]
assert len(s2) == [8, 88, 360, 968, 2008][ish]
#
unit_cell = uctbx.unit_cell((8,9,7,80,100,110))
fft_n_real = (11,13,15)
fft_m_real = (18,26,19)
sites_cart = flex.vec3_double([(3,11,5)])
ls = []
prev = 0
for r in itertools.count(1):
site_radii = flex.double([r])
l = len(get())
assert l > prev
ls.append(l)
if (l == 11*13*15):
break
assert r < 7
prev = l
assert ls == [18, 155, 524, 1225, 1940, 2139, 2145]
#
fft_m_real = (1073741824, 1073741824, 1073741824)
try:
maptbx.grid_indices_around_sites(
unit_cell=unit_cell, fft_n_real=fft_n_real, fft_m_real=fft_m_real,
sites_cart=sites_cart, site_radii=site_radii)
except RuntimeError as e:
assert str(e).startswith("product of fft_m_real")
else: raise Exception_expected
