def r_factor(self, use_scale=False):
if(use_scale):
return bulk_solvent.r_factor(self.f_obs.data(),
self.core.f_model.data(), self.selection_work.data())
else:
return bulk_solvent.r_factor(self.f_obs.data(),
self.core.f_model.data(), self.selection_work.data(), 1)
def r_factor(self, use_scale=False):
if (use_scale):
return bulk_solvent.r_factor(self.f_obs.data(),
self.core.f_model.data(),
self.selection_work.data())
else:
return bulk_solvent.r_factor(self.f_obs.data(),
self.core.f_model.data(),
self.selection_work.data(), 1)
def try_scale(self,
k_isotropic_exp=None,
k_isotropic=None,
k_mask=None,
k_anisotropic=None,
selection=None,
use_scale_r=False):
if (k_isotropic_exp is None):
k_isotropic_exp = self.core.k_isotropic_exp
if (k_isotropic is None): k_isotropic = self.core.k_isotropic
if (k_mask is None): k_mask = self.core.k_mask()
if (k_anisotropic is None): k_anisotropic = self.core.k_anisotropic
c = mmtbx.arrays.init(f_calc=self.core.f_calc,
f_masks=self.core.f_mask(),
k_isotropic_exp=k_isotropic_exp,
k_isotropic=k_isotropic,
k_anisotropic=k_anisotropic,
k_masks=k_mask)
sel = self.selection_work.data()
if (not use_scale_r):
if (selection is not None): sel = selection & sel
return bulk_solvent.r_factor(self.f_obs.data(), c.f_model.data(),
sel) # XXX
else:
return cctbx.xray.r_factor(self.f_obs.data().select(sel),
c.f_model.data().select(sel)).value()
def show(self):
b = self.bss_result
print >> self.log, " Statistics in resolution bins:"
#assert k_mask.size() == len(self.bin_selections)
fmt=" %7.5f %6.2f -%6.2f %5.1f %5d %-6s %-6s %-6s %6.3f %6.3f %8.2f %6.4f"
f_model = self.core.f_model.data()
print >> self.log, " s^2 Resolution Compl Nrefl k_mask k_iso k_ani <Fobs> R"
print >> self.log, " (A) (%) orig smooth average"
k_mask_bin_orig_ = str(None)
k_mask_bin_smooth_ = str(None)
k_mask_bin_approx_ = str(None)
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]
if(b is not None and self.bss_result.k_mask_bin_orig is not None):
k_mask_bin_orig_ = "%6.4f"%self.bss_result.k_mask_bin_orig[i_sel]
if(b is not None and self.bss_result.k_mask_bin_smooth is not None):
k_mask_bin_smooth_ = "%6.4f"%self.bss_result.k_mask_bin_smooth[i_sel]
k_mask_bin_averaged_ = "%6.4f"%flex.mean(self.core.k_mask().select(sel))
d_ = self.d_spacings.data().select(sel)
d_min_ = flex.min(d_)
d_max_ = flex.max(d_)
n_ref_ = d_.size()
f_obs_ = self.f_obs.select(sel)
f_obs_mean_ = flex.mean(f_obs_.data())
k_isotropic_ = flex.mean(self.core.k_isotropic.select(sel))
k_anisotropic_ = flex.mean(self.core.k_anisotropic.select(sel))
cmpl_ = f_obs_.completeness(d_max=d_max_)*100.
r_ = bulk_solvent.r_factor(f_obs_.data(),f_model.select(sel),1)
print >> self.log, fmt%(ss_, d_max_, d_min_, cmpl_, n_ref_,
k_mask_bin_orig_, k_mask_bin_smooth_,k_mask_bin_averaged_,
k_isotropic_, k_anisotropic_, f_obs_mean_, r_)
def try_scale(self,
k_isotropic_exp=None,
k_isotropic=None,
k_mask=None,
k_anisotropic=None,
selection=None,
use_scale_r=False):
if(k_isotropic_exp is None): k_isotropic_exp = self.core.k_isotropic_exp
if(k_isotropic is None): k_isotropic = self.core.k_isotropic
if(k_mask is None): k_mask = self.core.k_mask()
if(k_anisotropic is None): k_anisotropic = self.core.k_anisotropic
c = mmtbx.arrays.init(
f_calc = self.core.f_calc,
f_masks = self.core.f_mask(),
k_isotropic_exp = k_isotropic_exp,
k_isotropic = k_isotropic,
k_anisotropic = k_anisotropic,
k_masks = k_mask)
sel = self.selection_work.data()
if(not use_scale_r):
if(selection is not None): sel = selection & sel
return bulk_solvent.r_factor(self.f_obs.data(), c.f_model.data(), sel) # XXX
else:
return cctbx.xray.r_factor(
self.f_obs.data().select(sel), c.f_model.data().select(sel)).value()
def r_factor(self):
if(self.fmodel_twin is None):
return self.fmodel.r_factor()
else:
return bulk_solvent.r_factor(
self.fmodel.f_obs.data(),
self.fmodel.data.f_model,
self.fmodel_twin.data.f_model,
self.twin_fraction)
def r_work_and_completeness_in_resolution_bins(fmodel,
reflections_per_bin=500,
out=None,
prefix=""):
if (out is None): out = sys.stdout
from mmtbx import bulk_solvent
from cctbx.array_family import flex
fo_w = fmodel.f_obs_work()
fc_w = fmodel.f_model_scaled_with_k1_w()
reflections_per_bin = min(reflections_per_bin, fo_w.data().size())
fo_w.setup_binner(reflections_per_bin=reflections_per_bin)
fc_w.use_binning_of(fo_w)
result = []
for i_bin in fo_w.binner().range_used():
sel_w = fo_w.binner().selection(i_bin)
sel_all = fo_w.binner().selection(i_bin)
sel_fo_all = fo_w.select(sel_all)
sel_fo_w = fo_w.select(sel_w)
sel_fc_w = fc_w.select(sel_w)
d_max_, d_min_ = sel_fo_all.d_max_min()
completeness = sel_fo_all.completeness(d_max=d_max_)
d_range = fo_w.binner().bin_legend(i_bin=i_bin,
show_bin_number=False,
show_counts=False)
s_fo_w_d = sel_fo_w.data()
s_fc_w_d = sel_fc_w.data()
assert s_fo_w_d.size() == s_fc_w_d.size()
s_fc_w_d_a = flex.abs(s_fc_w_d)
if (s_fo_w_d.size() > 0):
bin = resolution_bin(
i_bin=i_bin,
d_range=d_range,
completeness=completeness,
r_work=bulk_solvent.r_factor(s_fo_w_d, s_fc_w_d, 1),
n_work=sel_fo_w.data().size(),
scale_k1_work=_scale_helper(num=s_fo_w_d, den=s_fc_w_d_a),
mean_f_obs=flex.mean_default(sel_fo_all.data(), None))
result.append(bin)
print(prefix +
" Bin Resolution Range Compl. Nwork Rwork Scale <Fobs>",
file=out)
for bin in result:
fmt = " %s %s %s %s %s %s %s"
print(
prefix + fmt %
(format_value("%3d", bin.i_bin), format_value(
"%-17s", bin.d_range), format_value("%4.2f", bin.completeness),
format_value("%8d", bin.n_work), format_value(
"%6.4f", bin.r_work), format_value("%6.4f",
bin.scale_k1_work),
format_value("%10.3f", bin.mean_f_obs)),
file=out)
def r_work_and_completeness_in_resolution_bins(fmodel, reflections_per_bin=500,
out = None, prefix=""):
if(out is None): out = sys.stdout
from mmtbx import bulk_solvent
from cctbx.array_family import flex
fo_w = fmodel.f_obs_work()
fc_w = fmodel.f_model_scaled_with_k1_w()
reflections_per_bin = min(reflections_per_bin, fo_w.data().size())
fo_w.setup_binner(reflections_per_bin = reflections_per_bin)
fc_w.use_binning_of(fo_w)
result = []
for i_bin in fo_w.binner().range_used():
sel_w = fo_w.binner().selection(i_bin)
sel_all = fo_w.binner().selection(i_bin)
sel_fo_all = fo_w.select(sel_all)
sel_fo_w = fo_w.select(sel_w)
sel_fc_w = fc_w.select(sel_w)
d_max_,d_min_ = sel_fo_all.d_max_min()
completeness = sel_fo_all.completeness(d_max = d_max_)
d_range = fo_w.binner().bin_legend(
i_bin=i_bin, show_bin_number=False, show_counts=False)
s_fo_w_d = sel_fo_w.data()
s_fc_w_d = sel_fc_w.data()
assert s_fo_w_d.size() == s_fc_w_d.size()
s_fc_w_d_a = flex.abs(s_fc_w_d)
if(s_fo_w_d.size() > 0):
bin = resolution_bin(
i_bin = i_bin,
d_range = d_range,
completeness = completeness,
r_work = bulk_solvent.r_factor(s_fo_w_d, s_fc_w_d, 1),
n_work = sel_fo_w.data().size(),
scale_k1_work= _scale_helper(num=s_fo_w_d, den=s_fc_w_d_a),
mean_f_obs = flex.mean_default(sel_fo_all.data(),None))
result.append(bin)
print >> out,\
prefix+" Bin Resolution Range Compl. Nwork Rwork Scale <Fobs>"
for bin in result:
fmt = " %s %s %s %s %s %s %s"
print >> out,prefix+fmt%(
format_value("%3d", bin.i_bin),
format_value("%-17s", bin.d_range),
format_value("%4.2f", bin.completeness),
format_value("%8d", bin.n_work),
format_value("%6.4f", bin.r_work),
format_value("%6.4f", bin.scale_k1_work),
format_value("%10.3f", bin.mean_f_obs))
def show(self):
b = self.bss_result
print(" Statistics in resolution bins:", file=self.log)
#assert k_mask.size() == len(self.bin_selections)
fmt = " %7.5f %6.2f -%6.2f %5.1f %5d %-6s %-6s %-6s %6.3f %6.3f %8.2f %6.4f"
f_model = self.core.f_model.data()
print(
" s^2 Resolution Compl Nrefl k_mask k_iso k_ani <Fobs> R",
file=self.log)
print(" (A) (%) orig smooth average",
file=self.log)
k_mask_bin_orig_ = str(None)
k_mask_bin_smooth_ = str(None)
k_mask_bin_approx_ = str(None)
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]
if (b is not None and self.bss_result.k_mask_bin_orig is not None):
k_mask_bin_orig_ = "%6.4f" % self.bss_result.k_mask_bin_orig[
i_sel]
if (b is not None
and self.bss_result.k_mask_bin_smooth is not None):
k_mask_bin_smooth_ = "%6.4f" % self.bss_result.k_mask_bin_smooth[
i_sel]
k_mask_bin_averaged_ = "%6.4f" % flex.mean(
self.core.k_mask().select(sel))
d_ = self.d_spacings.data().select(sel)
d_min_ = flex.min(d_)
d_max_ = flex.max(d_)
n_ref_ = d_.size()
f_obs_ = self.f_obs.select(sel)
f_obs_mean_ = flex.mean(f_obs_.data())
k_isotropic_ = flex.mean(self.core.k_isotropic.select(sel))
k_anisotropic_ = flex.mean(self.core.k_anisotropic.select(sel))
cmpl_ = f_obs_.completeness(d_max=d_max_) * 100.
r_ = bulk_solvent.r_factor(f_obs_.data(), f_model.select(sel), 1)
print(fmt % (ss_, d_max_, d_min_, cmpl_, n_ref_, k_mask_bin_orig_,
k_mask_bin_smooth_, k_mask_bin_averaged_,
k_isotropic_, k_anisotropic_, f_obs_mean_, r_),
file=self.log)
def run_0(symbol = "C 2"):
space_group_info = sgtbx.space_group_info(symbol = symbol)
xrs = random_structure.xray_structure(
space_group_info = space_group_info,
elements = ["N"]*50,
volume_per_atom = 100.0,
random_u_iso = True)
#
b_cart = adptbx.random_traceless_symmetry_constrained_b_cart(
crystal_symmetry=xrs.crystal_symmetry())
u_star = adptbx.u_cart_as_u_star(xrs.unit_cell(), adptbx.b_as_u(b_cart))
#
F = xrs.structure_factors(d_min = 1.5).f_calc()
k_anisotropic = mmtbx.f_model.ext.k_anisotropic(F.indices(), u_star)
#
bin_selections = []
F.setup_binner(reflections_per_bin=50)
for i_bin in F.binner().range_used():
sel = F.binner().selection(i_bin)
bin_selections.append(sel)
#
d_spacings = F.d_spacings().data()
ss = 1./flex.pow2(d_spacings) / 4.
k_mask_tmp = mmtbx.f_model.ext.k_mask(ss, 0.35, 80.)
k_mask = flex.double(F.data().size(), 0)
k_isotropic = flex.double(F.data().size(), 0)
for s in bin_selections:
d = d_spacings.select(s)
k_mask.set_selected(s, flex.mean(k_mask_tmp.select(s)))
k_isotropic.set_selected(s, random.randint(1,10))
#
fmodel = mmtbx.f_model.manager(
xray_structure = xrs,
f_obs = abs(F),
k_isotropic = k_isotropic,
k_anisotropic = k_anisotropic,
k_mask = k_mask)
f_calc = fmodel.f_calc()
f_masks = fmodel.f_masks()
f_model = fmodel.f_model()
f_obs = abs(f_model)
r_free_flags = f_obs.generate_r_free_flags(use_lattice_symmetry=False)
#
assert approx_equal(bulk_solvent.r_factor(f_obs.data(), f_model.data()), 0)
aso = scaler.run(
f_obs = f_obs,
f_calc = f_calc,
f_mask = f_masks,
r_free_flags = r_free_flags,
bin_selections = bin_selections,
number_of_cycles = 500,
auto_convergence_tolerance = 1.e-9,
ss = ss,
try_poly = True,
try_expanal = True,
try_expmin = True,
verbose = False)
assert approx_equal(aso.r_final, 0.00037, 0.00001)
assert approx_equal(aso.r_low, 0.00002, 0.00001)
assert approx_equal(aso.r_high, 0.00006, 0.00001)
assert approx_equal(
bulk_solvent.r_factor(f_obs.data(), abs(aso.core.f_model).data(), 1),
bulk_solvent.r_factor(f_obs.data(), abs(aso.core.f_model).data()))
def r_work(self):
return bulk_solvent.r_factor(self.f_obs.data(),
self.core.f_model.data(),
~self.r_free_flags.data())
def run_01():
time_aniso_u_scaler = 0
for symbol in sgtbx.bravais_types.acentric + sgtbx.bravais_types.centric:
#print symbol, "-"*50
space_group_info = sgtbx.space_group_info(symbol = symbol)
xrs = random_structure.xray_structure(
space_group_info = space_group_info,
elements = ["N"]*100,
volume_per_atom = 50.0,
random_u_iso = True)
# XXX ad a method to adptbx to do this
point_group = sgtbx.space_group_info(
symbol=symbol).group().build_derived_point_group()
adp_constraints = sgtbx.tensor_rank_2_constraints(
space_group=point_group,
reciprocal_space=True)
u_star = adptbx.u_cart_as_u_star(xrs.unit_cell(),
adptbx.random_u_cart(u_scale=1,u_min=0.1))
u_indep = adp_constraints.independent_params(all_params=u_star)
u_star = adp_constraints.all_params(independent_params=u_indep)
b_cart_start=adptbx.u_as_b(adptbx.u_star_as_u_cart(xrs.unit_cell(), u_star))
#
tr = (b_cart_start[0]+b_cart_start[1]+b_cart_start[2])/3
b_cart_start = [b_cart_start[0]-tr,b_cart_start[1]-tr,b_cart_start[2]-tr,
b_cart_start[3],b_cart_start[4],b_cart_start[5]]
tr = (b_cart_start[0]+b_cart_start[1]+b_cart_start[2])/3
#
#print "Input b_cart :", " ".join(["%8.4f"%i for i in b_cart_start]), "tr:", tr
F = xrs.structure_factors(d_min = 2.0).f_calc()
F = xrs.structure_factors(d_min = 2.0).f_calc()
u_star = adptbx.u_cart_as_u_star(
F.unit_cell(), adptbx.b_as_u(b_cart_start))
fbc = mmtbx.f_model.ext.k_anisotropic(F.indices(), u_star)
fc = F.structure_factors_from_scatterers(xray_structure=xrs).f_calc()
f_obs = F.customized_copy(data = flex.abs(fc.data()*fbc))
#print bulk_solvent.r_factor(f_obs.data(), fmodel.f_model().data())
obj = bulk_solvent.aniso_u_scaler(
f_model = fc.data(),
f_obs = f_obs.data(),
miller_indices = f_obs.indices(),
unit_cell = f_obs.unit_cell())
a = obj.a
####
#print "Input a :", " ".join(["%7.3f"%i for i in a])
overall_anisotropic_scale = mmtbx.f_model.ext.k_anisotropic(
f_obs.indices(), a, f_obs.unit_cell())
#print bulk_solvent.r_factor(f_obs.data(), fmodel.f_model().data()*overall_anisotropic_scale)
f_obs = abs(fc)
f_obs = f_obs.customized_copy(data = f_obs.data() * overall_anisotropic_scale)
#print bulk_solvent.r_factor(f_obs.data(), fmodel.f_model().data())
#print bulk_solvent.r_factor(f_obs.data(), fmodel.f_model().data())
t0 = time.time()
obj = bulk_solvent.aniso_u_scaler(
f_model = fc.data(),
f_obs = f_obs.data(),
miller_indices = f_obs.indices(),
unit_cell = f_obs.unit_cell())
time_aniso_u_scaler += (time.time()-t0)
overall_anisotropic_scale = mmtbx.f_model.ext.k_anisotropic(
f_obs.indices(), obj.a, f_obs.unit_cell())
assert approx_equal(bulk_solvent.r_factor(f_obs.data(),
fc.data()*overall_anisotropic_scale), 0.0, 1.e-2) # XXX seems to be low
#print "Output a:", " ".join(["%7.3f"%i for i in obj.a])
assert approx_equal(a, obj.a, 1.e-3) # XXX can it be smaller?
print "Time (aniso_u_scaler only): %6.4f"%time_aniso_u_scaler
def _r_low(self):
return bulk_solvent.r_factor(self.f_obs.data(),
self.core.f_model.data(),
self.low_resolution_selection, 1)
def _r_low(self):
return bulk_solvent.r_factor(self.f_obs.data(),
self.core.f_model.data(), self.low_resolution_selection, 1)
def r_all(self):
return bulk_solvent.r_factor(self.f_obs.data(),
self.core.f_model.data())
def r_all(self):
return bulk_solvent.r_factor(self.f_obs.data(),
self.core.f_model.data())
def r_factor(self):
return bulk_solvent.r_factor(self.f_obs.data(),
self.core.f_model.data(),
self.selection_work.data())
def _r_high(self):
return bulk_solvent.r_factor(self.f_obs.data(),
self.core.f_model.data(),
self.high_resolution_selection)
def statistics_in_resolution_bins(self,
fmodel,
free_reflections_per_bin,
max_number_of_bins,
n_bins=None):
from mmtbx import bulk_solvent
from cctbx.array_family import flex
if (self.target_name == "twin_lsq_f"):
return fmodel.statistics_in_resolution_bins()
result = []
target_functor = fmodel.target_functor()
target_result = target_functor(compute_gradients=False)
tpr = target_result.target_per_reflection()
if (tpr.size() != 0):
tpr_w = tpr.select(fmodel.arrays.work_sel)
tpr_t = tpr.select(fmodel.arrays.free_sel)
fo_t = fmodel.f_obs_free()
fc_t = fmodel.f_model_scaled_with_k1_t()
fo_w = fmodel.f_obs_work()
fc_w = fmodel.f_model_scaled_with_k1_w()
alpha_t, beta_t = fmodel.alpha_beta_t()
if (n_bins is None) or (n_bins < 1):
n_bins = fmodel.determine_n_bins(
free_reflections_per_bin=free_reflections_per_bin,
max_n_bins=max_number_of_bins)
fmodel.f_obs().setup_binner(n_bins=n_bins)
fo_t.use_binning_of(fmodel.f_obs())
fc_t.use_binning_of(fo_t)
fo_w.use_binning_of(fo_t)
fc_w.use_binning_of(fo_t)
self.alpha_w.use_binning_of(fo_t)
alpha_t.use_binning_of(fo_t)
self.beta_w.use_binning_of(fo_t)
beta_t.use_binning_of(fo_t)
for i_bin in fo_t.binner().range_used():
sel_t = fo_t.binner().selection(i_bin)
sel_w = fo_w.binner().selection(i_bin)
sel_all = fmodel.f_obs().binner().selection(i_bin)
sel_fo_all = fmodel.f_obs().select(sel_all)
sel_fo_t = fo_t.select(sel_t)
sel_fc_t = fc_t.select(sel_t)
sel_fo_w = fo_w.select(sel_w)
sel_fc_w = fc_w.select(sel_w)
if (tpr.size() == 0):
sel_tpr_w = None
sel_tpr_t = None
else:
denom_w = sel_fo_w.data().size()
denom_t = sel_fo_t.data().size()
if (denom_w != 0):
sel_tpr_w = flex.sum(tpr_w.select(sel_w)) / denom_w
else:
sel_tpr_w = flex.sum(tpr_w.select(sel_w))
if (denom_t != 0):
sel_tpr_t = flex.sum(tpr_t.select(sel_t)) / denom_t
else:
sel_tpr_t = flex.sum(tpr_t.select(sel_t))
d_max_, d_min_ = sel_fo_all.d_max_min()
completeness = sel_fo_all.completeness(d_max=d_max_)
d_range = "%7.2f - %7.2f" % (d_max_, d_min_)
s_fo_w_d = sel_fo_w.data()
s_fc_w_d = sel_fc_w.data()
assert s_fo_w_d.size() == s_fc_w_d.size()
s_fc_w_d_a = flex.abs(s_fc_w_d)
if (s_fo_w_d.size() > 0):
bin = resolution_bin(
i_bin=i_bin,
d_range=d_range,
completeness=completeness,
alpha_work=flex.mean_default(
self.alpha_w.select(sel_w).data(), None),
beta_work=flex.mean_default(
self.beta_w.select(sel_w).data(), None),
r_work=bulk_solvent.r_factor(s_fo_w_d, s_fc_w_d, 1),
r_free=bulk_solvent.r_factor(sel_fo_t.data(),
sel_fc_t.data(), 1),
target_work=sel_tpr_w,
target_free=sel_tpr_t,
n_work=sel_fo_w.data().size(),
n_free=sel_fo_t.data().size(),
scale_k1_work=_scale_helper(num=s_fo_w_d, den=s_fc_w_d_a),
mean_f_obs=flex.mean_default(sel_fo_all.data(), None),
fom_work=flex.mean_default(self.fom.select(sel_w), None),
pher_work=flex.mean_default(self.pher_w.select(sel_w),
None),
pher_free=flex.mean_default(self.pher_t.select(sel_t),
None),
cc_work=cc(s_fo_w_d, s_fc_w_d_a),
cc_free=cc(sel_fo_t.data(), flex.abs(sel_fc_t.data())))
result.append(bin)
return result
def run_0(symbol="C 2"):
space_group_info = sgtbx.space_group_info(symbol=symbol)
xrs = random_structure.xray_structure(space_group_info=space_group_info,
elements=["N"] * 50,
volume_per_atom=100.0,
random_u_iso=True)
#
b_cart = adptbx.random_traceless_symmetry_constrained_b_cart(
crystal_symmetry=xrs.crystal_symmetry())
u_star = adptbx.u_cart_as_u_star(xrs.unit_cell(), adptbx.b_as_u(b_cart))
#
F = xrs.structure_factors(d_min=1.5).f_calc()
k_anisotropic = mmtbx.f_model.ext.k_anisotropic(F.indices(), u_star)
#
bin_selections = []
F.setup_binner(reflections_per_bin=50)
for i_bin in F.binner().range_used():
sel = F.binner().selection(i_bin)
bin_selections.append(sel)
#
d_spacings = F.d_spacings().data()
ss = 1. / flex.pow2(d_spacings) / 4.
k_mask_tmp = mmtbx.f_model.ext.k_mask(ss, 0.35, 80.)
k_mask = flex.double(F.data().size(), 0)
k_isotropic = flex.double(F.data().size(), 0)
for s in bin_selections:
d = d_spacings.select(s)
k_mask.set_selected(s, flex.mean(k_mask_tmp.select(s)))
k_isotropic.set_selected(s, random.randint(1, 10))
#
fmodel = mmtbx.f_model.manager(xray_structure=xrs,
f_obs=abs(F),
k_isotropic=k_isotropic,
k_anisotropic=k_anisotropic,
k_mask=k_mask)
f_calc = fmodel.f_calc()
f_masks = fmodel.f_masks()
f_model = fmodel.f_model()
f_obs = abs(f_model)
r_free_flags = f_obs.generate_r_free_flags(use_lattice_symmetry=False)
#
assert approx_equal(bulk_solvent.r_factor(f_obs.data(), f_model.data()), 0)
aso = scaler.run(f_obs=f_obs,
f_calc=f_calc,
f_mask=f_masks,
r_free_flags=r_free_flags,
bin_selections=bin_selections,
number_of_cycles=500,
auto_convergence_tolerance=1.e-9,
ss=ss,
try_poly=True,
try_expanal=True,
try_expmin=True,
verbose=True)
print("r_f:", aso.r_final)
print("r_l:", aso.r_low)
print("r_h:", aso.r_high)
assert aso.r_final < 0.0009, [aso.r_final, 0.0009]
assert aso.r_low < 0.0017, [aso.r_low, 0.0017]
assert aso.r_high < 0.0006, [aso.r_high, 0.0006]
assert approx_equal(
bulk_solvent.r_factor(f_obs.data(),
abs(aso.core.f_model).data(), 1),
bulk_solvent.r_factor(f_obs.data(),
abs(aso.core.f_model).data()))
def run_01():
time_aniso_u_scaler = 0
for symbol in sgtbx.bravais_types.acentric + sgtbx.bravais_types.centric:
#print symbol, "-"*50
space_group_info = sgtbx.space_group_info(symbol=symbol)
xrs = random_structure.xray_structure(
space_group_info=space_group_info,
elements=["N"] * 100,
volume_per_atom=50.0,
random_u_iso=True)
# XXX ad a method to adptbx to do this
point_group = sgtbx.space_group_info(
symbol=symbol).group().build_derived_point_group()
adp_constraints = sgtbx.tensor_rank_2_constraints(
space_group=point_group, reciprocal_space=True)
u_star = adptbx.u_cart_as_u_star(
xrs.unit_cell(), adptbx.random_u_cart(u_scale=1, u_min=0.1))
u_indep = adp_constraints.independent_params(all_params=u_star)
u_star = adp_constraints.all_params(independent_params=u_indep)
b_cart_start = adptbx.u_as_b(
adptbx.u_star_as_u_cart(xrs.unit_cell(), u_star))
#
tr = (b_cart_start[0] + b_cart_start[1] + b_cart_start[2]) / 3
b_cart_start = [
b_cart_start[0] - tr, b_cart_start[1] - tr, b_cart_start[2] - tr,
b_cart_start[3], b_cart_start[4], b_cart_start[5]
]
tr = (b_cart_start[0] + b_cart_start[1] + b_cart_start[2]) / 3
#
#print "Input b_cart :", " ".join(["%8.4f"%i for i in b_cart_start]), "tr:", tr
F = xrs.structure_factors(d_min=2.0).f_calc()
F = xrs.structure_factors(d_min=2.0).f_calc()
u_star = adptbx.u_cart_as_u_star(F.unit_cell(),
adptbx.b_as_u(b_cart_start))
fbc = mmtbx.f_model.ext.k_anisotropic(F.indices(), u_star)
fc = F.structure_factors_from_scatterers(xray_structure=xrs).f_calc()
f_obs = F.customized_copy(data=flex.abs(fc.data() * fbc))
#print bulk_solvent.r_factor(f_obs.data(), fmodel.f_model().data())
obj = bulk_solvent.aniso_u_scaler(f_model_abs=flex.abs(fc.data()),
f_obs=f_obs.data(),
miller_indices=f_obs.indices(),
unit_cell=f_obs.unit_cell())
a = obj.a
####
#print "Input a :", " ".join(["%7.3f"%i for i in a])
overall_anisotropic_scale = mmtbx.f_model.ext.k_anisotropic(
f_obs.indices(), a, f_obs.unit_cell())
#print bulk_solvent.r_factor(f_obs.data(), fmodel.f_model().data()*overall_anisotropic_scale)
f_obs = abs(fc)
f_obs = f_obs.customized_copy(data=f_obs.data() *
overall_anisotropic_scale)
#print bulk_solvent.r_factor(f_obs.data(), fmodel.f_model().data())
#print bulk_solvent.r_factor(f_obs.data(), fmodel.f_model().data())
t0 = time.time()
obj = bulk_solvent.aniso_u_scaler(f_model_abs=flex.abs(fc.data()),
f_obs=f_obs.data(),
miller_indices=f_obs.indices(),
unit_cell=f_obs.unit_cell())
time_aniso_u_scaler += (time.time() - t0)
overall_anisotropic_scale = mmtbx.f_model.ext.k_anisotropic(
f_obs.indices(), obj.a, f_obs.unit_cell())
assert approx_equal(
bulk_solvent.r_factor(f_obs.data(),
fc.data() * overall_anisotropic_scale), 0.0,
1.e-2) # XXX seems to be low
#print "Output a:", " ".join(["%7.3f"%i for i in obj.a])
assert approx_equal(a, obj.a, 1.e-3) # XXX can it be smaller?
print("Time (aniso_u_scaler only): %6.4f" % time_aniso_u_scaler)
def statistics_in_resolution_bins(self, fmodel, free_reflections_per_bin,
max_number_of_bins, n_bins=None):
from mmtbx import bulk_solvent
from cctbx.array_family import flex
if(self.target_name == "twin_lsq_f"):
return fmodel.statistics_in_resolution_bins()
result = []
target_functor = fmodel.target_functor()
target_result = target_functor(compute_gradients=False)
tpr = target_result.target_per_reflection()
if(tpr.size() != 0):
tpr_w = tpr.select(fmodel.arrays.work_sel)
tpr_t = tpr.select(fmodel.arrays.free_sel)
fo_t = fmodel.f_obs_free()
fc_t = fmodel.f_model_scaled_with_k1_t()
fo_w = fmodel.f_obs_work()
fc_w = fmodel.f_model_scaled_with_k1_w()
alpha_w, beta_w = fmodel.alpha_beta_w()
alpha_t, beta_t = fmodel.alpha_beta_t()
pher_w = fmodel.phase_errors_work()
pher_t = fmodel.phase_errors_test()
fom = fmodel.figures_of_merit_work()
if (n_bins is None) or (n_bins < 1) :
n_bins = fmodel.determine_n_bins(
free_reflections_per_bin=free_reflections_per_bin,
max_n_bins=max_number_of_bins)
fmodel.f_obs().setup_binner(n_bins=n_bins)
fo_t.use_binning_of(fmodel.f_obs())
fc_t.use_binning_of(fo_t)
fo_w.use_binning_of(fo_t)
fc_w.use_binning_of(fo_t)
alpha_w.use_binning_of(fo_t)
alpha_t.use_binning_of(fo_t)
beta_w.use_binning_of(fo_t)
beta_t.use_binning_of(fo_t)
for i_bin in fo_t.binner().range_used():
sel_t = fo_t.binner().selection(i_bin)
sel_w = fo_w.binner().selection(i_bin)
sel_all = fmodel.f_obs().binner().selection(i_bin)
sel_fo_all = fmodel.f_obs().select(sel_all)
sel_fo_t = fo_t.select(sel_t)
sel_fc_t = fc_t.select(sel_t)
sel_fo_w = fo_w.select(sel_w)
sel_fc_w = fc_w.select(sel_w)
if (tpr.size() == 0):
sel_tpr_w = None
sel_tpr_t = None
else:
denom_w = sel_fo_w.data().size()
denom_t = sel_fo_t.data().size()
if(denom_w != 0):
sel_tpr_w = flex.sum(tpr_w.select(sel_w))/denom_w
else:
sel_tpr_w = flex.sum(tpr_w.select(sel_w))
if(denom_t != 0):
sel_tpr_t = flex.sum(tpr_t.select(sel_t))/denom_t
else:
sel_tpr_t = flex.sum(tpr_t.select(sel_t))
d_max_,d_min_ = sel_fo_all.d_max_min()
completeness = sel_fo_all.completeness(d_max = d_max_)
d_range = fo_t.binner().bin_legend(
i_bin=i_bin, show_bin_number=False, show_counts=False)
s_fo_w_d = sel_fo_w.data()
s_fc_w_d = sel_fc_w.data()
assert s_fo_w_d.size() == s_fc_w_d.size()
s_fc_w_d_a = flex.abs(s_fc_w_d)
if(s_fo_w_d.size() > 0):
bin = resolution_bin(
i_bin = i_bin,
d_range = d_range,
completeness = completeness,
alpha_work = flex.mean_default(alpha_w.select(sel_w).data(),None),
beta_work = flex.mean_default(beta_w.select(sel_w).data(),None),
r_work = bulk_solvent.r_factor(s_fo_w_d, s_fc_w_d, 1),
r_free = bulk_solvent.r_factor(sel_fo_t.data(), sel_fc_t.data(), 1),
target_work = sel_tpr_w,
target_free = sel_tpr_t,
n_work = sel_fo_w.data().size(),
n_free = sel_fo_t.data().size(),
scale_k1_work= _scale_helper(num=s_fo_w_d, den=s_fc_w_d_a),
mean_f_obs = flex.mean_default(sel_fo_all.data(),None),
fom_work = flex.mean_default(fom.select(sel_w),None),
pher_work = flex.mean_default(pher_w.select(sel_w),None),
pher_free = flex.mean_default(pher_t.select(sel_t),None),
cc_work = cc(s_fo_w_d, s_fc_w_d_a),
cc_free = cc(sel_fo_t.data(), flex.abs(sel_fc_t.data())))
result.append(bin)
return result
