def box_iterator(self):
p = self.xrs.unit_cell().parameters()
b = maptbx.boxes_by_dimension(n_real=self.n_real,
dim=self.box_dimension,
abc=p[:3])
i_box = 0
for s, e in zip(b.starts, b.ends):
i_box += 1
map_box_obs = maptbx.copy(self.map_data_obs, s, e)
map_box_calc = maptbx.copy(self.map_data_calc, s, e)
map_box_obs.reshape(flex.grid(map_box_obs.all()))
map_box_calc.reshape(flex.grid(map_box_calc.all()))
#######
# XXX Copy-paste from map_box
abc = []
for i in range(3):
abc.append(p[i] * map_box_calc.all()[i] / self.n_real[i])
ucb = uctbx.unit_cell(parameters=(abc[0], abc[1], abc[2], p[3],
p[4], p[5]))
cs = crystal.symmetry(unit_cell=ucb, space_group="P1")
#######
diff_map = scale_two_real_maps_in_fourier_space(
m1=map_box_obs,
m2=map_box_calc,
cs=cs,
d_min=self.d_min,
vector_map=self.vector_map)
maptbx.set_box(map_data_from=diff_map,
map_data_to=self.map_result,
start=s,
end=e)
sd = self.map_result.sample_standard_deviation()
if (sd != 0):
self.map_result = self.map_result / sd
def __init__(self,
crystal_gridding,
fmodel,
map_type,
max_boxes,
box_size_as_fraction=None):
sgt = fmodel.f_obs().space_group().type()
assert sgt.number() == 1
def get_map(fmodel, map_type, external_complete_set=None):
f_map = fmodel.electron_density_map().map_coefficients(
map_type=map_type, isotropize=True, fill_missing=False)
fft_map = miller.fft_map(crystal_gridding=crystal_gridding,
fourier_coefficients=f_map)
return fft_map.real_map_unpadded()
f_model = fmodel.f_model_scaled_with_k1()
fft_map = miller.fft_map(crystal_gridding=crystal_gridding,
fourier_coefficients=f_model)
f_model_map_data = fft_map.real_map_unpadded()
zero_complex_ma = f_model.customized_copy(
data=flex.complex_double(f_model.data().size(), 0))
b = maptbx.boxes(fraction=0.3,
n_real=f_model_map_data.focus(),
max_boxes=max_boxes,
log=sys.stdout)
self.map_result = flex.double(flex.grid(b.n_real))
self.r = flex.double()
for s, e in zip(b.starts, b.ends):
f_model_map_data_omit = maptbx.set_box_copy(
value=0, map_data_to=f_model_map_data, start=s, end=e)
f_model_omit = f_model.structure_factors_from_map(
map=f_model_map_data_omit,
use_scale=True,
anomalous_flag=False,
use_sg=False)
fmodel_ = mmtbx.f_model.manager(f_obs=fmodel.f_obs(),
r_free_flags=fmodel.r_free_flags(),
f_calc=f_model_omit,
f_mask=zero_complex_ma)
self.r.append(fmodel_.r_work())
f_map_data = get_map(fmodel=fmodel_, map_type=map_type)
etmp = [e[0] - 1, e[1] - 1,
e[2] - 1] # because .copy() includes right edge
box = maptbx.copy(f_map_data, s, etmp)
box.reshape(flex.grid(box.all()))
maptbx.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
self.map_coefficients = fmodel.f_obs().structure_factors_from_map(
map=self.map_result,
use_scale=True,
anomalous_flag=False,
use_sg=False)
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 modify_mask_box(self, mask_data, sites_frac):
box_buffer = self.params.box_buffer
# Number of selected atoms
n_selected = self.selection_bool.count(True)
na = mask_data.all()
n_selected_p1 = sites_frac.size()
n_boxes = int(n_selected_p1 / n_selected)
box_list = [[] for i in range(n_boxes)]
for n_box in range(n_boxes):
for i in range(n_selected):
box_list[n_box].append(sites_frac[n_box + n_boxes * i])
na = self.mask_data_all.all()
k = 0
for box in box_list:
k += 1
x_min = min(frac[0] for frac in box)
y_min = min(frac[1] for frac in box)
z_min = min(frac[2] for frac in box)
x_max = max(frac[0] for frac in box)
y_max = max(frac[1] for frac in box)
z_max = max(frac[2] for frac in box)
frac_min = [x_min, y_min, z_min]
frac_max = [x_max, y_max, z_max]
cs = self.xray_structure.crystal_symmetry()
# Add buffer to box if indicated.
if (box_buffer is not None):
cushion = flex.double(cs.unit_cell().fractionalize(
(box_buffer, ) * 3))
frac_min = list(flex.double(frac_min) - cushion)
frac_max = list(flex.double(frac_max) + cushion)
gridding_first = [ifloor(f * n) for f, n in zip(frac_min, na)]
gridding_last = [iceil(f * n) for f, n in zip(frac_max, na)]
for j in range(3):
if (gridding_last[j] - gridding_first[j] >= na[j]):
raise Sorry(
"The box is too big. Decrease box_buffer or use a " +
"different selection")
maptbx.set_box(value=0,
map_data_to=mask_data,
start=gridding_first,
end=gridding_last)
return mask_data
def get_diff_map(symmetry, fcalc_map, expt_map, d_min):
"""Compute a difference map between the calculated and experimental maps.
Modified from mmtbx.command_line.real_space_diff_map class compdiff."""
scale = scale_k1(x=expt_map, y=fcalc_map)
scaled_fcalc_map = fcalc_map * scale # should already be scaled but okay
origin = expt_map.origin()
shifted_expt_map = expt_map.shift_origin()
shifted_diff_map = flex.double(flex.grid(expt_map.all()))
diff_map = flex.double(flex.grid(expt_map.origin(), expt_map.focus()))
ucell_params = symmetry.unit_cell().parameters()
boxes = maptbx.boxes_by_dimension(n_real=expt_map.all(),
dim=30,
abc=ucell_params[:3])
i_box = 0
test_map_box_obs_all = None
for start, end in zip(boxes.starts, boxes.ends):
i_box += 1
map_box_obs = maptbx.copy(shifted_expt_map, start, end)
map_box_calc = maptbx.copy(scaled_fcalc_map, start, end)
map_box_obs.reshape(flex.grid(map_box_obs.all()))
map_box_calc.reshape(flex.grid(map_box_calc.all()))
# abc = [ucell_params[i]/expt_map.all()[i] for i in range(3)]
# ucb = uctbx.unit_cell(parameters=(
# abc[0],abc[1],abc[2],ucell_params[3],ucell_params[4],ucell_params[5]))
# cs = crystal.symmetry(unit_cell=ucb, space_group="P1")
cs = symmetry
diff_map_part = scale_two_real_maps_in_fourier_space(
m1=map_box_obs,
m2=map_box_calc,
cs=cs,
d_min=d_min,
vector_map=True) # this means yes, use the phases from fcalc
maptbx.set_box(map_data_from=diff_map_part,
map_data_to=shifted_diff_map,
start=start,
end=end)
# skip this additional scaling step -- it explodes everything
# sd = diff_map.sample_standard_deviation()
# if(sd!=0):
# diff_map = diff_map/sd
# somehow put the contents of shifted_diff_map into diff_map but keep origin?
for i in xrange(len(shifted_diff_map)):
diff_map[i] = shifted_diff_map[i]
# FIXME SUPER SLOW but it should work for now
return diff_map
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.)
# 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.")
else: raise Exception_expected
# test 1: transform entire unit cell
b1 = box.deep_copy()
maptbx.set_box(
value = -1,
map_data_to = b1,
start = [0,0,0],
end = b1.all())
assert approx_equal(b1.as_1d().min_max_mean().as_tuple(), [-1.0, -1.0, -1.0])
# test 2: transform entire unit cell, this time translated
b1 = box.deep_copy()
maptbx.set_box(
value = 1,
map_data_to = b1,
start = [-30,-30,-30],
end = [-20,-20,-20])
assert approx_equal(b1.as_1d().min_max_mean().as_tuple(), [1.0, 1.0, 1.0])
# test 3: start in neighboring cell and end at 0,0,0
b1 = box.deep_copy()
maptbx.set_box(
value = 1,
def __init__(
self,
crystal_gridding,
fmodel,
map_type,
max_boxes,
box_size_as_fraction=None):
sgt = fmodel.f_obs().space_group().type()
assert sgt.number() == 1
def get_map(fmodel, map_type, external_complete_set=None):
f_map = fmodel.electron_density_map().map_coefficients(
map_type = map_type,
isotropize = True,
fill_missing = False)
fft_map = miller.fft_map(
crystal_gridding = crystal_gridding,
fourier_coefficients = f_map)
return fft_map.real_map_unpadded()
f_model = fmodel.f_model_scaled_with_k1()
fft_map = miller.fft_map(
crystal_gridding = crystal_gridding,
fourier_coefficients = f_model)
f_model_map_data = fft_map.real_map_unpadded()
zero_complex_ma = f_model.customized_copy(
data = flex.complex_double(f_model.data().size(), 0))
b = maptbx.boxes(
fraction = 0.3,
n_real = f_model_map_data.focus(),
max_boxes=max_boxes,
log=sys.stdout)
self.map_result = flex.double(flex.grid(b.n_real))
self.r = flex.double()
for s,e in zip(b.starts, b.ends):
f_model_map_data_omit = maptbx.set_box_copy(
value = 0,
map_data_to = f_model_map_data,
start = s,
end = e)
f_model_omit = f_model.structure_factors_from_map(
map = f_model_map_data_omit,
use_scale = True,
anomalous_flag = False,
use_sg = False)
fmodel_ = mmtbx.f_model.manager(
f_obs = fmodel.f_obs(),
r_free_flags = fmodel.r_free_flags(),
f_calc = f_model_omit,
f_mask = zero_complex_ma)
self.r.append(fmodel_.r_work())
f_map_data = get_map(fmodel=fmodel_, map_type=map_type)
etmp = [e[0]-1, e[1]-1, e[2]-1] # because .copy() includes right edge
box = maptbx.copy(f_map_data, s, etmp)
box.reshape(flex.grid(box.all()))
maptbx.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
self.map_coefficients = fmodel.f_obs().structure_factors_from_map(
map = self.map_result,
use_scale = True,
anomalous_flag = False,
use_sg = False)
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 as e:
assert str(e).endswith("CCTBX_ASSERT(end[i] > start[i]) failure.")
else: raise Exception_expected
# test 1: transform entire unit cell
b1 = box.deep_copy()
maptbx.set_box(
value = -1,
map_data_to = b1,
start = [0,0,0],
end = b1.all())
assert approx_equal(b1.as_1d().min_max_mean().as_tuple(), [-1.0, -1.0, -1.0])
# test 2: transform entire unit cell, this time translated
b1 = box.deep_copy()
maptbx.set_box(
value = 1,
map_data_to = b1,
start = [-30,-30,-30],
end = [-20,-20,-20])
assert approx_equal(b1.as_1d().min_max_mean().as_tuple(), [1.0, 1.0, 1.0])
# test 3: start in neighboring cell and end at 0,0,0
b1 = box.deep_copy()
maptbx.set_box(
value = 1,
map_data_to = b1,
start = [-5,-5,-5],
end = [0,0,0])
assert approx_equal(b1.as_1d().min_max_mean().as_tuple(), [0.0, 1.0, 0.125])
# test 4: slice instead of a box
b1 = box.deep_copy()
try:
maptbx.set_box(
value = -1,
map_data_to = b1,
start = [1,2,3],
end = [2,2,3])
except RuntimeError as e:
assert str(e).endswith("CCTBX_ASSERT(end[i] > start[i]) failure.")
else: raise Exception_expected
# test 5: another slice
b1 = box.deep_copy()
try:
maptbx.set_box(
value = -1,
map_data_to = b1,
start = [-1,0,2],
end = [0,0,3])
except RuntimeError as e:
assert str(e).endswith("CCTBX_ASSERT(end[i] > start[i]) failure.")
else: raise Exception_expected
# test 6: one point changed
b1 = box.deep_copy()
maptbx.set_box(
value = 1,
map_data_to = b1,
start = [0,0,0],
end = [1,1,1])
assert (b1==0).count(True)==999
assert (b1==1).count(True)==1
# test 7: change 1/8 of the unit cell
b1 = box.deep_copy()
maptbx.set_box(
value = 1,
map_data_to = b1,
start = [0,0,0],
end = [5,5,5])
assert approx_equal(b1.as_1d().min_max_mean().as_tuple(), [0.0, 1.0, 0.125])
# test 8: change one point
b1 = box.deep_copy()
maptbx.set_box(
value = 1,
map_data_to = b1,
start = [-1,-1,-1],
end = [0,0,0])
assert (b1==0).count(True)==999
assert (b1==1).count(True)==1
# test 9: entire cell, end point is 0,0,0
b1 = box.deep_copy()
maptbx.set_box(
value = 1,
map_data_to = b1,
start = [-10,-10,-10],
end = [0,0,0])
assert approx_equal(b1.as_1d().min_max_mean().as_tuple(), [1.0, 1.0, 1.0])
# test 10: slice of a box
b1 = box.deep_copy()
try:
maptbx.set_box(
value = 1,
map_data_to = b1,
start = [0,0,0],
end = [9,0,0])
except RuntimeError as e:
assert str(e).endswith("CCTBX_ASSERT(end[i] > start[i]) failure.")
else: raise Exception_expected
# test 11: box within unit cell one period apart
b1 = box.deep_copy()
maptbx.set_box(
value = 1,
map_data_to = b1,
start = [14,14,14],
end = [19,19,19])
assert approx_equal(b1.as_1d().min_max_mean().as_tuple(), [0.0, 1.0, 0.125])
# test 12 box between cells, translated by a period
b1 = box.deep_copy()
maptbx.set_box(
value = 1,
map_data_to = b1,
start = [-14,-14,-14],
end = [-9,-9,-9])
assert approx_equal(b1.as_1d().min_max_mean().as_tuple(), [0.0, 1.0, 0.125])
# TEST 13: Reset map values in a box within a unit cell
n_real = (100, 60, 80)
n = n_real[0]*n_real[1]*n_real[2]
m1 = flex.double([1 for i in range(n)])
m1.resize(flex.grid(n_real))
maptbx.set_box(
value = -1,
map_data_to = m1,
start = [20,30,40],
end = [80,40,60])
assert m1.as_1d().min_max_mean().as_tuple() == (-1.,1.,0.95)
# TEST 14: reset map values in a box crossing the border of the unit cell
n_real = (60, 100, 80)
n = n_real[0]*n_real[1]*n_real[2]
m2 = flex.double([1 for i in range(n)])
m2.resize(flex.grid(n_real))
maptbx.set_box(
value = -1,
map_data_to = m2,
start = [-10,-20,20],
end = [30,40,50])
assert m2.as_1d().min_max_mean().as_tuple() == (-1.,1.,0.7)