def test_1():
tstart = time.time()
fraction_missing = 0.1
d_min = 1.5
# create dummy model
symmetry = crystal.symmetry(unit_cell=(15.67, 25.37, 35.68, 90, 90, 90),
space_group_symbol="P 21 21 21")
structure = xray.structure(crystal_symmetry=symmetry)
for k in range(1000):
scatterer = xray.scatterer(
site = ((1.+k*abs(math.sin(k)))/1000.0,
(1.+k*abs(math.cos(k)))/1000.0,
(1.+ k)/1000.0),
u = abs(math.cos(k))*100./(8.*math.pi**2),
occupancy = 1.0,
scattering_type = "C")
structure.add_scatterer(scatterer)
# partial model
n_keep = int(round(structure.scatterers().size() * (1-fraction_missing)))
partial_structure = xray.structure(special_position_settings=structure)
partial_structure.add_scatterers(structure.scatterers()[:n_keep])
# fcalc (partial model), fobs (fcalc full model)
f_calc = structure.structure_factors(d_min=d_min,
anomalous_flag=False).f_calc()
f_calc_partial = partial_structure.structure_factors(d_min=d_min,
anomalous_flag=False).f_calc()
f_obs = abs(f_calc)
f_calc= abs(f_calc_partial)
d_star_sq = 1./flex.pow2(f_obs.d_spacings().data())
assert approx_equal(flex.max(f_calc.data()),6810.19834824)
assert approx_equal(flex.min(f_calc.data()),0.019589341727)
assert approx_equal(flex.mean(f_calc.data()),76.651506629)
assert approx_equal(flex.max(f_obs.data()),6962.58343229)
assert approx_equal(flex.min(f_obs.data()),0.00111552904935)
assert approx_equal(flex.mean(f_obs.data()),74.5148786464)
assert f_obs.size() == f_calc.size()
# define test set reflections
flags=flex.bool(f_calc_partial.indices().size(), False)
k=0
for i in range(f_calc_partial.indices().size()):
k=k+1
if (k !=10):
flags[i]=False
else:
k=0
flags[i]=True
assert flags.count(True) == 250
assert flags.count(False) == 2258
assert flags.size() == 2508
# *********************************************************TEST = 1
alpha, beta = maxlik.alpha_beta_est_manager(
f_obs = f_obs,
f_calc = f_calc,
free_reflections_per_bin = 1000,
flags = flags,
interpolation = False,
epsilons = f_obs.epsilons().data().as_double()).alpha_beta()
assert alpha.data().size() == beta.data().size()
assert alpha.data().size() == f_obs.size()
assert approx_equal(flex.min(alpha.data()),0.914152454693)
assert approx_equal(flex.max(alpha.data()),0.914152454693)
assert approx_equal(flex.min(beta.data()),818.503411782)
assert approx_equal(flex.max(beta.data()),818.503411782)
# *********************************************************TEST = 2
alpha, beta = maxlik.alpha_beta_est_manager(
f_obs = f_obs,
f_calc = f_calc,
free_reflections_per_bin = 50,
flags = flags,
interpolation = False,
epsilons = f_obs.epsilons().data().as_double()).alpha_beta()
assert alpha.data().size() == beta.data().size()
assert alpha.data().size() == f_obs.size()
assert approx_equal(flex.min(alpha.data()), 0.910350007113)
assert approx_equal(flex.max(alpha.data()), 1.07104387776)
assert approx_equal(flex.min(beta.data()), 21.7374310013)
assert approx_equal(flex.max(beta.data()), 4222.81104745)
# *********************************************************TEST = 3
alpha, beta = maxlik.alpha_beta_calc(
f = f_obs,
n_atoms_absent = 100,
n_atoms_included= 900,
bf_atoms_absent = 25.0,
final_error = 0.0,
absent_atom_type = "C").alpha_beta()
fom = max_lik.fom_and_phase_error(
f_obs = f_obs.data(),
f_model = flex.abs(f_calc.data()),
alpha = alpha.data(),
beta = beta.data(),
epsilons = f_obs.epsilons().data().as_double(),
centric_flags = f_obs.centric_flags().data()).fom()
assert flex.max(fom) <= 1.0
assert flex.min(fom) >= 0.0
assert flex.min(alpha.data()) == flex.max(alpha.data()) == 1.0
assert approx_equal(flex.min(beta.data()),7.964134920)
assert approx_equal(flex.max(beta.data()),13695.1589364)
# *********************************************************TEST = 4
xs = crystal.symmetry((3,4,5), "P 2 2 2")
mi = flex.miller_index(((1,-2,3), (0,0,-4)))
ms = miller.set(xs, mi)
fc = flex.double((1.,2.))
fo = flex.double((1.,2.))
mso = miller.set(xs, mi)
mac = miller.array(ms, fc)
mao = miller.array(ms, fo)
alp = flex.double(2,0.0)
bet = flex.double(2,1e+9)
fom = max_lik.fom_and_phase_error(
f_obs = mao.data(),
f_model = mac.data(),
alpha = alp,
beta = bet,
epsilons = mao.epsilons().data().as_double(),
centric_flags = mao.centric_flags().data()).fom()
assert approx_equal(fom,[0.0, 0.0])
alp = flex.double(2,1.0)
bet = flex.double(2,1e+9)
fom = max_lik.fom_and_phase_error(
f_obs = mao.data(),
f_model = mac.data(),
alpha = alp,
beta = bet,
epsilons = mao.epsilons().data().as_double(),
centric_flags = mao.centric_flags().data()).fom()
assert approx_equal(fom,[0.0, 0.0])
alp = flex.double(2,0.0)
bet = flex.double(2,1e-9)
fom = max_lik.fom_and_phase_error(
f_obs = mao.data(),
f_model = mac.data(),
alpha = alp,
beta = bet,
epsilons = mao.epsilons().data().as_double(),
centric_flags = mao.centric_flags().data()).fom()
assert approx_equal(fom,[0.0, 0.0])
alp = flex.double(2,1.0)
bet = flex.double(2,1e-9)
fom = max_lik.fom_and_phase_error(
f_obs = mao.data(),
f_model = mac.data(),
alpha = alp,
beta = bet,
epsilons = mao.epsilons().data().as_double(),
centric_flags = mao.centric_flags().data()).fom()
assert approx_equal(fom,[1.0, 1.0])
def test_2():
n_sites = 1000
d_min = 2.0
volume_per_atom = 50
fraction_missing = (0.0,)
scale = 5.0
# create dummy model
space_group_info = sgtbx.space_group_info("P212121")
structure = random_structure.xray_structure(
space_group_info = space_group_info,
elements = ["N"]*(n_sites),
volume_per_atom = volume_per_atom,
random_u_iso = False)
structure.scattering_type_registry(table="wk1995")
f_calc = structure.structure_factors(d_min = d_min,
anomalous_flag = False,
algorithm = "direct").f_calc()
f_obs = abs(f_calc)
for fm in fraction_missing:
# partial model
n_keep = int(round(structure.scatterers().size() * (1-fm)))
partial_structure = xray.structure(special_position_settings=structure)
partial_structure.add_scatterers(structure.scatterers()[:n_keep])
# fcalc (partial model), fobs (fcalc full model)
f_calc_partial = partial_structure.structure_factors(d_min=d_min,
anomalous_flag=False,
algorithm = "direct").f_calc()
f_calc= abs(f_calc_partial)
# define test set reflections
flags=flex.bool(f_calc_partial.indices().size(), False)
k=0
for i in range(f_calc_partial.indices().size()):
k=k+1
if (k !=10):
flags[i]=False
else:
k=0
flags[i]=True
# *********************************************************TEST = 1
alpha, beta = maxlik.alpha_beta_est_manager(
f_obs = f_obs,
f_calc = f_calc,
free_reflections_per_bin = f_obs.data().size(),
flags = flags,
interpolation = False,
epsilons = f_obs.epsilons().data().as_double()).alpha_beta()
assert alpha.size() == beta.size()
assert alpha.size() == f_obs.size()
assert approx_equal(flex.min(alpha.data()),1.0, 1.e-2)
assert approx_equal(flex.max(alpha.data()),1.0, 1.e-2)
assert approx_equal(flex.min(beta.data()) ,0.0, 1.e-2)
assert approx_equal(flex.max(beta.data()) ,0.0, 1.e-2)
alpha, beta = maxlik.alpha_beta_est_manager(
f_obs = f_obs,
f_calc = f_calc,
free_reflections_per_bin = f_obs.data().size(),
flags = flags,
interpolation = True,
epsilons = f_obs.epsilons().data().as_double()).alpha_beta()
assert alpha.size() == beta.size()
assert alpha.size() == f_obs.size()
assert approx_equal(flex.min(alpha.data()),1.0, 1.e-2)
assert approx_equal(flex.max(alpha.data()),1.0, 1.e-2)
assert approx_equal(flex.min(beta.data()) ,0.0, 1.e-2)
assert approx_equal(flex.max(beta.data()) ,0.0, 1.e-2)
# *********************************************************TEST = 2
alpha, beta = maxlik.alpha_beta_est_manager(
f_obs = miller.array(miller_set = f_obs,
data = f_obs.data() * scale),
f_calc = f_calc,
free_reflections_per_bin = 200,
flags = flags,
interpolation = False,
epsilons = f_obs.epsilons().data().as_double()).alpha_beta()
assert alpha.size() == beta.size()
assert alpha.size() == f_obs.size()
assert approx_equal(flex.min(alpha.data()),1.0/scale, 1.e-2)
assert approx_equal(flex.max(alpha.data()),1.0/scale, 1.e-2)
assert approx_equal(flex.min(beta.data()) ,0.0, 1.e-2)
assert approx_equal(flex.max(beta.data()) ,0.0, 1.e-2)
alpha, beta = maxlik.alpha_beta_est_manager(
f_obs = miller.array(miller_set = f_obs,
data = f_obs.data() * scale),
f_calc = f_calc,
free_reflections_per_bin = 200,
flags = flags,
interpolation = True,
epsilons = f_obs.epsilons().data().as_double()).alpha_beta()
assert alpha.size() == beta.size()
assert alpha.size() == f_obs.size()
assert approx_equal(flex.min(alpha.data()),1.0/scale, 1.e-2)
assert approx_equal(flex.max(alpha.data()),1.0/scale, 1.e-2)
assert approx_equal(flex.min(beta.data()) ,0.0, 1.e-2)
assert approx_equal(flex.max(beta.data()) ,0.0, 1.e-2)
# *********************************************************TEST = 3
alpha, beta = maxlik.alpha_beta_est_manager(
f_obs = miller.array(miller_set = f_obs,
data = f_obs.data() * scale),
f_calc = f_calc,
free_reflections_per_bin = 200,
flags = flex.bool(f_obs.data().size(), True),
interpolation = False,
epsilons = f_obs.epsilons().data().as_double()).alpha_beta()
assert alpha.size() == beta.size()
assert alpha.size() == f_obs.size()
assert approx_equal(flex.min(alpha.data()),1.0/scale, 1.e-2)
assert approx_equal(flex.max(alpha.data()),1.0/scale, 1.e-2)
assert approx_equal(flex.min(beta.data()) ,0.0, 1.e-2)
assert approx_equal(flex.max(beta.data()) ,0.0, 1.e-2)
alpha, beta = maxlik.alpha_beta_est_manager(
f_obs = miller.array(miller_set = f_obs,
data = f_obs.data() * scale),
f_calc = f_calc,
free_reflections_per_bin = 200,
flags = flex.bool(f_obs.data().size(), True),
interpolation = True,
epsilons = f_obs.epsilons().data().as_double()).alpha_beta()
assert alpha.size() == beta.size()
assert alpha.size() == f_obs.size()
assert approx_equal(flex.min(alpha.data()),1.0/scale, 1.e-2)
assert approx_equal(flex.max(alpha.data()),1.0/scale, 1.e-2)
assert approx_equal(flex.min(beta.data()) ,0.0, 1.e-2)
assert approx_equal(flex.max(beta.data()) ,0.0, 1.e-2)
# *********************************************************TEST = 4
alpha, beta = maxlik.alpha_beta_est_manager(
f_obs = miller.array(miller_set = f_obs,
data = f_obs.data() * scale),
f_calc = f_calc,
free_reflections_per_bin = 200,
flags = flex.bool(f_obs.data().size(), False),
interpolation = False,
epsilons = f_obs.epsilons().data().as_double()).alpha_beta()
assert alpha.size() == beta.size()
assert alpha.size() == f_obs.size()
assert approx_equal(flex.min(alpha.data()),1.0/scale, 1.e-2)
assert approx_equal(flex.max(alpha.data()),1.0/scale, 1.e-2)
assert approx_equal(flex.min(beta.data()) ,0.0, 1.e-2)
assert approx_equal(flex.max(beta.data()) ,0.0, 1.e-2)
alpha, beta = maxlik.alpha_beta_est_manager(
f_obs = miller.array(miller_set = f_obs,
data = f_obs.data() * scale),
f_calc = f_calc,
free_reflections_per_bin = 200,
flags = flex.bool(f_obs.data().size(), False),
interpolation = True,
epsilons = f_obs.epsilons().data().as_double()).alpha_beta()
assert alpha.size() == beta.size()
assert alpha.size() == f_obs.size()
assert approx_equal(flex.min(alpha.data()),1.0/scale, 1.e-2)
assert approx_equal(flex.max(alpha.data()),1.0/scale, 1.e-2)
assert approx_equal(flex.min(beta.data()) ,0.0, 1.e-2)
assert approx_equal(flex.max(beta.data()) ,0.0, 1.e-2)
def compute_map_coefficients(self):
f_obs = self.f_obs_complete.select(
self.f_obs_complete.d_spacings().data() >= self.d_min)
f_calc = f_obs.structure_factors_from_map(self.map, use_sg=True)
f_obs_active = f_obs.select_indices(self.active_indices)
minimized = relative_scaling.ls_rel_scale_driver(
f_obs_active,
f_calc.as_amplitude_array().select_indices(self.active_indices),
use_intensities=False,
use_weights=False)
#minimized.show()
f_calc = f_calc.customized_copy(data=f_calc.data()\
* math.exp(-minimized.p_scale)\
* adptbx.debye_waller_factor_u_star(
f_calc.indices(), minimized.u_star))
f_calc_active = f_calc.common_set(f_obs_active)
matched_indices = f_obs.match_indices(self.f_obs_active)
lone_indices_selection = matched_indices.single_selection(0)
from mmtbx.max_lik import maxlik
alpha_beta_est = maxlik.alpha_beta_est_manager(
f_obs=f_obs_active,
f_calc=f_calc_active,
free_reflections_per_bin=140,
flags=flex.bool(f_obs_active.size()),
interpolation=True,
epsilons=f_obs_active.epsilons().data().as_double())
alpha, beta = alpha_beta_est.alpha_beta_for_each_reflection(
f_obs=self.f_obs_complete.select(
self.f_obs_complete.d_spacings().data() >= self.d_min))
f_obs.data().copy_selected(lone_indices_selection.iselection(),
flex.abs(f_calc.data()))
t = maxlik.fo_fc_alpha_over_eps_beta(f_obs=f_obs,
f_model=f_calc,
alpha=alpha,
beta=beta)
hl_coeff = flex.hendrickson_lattman(
t * flex.cos(f_calc.phases().data()),
t * flex.sin(f_calc.phases().data()))
dd = alpha.data()
#
hl_array = f_calc.array(
data=self.hl_coeffs_start.common_set(f_calc).data() + hl_coeff)
self.compute_phase_source(hl_array)
fom = flex.abs(self.phase_source.data())
mFo = hl_array.array(data=f_obs.data() * self.phase_source.data())
DFc = hl_array.array(data=dd *
f_calc.as_amplitude_array().phase_transfer(
self.phase_source).data())
centric_flags = f_obs.centric_flags().data()
acentric_flags = ~centric_flags
fo_scale = flex.double(centric_flags.size())
fc_scale = flex.double(centric_flags.size())
fo_scale.set_selected(acentric_flags, 2)
fo_scale.set_selected(centric_flags, 1)
fc_scale.set_selected(acentric_flags, 1)
fc_scale.set_selected(centric_flags, 0)
fo_scale.set_selected(lone_indices_selection, 0)
fc_scale.set_selected(lone_indices_selection, -1)
self.map_coeffs = hl_array.array(data=mFo.data() * fo_scale -
DFc.data() * fc_scale)
self.fom = hl_array.array(data=fom)
self.hl_coeffs = hl_array
# statistics
self.r1_factor = f_obs_active.r1_factor(f_calc_active)
fom = fom.select(matched_indices.pair_selection(0))
self.r1_factor_fom = flex.sum(
fom * flex.abs(f_obs_active.data() - f_calc_active.as_amplitude_array().data())) \
/ flex.sum(fom * f_obs_active.data())
phase_source, phase_source_previous = self.phase_source.common_sets(
self.phase_source_previous)
self.mean_delta_phi = phase_error(
flex.arg(phase_source.data()),
flex.arg(phase_source_previous.data()))
phase_source, phase_source_initial = self.phase_source.common_sets(
self.phase_source_initial)
self.mean_delta_phi_initial = phase_error(
flex.arg(phase_source.data()),
flex.arg(phase_source_initial.data()))
self.mean_fom = flex.mean(fom)
fom = f_obs_active.array(data=fom)
if fom.data().size() < 1000: # 2013-12-14 was hard-wired at 1000 tt
reflections_per_bin = fom.data().size()
else:
reflections_per_bin = 1000
fom.setup_binner(reflections_per_bin=reflections_per_bin)
self.mean_fom_binned = fom.mean(use_binning=True)
def compute_map_coefficients(self):
f_obs = self.f_obs_complete.select(self.f_obs_complete.d_spacings().data() >= self.d_min)
f_calc = f_obs.structure_factors_from_map(self.map, use_sg=True)
f_obs_active = f_obs.select_indices(self.active_indices)
minimized = relative_scaling.ls_rel_scale_driver(
f_obs_active,
f_calc.as_amplitude_array().select_indices(self.active_indices),
use_intensities=False,
use_weights=False)
#minimized.show()
f_calc = f_calc.customized_copy(data=f_calc.data()\
* math.exp(-minimized.p_scale)\
* adptbx.debye_waller_factor_u_star(
f_calc.indices(), minimized.u_star))
f_calc_active = f_calc.common_set(f_obs_active)
matched_indices = f_obs.match_indices(self.f_obs_active)
lone_indices_selection = matched_indices.single_selection(0)
from mmtbx.max_lik import maxlik
alpha_beta_est = maxlik.alpha_beta_est_manager(
f_obs=f_obs_active,
f_calc=f_calc_active,
free_reflections_per_bin=140,
flags=flex.bool(f_obs_active.size()),
interpolation=True,
epsilons=f_obs_active.epsilons().data().as_double())
alpha, beta = alpha_beta_est.alpha_beta_for_each_reflection(
f_obs=self.f_obs_complete.select(self.f_obs_complete.d_spacings().data() >= self.d_min))
f_obs.data().copy_selected(
lone_indices_selection.iselection(), flex.abs(f_calc.data()))
t = maxlik.fo_fc_alpha_over_eps_beta(
f_obs=f_obs,
f_model=f_calc,
alpha=alpha,
beta=beta)
hl_coeff = flex.hendrickson_lattman(
t * flex.cos(f_calc.phases().data()),
t * flex.sin(f_calc.phases().data()))
dd = alpha.data()
#
hl_array = f_calc.array(
data=self.hl_coeffs_start.common_set(f_calc).data()+hl_coeff)
self.compute_phase_source(hl_array)
fom = flex.abs(self.phase_source.data())
mFo = hl_array.array(data=f_obs.data()*self.phase_source.data())
DFc = hl_array.array(data=dd*f_calc.as_amplitude_array().phase_transfer(
self.phase_source).data())
centric_flags = f_obs.centric_flags().data()
acentric_flags = ~centric_flags
fo_scale = flex.double(centric_flags.size())
fc_scale = flex.double(centric_flags.size())
fo_scale.set_selected(acentric_flags, 2)
fo_scale.set_selected(centric_flags, 1)
fc_scale.set_selected(acentric_flags, 1)
fc_scale.set_selected(centric_flags, 0)
fo_scale.set_selected(lone_indices_selection, 0)
fc_scale.set_selected(lone_indices_selection, -1)
self.map_coeffs = hl_array.array(
data=mFo.data()*fo_scale - DFc.data()*fc_scale)
self.fom = hl_array.array(data=fom)
self.hl_coeffs = hl_array
# statistics
self.r1_factor = f_obs_active.r1_factor(f_calc_active)
fom = fom.select(matched_indices.pair_selection(0))
self.r1_factor_fom = flex.sum(
fom * flex.abs(f_obs_active.data() - f_calc_active.as_amplitude_array().data())) \
/ flex.sum(fom * f_obs_active.data())
phase_source, phase_source_previous = self.phase_source.common_sets(
self.phase_source_previous)
self.mean_delta_phi = phase_error(
flex.arg(phase_source.data()), flex.arg(phase_source_previous.data()))
phase_source, phase_source_initial = self.phase_source.common_sets(
self.phase_source_initial)
self.mean_delta_phi_initial = phase_error(
flex.arg(phase_source.data()), flex.arg(phase_source_initial.data()))
self.mean_fom = flex.mean(fom)
fom = f_obs_active.array(data=fom)
if fom.data().size()<1000: # 2013-12-14 was hard-wired at 1000 tt
reflections_per_bin=fom.data().size()
else:
reflections_per_bin=1000
fom.setup_binner(reflections_per_bin=reflections_per_bin)
self.mean_fom_binned = fom.mean(use_binning=True)
def test_1():
tstart = time.time()
fraction_missing = 0.1
d_min = 1.5
# create dummy model
symmetry = crystal.symmetry(unit_cell=(15.67, 25.37, 35.68, 90, 90, 90),
space_group_symbol="P 21 21 21")
structure = xray.structure(crystal_symmetry=symmetry)
for k in xrange(1000):
scatterer = xray.scatterer(
site = ((1.+k*abs(math.sin(k)))/1000.0,
(1.+k*abs(math.cos(k)))/1000.0,
(1.+ k)/1000.0),
u = abs(math.cos(k))*100./(8.*math.pi**2),
occupancy = 1.0,
scattering_type = "C")
structure.add_scatterer(scatterer)
# partial model
n_keep = int(round(structure.scatterers().size() * (1-fraction_missing)))
partial_structure = xray.structure(special_position_settings=structure)
partial_structure.add_scatterers(structure.scatterers()[:n_keep])
# fcalc (partial model), fobs (fcalc full model)
f_calc = structure.structure_factors(d_min=d_min,
anomalous_flag=False).f_calc()
f_calc_partial = partial_structure.structure_factors(d_min=d_min,
anomalous_flag=False).f_calc()
f_obs = abs(f_calc)
f_calc= abs(f_calc_partial)
d_star_sq = 1./flex.pow2(f_obs.d_spacings().data())
assert approx_equal(flex.max(f_calc.data()),6810.19834824)
assert approx_equal(flex.min(f_calc.data()),0.019589341727)
assert approx_equal(flex.mean(f_calc.data()),76.651506629)
assert approx_equal(flex.max(f_obs.data()),6962.58343229)
assert approx_equal(flex.min(f_obs.data()),0.00111552904935)
assert approx_equal(flex.mean(f_obs.data()),74.5148786464)
assert f_obs.size() == f_calc.size()
# define test set reflections
flags=flex.bool(f_calc_partial.indices().size(), False)
k=0
for i in xrange(f_calc_partial.indices().size()):
k=k+1
if (k !=10):
flags[i]=False
else:
k=0
flags[i]=True
assert flags.count(True) == 250
assert flags.count(False) == 2258
assert flags.size() == 2508
# *********************************************************TEST = 1
alpha, beta = maxlik.alpha_beta_est_manager(
f_obs = f_obs,
f_calc = f_calc,
free_reflections_per_bin = 1000,
flags = flags,
interpolation = False,
epsilons = f_obs.epsilons().data().as_double()).alpha_beta()
assert alpha.data().size() == beta.data().size()
assert alpha.data().size() == f_obs.size()
assert approx_equal(flex.min(alpha.data()),0.914152454693)
assert approx_equal(flex.max(alpha.data()),0.914152454693)
assert approx_equal(flex.min(beta.data()),818.503411782)
assert approx_equal(flex.max(beta.data()),818.503411782)
# *********************************************************TEST = 2
alpha, beta = maxlik.alpha_beta_est_manager(
f_obs = f_obs,
f_calc = f_calc,
free_reflections_per_bin = 50,
flags = flags,
interpolation = False,
epsilons = f_obs.epsilons().data().as_double()).alpha_beta()
assert alpha.data().size() == beta.data().size()
assert alpha.data().size() == f_obs.size()
assert approx_equal(flex.min(alpha.data()), 0.910350007113)
assert approx_equal(flex.max(alpha.data()), 1.07104387776)
assert approx_equal(flex.min(beta.data()), 21.7374310013)
assert approx_equal(flex.max(beta.data()), 4222.81104745)
# *********************************************************TEST = 3
alpha, beta = maxlik.alpha_beta_calc(
f = f_obs,
n_atoms_absent = 100,
n_atoms_included= 900,
bf_atoms_absent = 25.0,
final_error = 0.0,
absent_atom_type = "C").alpha_beta()
fom = max_lik.fom_and_phase_error(
f_obs = f_obs.data(),
f_model = flex.abs(f_calc.data()),
alpha = alpha.data(),
beta = beta.data(),
epsilons = f_obs.epsilons().data().as_double(),
centric_flags = f_obs.centric_flags().data()).fom()
assert flex.max(fom) <= 1.0
assert flex.min(fom) >= 0.0
assert flex.min(alpha.data()) == flex.max(alpha.data()) == 1.0
assert approx_equal(flex.min(beta.data()),7.964134920)
assert approx_equal(flex.max(beta.data()),13695.1589364)
# *********************************************************TEST = 4
xs = crystal.symmetry((3,4,5), "P 2 2 2")
mi = flex.miller_index(((1,-2,3), (0,0,-4)))
ms = miller.set(xs, mi)
fc = flex.double((1.,2.))
fo = flex.double((1.,2.))
mso = miller.set(xs, mi)
mac = miller.array(ms, fc)
mao = miller.array(ms, fo)
alp = flex.double(2,0.0)
bet = flex.double(2,1e+9)
fom = max_lik.fom_and_phase_error(
f_obs = mao.data(),
f_model = mac.data(),
alpha = alp,
beta = bet,
epsilons = mao.epsilons().data().as_double(),
centric_flags = mao.centric_flags().data()).fom()
assert approx_equal(fom,[0.0, 0.0])
alp = flex.double(2,1.0)
bet = flex.double(2,1e+9)
fom = max_lik.fom_and_phase_error(
f_obs = mao.data(),
f_model = mac.data(),
alpha = alp,
beta = bet,
epsilons = mao.epsilons().data().as_double(),
centric_flags = mao.centric_flags().data()).fom()
assert approx_equal(fom,[0.0, 0.0])
alp = flex.double(2,0.0)
bet = flex.double(2,1e-9)
fom = max_lik.fom_and_phase_error(
f_obs = mao.data(),
f_model = mac.data(),
alpha = alp,
beta = bet,
epsilons = mao.epsilons().data().as_double(),
centric_flags = mao.centric_flags().data()).fom()
assert approx_equal(fom,[0.0, 0.0])
alp = flex.double(2,1.0)
bet = flex.double(2,1e-9)
fom = max_lik.fom_and_phase_error(
f_obs = mao.data(),
f_model = mac.data(),
alpha = alp,
beta = bet,
epsilons = mao.epsilons().data().as_double(),
centric_flags = mao.centric_flags().data()).fom()
assert approx_equal(fom,[1.0, 1.0])
def test_2():
n_sites = 1000
d_min = 2.0
volume_per_atom = 50
fraction_missing = (0.0,)
scale = 5.0
# create dummy model
space_group_info = sgtbx.space_group_info("P212121")
structure = random_structure.xray_structure(
space_group_info = space_group_info,
elements = ["N"]*(n_sites),
volume_per_atom = volume_per_atom,
random_u_iso = False)
structure.scattering_type_registry(table="wk1995")
f_calc = structure.structure_factors(d_min = d_min,
anomalous_flag = False,
algorithm = "direct").f_calc()
f_obs = abs(f_calc)
for fm in fraction_missing:
# partial model
n_keep = int(round(structure.scatterers().size() * (1-fm)))
partial_structure = xray.structure(special_position_settings=structure)
partial_structure.add_scatterers(structure.scatterers()[:n_keep])
# fcalc (partial model), fobs (fcalc full model)
f_calc_partial = partial_structure.structure_factors(d_min=d_min,
anomalous_flag=False,
algorithm = "direct").f_calc()
f_calc= abs(f_calc_partial)
# define test set reflections
flags=flex.bool(f_calc_partial.indices().size(), False)
k=0
for i in xrange(f_calc_partial.indices().size()):
k=k+1
if (k !=10):
flags[i]=False
else:
k=0
flags[i]=True
# *********************************************************TEST = 1
alpha, beta = maxlik.alpha_beta_est_manager(
f_obs = f_obs,
f_calc = f_calc,
free_reflections_per_bin = f_obs.data().size(),
flags = flags,
interpolation = False,
epsilons = f_obs.epsilons().data().as_double()).alpha_beta()
assert alpha.size() == beta.size()
assert alpha.size() == f_obs.size()
assert approx_equal(flex.min(alpha.data()),1.0, 1.e-2)
assert approx_equal(flex.max(alpha.data()),1.0, 1.e-2)
assert approx_equal(flex.min(beta.data()) ,0.0, 1.e-2)
assert approx_equal(flex.max(beta.data()) ,0.0, 1.e-2)
alpha, beta = maxlik.alpha_beta_est_manager(
f_obs = f_obs,
f_calc = f_calc,
free_reflections_per_bin = f_obs.data().size(),
flags = flags,
interpolation = True,
epsilons = f_obs.epsilons().data().as_double()).alpha_beta()
assert alpha.size() == beta.size()
assert alpha.size() == f_obs.size()
assert approx_equal(flex.min(alpha.data()),1.0, 1.e-2)
assert approx_equal(flex.max(alpha.data()),1.0, 1.e-2)
assert approx_equal(flex.min(beta.data()) ,0.0, 1.e-2)
assert approx_equal(flex.max(beta.data()) ,0.0, 1.e-2)
# *********************************************************TEST = 2
alpha, beta = maxlik.alpha_beta_est_manager(
f_obs = miller.array(miller_set = f_obs,
data = f_obs.data() * scale),
f_calc = f_calc,
free_reflections_per_bin = 200,
flags = flags,
interpolation = False,
epsilons = f_obs.epsilons().data().as_double()).alpha_beta()
assert alpha.size() == beta.size()
assert alpha.size() == f_obs.size()
assert approx_equal(flex.min(alpha.data()),1.0/scale, 1.e-2)
assert approx_equal(flex.max(alpha.data()),1.0/scale, 1.e-2)
assert approx_equal(flex.min(beta.data()) ,0.0, 1.e-2)
assert approx_equal(flex.max(beta.data()) ,0.0, 1.e-2)
alpha, beta = maxlik.alpha_beta_est_manager(
f_obs = miller.array(miller_set = f_obs,
data = f_obs.data() * scale),
f_calc = f_calc,
free_reflections_per_bin = 200,
flags = flags,
interpolation = True,
epsilons = f_obs.epsilons().data().as_double()).alpha_beta()
assert alpha.size() == beta.size()
assert alpha.size() == f_obs.size()
assert approx_equal(flex.min(alpha.data()),1.0/scale, 1.e-2)
assert approx_equal(flex.max(alpha.data()),1.0/scale, 1.e-2)
assert approx_equal(flex.min(beta.data()) ,0.0, 1.e-2)
assert approx_equal(flex.max(beta.data()) ,0.0, 1.e-2)
# *********************************************************TEST = 3
alpha, beta = maxlik.alpha_beta_est_manager(
f_obs = miller.array(miller_set = f_obs,
data = f_obs.data() * scale),
f_calc = f_calc,
free_reflections_per_bin = 200,
flags = flex.bool(f_obs.data().size(), True),
interpolation = False,
epsilons = f_obs.epsilons().data().as_double()).alpha_beta()
assert alpha.size() == beta.size()
assert alpha.size() == f_obs.size()
assert approx_equal(flex.min(alpha.data()),1.0/scale, 1.e-2)
assert approx_equal(flex.max(alpha.data()),1.0/scale, 1.e-2)
assert approx_equal(flex.min(beta.data()) ,0.0, 1.e-2)
assert approx_equal(flex.max(beta.data()) ,0.0, 1.e-2)
alpha, beta = maxlik.alpha_beta_est_manager(
f_obs = miller.array(miller_set = f_obs,
data = f_obs.data() * scale),
f_calc = f_calc,
free_reflections_per_bin = 200,
flags = flex.bool(f_obs.data().size(), True),
interpolation = True,
epsilons = f_obs.epsilons().data().as_double()).alpha_beta()
assert alpha.size() == beta.size()
assert alpha.size() == f_obs.size()
assert approx_equal(flex.min(alpha.data()),1.0/scale, 1.e-2)
assert approx_equal(flex.max(alpha.data()),1.0/scale, 1.e-2)
assert approx_equal(flex.min(beta.data()) ,0.0, 1.e-2)
assert approx_equal(flex.max(beta.data()) ,0.0, 1.e-2)
# *********************************************************TEST = 4
alpha, beta = maxlik.alpha_beta_est_manager(
f_obs = miller.array(miller_set = f_obs,
data = f_obs.data() * scale),
f_calc = f_calc,
free_reflections_per_bin = 200,
flags = flex.bool(f_obs.data().size(), False),
interpolation = False,
epsilons = f_obs.epsilons().data().as_double()).alpha_beta()
assert alpha.size() == beta.size()
assert alpha.size() == f_obs.size()
assert approx_equal(flex.min(alpha.data()),1.0/scale, 1.e-2)
assert approx_equal(flex.max(alpha.data()),1.0/scale, 1.e-2)
assert approx_equal(flex.min(beta.data()) ,0.0, 1.e-2)
assert approx_equal(flex.max(beta.data()) ,0.0, 1.e-2)
alpha, beta = maxlik.alpha_beta_est_manager(
f_obs = miller.array(miller_set = f_obs,
data = f_obs.data() * scale),
f_calc = f_calc,
free_reflections_per_bin = 200,
flags = flex.bool(f_obs.data().size(), False),
interpolation = True,
epsilons = f_obs.epsilons().data().as_double()).alpha_beta()
assert alpha.size() == beta.size()
assert alpha.size() == f_obs.size()
assert approx_equal(flex.min(alpha.data()),1.0/scale, 1.e-2)
assert approx_equal(flex.max(alpha.data()),1.0/scale, 1.e-2)
assert approx_equal(flex.min(beta.data()) ,0.0, 1.e-2)
assert approx_equal(flex.max(beta.data()) ,0.0, 1.e-2)
