def get_f_masks(xrs, miller_array):
crystal_gridding = maptbx.crystal_gridding(
unit_cell = xrs.unit_cell(),
d_min = miller_array.d_min(),
resolution_factor = 1./4,
symmetry_flags = maptbx.use_space_group_symmetry,
space_group_info = xrs.space_group_info())
mp = mmtbx.masks.mask_master_params.extract()
mask_data = mmtbx.masks.mask_from_xray_structure(
xray_structure = xrs,
p1 = True,
solvent_radius = mp.solvent_radius,
shrink_truncation_radius = mp.shrink_truncation_radius,
for_structure_factors = True,
n_real = crystal_gridding.n_real()).mask_data
n = mask_data.all()
mask_data1 = flex.double(flex.grid(n), 0)
mask_data2 = flex.double(flex.grid(n), 0)
I,J,K = xrange(n[0]), xrange(n[1]), xrange(n[2])
for i in I:
for j in J:
for k in K:
if(i < n[0]//2 and j < n[1]//2 and k < n[2]//2):
mask_data1[i,j,k]=mask_data[i,j,k]
else:
mask_data2[i,j,k]=mask_data[i,j,k]
f_mask1 = miller_array.structure_factors_from_map(map=mask_data1,
use_scale = True, anomalous_flag = False, use_sg = False)
f_mask2 = miller_array.structure_factors_from_map(map=mask_data2,
use_scale = True, anomalous_flag = False, use_sg = False)
return [f_mask1.data(), f_mask2.data()]
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 plot_grid(values, grid, file_name, cmap=pyplot.cm.Reds,
vmin=None, vmax=None, invalid='white'):
values = values.as_double()
# At DLS, fast direction appears to be largest direction
if grid[0] > grid[1]:
values.reshape(flex.grid(reversed(grid)))
values = values.matrix_transpose()
else:
values.reshape(flex.grid(grid))
Z = values.as_numpy_array()
#f, (ax1, ax2) = pyplot.subplots(2)
f, ax1 = pyplot.subplots(1)
mesh1 = ax1.pcolormesh(
values.as_numpy_array(), cmap=cmap, vmin=vmin, vmax=vmax)
mesh1.cmap.set_under(color=invalid, alpha=None)
mesh1.cmap.set_over(color=invalid, alpha=None)
#mesh2 = ax2.contour(Z, cmap=cmap, vmin=vmin, vmax=vmax)
#mesh2 = ax2.contourf(Z, cmap=cmap, vmin=vmin, vmax=vmax)
ax1.set_aspect('equal')
ax1.invert_yaxis()
#ax2.set_aspect('equal')
#ax2.invert_yaxis()
pyplot.colorbar(mesh1, ax=ax1)
#pyplot.colorbar(mesh2, ax=ax2)
pyplot.savefig(file_name, dpi=600)
pyplot.clf()
def get_f_masks(xrs, miller_array):
crystal_gridding = maptbx.crystal_gridding(
unit_cell=xrs.unit_cell(),
d_min=miller_array.d_min(),
resolution_factor=1. / 4,
symmetry_flags=maptbx.use_space_group_symmetry,
space_group_info=xrs.space_group_info())
mp = mmtbx.masks.mask_master_params.extract()
mask_data = mmtbx.masks.mask_from_xray_structure(
xray_structure=xrs,
p1=True,
solvent_radius=mp.solvent_radius,
shrink_truncation_radius=mp.shrink_truncation_radius,
for_structure_factors=True,
n_real=crystal_gridding.n_real()).mask_data
n = mask_data.all()
mask_data1 = flex.double(flex.grid(n), 0)
mask_data2 = flex.double(flex.grid(n), 0)
I, J, K = range(n[0]), range(n[1]), range(n[2])
for i in I:
for j in J:
for k in K:
if (i < n[0] // 2 and j < n[1] // 2 and k < n[2] // 2):
mask_data1[i, j, k] = mask_data[i, j, k]
else:
mask_data2[i, j, k] = mask_data[i, j, k]
f_mask1 = miller_array.structure_factors_from_map(map=mask_data1,
use_scale=True,
anomalous_flag=False,
use_sg=False)
f_mask2 = miller_array.structure_factors_from_map(map=mask_data2,
use_scale=True,
anomalous_flag=False,
use_sg=False)
return [f_mask1.data(), f_mask2.data()]
def get_proposal_score(reports_as_lists):
n_proposal_score = 0
NN = len(reports_as_lists) # = n_tranches x n_operators
rij = flex.double(flex.grid(NN, NN), 0.)
wij = flex.double(flex.grid(NN, NN), 1.)
for ix in range(len(reports_as_lists)):
base_report = reports_as_lists[ix]
# compute the unions
base_all = set(base_report[0])
for icoset in range(1, len(base_report)):
base_all = base_all.union(set(base_report[icoset]))
for iy in range(len(reports_as_lists)):
test_report = reports_as_lists[iy]
matches = 0
# compute the unions
test_all = set(test_report[0])
for icoset in range(1, len(test_report)):
test_all = test_all.union(set(test_report[icoset]))
# total overlap between base and test irrespective of cosets;
total_overlay = len(base_all.intersection(test_all))
for icoset in range(len(test_report)):
matches += len(
set(base_report[icoset]).intersection(
set(test_report[icoset])))
print('%3d/%3d' % (matches, total_overlay), end=' ')
rij[(ix,
iy)] = matches / total_overlay if total_overlay > 0 else 0.
wij[(ix, iy)] = total_overlay if total_overlay > 0 else 1.
n_proposal_score += matches
print()
return rij, wij
def plot_grid(
values,
grid,
file_name,
cmap=pyplot.cm.Reds,
vmin=None,
vmax=None,
invalid="white",
):
values = values.as_double()
# At DLS, fast direction appears to be largest direction
if grid[0] > grid[1]:
values.reshape(flex.grid(reversed(grid)))
values = values.matrix_transpose()
else:
values.reshape(flex.grid(grid))
f, ax1 = pyplot.subplots(1)
mesh1 = ax1.pcolormesh(values.as_numpy_array(), cmap=cmap, vmin=vmin, vmax=vmax)
mesh1.cmap.set_under(color=invalid, alpha=None)
mesh1.cmap.set_over(color=invalid, alpha=None)
ax1.set_aspect("equal")
ax1.invert_yaxis()
pyplot.colorbar(mesh1, ax=ax1)
pyplot.savefig(file_name, dpi=600)
pyplot.clf()
def __init__(
self,
crystal_gridding,
crystal_symmetry,
f_map=None,
map_data=None,
miller_array=None,
d_min = None): #XXX =1: more features and noise
# process inputs
assert [f_map, map_data].count(None) == 1
if(f_map is not None):
import cctbx.miller
fft_map = cctbx.miller.fft_map(
crystal_gridding = crystal_gridding,
fourier_coefficients = f_map)
fft_map.apply_sigma_scaling()
map_data = fft_map.real_map_unpadded()
#
self.map_result = None
self.map_coefficients = None
b = boxes(
n_real = crystal_gridding.n_real(),
fraction = 0.03)
# Loop over boxes, fill map_result with one box at a time
self.map_result = flex.double(flex.grid(b.n_real))
for s,e in zip(b.starts, b.ends):
box = copy(map_data, s, e)
box.reshape(flex.grid(box.all()))
mi,ma,me = box.as_1d().min_max_mean().as_tuple()
if(mi < ma):
box = volume_scale(map = box, n_bins = 1000).map_data()
set_box(
map_data_from = box,
map_data_to = self.map_result,
start = s,
end = e)
sd = self.map_result.sample_standard_deviation()
self.map_result = self.map_result/sd
if(miller_array is not None):
complete_set = miller_array
if(d_min is not None):
d_min = miller_array.d_min()
complete_set = miller_array.complete_set(d_min=d_min)
self.map_coefficients = complete_set.structure_factors_from_map(
map = self.map_result,
use_scale = True,
anomalous_flag = False,
use_sg = False)
def peak_search(self, parameters, map, verify_symmetry=True):
if (parameters is None):
parameters = peak_search_parameters()
if (verify_symmetry and libtbx.env.full_testing):
assert self._tags.verify(map)
if (map.accessor().is_padded()):
map = copy(map, flex.grid(map.focus()))
grid_peaks = peak_list(
data=map,
tags=self._tags.tag_array(),
peak_search_level=parameters.peak_search_level(),
max_peaks=parameters.max_peaks(),
peak_cutoff=parameters.peak_cutoff(),
interpolate=parameters.interpolate())
if (parameters.min_distance_sym_equiv() is None):
return grid_peaks
return peak_cluster_analysis(
peak_list=grid_peaks,
special_position_settings=crystal.special_position_settings(
crystal_symmetry=self.crystal_symmetry(),
min_distance_sym_equiv=parameters.min_distance_sym_equiv()),
general_positions_only=parameters.general_positions_only(),
effective_resolution=parameters.effective_resolution(),
significant_height_fraction=parameters.significant_height_fraction(),
cluster_height_fraction=parameters.cluster_height_fraction(),
min_cross_distance=parameters.min_cross_distance(),
max_clusters=parameters.max_clusters(),
min_cubicle_edge=parameters.min_cubicle_edge())
def exercise_f000():
miller_indices = flex.miller_index([(0,0,0)])
data = flex.complex_double([1-2j])
n_real = [1,2,3]
conjugate_flag = True
for hall_symbol in ["P 1", "P 3", "R 3*"]:
for is_centric in [False, True]:
if (not is_centric):
space_group = sgtbx.space_group(hall_symbol)
else:
space_group.expand_smx("-x,-y,-z")
for anomalous_flag in [False, True]:
if (not anomalous_flag):
rfft = fftpack.real_to_complex_3d(n_real)
n_complex = rfft.n_complex()
else:
cfft = fftpack.complex_to_complex_3d(n_real)
n_complex = cfft.n()
for treat_restricted in [False, True]:
map = maptbx.structure_factors.to_map(
space_group=space_group,
anomalous_flag=anomalous_flag,
miller_indices=miller_indices,
structure_factors=data,
n_real=n_real,
map_grid=flex.grid(n_complex),
conjugate_flag=conjugate_flag,
treat_restricted=treat_restricted)
if (treat_restricted):
assert approx_equal(
map.complex_map()[0], data[0])
else:
assert approx_equal(
map.complex_map()[0], data[0]*space_group.order_p())
def plot_positions(values, positions, file_name, cmap=pyplot.cm.Reds,
vmin=None, vmax=None, invalid='white'):
values = values.as_double()
assert positions.size() >= values.size()
positions = positions[:values.size()]
if vmin is None:
vmin = flex.min(values)
if vmax is None:
vmax = flex.max(values)
x, y = positions.parts()
dx = flex.abs(x[1:] - x[:-1])
dy = flex.abs(y[1:] - y[:-1])
dx = dx.select(dx > 0)
dy = dy.select(dy > 0)
scale = 1/flex.min(dx)
#print scale
x = (x * scale).iround()
y = (y * scale).iround()
from libtbx.math_utils import iceil
z = flex.double(flex.grid(iceil(flex.max(y))+1, iceil(flex.max(x))+1), -2)
#print z.all()
for x_, y_, z_ in zip(x, y, values):
z[y_, x_] = z_
plot_grid(z.as_1d(), z.all(), file_name, cmap=cmap, vmin=vmin, vmax=vmax,
invalid=invalid)
return
def hessian_transform(self,
original_hessian,
adp_constraints):
constraint_matrix_tensor = matrix.rec(
adp_constraints.gradient_sum_matrix(),
adp_constraints.gradient_sum_matrix().focus())
hessian_matrix = matrix.rec( original_hessian,
original_hessian.focus())
## now create an expanded matrix
rows=adp_constraints.gradient_sum_matrix().focus()[0]+1
columns=adp_constraints.gradient_sum_matrix().focus()[1]+1
expanded_constraint_array = flex.double(rows*columns,0)
count_new=0
count_old=0
for ii in range(rows):
for jj in range(columns):
if (ii>0):
if (jj>0):
expanded_constraint_array[count_new]=\
constraint_matrix_tensor[count_old]
count_old+=1
count_new+=1
## place the first element please
expanded_constraint_array[0]=1
result=matrix.rec( expanded_constraint_array,
(rows, columns) )
#print result.mathematica_form()
new_hessian = result * hessian_matrix * result.transpose()
result = flex.double(new_hessian)
result.resize(flex.grid( new_hessian.n ) )
return(result)
def plot_positions(values, positions, file_name, cmap=pyplot.cm.Reds,
vmin=None, vmax=None, invalid='white'):
values = values.as_double()
assert positions.size() >= values.size()
positions = positions[:values.size()]
if vmin is None:
vmin = flex.min(values)
if vmax is None:
vmax = flex.max(values)
x, y = positions.parts()
dx = flex.abs(x[1:] - x[:-1])
dy = flex.abs(y[1:] - y[:-1])
dx = dx.select(dx > 0)
dy = dy.select(dy > 0)
scale = 1/flex.min(dx)
#print scale
x = (x * scale).iround()
y = (y * scale).iround()
from libtbx.math_utils import iceil
z = flex.double(flex.grid(iceil(flex.max(y))+1, iceil(flex.max(x))+1), -2)
#print z.all()
for x_, y_, z_ in zip(x, y, values):
z[y_, x_] = z_
plot_grid(z.as_1d(), z.all(), file_name, cmap=cmap, vmin=vmin, vmax=vmax,
invalid=invalid)
return
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 exercise_f000():
miller_indices = flex.miller_index([(0, 0, 0)])
data = flex.complex_double([1 - 2j])
n_real = [1, 2, 3]
conjugate_flag = True
for hall_symbol in ["P 1", "P 3", "R 3*"]:
for is_centric in [False, True]:
if (not is_centric):
space_group = sgtbx.space_group(hall_symbol)
else:
space_group.expand_smx("-x,-y,-z")
for anomalous_flag in [False, True]:
if (not anomalous_flag):
rfft = fftpack.real_to_complex_3d(n_real)
n_complex = rfft.n_complex()
else:
cfft = fftpack.complex_to_complex_3d(n_real)
n_complex = cfft.n()
for treat_restricted in [False, True]:
map = maptbx.structure_factors.to_map(
space_group=space_group,
anomalous_flag=anomalous_flag,
miller_indices=miller_indices,
structure_factors=data,
n_real=n_real,
map_grid=flex.grid(n_complex),
conjugate_flag=conjugate_flag,
treat_restricted=treat_restricted)
if (treat_restricted):
assert approx_equal(map.complex_map()[0], data[0])
else:
assert approx_equal(map.complex_map()[0],
data[0] * space_group.order_p())
def exercise_sample_all_mask_regions():
cmap = flex.double(flex.grid(30,30,30))
cmap.fill(1)
for i in range(0,10):
for j in range(0,10):
for k in range(0,10):
cmap[i,j,k] = 10
for i in range(15,25):
for j in range(15,25):
for k in range(15,25):
cmap[i,j,k] = 20
co = maptbx.connectivity(map_data=cmap, threshold=5, wrapping=False)
uc = uctbx.unit_cell((10,10,10))
mask_result = co.result()
sample_regs_obj = maptbx.sample_all_mask_regions(
mask=mask_result,
volumes=flex.int([0, 1000,1000]),
sampling_rates=flex.int([0, 10,10]),
unit_cell=uc)
a = sample_regs_obj.get_array(1)
b = sample_regs_obj.get_array(2)
assert a.size() == b.size() == 101
assert approx_equal(a[0], (0,0,0))
assert approx_equal(b[0], (5,5,5))
def get_map(): av = [random.random() for i in xrange(10*20*30)] m = flex.double(av) m = m-flex.min(m) m = m/flex.max(m) m.resize(flex.grid((10,20,30))) return m
def prepare_target_map(self): # XXX This may need to go external
if self.map_data is None:
# This just makes dummy map to allow functionality working without it.
self.map_data = flex.double(flex.grid(50,50,50), 0)
map_data = self.map_data.deep_copy()
# truncate map
selection = self.atom_selection_cache.selection(
string = "element C or element O or element N")
mean_atom = flex.double()
for i_a, a in enumerate(list(self.pdb_hierarchy.atoms())):
if(selection[i_a]):
site_frac = self.crystal_symmetry.unit_cell().fractionalize(a.xyz)
mean_atom.append(map_data.eight_point_interpolation(site_frac))
mean_atom = flex.mean(mean_atom)
map_data = map_data.set_selected(map_data>mean_atom, mean_atom)
# Blend maps if applicable
if(self.diff_map_data is not None):
diff_map_data = self.diff_map_data.deep_copy()
sel = diff_map_data < 2.
diff_map_data = diff_map_data.set_selected(sel, 0)
sel = diff_map_data > 3.
diff_map_data = diff_map_data.set_selected(sel, 3)
diff_map_data = diff_map_data/3.
maptbx.combine_1(map_data=map_data, diff_map=diff_map_data)
return map_data
def calculate_exp_i_two_phi_peaks(xray_structure, d_min,
min_peak_distance,
max_reduced_peaks):
f_h = xray_structure.structure_factors(
anomalous_flag=False,
d_min=d_min).f_calc()
two_i_phi_h = miller.array(
miller_set=f_h,
data=flex.polar(1, flex.arg(f_h.data())*2))
fft_map = two_i_phi_h.fft_map(
d_min=d_min,
symmetry_flags=maptbx.use_space_group_symmetry)
real_map = fft_map.real_map()
real_map = maptbx.copy(real_map, flex.grid(real_map.focus()))
stats = maptbx.statistics(real_map)
if (stats.max() != 0):
real_map /= abs(stats.max())
grid_tags = maptbx.grid_tags(real_map.focus())
grid_tags.build(fft_map.space_group_info().type(), fft_map.symmetry_flags())
grid_tags.verify(real_map)
peak_list = maptbx.peak_list(
data=real_map,
tags=grid_tags.tag_array(),
max_peaks=10*max_reduced_peaks,
interpolate=True)
reduced_peaks = peak_cluster_reduction(
crystal_symmetry=xray_structure,
peak_list=peak_list,
min_peak_distance=min_peak_distance,
max_reduced_peaks=max_reduced_peaks)
return reduced_peaks
def peak_search(self, parameters, map, verify_symmetry=True):
if (parameters is None):
parameters = peak_search_parameters()
if (verify_symmetry and libtbx.env.full_testing):
assert self._tags.verify(map)
if (map.accessor().is_padded()):
map = copy(map, flex.grid(map.focus()))
grid_peaks = peak_list(
data=map,
tags=self._tags.tag_array(),
peak_search_level=parameters.peak_search_level(),
max_peaks=parameters.max_peaks(),
peak_cutoff=parameters.peak_cutoff(),
interpolate=parameters.interpolate())
if (parameters.min_distance_sym_equiv() is None):
return grid_peaks
return peak_cluster_analysis(
peak_list=grid_peaks,
special_position_settings=crystal.special_position_settings(
crystal_symmetry=self.crystal_symmetry(),
min_distance_sym_equiv=parameters.min_distance_sym_equiv()),
general_positions_only=parameters.general_positions_only(),
effective_resolution=parameters.effective_resolution(),
significant_height_fraction=parameters.significant_height_fraction(
),
cluster_height_fraction=parameters.cluster_height_fraction(),
min_cross_distance=parameters.min_cross_distance(),
max_clusters=parameters.max_clusters(),
min_cubicle_edge=parameters.min_cubicle_edge())
def exercise_average_density():
map = test_map.deep_copy()
map.resize(flex.grid(4,5,6))
sites_frac = flex.vec3_double([
(-0.8492400683111605, 0.49159543530354166, 0.55624239788303198),
(0.10631567870879444, -0.38726326483005269, -0.13581656178827783),
(0.1895918946688977, -0.25027164520003642, -0.61981792226895172),
(-0.88980846616667897, -0.79492758628794169, 0.015347308715653485)])
unit_cell = uctbx.unit_cell((130,130,288,90,90,120))
densities = maptbx.average_densities(
unit_cell=unit_cell,
data=map,
sites_frac=sites_frac,
radius=5)
assert approx_equal(densities, [0,0,0,0])
densities = maptbx.average_densities(
unit_cell=unit_cell,
data=map,
sites_frac=sites_frac,
radius=50)
assert approx_equal(densities, [
-0.27089094117647061,
-0.34313799999999994,
-0.2644232307692308,
-0.20403226666666666])
def map_centroids_to_reciprocal_space_grid(self):
d_min = self.params.fft3d.reciprocal_space_grid.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")
logger.info("FFT gridding: (%i,%i,%i)" %self.gridding)
grid = flex.double(flex.grid(self.gridding), 0)
selection = self.reflections['id'] == -1
if self.params.b_iso is libtbx.Auto:
self.params.b_iso = -4 * d_min**2 * math.log(0.05)
logger.debug("Setting b_iso = %.1f" %self.params.b_iso)
from dials.algorithms.indexing import map_centroids_to_reciprocal_space_grid
map_centroids_to_reciprocal_space_grid(
grid, self.reflections['rlp'], selection,
d_min, b_iso=self.params.b_iso)
reflections_used_for_indexing = selection.iselection()
self.reciprocal_space_grid = grid
self.reflections_used_for_indexing = reflections_used_for_indexing
def show_plot(widegrid, excursi):
excursi.reshape(flex.grid(widegrid, widegrid))
plot_max = flex.max(excursi)
idx_max = flex.max_index(excursi)
def igrid(x):
return x - (widegrid // 2)
idxs = [igrid(i) * plot_px_sz for i in xrange(widegrid)]
from matplotlib import pyplot as plt
plt.figure()
CS = plt.contour(
[igrid(i) * plot_px_sz for i in xrange(widegrid)],
[igrid(i) * plot_px_sz for i in xrange(widegrid)],
excursi.as_numpy_array())
plt.clabel(CS, inline=1, fontsize=10, fmt="%6.3f")
plt.title("Wide scope search for detector origin offset")
plt.scatter([0.0], [0.0], color='g', marker='o')
plt.scatter([new_offset[0]], [new_offset[1]],
color='r',
marker='*')
plt.scatter([idxs[idx_max % widegrid]],
[idxs[idx_max // widegrid]],
color='k',
marker='s')
plt.axes().set_aspect("equal")
plt.xlabel("offset (mm) along beamr1 vector")
plt.ylabel("offset (mm) along beamr2 vector")
plt.savefig("search_scope.png")
#changing value
trial_origin_offset = (idxs[idx_max % widegrid]) * beamr1 + (
idxs[idx_max // widegrid]) * beamr2
return trial_origin_offset
def _massage_map(self):
self.ma.add(" input map (min,max,mean): %s" % self._map_mmm_str())
#
self.map_data = self.map_data - flex.mean(self.map_data)
self.map_data = self.map_data.set_selected(self.map_data < 0, 0)
sd = self.map_data.sample_standard_deviation()
assert sd != 0
self.map_data = self.map_data / sd
self.ma.add(" re-scaled map (min,max,mean): %s" % self._map_mmm_str())
if (self.debug):
self._write_map(file_name="rescaled.mrc")
#
a, b, c = self.unit_cell.parameters()[:3]
n_real = self.map_data.accessor().all()
sx, sy, sz = a / n_real[0], b / n_real[1], c / n_real[2]
self.ma.add(" input map dimenstions: %d %d %d" % n_real)
self.ma.add(" input map grid steps (A): %s %s %s" %
(("%6.3f" % sx).strip(), ("%6.3f" % sy).strip(),
("%6.3f" % sz).strip()))
if (max(sx, sy, sz) > self.step):
n_real_fine = (int(a / self.step), int(b / self.step),
int(c / self.step))
self.ma.add(" re-sampled map dimenstions: %d %d %d" % n_real_fine)
map_fine = flex.double(flex.grid(n_real_fine), 0)
maptbx.resample(map_data=self.map_data,
map_data_new=map_fine,
unit_cell=self.unit_cell)
self.map_data = map_fine
self.ma.add(" input map (min,max,mean): %s" % self._map_mmm_str())
if (self.debug):
self._write_map(file_name="resampled.mrc")
def show_plot(widegrid,excursi):
excursi.reshape(flex.grid(widegrid, widegrid))
plot_max = flex.max(excursi)
idx_max = flex.max_index(excursi)
def igrid(x): return x - (widegrid//2)
idxs = [igrid(i)*plot_px_sz for i in xrange(widegrid)]
from matplotlib import pyplot as plt
plt.figure()
CS = plt.contour([igrid(i)*plot_px_sz for i in xrange(widegrid)],
[igrid(i)*plot_px_sz for i in xrange(widegrid)], excursi.as_numpy_array())
plt.clabel(CS, inline=1, fontsize=10, fmt="%6.3f")
plt.title("Wide scope search for detector origin offset")
plt.scatter([0.0],[0.0],color='g',marker='o')
plt.scatter([new_offset[0]] , [new_offset[1]],color='r',marker='*')
plt.scatter([idxs[idx_max%widegrid]] , [idxs[idx_max//widegrid]],color='k',marker='s')
plt.axes().set_aspect("equal")
plt.xlabel("offset (mm) along beamr1 vector")
plt.ylabel("offset (mm) along beamr2 vector")
plt.show()
#changing value
trial_origin_offset = (idxs[idx_max%widegrid])*beamr1 + (idxs[idx_max//widegrid])*beamr2
return trial_origin_offset
def direct_space_squaring(start, selection_fixed):
map_gridding = miller.index_span(
miller.set.expand_to_p1(start).indices()).map_grid()
if (selection_fixed is None):
fixed = start
var = start
else:
fixed = start.select(selection_fixed)
var = start.select(~selection_fixed)
rfft = fftpack.real_to_complex_3d([n * 3 // 2 for n in map_gridding])
conjugate_flag = True
structure_factor_map = maptbx.structure_factors.to_map(
space_group=fixed.space_group(),
anomalous_flag=fixed.anomalous_flag(),
miller_indices=fixed.indices(),
structure_factors=fixed.data(),
n_real=rfft.n_real(),
map_grid=flex.grid(rfft.n_complex()),
conjugate_flag=conjugate_flag)
real_map = rfft.backward(structure_factor_map.complex_map())
squared_map = flex.pow2(real_map)
squared_sf_map = rfft.forward(squared_map)
allow_miller_indices_outside_map = False
from_map = maptbx.structure_factors.from_map(
anomalous_flag=var.anomalous_flag(),
miller_indices=var.indices(),
complex_map=squared_sf_map,
conjugate_flag=conjugate_flag,
allow_miller_indices_outside_map=allow_miller_indices_outside_map)
if (selection_fixed is None):
return from_map.data()
result = start.data().deep_copy()
result.set_selected(~selection_fixed, from_map.data())
assert result.select(selection_fixed).all_eq(fixed.data())
return result
def hessian_transform(self,
original_hessian,
adp_constraints):
constraint_matrix_tensor = matrix.rec(
adp_constraints.gradient_sum_matrix(),
adp_constraints.gradient_sum_matrix().focus())
hessian_matrix = matrix.rec( original_hessian,
original_hessian.focus())
## now create an expanded matrix
rows=adp_constraints.gradient_sum_matrix().focus()[0]+1
columns=adp_constraints.gradient_sum_matrix().focus()[1]+1
expanded_constraint_array = flex.double(rows*columns,0)
count_new=0
count_old=0
for ii in range(rows):
for jj in range(columns):
if (ii>0):
if (jj>0):
expanded_constraint_array[count_new]=\
constraint_matrix_tensor[count_old]
count_old+=1
count_new+=1
## place the first element please
expanded_constraint_array[0]=1
result=matrix.rec( expanded_constraint_array,
(rows, columns) )
#print result.mathematica_form()
new_hessian = result * hessian_matrix * result.transpose()
result = flex.double(new_hessian)
result.resize(flex.grid( new_hessian.n ) )
return(result)
def python_tensor_constraints(self, reciprocal_space):
"""row-reduced echelon form of coefficients
r.transpose() * t * r - t = 0
Mathematica code:
r={{r0,r1,r2},{r3,r4,r5},{r6,r7,r8}}
t={{t0,t3,t4},{t3,t1,t5},{t4,t5,t2}}
FortranForm[Expand[Transpose[r].t.r - t]]
"""
result = flex.int()
for s in self.smx():
r = s.r()
if (reciprocal_space):
r = r.transpose()
r0, r1, r2, r3, r4, r5, r6, r7, r8 = r.num()
result.extend(
flex.int(
(r0 * r0 - 1, r3 * r3, r6 * r6, 2 * r0 * r3, 2 * r0 * r6,
2 * r3 * r6, r1 * r1, r4 * r4 - 1, r7 * r7, 2 * r1 * r4,
2 * r1 * r7, 2 * r4 * r7, r2 * r2, r5 * r5, r8 * r8 - 1,
2 * r2 * r5, 2 * r2 * r8, 2 * r5 * r8, r0 * r1, r3 * r4,
r6 * r7, r1 * r3 + r0 * r4 - 1, r1 * r6 + r0 * r7,
r4 * r6 + r3 * r7, r0 * r2, r3 * r5, r6 * r8,
r2 * r3 + r0 * r5, r2 * r6 + r0 * r8 - 1, r5 * r6 + r3 * r8,
r1 * r2, r4 * r5, r7 * r8, r2 * r4 + r1 * r5,
r2 * r7 + r1 * r8, r5 * r7 + r4 * r8 - 1)))
result.resize(flex.grid(result.size() // 6, 6))
scitbx.math.row_echelon_form(result)
return result
def show_plot(OO,excursi,rmsdpos,minimum):
excursi.reshape(flex.grid(len(OO.grid), len(OO.grid)))
rmsdpos.reshape(flex.grid(len(OO.grid), len(OO.grid)))
from matplotlib import pyplot as plt
plt.figure()
CS = plt.contour([i*0.02 for i in OO.grid],[i*0.02 for i in OO.grid], excursi.as_numpy_array())
plt.clabel(CS, inline=1, fontsize=10, fmt="%6.3f"+unichr(176))
plt.plot([minimum[1]*180./math.pi],[minimum[0]*180./math.pi], "r+")
plt.title("Rms rotational excursion to reflection condition, degrees")
plt.axes().set_aspect("equal")
plt.figure()
CS = plt.contour([i*0.02 for i in OO.grid],[i*0.02 for i in OO.grid], rmsdpos.as_numpy_array())
plt.clabel(CS, inline=1, fontsize=10, fmt="%7.4f px")
plt.title("Rms position shift, obs vs. model, pixels")
plt.axes().set_aspect("equal")
plt.show()
def show_plot(OO,excursi,rmsdpos,minimum):
excursi.reshape(flex.grid(len(OO.grid), len(OO.grid)))
rmsdpos.reshape(flex.grid(len(OO.grid), len(OO.grid)))
from matplotlib import pyplot as plt
plt.figure()
CS = plt.contour([i*0.02 for i in OO.grid],[i*0.02 for i in OO.grid], excursi.as_numpy_array())
plt.clabel(CS, inline=1, fontsize=10, fmt="%6.3f"+unichr(176))
plt.plot([minimum[1]*180./math.pi],[minimum[0]*180./math.pi], "r+")
plt.title("Rms rotational excursion to reflection condition, degrees")
plt.axes().set_aspect("equal")
plt.figure()
CS = plt.contour([i*0.02 for i in OO.grid],[i*0.02 for i in OO.grid], rmsdpos.as_numpy_array())
plt.clabel(CS, inline=1, fontsize=10, fmt="%7.4f px")
plt.title("Rms position shift, obs vs. model, pixels")
plt.axes().set_aspect("equal")
plt.show()
def exercise_peak_search():
t = flex.long(flex.grid((3,4,5)))
for flex_type in flex_types():
d = flex_type(flex.grid((3,4,5)))
l = maptbx.peak_list(d, t, peak_search_level=0, interpolate=False)
assert l.gridding() == d.focus()
assert l.grid_indices(0) == (0,0,0)
assert list(l.grid_heights()) == [0]
assert list(l.sites()) == [(0,0,0)]
assert list(l.heights()) == [0]
l = maptbx.peak_list(
d, t, peak_search_level=0,peak_cutoff=-1, interpolate=False)
assert l.gridding() == d.focus()
assert l.grid_indices(0) == (0,0,0)
assert list(l.grid_heights()) == [0]
assert list(l.sites()) == [(0,0,0)]
assert list(l.heights()) == [0]
def get_ma(n1,n2,n3, points):
ma = maptbx.map_accumulator(n_real = (n1,n2,n3), use_max_map=False)
for value in points:
m = [value for i in xrange(n1*n2*n3)]
m = flex.double(m)
m.resize(flex.grid((n1,n2,n3)))
ma.add(map_data=m)
return ma
def compute_i_mask_asu(self, selection, volume):
mask_i = flex.double(flex.grid(self.n_real), 0)
mask_i = mask_i.set_selected(selection, 1)
if (self.write_masks):
write_map_file(crystal_symmetry=self.crystal_symmetry,
map_data=mask_i,
file_name="mask_%s.mrc" % str(round(volume, 3)))
return asu_map_ext.asymmetric_map(
self.crystal_symmetry.space_group().type(), mask_i).data()
def main(filenames, map_file, npoints=192, max_resolution=6, reverse_phi=False):
rec_range = 1 / max_resolution
image = ImageFactory(filenames[0])
panel = image.get_detector()[0]
beam = image.get_beam()
s0 = beam.get_s0()
pixel_size = panel.get_pixel_size()
xlim, ylim = image.get_raw_data().all()
xy = recviewer.get_target_pixels(panel, s0, xlim, ylim, max_resolution)
s1 = panel.get_lab_coord(xy * pixel_size[0]) # FIXME: assumed square pixel
s1 = s1 / s1.norms() * (1 / beam.get_wavelength()) # / is not supported...
S = s1 - s0
grid = flex.double(flex.grid(npoints, npoints, npoints), 0)
cnts = flex.int(flex.grid(npoints, npoints, npoints), 0)
for filename in filenames:
print "Processing image", filename
try:
fill_voxels(ImageFactory(filename), grid, cnts, S, xy, reverse_phi, rec_range)
except:
print " Failed to process. Skipped this."
recviewer.normalize_voxels(grid, cnts)
uc = uctbx.unit_cell((npoints, npoints, npoints, 90, 90, 90))
ccp4_map.write_ccp4_map(map_file, uc, sgtbx.space_group("P1"),
(0, 0, 0), grid.all(), grid,
flex.std_string(["cctbx.miller.fft_map"]))
return
from scitbx import fftpack
fft = fftpack.complex_to_complex_3d(grid.all())
grid_complex = flex.complex_double(
reals=flex.pow2(grid),
imags=flex.double(grid.size(), 0))
grid_transformed = flex.abs(fft.backward(grid_complex))
print flex.max(grid_transformed), flex.min(grid_transformed), grid_transformed.all()
ccp4_map.write_ccp4_map(map_file, uc, sgtbx.space_group("P1"),
(0, 0, 0), grid.all(), grid_transformed,
flex.std_string(["cctbx.miller.fft_map"]))
def __init__(self,
crystal_gridding,
crystal_symmetry,
f_map=None,
map_data=None,
miller_array=None,
d_min=None): #XXX =1: more features and noise
# process inputs
assert [f_map, map_data].count(None) == 1
if (f_map is not None):
import cctbx.miller
fft_map = cctbx.miller.fft_map(crystal_gridding=crystal_gridding,
fourier_coefficients=f_map)
fft_map.apply_sigma_scaling()
map_data = fft_map.real_map_unpadded()
#
self.map_result = None
self.map_coefficients = None
b = boxes(n_real=crystal_gridding.n_real(), fraction=0.03)
# Loop over boxes, fill map_result with one box at a time
self.map_result = flex.double(flex.grid(b.n_real))
for s, e in zip(b.starts, b.ends):
box = copy(map_data, s, e)
box.reshape(flex.grid(box.all()))
mi, ma, me = box.as_1d().min_max_mean().as_tuple()
if (mi < ma):
box = volume_scale(map=box, n_bins=1000).map_data()
set_box(map_data_from=box,
map_data_to=self.map_result,
start=s,
end=e)
sd = self.map_result.sample_standard_deviation()
self.map_result = self.map_result / sd
if (miller_array is not None):
complete_set = miller_array
if (d_min is not None):
d_min = miller_array.d_min()
complete_set = miller_array.complete_set(d_min=d_min)
self.map_coefficients = complete_set.structure_factors_from_map(
map=self.map_result,
use_scale=True,
anomalous_flag=False,
use_sg=False)
def intersection(cuts):
assert len(cuts) == 3
m = flex.int()
t = flex.int()
denominator = 1
for cut in cuts:
denominator = cut.lcm_of_denominators(start_lcm=denominator)
for cut in cuts:
for e in cut.n: m.append(int(e * denominator))
t.append(-int(cut.c * denominator))
m.reshape(flex.grid(3,3))
t.reshape(flex.grid(3,1))
r = scitbx.math.row_echelon_form_t(m, t)
assert r in (2,3)
if (r != 3): return None
t.reshape(flex.grid(3))
sol = flex.int(3)
d = scitbx.math.row_echelon_back_substitution_int(m, t, sol)
assert d > 0
return tuple([rational.int(s,d) for s in sol])
def d2_dw_d_u_star_d_u_star_finite(h, u_star, eps=1.e-6):
result = flex.double()
for ip in xrange(len(u_star)):
vs = []
for signed_eps in [eps,-eps]:
u_star_eps = list(u_star)
u_star_eps[ip] += signed_eps
vs.append(d_dw_d_u_star_analytical(h, u_star_eps))
result.extend((vs[0]-vs[1])/(2*eps))
result.reshape(flex.grid(6,6))
return result.matrix_symmetric_as_packed_u(relative_epsilon=1.e-5)
def compute_shoebox_overlap_fraction(self, overlaps):
'''
Compute the fraction of shoebox overlapping.
:param overlaps: The list of overlaps
:return: The fraction of shoebox overlapped with other reflections
'''
from dials.array_family import flex
result = flex.double(len(self))
bbox = self['bbox']
for i in range(len(self)):
b1 = bbox[i]
xs = b1[1] - b1[0]
ys = b1[3] - b1[2]
zs = b1[5] - b1[4]
assert (xs > 0)
assert (ys > 0)
assert (zs > 0)
mask = flex.bool(flex.grid(zs, ys, xs), False)
for edge in overlaps.adjacent_vertices(i):
b2 = bbox[edge]
x0 = b2[0] - b1[0]
x1 = b2[1] - b1[0]
y0 = b2[2] - b1[2]
y1 = b2[3] - b1[2]
z0 = b2[4] - b1[4]
z1 = b2[5] - b1[4]
if x0 < 0: x0 = 0
if y0 < 0: y0 = 0
if z0 < 0: z0 = 0
if x1 > xs: x1 = xs
if y1 > ys: y1 = ys
if z1 > zs: z1 = zs
assert (x1 > x0)
assert (y1 > y0)
assert (z1 > z0)
m2 = flex.bool(flex.grid(z1 - z0, y1 - y0, x1 - x0), True)
mask[z0:z1, y0:y1, x0:x1] = m2
result[i] = (1.0 * mask.count(True)) / mask.size()
return result
def compute_shoebox_overlap_fraction(self, overlaps):
'''
Compute the fraction of shoebox overlapping.
:param overlaps: The list of overlaps
:return: The fraction of shoebox overlapped with other reflections
'''
from dials.array_family import flex
result = flex.double(len(self))
bbox = self['bbox']
for i in range(len(self)):
b1 = bbox[i]
xs = b1[1] - b1[0]
ys = b1[3] - b1[2]
zs = b1[5] - b1[4]
assert(xs > 0)
assert(ys > 0)
assert(zs > 0)
mask = flex.bool(flex.grid(zs,ys,xs),False)
for edge in overlaps.adjacent_vertices(i):
b2 = bbox[edge]
x0 = b2[0]-b1[0]
x1 = b2[1]-b1[0]
y0 = b2[2]-b1[2]
y1 = b2[3]-b1[2]
z0 = b2[4]-b1[4]
z1 = b2[5]-b1[4]
if x0 < 0: x0 = 0
if y0 < 0: y0 = 0
if z0 < 0: z0 = 0
if x1 > xs: x1 = xs
if y1 > ys: y1 = ys
if z1 > zs: z1 = zs
assert(x1 > x0)
assert(y1 > y0)
assert(z1 > z0)
m2 = flex.bool(flex.grid(z1-z0,y1-y0,x1-x0),True)
mask[z0:z1,y0:y1,x0:x1] = m2
result[i] = (1.0*mask.count(True)) / mask.size()
return result
def d2_dw_d_u_indep_d_u_indep_finite(adp_constraints, h, u_indep, eps=1.e-6):
result = flex.double()
for i_indep in xrange(len(u_indep)):
vs = []
for signed_eps in [eps,-eps]:
u_indep_eps = list(u_indep)
u_indep_eps[i_indep] += signed_eps
vs.append(d_dw_d_u_indep_finite(adp_constraints, h, u_indep_eps))
result.extend((vs[0]-vs[1])/(2*eps))
np = len(u_indep)
result.reshape(flex.grid(np,np))
return result.matrix_symmetric_as_packed_u(relative_epsilon=1.e-5)
def intersection(cuts):
assert len(cuts) == 3
m = flex.int()
t = flex.int()
denominator = 1
for cut in cuts:
denominator = cut.lcm_of_denominators(start_lcm=denominator)
for cut in cuts:
for e in cut.n:
m.append(int(e * denominator))
t.append(-int(cut.c * denominator))
m.reshape(flex.grid(3, 3))
t.reshape(flex.grid(3, 1))
r = scitbx.math.row_echelon_form_t(m, t)
assert r in (2, 3)
if (r != 3): return None
t.reshape(flex.grid(3))
sol = flex.int(3)
d = scitbx.math.row_echelon_back_substitution_int(m, t, sol)
assert d > 0
return tuple([rational.int(s, d) for s in sol])
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 build_up(pfh, objective_only=False):
residuals = pfh.fvec_callable(pfh.x)
pfh.reset()
if objective_only:
pfh.add_residuals(residuals, weights=None)
else:
grad_r = pfh.jacobian_callable(pfh.x)
jacobian = flex.double(
flex.grid(len(I_ref), pfh.n_parameters))
for j, der_r in enumerate(grad_r):
jacobian.matrix_paste_column_in_place(der_r,j)
pfh.add_equations(residuals, jacobian, weights=None)
def map_of_coeff_scaled(mask_map,structure,nxyz):
assert mask_map.is_0_based()
assert not mask_map.is_padded()
fft_manager = fftpack.real_to_complex_3d(mask_map.focus())
padded_data = maptbx.copy(mask_map,
flex.grid(fft_manager.m_real()
).set_focus(fft_manager.n_real()))
map_of_coeff = fft_manager.forward(padded_data)
scale = matrix.col(nxyz).product()/structure.unit_cell().volume()
sc = matrix.col(mask_map.focus()).product()/structure.unit_cell().volume()
assert sc == scale
map_of_coeff /= scale
return map_of_coeff
def exercise_set_box():
n_real = (60, 100, 160)
n = n_real[0]*n_real[1]*n_real[2]
cs=crystal.symmetry(
unit_cell=(21,37,58,80,111,117),
space_group_symbol="P1")
be = maptbx.boxes(n_real = n_real, fraction=0.1)
#
m1 = flex.double([-1 for i in xrange(n)])
m1.resize(flex.grid(n_real))
m2 = flex.double([1 for i in xrange(n)])
m2.resize(flex.grid(n_real))
#
for s,e in zip(be.starts, be.ends):
box = maptbx.copy(m2, s, e)
box.reshape(flex.grid(box.all()))
maptbx.set_box(
map_data_from = box,
map_data_to = m1,
start = s,
end = e)
assert m2.as_1d().min_max_mean().as_tuple() == (1.,1.,1.)
def hessian(self, x):
result = hessian(
self.two_thetas_obs, self.miller_indices, self.wavelength,
unit_cell=uctbx.unit_cell(iter(x)))
if (self.mode == 1):
d = result.matrix_diagonal()
result = flex.double(flex.grid(6,6), 0)
result.matrix_diagonal_set_in_place(diagonal=d)
if (0):
from scitbx import matrix
print("hessian:")
print(matrix.sqr(result))
return result
def exercise_asu_eight_point_interpolation():
map = flex.double(flex.grid(2,3,5), 10)
cs = crystal.symmetry(
unit_cell=(1,1,1,90,90,90),
space_group="P1")
asu_mappings=cs.asu_mappings(buffer_thickness=0)
for shift in [0,1,-1]:
for index in flex.nested_loop(map.focus()):
x_frac = [float(i)/n+shift for i,n in zip(index, map.focus())]
assert approx_equal(
maptbx.asu_eight_point_interpolation(map, asu_mappings, x_frac), 10)
assert approx_equal(
maptbx.asu_eight_point_interpolation(map, asu_mappings, (10,11,12)), 10)
def exercise_set_box_0():
# Create a grid of size 10x10x10 having value 0 everywhere
box = flex.double(flex.grid(10,10,10), 0)
# test 0: same start and end
b1 = box.deep_copy()
try:
maptbx.set_box(
value = -1,
map_data_to = b1,
start = b1.all(),
end = b1.all())
except RuntimeError, e:
assert str(e).endswith("CCTBX_ASSERT(end[i] > start[i]) failure.")
def hessian(self, x):
result = hessian(
self.two_thetas_obs, self.miller_indices, self.wavelength,
unit_cell=uctbx.unit_cell(iter(x)))
if (self.mode == 1):
d = result.matrix_diagonal()
result = flex.double(flex.grid(6,6), 0)
result.matrix_diagonal_set_in_place(diagonal=d)
if (0):
from scitbx import matrix
print "hessian:"
print matrix.sqr(result)
return result
def _gradient_map_coeff_to_map(self, coeff):
if (not coeff.anomalous_flag()):
n_complex = self.manager().rfft().n_complex()
else:
n_complex = self.manager().rfft().n_real()
return maptbx.structure_factors.to_map(
space_group=coeff.space_group(),
anomalous_flag=coeff.anomalous_flag(),
miller_indices=coeff.indices(),
structure_factors=coeff.data(),
n_real=self.manager().rfft().n_real(),
map_grid=flex.grid(n_complex),
conjugate_flag=True,
treat_restricted=False)
def exercise_factor_u_star_u_iso():
for i_trial in xrange(100):
a = flex.random_double(size=9, factor=3)
a.resize(flex.grid(3, 3))
u = a.matrix_transpose().matrix_multiply(a) # always positive-definite
u_cart = [u[0], u[4], u[8], u[1], u[2], u[5]]
unit_cell = uctbx.unit_cell((3, 5, 7, 80, 100, 110))
u_star = adptbx.u_cart_as_u_star(unit_cell, u_cart)
airlie = u_star_minus_u_iso_airlie(unit_cell, u_star)
ralf = u_star_minus_u_iso_ralf(unit_cell, u_star)
assert approx_equal(ralf, airlie, 1.0e-10)
f = adptbx.factor_u_star_u_iso(unit_cell=unit_cell, u_star=u_star)
assert approx_equal(f.u_iso, adptbx.u_cart_as_u_iso(u_cart))
assert approx_equal(f.u_star_minus_u_iso, airlie, 1.0e-10)
def mask_grid(xrs, buffer, map_data, n_real):
# XXX move to C++
frac_min, frac_max = xrs.unit_cell().box_frac_around_sites(
sites_cart = xrs.sites_cart(), buffer = buffer-1.5)
gridding_first=[ifloor(f*n) for f,n in zip(frac_min,n_real)]
gridding_last=[iceil(f*n) for f,n in zip(frac_max,n_real)]
new_map = flex.double(flex.grid(n_real),0)
for i in range(gridding_first[0], gridding_last[0]):
for j in xrange(gridding_first[1], gridding_last[1]):
for k in xrange(gridding_first[2], gridding_last[2]):
if(i> 0 and i<n_real[0] and
j> 0 and j<n_real[1] and
k> 0 and k<n_real[2]):
new_map[(i,j,k)] = map_data[(i,j,k)]
return new_map
def map_data(self):
m_data = self.data.as_double()
n_real = self.unit_cell_grid
if(n_real == m_data.all()):
return m_data
else:
# XXX hideously SLOW! MOVE TO C++
map_new = flex.double(flex.grid(n_real), 0)
o = m_data.origin()
f = m_data.focus()
for i in range(o[0],f[0]):
for j in range(o[1],f[1]):
for k in range(o[2],f[2]):
map_new[i%n_real[0], j%n_real[1], k%n_real[2]] = m_data[i, j, k]
return map_new
def finite_differences(unit_cell, eps=1e-6):
grads = []
for i in range(6):
params = list(unit_cell.parameters())
params[i] += eps
uc = uctbx.unit_cell(parameters=params)
qm = matrix.col(uc.metrical_matrix())
params[i] -= 2*eps
uc = uctbx.unit_cell(parameters=params)
qp = matrix.col(uc.metrical_matrix())
dq = (qm-qp)/(2*eps)
grads.extend(list(dq))
grads = flex.double(grads)
grads.resize(flex.grid((6,6)))
return grads.matrix_transpose()
def build_up(pfh, objective_only=False):
if OO.pvr_fix:
residuals = pfh.fvec_callable_pvr(pfh.x)
else:
residuals = pfh.fvec_callable_NOT_USED_AFTER_BUGFIX(pfh.x)
pfh.reset()
if objective_only:
pfh.add_residuals(residuals, weights=None)
else:
grad_r = pfh.jacobian_callable(pfh.x)
jacobian = flex.double(
flex.grid(len(OO.parent.indexed_pairs), pfh.n_parameters))
for j, der_r in enumerate(grad_r):
jacobian.matrix_paste_column_in_place(der_r,j)
pfh.add_equations(residuals, jacobian, weights=None)
def hessian(
two_thetas_obs, miller_indices, wavelength, unit_cell, eps=1.e-6):
result = flex.double()
for i in xrange(6):
rs = []
for signed_eps in [eps, -eps]:
params_eps = list(unit_cell.parameters())
params_eps[i] += signed_eps
rs.append(
gradients(
two_thetas_obs, miller_indices, wavelength,
uctbx.unit_cell(params_eps)))
result.extend((rs[0]-rs[1])/(2*eps))
result.reshape(flex.grid(6,6))
u = result.matrix_symmetric_as_packed_u(relative_epsilon=eps*10)
return u.matrix_packed_u_as_symmetric()
def d2f_d_site_finite(h, site_constraints, independent_params, eps=1.e-8):
result = flex.double()
independent_params_eps = list(independent_params)
for ip in xrange(len(independent_params)):
vs = []
for signed_eps in [eps, -eps]:
independent_params_eps[ip] = independent_params[ip] + signed_eps
ca = cos_alpha(
h=h,
site_constraints=site_constraints,
independent_params=independent_params_eps)
vs.append(ca.df_d_site())
result.extend((vs[0]-vs[1])/(2*eps))
independent_params_eps[ip] = independent_params[ip]
np = len(independent_params)
result.reshape(flex.grid(np,np))
return result.matrix_symmetric_as_packed_u(relative_epsilon=1.e-5)
