def algorithm_0(f_obs, F, kt):
"""
Grid search
"""
fc, f_masks = F[0], F[1:]
k_mask_trial_range = []
s = -1
while s < 1:
k_mask_trial_range.append(s)
s += 0.0001
r = []
fc_data = fc.data()
for i, f_mask in enumerate(f_masks):
#print("mask ",i)
assert f_obs.data().size() == fc.data().size()
assert f_mask.data().size() == fc.data().size()
#print (bulk_solvent.r_factor(f_obs.data(),fc_data))
kmask_, k_ = \
bulk_solvent.k_mask_and_k_overall_grid_search(
f_obs.data()*kt,
fc_data*kt,
f_mask.data()*kt,
flex.double(k_mask_trial_range),
flex.bool(fc.data().size(),True))
r.append(kmask_)
fc_data += fc_data * k_ + kmask_ * f_mask.data()
#print (bulk_solvent.r_factor(f_obs.data(),fc_data + kmask_*f_mask.data(),k_))
r = [
1,
] + r
return r
def k_mask_grid_search(self, r_start):
k_mask_trial_range = flex.double(
[i / 1000. for i in range(0, 650, 50)])
k_mask = flex.double(self.f_obs.size(), 0)
k_mask_bin = flex.double()
for i_cas, cas in enumerate(self.cores_and_selections):
selection, core, selection_use, sel_work = cas
scale = self.core.k_anisotropic.select(selection) * \
self.core.k_isotropic.select(selection) * \
self.core.k_isotropic_exp.select(selection)
f_obs = self.f_obs.select(selection)
k_mask_bin_, k_isotropic_bin_ = \
bulk_solvent.k_mask_and_k_overall_grid_search(
f_obs.data()/scale,
core.f_calc.data(),
core.f_mask().data(),
k_mask_trial_range,
selection_use)
k_mask_bin.append(k_mask_bin_)
k_mask.set_selected(selection, k_mask_bin_)
k_mask_bin_smooth = self.smooth(k_mask_bin)
k_mask = self.populate_bin_to_individual_k_mask_linear_interpolation(
k_mask_bin=k_mask_bin_smooth)
k_isotropic = self._k_isotropic_as_scale_k1(r_start=r_start,
k_mask=k_mask)
self.core = self.core.update(k_masks=k_mask, k_isotropic=k_isotropic)
self.bss_result.k_mask_bin_orig = k_mask_bin
self.bss_result.k_mask_bin_smooth = k_mask_bin_smooth
self.bss_result.k_mask = k_mask
self.bss_result.k_isotropic = k_isotropic
r_start = self.r_factor()
####
if (len(self.cores_and_selections) > 2):
x = flex.double()
y = flex.double()
for i_sel, cas in enumerate(self.cores_and_selections):
selection, core, selection_use, sel_work = cas
sel = sel_work
ss_ = self.ss_bin_values[i_sel][2]
k_isotropic_ = flex.mean(self.core.k_isotropic.select(sel))
x.append(ss_)
y.append(k_isotropic_)
import scitbx.math
r = scitbx.math.gaussian_fit_1d_analytical(x=flex.sqrt(x), y=y)
r_start = self.r_factor()
k_isotropic = r.a * flex.exp(-self.ss * r.b)
r = self.try_scale(k_isotropic=k_isotropic)
if (r < r_start):
self.core = self.core.update(k_isotropic=k_isotropic)
r_start = self.r_factor()
return r_start
def k_mask_grid_search(self, r_start):
k_mask_trial_range = flex.double([i/1000. for i in range(0,650,50)])
k_mask = flex.double(self.f_obs.size(), 0)
k_mask_bin = flex.double()
for i_cas, cas in enumerate(self.cores_and_selections):
selection, core, selection_use, sel_work = cas
scale = self.core.k_anisotropic.select(selection) * \
self.core.k_isotropic.select(selection) * \
self.core.k_isotropic_exp.select(selection)
f_obs = self.f_obs.select(selection)
k_mask_bin_, k_isotropic_bin_ = \
bulk_solvent.k_mask_and_k_overall_grid_search(
f_obs.data()/scale,
core.f_calc.data(),
core.f_mask().data(),
k_mask_trial_range,
selection_use)
k_mask_bin.append(k_mask_bin_)
k_mask.set_selected(selection, k_mask_bin_)
k_mask_bin_smooth = self.smooth(k_mask_bin)
k_mask = self.populate_bin_to_individual_k_mask_linear_interpolation(
k_mask_bin = k_mask_bin_smooth)
k_isotropic = self._k_isotropic_as_scale_k1(r_start=r_start, k_mask=k_mask)
self.core = self.core.update(k_masks = k_mask, k_isotropic = k_isotropic)
self.bss_result.k_mask_bin_orig = k_mask_bin
self.bss_result.k_mask_bin_smooth = k_mask_bin_smooth
self.bss_result.k_mask = k_mask
self.bss_result.k_isotropic = k_isotropic
r_start = self.r_factor()
####
if(len(self.cores_and_selections)>2):
x=flex.double()
y=flex.double()
for i_sel, cas in enumerate(self.cores_and_selections):
selection, core, selection_use, sel_work = cas
sel = sel_work
ss_ = self.ss_bin_values[i_sel][2]
k_isotropic_ = flex.mean(self.core.k_isotropic.select(sel))
x.append(ss_)
y.append(k_isotropic_)
import scitbx.math
r = scitbx.math.gaussian_fit_1d_analytical(x = flex.sqrt(x), y = y)
r_start = self.r_factor()
k_isotropic = r.a*flex.exp(-self.ss*r.b)
r = self.try_scale(k_isotropic = k_isotropic)
if(r<r_start):
self.core = self.core.update(k_isotropic = k_isotropic)
r_start = self.r_factor()
return r_start
def k_mask_grid_search(self, r_start):
if (self.verbose):
print(" k_mask_grid_search:", file=self.log)
print(" r_start: %6.4f (r_low: %6.4f)" %
(r_start, self._r_low()))
#k_mask_trial_range = flex.double([i/1000. for i in range(0,650,50)])
k_mask_trial_range = flex.double(
[i / 1000. for i in range(0, 1010, 10)])
k_mask = flex.double(self.f_obs.size(), 0)
k_mask_bin = flex.double()
k_isotropic = flex.double(self.f_obs.size(), 0)
k_total = self.get_k_total()
for i_cas, cas in enumerate(self.cores_and_selections):
selection, core, selection_use, sel_work = cas
f_obs = self.f_obs.select(selection)
k_total_ = k_total.select(selection)
k_mask_bin_, k_isotropic_bin_ = \
bulk_solvent.k_mask_and_k_overall_grid_search(
f_obs.data()/k_total_,
core.f_calc.data(),
core.f_mask().data(),
k_mask_trial_range,
selection_use)
k_mask_bin.append(k_mask_bin_)
k_mask.set_selected(selection, k_mask_bin_)
k_isotropic.set_selected(selection, k_isotropic_bin_)
k_mask_bin_smooth = self.smooth(k_mask_bin)
k_mask = self.populate_bin_to_individual_k_mask_linear_interpolation(
k_mask_bin=k_mask_bin_smooth)
r_try = self.try_scale(k_mask=k_mask, k_isotropic=k_isotropic)
if (r_try < r_start):
self.core = self.core.update(k_masks=k_mask,
k_isotropic=k_isotropic)
# ????
self.bss_result.k_mask_bin_orig = k_mask_bin
self.bss_result.k_mask_bin_smooth = k_mask_bin_smooth
self.bss_result.k_mask = k_mask
self.bss_result.k_isotropic = k_isotropic
r = self.r_factor()
if (self.verbose):
print(" r_final: %6.4f (r_low: %6.4f)" % (r, self._r_low()))
return r
def bulk_solvent_scaling(self, r_start):
k_mask = flex.double(self.f_obs.size(), -1)
k_mask_bin = flex.double()
k_mask_trial_range = flex.double(
[i / 1000. for i in range(0, 1000, 10)])
scale_k1 = self.estimate_scale_k1()
def get_k_mask_trial_range(x, shift=0.05):
if (x > 1): x = 1
result = flex.double()
inc = max(0, x - shift)
while inc <= x + shift + 1.e-3:
result.append(inc)
inc += 0.01
return result
for i_cas, cas in enumerate(self.cores_and_selections):
selection, core, selection_use, sel_work = cas
scale = self.core.k_anisotropic.select(selection)*scale_k1*\
self.core.k_isotropic_exp.select(selection)
f_obs = self.f_obs.select(selection).data()
f_calc = core.f_calc.data() * scale
f_mask = core.f_mask().data() * scale
if (self.scale_method == "k_iso_k_mask_anal"):
obj = bulk_solvent.overall_and_bulk_solvent_scale_coefficients_analytical(
f_obs=f_obs,
f_calc=f_calc,
f_mask=f_mask,
selection=selection_use)
k_mask_bin.append(obj.x_best)
k_mask.set_selected(selection, obj.x_best)
elif (self.scale_method == "k_mask_anal"):
obj = bulk_solvent.bulk_solvent_scale_coefficients_analytical(
f_obs=f_obs,
f_calc=f_calc,
f_mask=f_mask,
selection=selection_use)
k_mask_bin.append(obj.x_best)
k_mask.set_selected(selection, obj.x_best)
elif (self.scale_method == "k_mask_r_grid_search"):
k_mask_bin_, k_isotropic_bin_ = \
bulk_solvent.k_mask_and_k_overall_grid_search(
f_obs,
f_calc,
f_mask,
k_mask_trial_range,
selection_use)
k_mask_bin.append(k_mask_bin_)
k_mask.set_selected(selection, k_mask_bin_)
elif (self.scale_method == "combo"):
r = flex.double()
k = flex.double()
x0 = self.bss_result.k_mask_bin_orig[i_cas]
k_mask.set_selected(selection, x0)
r0 = self.try_scale(k_mask=k_mask, selection=selection)
r.append(r0)
k.append(x0)
#
fmv = flex.min(flex.abs(f_mask).select(selection_use))
if (abs(fmv) > 1.e-9):
obj1 = bulk_solvent.overall_and_bulk_solvent_scale_coefficients_analytical(
f_obs=f_obs,
f_calc=f_calc,
f_mask=f_mask,
selection=selection_use)
k_mask.set_selected(selection, obj1.x_best)
k.append(obj1.x_best)
else:
k_mask.set_selected(selection, 0)
k.append(0)
r.append(self.try_scale(k_mask=k_mask, selection=selection))
#
if (abs(fmv) > 1.e-9):
obj2 = bulk_solvent.bulk_solvent_scale_coefficients_analytical(
f_obs=f_obs,
f_calc=f_calc,
f_mask=f_mask,
selection=selection_use)
k_mask.set_selected(selection, obj2.x_best)
k.append(obj2.x_best)
else:
k_mask.set_selected(selection, 0)
k.append(0)
r.append(self.try_scale(k_mask=k_mask, selection=selection))
s = flex.sort_permutation(r)
x = k.select(s)[0]
# fine-sample k_mask around minimum of LS to fall into minimum of R
k_mask_bin_, k_isotropic_bin_ = \
bulk_solvent.k_mask_and_k_overall_grid_search(
f_obs,
f_calc,
f_mask,
get_k_mask_trial_range(x = x),
selection_use)
k_mask_bin.append(k_mask_bin_)
k_mask.set_selected(selection, k_mask_bin_)
else:
assert 0
#
k_mask_bin_smooth = self.smooth(k_mask_bin)
k_mask = self.populate_bin_to_individual_k_mask_linear_interpolation(
k_mask_bin=k_mask_bin_smooth)
k_isotropic = self._k_isotropic_as_scale_k1(r_start=r_start,
k_mask=k_mask)
#
r = self.try_scale(k_mask=k_mask, k_isotropic=k_isotropic)
if (r <= r_start or
(r > r_start and abs(r - r_start) * 100 < 0.5)): # may be 0.5?
self.core = self.core.update(k_isotropic=k_isotropic,
k_masks=k_mask)
self.bss_result.k_mask_bin_orig = k_mask_bin
self.bss_result.k_mask_bin_smooth = k_mask_bin_smooth
self.bss_result.k_mask = k_mask
self.bss_result.k_isotropic = k_isotropic
r_start = r
if (self.verbose):
print >> self.log, " %s: %6.4f" % ("bulk-solvent", r_start)
else:
if (self.verbose):
print >> self.log, " %s: %6.4f (%s)" % ("bulk-solvent", r,
"result rejected")
return self.r_factor()
def bulk_solvent_scaling(self, r_start):
if (self.verbose):
print(" bulk_solvent_scaling:", file=self.log)
print(" r_start: %6.4f (r_low: %6.4f)" %
(r_start, self._r_low()))
k_mask = flex.double(self.f_obs.size(), -1)
k_mask_bin = flex.double()
k_mask_trial_range = flex.double(
[i / 1000. for i in range(0, 1000, 10)])
k_total = self.get_k_total()
def get_k_mask_trial_range(x, shift=0.05):
result = flex.double([x])
if (x > 1): x = 1
inc = max(0, x - shift)
while inc <= x + shift + 1.e-3:
result.append(inc)
inc += 0.01
return result
for i_cas, cas in enumerate(self.cores_and_selections):
selection, core, selection_use, sel_work = cas
f_obs = self.f_obs.select(selection).data()
f_calc = core.f_calc.data() * k_total.select(selection)
f_mask = core.f_mask().data() * k_total.select(selection)
if (self.scale_method == "k_iso_k_mask_anal"):
obj = bulk_solvent.overall_and_bulk_solvent_scale_coefficients_analytical(
f_obs=f_obs,
f_calc=f_calc,
f_mask=f_mask,
selection=selection_use)
k_mask_bin.append(obj.x_best)
k_mask.set_selected(selection, obj.x_best)
elif (self.scale_method == "k_mask_anal"):
obj = bulk_solvent.bulk_solvent_scale_coefficients_analytical(
f_obs=f_obs,
f_calc=f_calc,
f_mask=f_mask,
selection=selection_use)
k_mask_bin.append(obj.x_best)
k_mask.set_selected(selection, obj.x_best)
elif (self.scale_method == "k_mask_r_grid_search"):
k_mask_bin_, k_isotropic_bin_ = \
bulk_solvent.k_mask_and_k_overall_grid_search(
f_obs,
f_calc,
f_mask,
k_mask_trial_range,
selection_use)
k_mask_bin.append(k_mask_bin_)
k_mask.set_selected(selection, k_mask_bin_)
elif (self.scale_method == "combo"):
r = flex.double()
k = flex.double()
#
if (self.bss_result.k_mask_bin_orig is not None):
x0 = self.bss_result.k_mask_bin_orig[i_cas]
k_mask.set_selected(selection, x0)
r0 = self.try_scale(k_mask=k_mask, selection=selection)
r.append(r0)
k.append(x0)
#
fmv = flex.min(flex.abs(f_mask).select(selection_use))
if (abs(fmv) > 1.e-9):
obj1 = bulk_solvent.overall_and_bulk_solvent_scale_coefficients_analytical(
f_obs=f_obs,
f_calc=f_calc,
f_mask=f_mask,
selection=selection_use)
k_mask.set_selected(selection, obj1.x_best)
k.append(obj1.x_best)
else:
k_mask.set_selected(selection, 0)
k.append(0)
r.append(self.try_scale(k_mask=k_mask, selection=selection))
#
s = flex.sort_permutation(r)
x = k.select(s)[0]
# fine-sample k_mask around minimum of LS to fall into minimum of R
k_mask_bin_, k_isotropic_bin_ = \
bulk_solvent.k_mask_and_k_overall_grid_search(
f_obs,
f_calc,
f_mask,
get_k_mask_trial_range(x = x),
selection_use)
k_mask_bin.append(k_mask_bin_)
k_mask.set_selected(selection, k_mask_bin_)
#k_mask_bin.append(x)
#k_mask.set_selected(selection, x)
else:
assert 0
#
k_mask_bin_smooth = self.smooth(k_mask_bin)
k_mask = self.populate_bin_to_individual_k_mask_linear_interpolation(
k_mask_bin=k_mask_bin_smooth)
k_isotropic = self._k_isotropic_as_scale_k1(r_start=r_start,
k_mask=k_mask)
r_try = self.try_scale(k_mask=k_mask, k_isotropic=k_isotropic)
if (r_try < r_start):
self.core = self.core.update(k_isotropic=k_isotropic,
k_masks=k_mask)
r = self.r_factor()
if (self.verbose):
print(" r_final: %6.4f (r_low: %6.4f)" % (r, self._r_low()))
return r
def bulk_solvent_scaling(self, r_start):
k_mask = flex.double(self.f_obs.size(), -1)
k_mask_bin = flex.double()
k_mask_trial_range = flex.double([i/1000. for i in range(0,1000,10)])
scale_k1 = self.estimate_scale_k1()
def get_k_mask_trial_range(x, shift=0.05):
if(x > 1): x = 1
result = flex.double()
inc = max(0,x-shift)
while inc<=x+shift+1.e-3:
result.append(inc)
inc+=0.01
return result
for i_cas, cas in enumerate(self.cores_and_selections):
selection, core, selection_use, sel_work = cas
scale = self.core.k_anisotropic.select(selection)*scale_k1*\
self.core.k_isotropic_exp.select(selection)
f_obs = self.f_obs.select(selection).data()
f_calc = core.f_calc.data()*scale
f_mask = core.f_mask().data()*scale
if(self.scale_method == "k_iso_k_mask_anal"):
obj = bulk_solvent.overall_and_bulk_solvent_scale_coefficients_analytical(
f_obs = f_obs,
f_calc = f_calc,
f_mask = f_mask,
selection = selection_use)
k_mask_bin.append(obj.x_best)
k_mask.set_selected(selection, obj.x_best)
elif(self.scale_method == "k_mask_anal"):
obj = bulk_solvent.bulk_solvent_scale_coefficients_analytical(
f_obs = f_obs,
f_calc = f_calc,
f_mask = f_mask,
selection = selection_use)
k_mask_bin.append(obj.x_best)
k_mask.set_selected(selection, obj.x_best)
elif(self.scale_method == "k_mask_r_grid_search"):
k_mask_bin_, k_isotropic_bin_ = \
bulk_solvent.k_mask_and_k_overall_grid_search(
f_obs,
f_calc,
f_mask,
k_mask_trial_range,
selection_use)
k_mask_bin.append(k_mask_bin_)
k_mask.set_selected(selection, k_mask_bin_)
elif(self.scale_method == "combo"):
r = flex.double()
k = flex.double()
x0 = self.bss_result.k_mask_bin_orig[i_cas]
k_mask.set_selected(selection, x0)
r0 = self.try_scale(k_mask = k_mask, selection=selection)
r.append(r0)
k.append(x0)
#
fmv = flex.min(flex.abs(f_mask).select(selection_use))
if(abs(fmv)>1.e-9):
obj1 = bulk_solvent.overall_and_bulk_solvent_scale_coefficients_analytical(
f_obs = f_obs,
f_calc = f_calc,
f_mask = f_mask,
selection = selection_use)
k_mask.set_selected(selection, obj1.x_best)
k.append(obj1.x_best)
else:
k_mask.set_selected(selection, 0)
k.append(0)
r.append(self.try_scale(k_mask = k_mask, selection=selection))
#
if(abs(fmv)>1.e-9):
obj2 = bulk_solvent.bulk_solvent_scale_coefficients_analytical(
f_obs = f_obs,
f_calc = f_calc,
f_mask = f_mask,
selection = selection_use)
k_mask.set_selected(selection, obj2.x_best)
k.append(obj2.x_best)
else:
k_mask.set_selected(selection, 0)
k.append(0)
r.append(self.try_scale(k_mask = k_mask, selection=selection))
s = flex.sort_permutation(r)
x = k.select(s)[0]
# fine-sample k_mask around minimum of LS to fall into minimum of R
k_mask_bin_, k_isotropic_bin_ = \
bulk_solvent.k_mask_and_k_overall_grid_search(
f_obs,
f_calc,
f_mask,
get_k_mask_trial_range(x = x),
selection_use)
k_mask_bin.append(k_mask_bin_)
k_mask.set_selected(selection, k_mask_bin_)
else: assert 0
#
k_mask_bin_smooth = self.smooth(k_mask_bin)
k_mask = self.populate_bin_to_individual_k_mask_linear_interpolation(
k_mask_bin = k_mask_bin_smooth)
k_isotropic = self._k_isotropic_as_scale_k1(r_start=r_start,k_mask = k_mask)
#
r = self.try_scale(k_mask = k_mask, k_isotropic = k_isotropic)
if(r<=r_start or (r>r_start and abs(r-r_start)*100<0.5)): # may be 0.5?
self.core = self.core.update(k_isotropic = k_isotropic, k_masks = k_mask)
self.bss_result.k_mask_bin_orig = k_mask_bin
self.bss_result.k_mask_bin_smooth = k_mask_bin_smooth
self.bss_result.k_mask = k_mask
self.bss_result.k_isotropic = k_isotropic
r_start = r
if(self.verbose):
print >> self.log, " %s: %6.4f"%("bulk-solvent", r_start)
else:
if(self.verbose):
print >> self.log, " %s: %6.4f (%s)"%("bulk-solvent", r, "result rejected")
return self.r_factor()
