def exercise_tensor_constraints_core(crystal_symmetry):
from cctbx import crystal
from cctbx import adptbx
from scitbx import matrix
site_symmetry = crystal.special_position_settings(
crystal_symmetry).site_symmetry(site=(0,0,0))
unit_cell = crystal_symmetry.unit_cell()
group = crystal_symmetry.space_group()
assert site_symmetry.n_matrices() == group.order_p()
for reciprocal_space in [False, True]:
c_tensor_constraints = sgtbx.tensor_rank_2_constraints(
space_group=group,
reciprocal_space=reciprocal_space).row_echelon_form()
p_tensor_constraints = python_tensor_constraints(
self=group, reciprocal_space=reciprocal_space)
assert c_tensor_constraints.all_eq(p_tensor_constraints)
adp_constraints = group.adp_constraints()
u_cart_p1 = adptbx.random_u_cart()
u_star_p1 = adptbx.u_cart_as_u_star(unit_cell, u_cart_p1)
u_star = site_symmetry.average_u_star(u_star_p1)
f = unit_cell.volume()**(2/3.)
assert approx_equal(
list(matrix.col(group.average_u_star(u_star=u_star_p1))*f),
list(matrix.col(u_star)*f))
independent_params = adp_constraints.independent_params(u_star)
assert adp_constraints.n_independent_params() == len(independent_params)
assert adp_constraints.n_independent_params() \
+ adp_constraints.n_dependent_params() == 6
u_star_vfy = adp_constraints.all_params(independent_params)
u_cart = adptbx.u_star_as_u_cart(unit_cell, u_star)
u_cart_vfy = adptbx.u_star_as_u_cart(unit_cell, list(u_star_vfy))
assert approx_equal(u_cart_vfy, u_cart)
def _ksol_bsol_grid_search(self):
# XXX HERE
start_r_factor = self.fmodel_kbu.r_factor()
final_ksol = self.fmodel_kbu.data.k_sols()
final_bsol = self.fmodel_kbu.data.b_sols()
final_b_cart = self.fmodel_kbu.b_cart()
final_r_factor = start_r_factor
k_sols = kb_range(0.6, 0.0, 0.1)
b_sols = kb_range(80., 10, 5)
assert len(self.fmodel_kbu.f_masks) == 1
o = bulk_solvent.k_sol_b_sol_k_anisotropic_scaler_twin(
f_obs=self.fmodel_kbu.f_obs.data(),
f_calc=self.fmodel_kbu.f_calc.data(),
f_mask=self.fmodel_kbu.f_masks[0].data(),
ss=self.fmodel_kbu.ss,
k_sol_range=flex.double(k_sols),
b_sol_range=flex.double(b_sols),
miller_indices=self.fmodel_kbu.f_obs.indices(),
r_ref=start_r_factor)
if (o.updated()):
assert o.r() < start_r_factor
final_r_factor = o.r()
final_ksol = o.k_sol()
final_bsol = o.b_sol()
final_b_cart = adptbx.u_as_b(
adptbx.u_star_as_u_cart(self.fmodel_kbu.f_obs.unit_cell(),
o.u_star()))
self.fmodel_kbu.update(k_sols=[final_ksol],
b_sols=[final_bsol],
b_cart=final_b_cart)
assert self.fmodel_kbu.r_factor() <= start_r_factor
if (final_ksol < 0.01):
final_ksol = 0
self.fmodel_kbu.update(k_sols=[final_ksol])
final_r_factor = self.fmodel_kbu.r_factor()
else:
o = k_sol_b_sol_b_cart_minimizer(fmodel_kbu=self.fmodel_kbu,
refine_kbu=True)
if (o.kbu.r_factor() < final_r_factor):
final_b_cart = adptbx.u_as_b(
adptbx.u_star_as_u_cart(
self.fmodel_kbu.f_obs.unit_cell(), o.kbu.u_star()))
final_ksol = list(o.kbu.k_sols())
final_bsol = list(o.kbu.b_sols())
self.fmodel_kbu.update(k_sols=final_ksol,
b_sols=final_bsol,
b_cart=final_b_cart)
else:
self.fmodel_kbu.update(k_sols=[final_ksol],
b_sols=[final_bsol],
b_cart=final_b_cart)
final_r_factor = self.fmodel_kbu.r_factor()
assert self.fmodel_kbu.r_factor() <= start_r_factor
self.fmodel_kbu.update(k_sols=final_ksol,
b_sols=final_bsol,
b_cart=final_b_cart)
assert abs(self.fmodel_kbu.r_factor() - final_r_factor) < 1.e-6
assert self.fmodel_kbu.r_factor() <= start_r_factor
return final_ksol, final_bsol, final_b_cart, final_r_factor
def exercise_tensor_constraints_core(crystal_symmetry):
from cctbx import crystal
from cctbx import adptbx
from scitbx import matrix
site_symmetry = crystal.special_position_settings(
crystal_symmetry).site_symmetry(site=(0, 0, 0))
unit_cell = crystal_symmetry.unit_cell()
group = crystal_symmetry.space_group()
assert site_symmetry.n_matrices() == group.order_p()
for reciprocal_space in [False, True]:
c_tensor_constraints = sgtbx.tensor_rank_2_constraints(
space_group=group,
reciprocal_space=reciprocal_space).row_echelon_form()
p_tensor_constraints = python_tensor_constraints(
self=group, reciprocal_space=reciprocal_space)
assert c_tensor_constraints.all_eq(p_tensor_constraints)
adp_constraints = group.adp_constraints()
u_cart_p1 = adptbx.random_u_cart()
u_star_p1 = adptbx.u_cart_as_u_star(unit_cell, u_cart_p1)
u_star = site_symmetry.average_u_star(u_star_p1)
f = unit_cell.volume()**(2 / 3.)
assert approx_equal(
list(matrix.col(group.average_u_star(u_star=u_star_p1)) * f),
list(matrix.col(u_star) * f))
independent_params = adp_constraints.independent_params(u_star)
assert adp_constraints.n_independent_params() == len(independent_params)
assert adp_constraints.n_independent_params() \
+ adp_constraints.n_dependent_params() == 6
u_star_vfy = adp_constraints.all_params(independent_params)
u_cart = adptbx.u_star_as_u_cart(unit_cell, u_star)
u_cart_vfy = adptbx.u_star_as_u_cart(unit_cell, list(u_star_vfy))
assert approx_equal(u_cart_vfy, u_cart)
def run_00():
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()
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))
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(),
adp_constraint_matrix=adp_constraints.gradient_sum_matrix())
time_aniso_u_scaler += (time.time() - t0)
b_cart_final = adptbx.u_as_b(
adptbx.u_star_as_u_cart(
f_obs.unit_cell(),
adp_constraints.all_params(tuple(obj.u_star_independent))))
#
obj = bulk_solvent.aniso_u_scaler(f_model_abs=flex.abs(fc.data()),
f_obs=f_obs.data(),
miller_indices=f_obs.indices())
b_cart_final2 = adptbx.u_as_b(
adptbx.u_star_as_u_cart(f_obs.unit_cell(), tuple(obj.u_star)))
#
assert approx_equal(b_cart_final, b_cart_final2)
#print "Output b_cart:", " ".join(["%8.4f"%i for i in b_cart_final])
assert approx_equal(b_cart_start, b_cart_final, 1.e-4)
print("Time (aniso_u_scaler only): %6.4f" % time_aniso_u_scaler)
def run_00():
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()
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))
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(),
adp_constraint_matrix = adp_constraints.gradient_sum_matrix())
time_aniso_u_scaler += (time.time()-t0)
b_cart_final = adptbx.u_as_b(adptbx.u_star_as_u_cart(f_obs.unit_cell(),
adp_constraints.all_params(tuple(obj.u_star_independent))))
#
obj = bulk_solvent.aniso_u_scaler(
f_model_abs = flex.abs(fc.data()),
f_obs = f_obs.data(),
miller_indices = f_obs.indices())
b_cart_final2 = adptbx.u_as_b(adptbx.u_star_as_u_cart(f_obs.unit_cell(),
tuple(obj.u_star)))
#
assert approx_equal(b_cart_final, b_cart_final2)
#print "Output b_cart:", " ".join(["%8.4f"%i for i in b_cart_final])
assert approx_equal(b_cart_start, b_cart_final, 1.e-4)
print "Time (aniso_u_scaler only): %6.4f"%time_aniso_u_scaler
def run():
symmetry = crystal.symmetry(
unit_cell=(10.67, 10.67, 4.68, 90, 90, 120),
space_group_symbol="P 3")
special_position_settings = crystal.special_position_settings(
crystal_symmetry=symmetry,
min_distance_sym_equiv=0.5)
site = (0, 0, 0.236)
u_cif = ((0.17, 0.17, 0.19, 0.09, 0, 0))
site_symmetry = special_position_settings.site_symmetry(site)
print "Input Ucif:", u_cif
u_star = adptbx.u_cif_as_u_star(symmetry.unit_cell(), u_cif)
if (not site_symmetry.is_compatible_u_star(u_star)):
print "Warning: ADP tensor is incompatible with site symmetry."
u_star = site_symmetry.average_u_star(u_star)
u_cif = adptbx.u_star_as_u_cif(symmetry.unit_cell(), u_star)
print "Averaged Ucif:", u_cif
u_cart = adptbx.u_star_as_u_cart(symmetry.unit_cell(), u_star)
eigenvalues = adptbx.eigenvalues(u_cart)
if (not adptbx.is_positive_definite(eigenvalues)):
print "ADP tensor is not positive definite."
print "Eigenvectors and values:"
eigensystem = adptbx.eigensystem(u_cart)
for i in xrange(3):
print " v=(%.5f %.5f %.5f) " % eigensystem.vectors(i),
print "lambda=%.4f" % (eigensystem.values()[i],)
def show_scatterer(self, f=None, unit_cell=None):
if (f is None): f = sys.stdout
from cctbx import adptbx
print("%-4s" % self.label[5:15], end=' ', file=f)
print("%-4s" % self.scattering_type, end=' ', file=f)
#print >> f, "%3d" % self.multiplicity(),
print("%6.3f" % (self.fdp), end=' ', file=f)
print("(%7.4f %7.4f %7.4f)" % self.site, end=' ', file=f)
print("%4.2f" % self.occupancy, end=' ', file=f)
if self.flags.use_u_iso():
print("%6.4f" % self.u_iso, end=' ', file=f)
else:
print('[ - ]', end=' ', file=f)
if self.flags.use_u_aniso():
assert unit_cell is not None
u_cart = adptbx.u_star_as_u_cart(unit_cell, self.u_star)
print("%6.4f" % adptbx.u_cart_as_u_iso(u_cart), file=f)
print(" u_cart =", ("%6.3f " * 5 + "%6.3f") % u_cart,
end=' ',
file=f)
else:
print('[ - ]', end=' ', file=f)
if False and (self.fp != 0 or self.fdp != 0):
print("\n fp,fdp = %6.4f,%6.4f" % (self.fp, self.fdp),
end=' ',
file=f)
print(file=f)
def run():
symmetry = crystal.symmetry(unit_cell=(10.67, 10.67, 4.68, 90, 90, 120),
space_group_symbol="P 3")
special_position_settings = crystal.special_position_settings(
crystal_symmetry=symmetry, min_distance_sym_equiv=0.5)
site = (0, 0, 0.236)
u_cif = ((0.17, 0.17, 0.19, 0.09, 0, 0))
site_symmetry = special_position_settings.site_symmetry(site)
print "Input Ucif:", u_cif
u_star = adptbx.u_cif_as_u_star(symmetry.unit_cell(), u_cif)
if (not site_symmetry.is_compatible_u_star(u_star)):
print "Warning: ADP tensor is incompatible with site symmetry."
u_star = site_symmetry.average_u_star(u_star)
u_cif = adptbx.u_star_as_u_cif(symmetry.unit_cell(), u_star)
print "Averaged Ucif:", u_cif
u_cart = adptbx.u_star_as_u_cart(symmetry.unit_cell(), u_star)
eigenvalues = adptbx.eigenvalues(u_cart)
if (not adptbx.is_positive_definite(eigenvalues)):
print "ADP tensor is not positive definite."
print "Eigenvectors and values:"
eigensystem = adptbx.eigensystem(u_cart)
for i in xrange(3):
print " v=(%.5f %.5f %.5f) " % eigensystem.vectors(i),
print "lambda=%.4f" % (eigensystem.values()[i], )
def show_scatterer(self, f=None, unit_cell=None):
if (f is None): f = sys.stdout
from cctbx import adptbx
print >> f, "%-4s" % self.label[5:15],
print >> f, "%-4s" % self.scattering_type,
#print >> f, "%3d" % self.multiplicity(),
print >> f, "%6.3f" % (self.fdp),
print >> f, "(%7.4f %7.4f %7.4f)" % self.site,
print >> f, "%4.2f" % self.occupancy,
if self.flags.use_u_iso():
print >> f, "%6.4f" % self.u_iso,
else:
print >> f, '[ - ]',
if self.flags.use_u_aniso():
assert unit_cell is not None
u_cart = adptbx.u_star_as_u_cart(unit_cell, self.u_star)
print >> f, "%6.4f" % adptbx.u_cart_as_u_iso(u_cart)
print >> f, " u_cart =", ("%6.3f " * 5 + "%6.3f") % u_cart,
else:
print >> f, '[ - ]',
if False and (self.fp != 0 or self.fdp != 0):
print >> f, "\n fp,fdp = %6.4f,%6.4f" % (
self.fp,
self.fdp),
print >> f
def as_pdb_file(self,
remark,
remarks,
fractional_coordinates,
resname,
connect):
if (remark is not None):
remarks.insert(0, remark)
s = StringIO()
for remark in remarks:
print >> s, "REMARK", remark
print >> s, "REMARK Number of scatterers:", self.scatterers().size()
print >> s, "REMARK At special positions:", \
self.special_position_indices().size()
if (fractional_coordinates):
print >> s, "REMARK Fractional coordinates"
else:
print >> s, "REMARK Cartesian coordinates"
print >> s, iotbx.pdb.format_cryst1_record(crystal_symmetry=self)
print >> s, iotbx.pdb.format_scale_records(unit_cell=self.unit_cell())
atom = iotbx.pdb.hierarchy.atom_with_labels()
if (resname is not None):
atom.resname = resname.upper()
serial = 0
for scatterer in self.scatterers():
serial += 1
atom.serial = iotbx.pdb.hy36encode(width=5, value=serial)
if (scatterer.flags.use_u_aniso_only()):
atom.uij = adptbx.u_star_as_u_cart(self.unit_cell(), scatterer.u_star)
atom.b = adptbx.u_as_b(adptbx.u_cart_as_u_iso(atom.uij))
else:
atom.uij_erase()
atom.b = adptbx.u_as_b(scatterer.u_iso)
if (fractional_coordinates):
atom.xyz = scatterer.site
else:
atom.xyz = self.unit_cell().orthogonalize(scatterer.site)
atom.occ = scatterer.occupancy
label = scatterer.label.upper()
atom.name = label[:4]
if (resname is None):
atom.resname = label[:3]
element_symbol = scatterer.element_symbol()
if (element_symbol is None): element_symbol = "Q"
assert len(element_symbol) in (1,2)
atom.element = element_symbol.upper()
atom.resseq = iotbx.pdb.hy36encode(width=4, value=serial)
print >> s, atom.format_atom_record_group()
if (connect is not None):
assert len(connect) == self.scatterers().size()
i = 0
for bonds in connect:
i += 1
l = "CONNECT%5d" % i
for bond in bonds:
l += "%5d" % (bond+1)
print >> s, l
print >> s, "END"
return s.getvalue()
def as_pdb_file(self, remark, remarks, fractional_coordinates, resname,
connect):
if (remark is not None):
remarks.insert(0, remark)
s = StringIO()
for remark in remarks:
print >> s, "REMARK", remark
print >> s, "REMARK Number of scatterers:", self.scatterers().size()
print >> s, "REMARK At special positions:", \
self.special_position_indices().size()
if (fractional_coordinates):
print >> s, "REMARK Fractional coordinates"
else:
print >> s, "REMARK Cartesian coordinates"
print >> s, iotbx.pdb.format_cryst1_record(crystal_symmetry=self)
print >> s, iotbx.pdb.format_scale_records(unit_cell=self.unit_cell())
atom = iotbx.pdb.hierarchy.atom_with_labels()
if (resname is not None):
atom.resname = resname.upper()
serial = 0
for scatterer in self.scatterers():
serial += 1
atom.serial = iotbx.pdb.hy36encode(width=5, value=serial)
if (scatterer.flags.use_u_aniso_only()):
atom.uij = adptbx.u_star_as_u_cart(self.unit_cell(),
scatterer.u_star)
atom.b = adptbx.u_as_b(adptbx.u_cart_as_u_iso(atom.uij))
else:
atom.uij_erase()
atom.b = adptbx.u_as_b(scatterer.u_iso)
if (fractional_coordinates):
atom.xyz = scatterer.site
else:
atom.xyz = self.unit_cell().orthogonalize(scatterer.site)
atom.occ = scatterer.occupancy
label = scatterer.label.upper()
atom.name = label[:4]
if (resname is None):
atom.resname = label[:3]
element_symbol = scatterer.element_symbol()
if (element_symbol is None): element_symbol = "Q"
assert len(element_symbol) in (1, 2)
atom.element = element_symbol.upper()
atom.resseq = iotbx.pdb.hy36encode(width=4, value=serial)
print >> s, atom.format_atom_record_group()
if (connect is not None):
assert len(connect) == self.scatterers().size()
i = 0
for bonds in connect:
i += 1
l = "CONNECT%5d" % i
for bond in bonds:
l += "%5d" % (bond + 1)
print >> s, l
print >> s, "END"
return s.getvalue()
def exercise_02_b_cart_sym_constr(d_min = 2.0, tolerance = 1.e-6):
for symbol in sgtbx.bravais_types.acentric + sgtbx.bravais_types.centric:
space_group_info = sgtbx.space_group_info(symbol = symbol)
xray_structure = get_xray_structure_random(space_group_info)
sg = xray_structure.space_group()
uc = xray_structure.unit_cell()
u_cart_p1 = adptbx.random_u_cart(u_scale=5, u_min=5)
u_star_p1 = adptbx.u_cart_as_u_star(uc, u_cart_p1)
b_cart_1 = adptbx.u_star_as_u_cart(uc, u_star_p1)
b_cart_2 = adptbx.u_star_as_u_cart(uc, sg.average_u_star(u_star = u_star_p1))
for b_cart in (b_cart_1, b_cart_2):
f_obs, r_free_flags = \
get_f_obs_freer(d_min = d_min,
k_sol = 0,
b_sol = 0,
b_cart = b_cart,
xray_structure = xray_structure)
fmodel = mmtbx.f_model.manager(
r_free_flags = r_free_flags,
f_obs = f_obs,
xray_structure = xray_structure)
for flag in (True, False):
params = bss.master_params.extract()
params.bulk_solvent = False
params.anisotropic_scaling = True
params.k_sol_b_sol_grid_search = False
params.minimization_k_sol_b_sol = False
params.minimization_b_cart = True
params.symmetry_constraints_on_b_cart = flag
params.max_iterations = 50
params.min_iterations = 50
result = bss.bulk_solvent_and_scales(
fmodel_kbu = fmodel.fmodel_kbu(), params = params)
if(flag == False and approx_equal(b_cart, b_cart_1, out=None)):
assert approx_equal(result.b_cart(), b_cart, tolerance)
if(flag == True and approx_equal(b_cart, b_cart_2, out=None)):
assert approx_equal(result.b_cart(), b_cart, tolerance)
if(flag == False and approx_equal(b_cart, b_cart_2, out=None)):
assert approx_equal(result.b_cart(), b_cart, tolerance)
if(flag == True and approx_equal(b_cart, b_cart_1, out=None)):
for u2, ufm in zip(b_cart_2, result.b_cart()):
if(abs(u2) < 1.e-6): assert approx_equal(ufm, 0.0, tolerance)
def exercise_02_b_cart_sym_constr(d_min=2.0, tolerance=1.e-6):
for symbol in sgtbx.bravais_types.acentric + sgtbx.bravais_types.centric:
space_group_info = sgtbx.space_group_info(symbol=symbol)
xray_structure = get_xray_structure_random(space_group_info)
sg = xray_structure.space_group()
uc = xray_structure.unit_cell()
u_cart_p1 = adptbx.random_u_cart(u_scale=5, u_min=5)
u_star_p1 = adptbx.u_cart_as_u_star(uc, u_cart_p1)
b_cart_1 = adptbx.u_star_as_u_cart(uc, u_star_p1)
b_cart_2 = adptbx.u_star_as_u_cart(uc,
sg.average_u_star(u_star=u_star_p1))
for b_cart in (b_cart_1, b_cart_2):
f_obs, r_free_flags = \
get_f_obs_freer(d_min = d_min,
k_sol = 0,
b_sol = 0,
b_cart = b_cart,
xray_structure = xray_structure)
fmodel = mmtbx.f_model.manager(r_free_flags=r_free_flags,
f_obs=f_obs,
xray_structure=xray_structure)
flag = True
params = bss.master_params.extract()
params.number_of_macro_cycles = 3
params.bulk_solvent = False
params.anisotropic_scaling = True
params.k_sol_b_sol_grid_search = False
params.minimization_k_sol_b_sol = False
params.minimization_b_cart = True
params.symmetry_constraints_on_b_cart = flag
params.max_iterations = 50
params.min_iterations = 50
result = bss.bulk_solvent_and_scales(
fmodel_kbu=fmodel.fmodel_kbu(), params=params)
if (flag == True and approx_equal(b_cart, b_cart_2, out=None)):
assert approx_equal(result.b_cart(), b_cart, tolerance)
if (flag == True and approx_equal(b_cart, b_cart_1, out=None)):
for u2, ufm in zip(b_cart_2, result.b_cart()):
if (abs(u2) < 1.e-6):
assert approx_equal(ufm, 0.0, tolerance)
def exercise_tensor_rank_2_orth_and_frac_linear_maps():
from cctbx import adptbx, sgtbx
p1 = sgtbx.space_group_info('P1')
for i in range(100):
uc = p1.any_compatible_unit_cell(27)
u_star = matrix.col.random(n=6, a=0, b=1)
u_iso_ref = adptbx.u_star_as_u_iso(uc, u_star)
u_iso = matrix.col(uc.u_star_to_u_iso_linear_form()).dot(u_star)
assert approx_equal(u_iso, u_iso_ref, eps=1e-15)
u_cart_ref = adptbx.u_star_as_u_cart(uc, u_star)
u_cart = matrix.sqr(uc.u_star_to_u_cart_linear_map()) * u_star
assert approx_equal(u_cart, u_cart_ref, eps=1e-15)
u_cif_ref = adptbx.u_star_as_u_cif(uc, u_star)
u_cif = matrix.diag(uc.u_star_to_u_cif_linear_map()) * (u_star)
assert approx_equal(u_cif, u_cif_ref)
def show_scatterers(self, f=None):
if (f is None): f = sys.stdout
print >> f, "Label M Coordinates Occ Uiso or Ucart"
for scatterer in self.scatterers():
print >> f, "%-4s" % (scatterer.label,),
print >> f, "%3d" % (scatterer.multiplicity(),),
print >> f, "%7.4f %7.4f %7.4f" % scatterer.site,
print >> f, "%4.2f" % (scatterer.occupancy,),
if (not scatterer.anisotropic_flag):
print >> f, "%6.4f" % (scatterer.u_iso,),
else:
print >> f, ("%6.3f " * 5 + "%6.3f") % adptbx.u_star_as_u_cart(
self.unit_cell(), scatterer.u_star),
print >> f
return self
def show_scatterers(self, f=None):
if (f is None): f = sys.stdout
print >> f, "Label M Coordinates Occ Uiso or Ucart"
for scatterer in self.scatterers():
print >> f, "%-4s" % (scatterer.label, ),
print >> f, "%3d" % (scatterer.multiplicity(), ),
print >> f, "%7.4f %7.4f %7.4f" % scatterer.site,
print >> f, "%4.2f" % (scatterer.occupancy, ),
if (not scatterer.anisotropic_flag):
print >> f, "%6.4f" % (scatterer.u_iso, ),
else:
print >> f, ("%6.3f " * 5 + "%6.3f") % adptbx.u_star_as_u_cart(
self.unit_cell(), scatterer.u_star),
print >> f
return self
def ru(crystal_symmetry, u_scale=1, u_min=0.1):
from cctbx import sgtbx
symbol = crystal_symmetry.space_group().type().lookup_symbol()
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(crystal_symmetry.unit_cell(),
adptbx.random_u_cart(u_scale=u_scale,u_min=u_min))
u_indep = adp_constraints.independent_params(all_params=u_star)
u_star = adp_constraints.all_params(independent_params=u_indep)
r = flex.sym_mat3_double()
r.append(adptbx.u_star_as_u_cart(crystal_symmetry.unit_cell(), u_star))
return r
def exercise_tensor_rank_2_orth_and_frac_linear_maps():
from cctbx import adptbx, sgtbx
p1 = sgtbx.space_group_info('P1')
for i in xrange(100):
uc = p1.any_compatible_unit_cell(27)
u_star = matrix.col.random(n=6, a=0, b=1)
u_iso_ref = adptbx.u_star_as_u_iso(uc, u_star)
u_iso = matrix.col(uc.u_star_to_u_iso_linear_form()).dot(u_star)
assert approx_equal(u_iso, u_iso_ref, eps=1e-15)
u_cart_ref = adptbx.u_star_as_u_cart(uc, u_star)
u_cart = matrix.sqr(uc.u_star_to_u_cart_linear_map()) * u_star
assert approx_equal(u_cart, u_cart_ref, eps=1e-15)
u_cif_ref = adptbx.u_star_as_u_cif(uc, u_star)
u_cif = matrix.diag(uc.u_star_to_u_cif_linear_map())*(u_star)
assert approx_equal(u_cif, u_cif_ref)
def ru(crystal_symmetry, u_scale=1, u_min=0.1):
from cctbx import sgtbx
symbol = crystal_symmetry.space_group().type().lookup_symbol()
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(
crystal_symmetry.unit_cell(),
adptbx.random_u_cart(u_scale=u_scale, u_min=u_min))
u_indep = adp_constraints.independent_params(all_params=u_star)
u_star = adp_constraints.all_params(independent_params=u_indep)
r = flex.sym_mat3_double()
r.append(adptbx.u_star_as_u_cart(crystal_symmetry.unit_cell(), u_star))
return r
def _b_cart_minimizer_helper(self, n_macro_cycles = 1):
r_start = self.fmodel_kbu.r_factor()
b_start = self.fmodel_kbu.b_cart()
for u_cycle in xrange(n_macro_cycles):
u_min = k_sol_b_sol_b_cart_minimizer(
fmodel_kbu = self.fmodel_kbu,
params = self.params,
refine_u_star = True).kbu.u_star()
b_cart = adptbx.u_as_b(
adptbx.u_star_as_u_cart(self.fmodel_kbu.f_obs.unit_cell(),u_min))
self.fmodel_kbu.update(b_cart = b_cart)
r_final = self.fmodel_kbu.r_factor()
if(r_final >= r_start):
self.fmodel_kbu.update(b_cart = b_start)
return b_start
else: return b_cart
def _b_cart_minimizer_helper(self, n_macro_cycles=1):
r_start = self.fmodel_kbu.r_factor()
b_start = self.fmodel_kbu.b_cart()
for u_cycle in range(n_macro_cycles):
u_min = k_sol_b_sol_b_cart_minimizer(
fmodel_kbu=self.fmodel_kbu,
params=self.params,
refine_u_star=True).kbu.u_star()
b_cart = adptbx.u_as_b(
adptbx.u_star_as_u_cart(self.fmodel_kbu.f_obs.unit_cell(),
u_min))
self.fmodel_kbu.update(b_cart=b_cart)
r_final = self.fmodel_kbu.r_factor()
if (r_final >= r_start):
self.fmodel_kbu.update(b_cart=b_start)
return b_start
else:
return b_cart
def random_modify_u_star(self, u_star, gauss_sigma,
max_relative_difference=1./3,
max_trials=100):
for trial in xrange(max_trials):
modified_u_star = []
for i in xrange(len(u_star)):
u = u_star[i]
max_diff = u * max_relative_difference
modified_u = random.gauss(u, gauss_sigma)
if (modified_u - u > u + max_diff):
modified_u = u + max_diff
elif (u - modified_u > u + max_diff):
modified_u = u - max_diff
modified_u_star.append(modified_u)
u_cart = adptbx.u_star_as_u_cart(self.unit_cell(), modified_u_star)
eigenvalues = adptbx.eigenvalues(u_cart)
if (min(eigenvalues) > 0.001):
return modified_u_star
raise RuntimeError, "Cannot find suitable u_star."
def random_modify_u_star(self,
u_star,
gauss_sigma,
max_relative_difference=1. / 3,
max_trials=100):
for trial in xrange(max_trials):
modified_u_star = []
for i in xrange(len(u_star)):
u = u_star[i]
max_diff = u * max_relative_difference
modified_u = random.gauss(u, gauss_sigma)
if (modified_u - u > u + max_diff):
modified_u = u + max_diff
elif (u - modified_u > u + max_diff):
modified_u = u - max_diff
modified_u_star.append(modified_u)
u_cart = adptbx.u_star_as_u_cart(self.unit_cell(), modified_u_star)
eigenvalues = adptbx.eigenvalues(u_cart)
if (min(eigenvalues) > 0.001):
return modified_u_star
raise RuntimeError, "Cannot find suitable u_star."
def show(self, f=None, unit_cell=None):
if (f is None): f = sys.stdout
print >> f, "%-4s" % self.label,
print >> f, "%-4s" % self.scattering_type,
print >> f, "%3d" % self.multiplicity(),
print >> f, "(%7.4f %7.4f %7.4f)" % self.site,
print >> f, "%4.2f" % self.occupancy,
if self.flags.use_u_iso():
print >> f, "%6.4f" % self.u_iso,
else:
print >> f, '[ - ]',
if self.flags.use_u_aniso():
assert unit_cell is not None
u_cart = adptbx.u_star_as_u_cart(unit_cell, self.u_star)
print >> f, "%6.4f" % adptbx.u_cart_as_u_iso(u_cart)
print >> f, " u_cart =", ("%6.3f " * 5 + "%6.3f") % u_cart,
else:
print >> f, '[ - ]',
if (self.fp != 0 or self.fdp != 0):
print >> f, "\n fp,fdp = %6.4f,%6.4f" % (self.fp, self.fdp),
print >> f
def check_anisou(shelx_titl, xray_structure, shelx_pdb, verbose):
# SHELXL WPDB does not include H atoms. Therefore we
# need a dictionary of labels to map back to the index
# in the xray_structure.scatterers() list.
lbl_dict = {}
i = 0
for scatterer in xray_structure.scatterers():
i += 1
lbl = (scatterer.scattering_type + str(i)).upper()
lbl_dict[lbl] = i - 1
TotalANISOU = 0
TotalMismatches = 0
for l in shelx_pdb[4:]:
if (l[:6] == "ANISOU"):
TotalANISOU += 1
lbl = l[11:16].strip()
i = lbl_dict[lbl]
assert xray_structure.scatterers()[i].flags.use_u_aniso()
u = l[28:70]
u_cart = adptbx.u_star_as_u_cart(
xray_structure.unit_cell(),
xray_structure.scatterers()[i].u_star)
mismatch = 0
s = ""
for i in xrange(6):
u_shelx = int(u[i * 7:(i + 1) * 7])
u_adptbx = int(round(u_cart[i] * 1.e+4, ))
s += "%7d" % u_adptbx
if (abs(u_shelx - u_adptbx) > 1): mismatch = 1
if (mismatch != 0):
print l[:-1]
print u
print s
print "Error: ANISOU mismatch."
TotalMismatches += 1
if (0 or verbose or TotalMismatches > 0):
print shelx_titl + (": ANISOU mismatches: %d of %d" %
(TotalMismatches, TotalANISOU))
assert TotalMismatches == 0
def show(self, f=None, unit_cell=None):
if f is None:
f = sys.stdout
print >> f, "%-4s" % self.label,
print >> f, "%-4s" % self.scattering_type,
print >> f, "%3d" % self.multiplicity(),
print >> f, "(%7.4f %7.4f %7.4f)" % self.site,
print >> f, "%4.2f" % self.occupancy,
if self.flags.use_u_iso():
print >> f, "%6.4f" % self.u_iso,
else:
print >> f, "[ - ]",
if self.flags.use_u_aniso():
assert unit_cell is not None
u_cart = adptbx.u_star_as_u_cart(unit_cell, self.u_star)
print >> f, "%6.4f" % adptbx.u_cart_as_u_iso(u_cart)
print >> f, " u_cart =", ("%6.3f " * 5 + "%6.3f") % u_cart,
else:
print >> f, "[ - ]",
if self.fp != 0 or self.fdp != 0:
print >> f, "\n fp,fdp = %6.4f,%6.4f" % (self.fp, self.fdp),
print >> f
def check_anisou(shelx_titl, xray_structure, shelx_pdb, verbose):
# SHELXL WPDB does not include H atoms. Therefore we
# need a dictionary of labels to map back to the index
# in the xray_structure.scatterers() list.
lbl_dict = {}
i = 0
for scatterer in xray_structure.scatterers():
i += 1
lbl = (scatterer.scattering_type + str(i)).upper()
lbl_dict[lbl] = i - 1
TotalANISOU = 0
TotalMismatches = 0
for l in shelx_pdb[4:]:
if (l[:6] == "ANISOU"):
TotalANISOU += 1
lbl = l[11:16].strip()
i = lbl_dict[lbl]
assert xray_structure.scatterers()[i].flags.use_u_aniso()
u = l[28:70]
u_cart = adptbx.u_star_as_u_cart(
xray_structure.unit_cell(), xray_structure.scatterers()[i].u_star)
mismatch = 0
s = ""
for i in xrange(6):
u_shelx = int(u[i*7:(i+1)*7])
u_adptbx = int(round(u_cart[i] * 1.e+4,))
s += "%7d" % u_adptbx
if (abs(u_shelx - u_adptbx) > 1): mismatch = 1
if (mismatch != 0):
print l[:-1]
print u
print s
print "Error: ANISOU mismatch."
TotalMismatches += 1
if (0 or verbose or TotalMismatches > 0):
print shelx_titl + (": ANISOU mismatches: %d of %d" % (
TotalMismatches, TotalANISOU))
assert TotalMismatches == 0
def exercise_interface():
episq = 8 * (math.pi ** 2)
assert approx_equal(adptbx.u_as_b(2.3), 2.3 * episq)
assert approx_equal(adptbx.b_as_u(adptbx.u_as_b(2.3)), 2.3)
u = (3, 4, 9, 2, 1, 7)
assert approx_equal(adptbx.u_as_b(u), [x * episq for x in u])
assert approx_equal(adptbx.b_as_u(adptbx.u_as_b(u)), u)
uc = uctbx.unit_cell((5, 4, 7, 80, 110, 100))
for fw, bw in (
(adptbx.u_cif_as_u_star, adptbx.u_star_as_u_cif),
(adptbx.u_cart_as_u_star, adptbx.u_star_as_u_cart),
(adptbx.u_cart_as_u_cif, adptbx.u_cif_as_u_cart),
(adptbx.u_cart_as_beta, adptbx.beta_as_u_cart),
(adptbx.u_cif_as_beta, adptbx.beta_as_u_cif),
):
assert approx_equal(bw(uc, fw(uc, u)), u)
assert approx_equal(adptbx.beta_as_u_star(adptbx.u_star_as_beta(u)), u)
assert approx_equal(adptbx.u_cart_as_u_iso(adptbx.u_iso_as_u_cart(2.3)), 2.3)
for fw, bw in (
(adptbx.u_iso_as_u_star, adptbx.u_star_as_u_iso),
(adptbx.u_iso_as_u_cif, adptbx.u_cif_as_u_iso),
(adptbx.u_iso_as_beta, adptbx.beta_as_u_iso),
):
assert approx_equal(bw(uc, fw(uc, 2.3)), 2.3)
fc = adptbx.factor_u_cart_u_iso(u_cart=u)
assert approx_equal(fc.u_iso, adptbx.u_cart_as_u_iso(u))
assert approx_equal(fc.u_cart_minus_u_iso, [uii - fc.u_iso for uii in u[:3]] + list(u[3:]))
f = adptbx.factor_u_star_u_iso(unit_cell=uc, u_star=adptbx.u_cart_as_u_star(uc, u))
assert approx_equal(f.u_iso, fc.u_iso)
assert approx_equal(f.u_star_minus_u_iso, adptbx.u_cart_as_u_star(uc, fc.u_cart_minus_u_iso))
f = adptbx.factor_u_cif_u_iso(unit_cell=uc, u_cif=adptbx.u_cart_as_u_cif(uc, u))
assert approx_equal(f.u_iso, fc.u_iso)
assert approx_equal(f.u_cif_minus_u_iso, adptbx.u_cart_as_u_cif(uc, fc.u_cart_minus_u_iso))
f = adptbx.factor_beta_u_iso(unit_cell=uc, beta=adptbx.u_cart_as_beta(uc, u))
assert approx_equal(f.u_iso, fc.u_iso)
assert approx_equal(f.beta_minus_u_iso, adptbx.u_cart_as_beta(uc, fc.u_cart_minus_u_iso))
assert approx_equal(adptbx.debye_waller_factor_b_iso(0.25, 2.3), math.exp(-2.3 * 0.25))
assert approx_equal(adptbx.debye_waller_factor_u_iso(0.25, 2.3), math.exp(-2.3 * episq * 0.25))
assert approx_equal(
adptbx.debye_waller_factor_b_iso(uc, (1, 2, 3), 2.3),
adptbx.debye_waller_factor_u_iso(uc, (1, 2, 3), 2.3 / episq),
)
u_star = adptbx.u_cart_as_u_star(uc, u)
dw = adptbx.debye_waller_factor_u_star((1, 2, 3), u_star)
assert approx_equal(dw, adptbx.debye_waller_factor_beta((1, 2, 3), adptbx.u_star_as_beta(u_star)))
assert approx_equal(dw, adptbx.debye_waller_factor_u_cif(uc, (1, 2, 3), adptbx.u_star_as_u_cif(uc, u_star)))
assert approx_equal(dw, adptbx.debye_waller_factor_u_cart(uc, (1, 2, 3), adptbx.u_star_as_u_cart(uc, u_star)))
for e in adptbx.eigenvalues(u):
check_eigenvalue(u, e)
assert not adptbx.is_positive_definite(adptbx.eigenvalues(u))
assert not adptbx.is_positive_definite(adptbx.eigenvalues(u), 0)
assert adptbx.is_positive_definite(adptbx.eigenvalues(u), 1.22)
assert not adptbx.is_positive_definite(u)
assert not adptbx.is_positive_definite(u, 0)
assert adptbx.is_positive_definite(u, 1.22)
up = (0.534, 0.812, 0.613, 0.0166, 0.134, -0.0124)
s = adptbx.eigensystem(up)
assert approx_equal(s.values(), (0.813132, 0.713201, 0.432668))
for i in xrange(3):
check_eigenvector(up, s.values()[i], s.vectors(i))
c = (1, 2, 3, 3, -4, 5, 4, 5, 6)
v = (198, 18, 1020, 116, 447, 269)
assert approx_equal(adptbx.c_u_c_transpose(c, u), v)
assert approx_equal(adptbx.eigensystem(u).values(), (14.279201519086316, 2.9369143826320214, -1.2161159017183376))
s = adptbx.eigensystem(up)
try:
s.vectors(4)
except RuntimeError, e:
assert str(e).endswith("Index out of range.")
def u_star_minus_u_iso_ralf(unit_cell, u_star): u_cart = adptbx.u_star_as_u_cart(unit_cell, u_star) u_iso = adptbx.u_cart_as_u_iso(u_cart) u_cart_minus_u_iso = [a-u_iso for a in u_cart[:3]] + list(u_cart[3:]) return adptbx.u_cart_as_u_star(unit_cell, u_cart_minus_u_iso)
def fd_grads(self, proxy):
dynamic_restraint_proxy_classes = (
adp.adp_u_eq_similarity_proxy,
adp.adp_volume_similarity_proxy,
)
if isinstance(proxy, (dynamic_restraint_proxy_classes)):
n_restraints = len(proxy.i_seqs)
else:
n_restraints = rows_per_restraint.get(proxy.__class__, 1)
grads = [
flex.double(self.param_map.n_parameters)
for i in range(n_restraints)
]
eps = 1e-8
uc = self.xray_structure.unit_cell()
xs = self.xray_structure
u_cart = xs.scatterers().extract_u_cart(uc).deep_copy()
u_star = xs.scatterers().extract_u_star().deep_copy()
u_iso = xs.scatterers().extract_u_iso().deep_copy()
single_delta_classes = (adp.fixed_u_eq_adp, )
for n in xrange(n_restraints):
for i in xrange(self.param_map.n_scatterers):
use_u_aniso = self.param_map[i].u_aniso > -1
use_u_iso = self.param_map[i].u_iso > -1
for j in range(6):
if use_u_aniso:
h = [0, 0, 0, 0, 0, 0]
h[j] = eps
h = matrix.sym(sym_mat3=h)
u_star[i] = list(
(matrix.sym(sym_mat3=u_star[i]) + h).as_sym_mat3())
r = self.restraint(proxy,
u_cart=flex.sym_mat3_double([
adptbx.u_star_as_u_cart(uc, u)
for u in u_star
]))
if isinstance(r, adp.rigid_bond):
d1 = r.delta_z()
elif isinstance(r, single_delta_classes):
d1 = r.delta()
else:
d1 = r.deltas()[n]
u_star[i] = list((matrix.sym(sym_mat3=u_star[i]) -
2 * h).as_sym_mat3())
r = self.restraint(proxy,
u_cart=flex.sym_mat3_double([
adptbx.u_star_as_u_cart(uc, u)
for u in u_star
]))
if isinstance(r, adp.rigid_bond):
d2 = r.delta_z()
elif isinstance(r, single_delta_classes):
d2 = r.delta()
else:
d2 = r.deltas()[n]
elif use_u_iso:
u_iso[i] += eps
r = self.restraint(proxy, u_iso=u_iso)
if isinstance(r, adp.rigid_bond):
d1 = r.delta_z()
elif isinstance(r, single_delta_classes):
d1 = r.delta()
else:
d1 = r.deltas()[n]
u_iso[i] -= 2 * eps
r = self.restraint(proxy, u_iso=u_iso)
if isinstance(r, adp.rigid_bond):
d2 = r.delta_z()
elif isinstance(r, single_delta_classes):
d2 = r.delta()
else:
d2 = r.deltas()[n]
d_delta = (d1 - d2) / (2 * eps)
if not isinstance(r, adp.rigid_bond) and j > 2:
d_delta *= 2 # off diagonals count twice
if use_u_aniso:
grads[n][self.param_map[i].u_aniso + j] = d_delta
elif use_u_iso:
grads[n][self.param_map[i].u_iso] = d_delta
break
return grads
def exercise(space_group_info,
n_elements=10,
table="wk1995",
d_min=2.0,
k_sol=0.35,
b_sol=45.0,
b_cart=None,
quick=False,
verbose=0):
xray_structure = random_structure.xray_structure(
space_group_info=space_group_info,
elements=(("O", "N", "C") * (n_elements // 3 + 1))[:n_elements],
volume_per_atom=100,
min_distance=1.5,
general_positions_only=True,
random_u_iso=False,
random_occupancy=False)
xray_structure.scattering_type_registry(table=table)
sg = xray_structure.space_group()
uc = xray_structure.unit_cell()
u_cart_1 = adptbx.random_u_cart(u_scale=5, u_min=5)
u_star_1 = adptbx.u_cart_as_u_star(uc, u_cart_1)
b_cart = adptbx.u_star_as_u_cart(uc, sg.average_u_star(u_star=u_star_1))
for anomalous_flag in [False, True]:
scatterers = xray_structure.scatterers()
if (anomalous_flag):
assert scatterers.size() >= 7
for i in [1, 7]:
scatterers[i].fp = -0.2
scatterers[i].fdp = 5
have_non_zero_fdp = True
else:
for i in [1, 7]:
scatterers[i].fp = 0
scatterers[i].fdp = 0
have_non_zero_fdp = False
f_obs = abs(
xray_structure.structure_factors(
d_min=d_min,
anomalous_flag=anomalous_flag,
cos_sin_table=sfg_params.cos_sin_table,
algorithm=sfg_params.algorithm).f_calc())
f_obs_comp = f_obs.structure_factors_from_scatterers(
xray_structure=xray_structure,
algorithm=sfg_params.algorithm,
cos_sin_table=sfg_params.cos_sin_table).f_calc()
f_obs = abs(f_obs_comp)
flags = f_obs.generate_r_free_flags(fraction=0.1, max_free=99999999)
#flags = flags.array(data = flex.bool(f_obs.data().size(), False))
xrs = xray_structure.deep_copy_scatterers()
xrs.shake_sites_in_place(rms_difference=0.3)
for target in mmtbx.refinement.targets.target_names:
if target == "mli": continue
if (quick):
if (target not in ["ls_wunit_k1", "ml", "mlhl", "ml_sad"]):
continue
if (target == "mlhl"):
if (have_non_zero_fdp): continue # XXX gradients not correct!
experimental_phases = generate_random_hl(miller_set=f_obs)
else:
experimental_phases = None
if (target == "ml_sad"
and (not anomalous_flag
or mmtbx.refinement.targets.phaser is None)):
continue
print(" ", target)
xray.set_scatterer_grad_flags(scatterers=xrs.scatterers(),
site=True)
ss = 1. / flex.pow2(f_obs.d_spacings().data()) / 4.
u_star = adptbx.u_cart_as_u_star(f_obs.unit_cell(),
adptbx.b_as_u(b_cart))
k_anisotropic = mmtbx.f_model.ext.k_anisotropic(
f_obs.indices(), u_star)
k_mask = mmtbx.f_model.ext.k_mask(ss, k_sol, b_sol)
fmodel = mmtbx.f_model.manager(
xray_structure=xrs,
f_obs=f_obs,
r_free_flags=flags,
target_name=target,
abcd=experimental_phases,
sf_and_grads_accuracy_params=sfg_params,
k_mask=k_mask,
k_anisotropic=k_anisotropic,
mask_params=masks.mask_master_params.extract())
fmodel.update_xray_structure(xray_structure=xrs,
update_f_calc=True,
update_f_mask=True)
xray.set_scatterer_grad_flags(
scatterers=fmodel.xray_structure.scatterers(), site=True)
fmodel.update_xray_structure(update_f_calc=True)
t_f = fmodel.target_functor()
t_f.prepare_for_minimization()
gs = t_f(compute_gradients=True).d_target_d_site_cart().as_double()
gfd = finite_differences_site(target_functor=t_f)
cc = flex.linear_correlation(gs, gfd).coefficient()
if (0 or verbose):
print("ana:", list(gs))
print("fin:", list(gfd))
print("rat:", [f / a for a, f in zip(gs, gfd)])
print(target, "corr:", cc, space_group_info)
print()
diff = gs - gfd
diff /= max(1, flex.max(flex.abs(gfd)))
tolerance = 1.2e-5
assert approx_equal(abs(flex.min(diff)), 0.0, tolerance)
assert approx_equal(abs(flex.mean(diff)), 0.0, tolerance)
assert approx_equal(abs(flex.max(diff)), 0.0, tolerance)
assert approx_equal(cc, 1.0, tolerance)
fmodel.model_error_ml()
def run_02():
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)
xrs.scattering_type_registry(table="wk1995")
# 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
reg = xrs.scattering_type_registry(table="wk1995", d_min=1 / 12)
f_000 = reg.sum_of_scattering_factors_at_diffraction_angle_0()
F = xrs.structure_factors(d_min=2.0).f_calc()
i = F.indices()
i.append([0, 0, 0])
d = F.data()
d.append(f_000)
F = F.customized_copy(indices=i, data=d)
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-4) # XXX can it be smaller?
assert overall_anisotropic_scale[len(overall_anisotropic_scale) -
1] == 1
print("Time (aniso_u_scaler only): %6.4f" % time_aniso_u_scaler)
def random_aniso_adp(space_group, unit_cell, u_scale=2, u_min=0):
return adptbx.u_star_as_u_cart(unit_cell, space_group.average_u_star(
u_star = adptbx.u_cart_as_u_star(unit_cell, adptbx.random_u_cart(
u_scale=u_scale, u_min=u_min))))
def __init__(self,
miller_native,
miller_derivative,
use_intensities=True,
scale_weight=False,
use_weights=False,
mask=[1,1],
start_values=None ):
## This mask allows one to refine only scale factor and only B values
self.mask = mask ## multiplier for gradients of [scale factor, u tensor]
## make deep copies just to avoid any possible problems
self.native = miller_native.deep_copy().set_observation_type(
miller_native)
if not self.native.is_real_array():
raise Sorry("A real array is need for ls scaling")
self.derivative = miller_derivative.deep_copy().set_observation_type(
miller_derivative)
if not self.derivative.is_real_array():
raise Sorry("A real array is need for ls scaling")
if use_intensities:
if not self.native.is_xray_intensity_array():
self.native = self.native.f_as_f_sq()
if not self.derivative.is_xray_intensity_array():
self.derivative = self.derivative.f_as_f_sq()
if not use_intensities:
if self.native.is_xray_intensity_array():
self.native = self.native.f_sq_as_f()
if self.derivative.is_xray_intensity_array():
self.derivative = self.derivative.f_sq_as_f()
## Get the common sets
self.native, self.derivative = self.native.map_to_asu().common_sets(
self.derivative.map_to_asu() )
## Get the required information
self.hkl = self.native.indices()
self.i_or_f_nat = self.native.data()
self.sig_nat = self.native.sigmas()
if self.sig_nat is None:
self.sig_nat = self.i_or_f_nat*0 + 1
self.i_or_f_der = self.derivative.data()
self.sig_der = self.derivative.sigmas()
if self.sig_der is None:
self.sig_der = self.i_or_f_der*0+1
self.unit_cell = self.native.unit_cell()
# Modifiy the weights if required
if not use_weights:
self.sig_nat = self.sig_nat*0.0 + 1.0
self.sig_der = self.sig_der*0.0
## Set up the minimiser 'cache'
self.minimizer_object = None
if use_intensities:
if scale_weight:
self.minimizer_object = scaling.least_squares_on_i_wt(
self.hkl,
self.i_or_f_nat,
self.sig_nat,
self.i_or_f_der,
self.sig_der,
0,
self.unit_cell,
[0,0,0,0,0,0])
else :
self.minimizer_object = scaling.least_squares_on_i(
self.hkl,
self.i_or_f_nat,
self.sig_nat,
self.i_or_f_der,
self.sig_der,
0,
self.unit_cell,
[0,0,0,0,0,0])
else:
if scale_weight:
self.minimizer_object = scaling.least_squares_on_f_wt(
self.hkl,
self.i_or_f_nat,
self.sig_nat,
self.i_or_f_der,
self.sig_der,
0,
self.unit_cell,
[0,0,0,0,0,0])
else :
self.minimizer_object = scaling.least_squares_on_f(
self.hkl,
self.i_or_f_nat,
self.sig_nat,
self.i_or_f_der,
self.sig_der,
0,
self.unit_cell,
[0,0,0,0,0,0])
## Symmetry related issues
self.sg = self.native.space_group()
self.adp_constraints = self.sg.adp_constraints()
self.dim_u = self.adp_constraints.n_independent_params
## Setup number of parameters
assert self.dim_u()<=6
## Optimisation stuff
x0 = flex.double(self.dim_u()+1, 0.0) ## B-values and scale factor!
if start_values is not None:
assert( start_values.size()==self.x.size() )
x0 = start_values
minimized = newton_more_thuente_1994(
function=self, x0=x0, gtol=0.9e-6, eps_1=1.e-6, eps_2=1.e-6,
matrix_symmetric_relative_epsilon=1.e-6)
Vrwgk = math.pow(self.unit_cell.volume(),2.0/3.0)
self.p_scale = minimized.x_star[0]
self.u_star = self.unpack( minimized.x_star )
self.u_star = list( flex.double(self.u_star) / Vrwgk )
self.b_cart = adptbx.u_as_b(adptbx.u_star_as_u_cart(self.unit_cell,
self.u_star))
self.u_cif = adptbx.u_star_as_u_cif(self.unit_cell,
self.u_star)
def fd_grads(self, proxy):
dynamic_restraint_proxy_classes = (
adp.adp_u_eq_similarity_proxy,
adp.adp_volume_similarity_proxy,
)
if isinstance(proxy, (dynamic_restraint_proxy_classes)):
n_restraints = len(proxy.i_seqs)
else:
n_restraints = rows_per_restraint.get(proxy.__class__, 1)
grads = [flex.double(self.param_map.n_parameters) for i in range(n_restraints)]
eps = 1e-8
uc = self.xray_structure.unit_cell()
xs = self.xray_structure
u_cart = xs.scatterers().extract_u_cart(uc).deep_copy()
u_star = xs.scatterers().extract_u_star().deep_copy()
u_iso = xs.scatterers().extract_u_iso().deep_copy()
single_delta_classes = (
adp.fixed_u_eq_adp,
)
for n in xrange(n_restraints):
for i in xrange(self.param_map.n_scatterers):
use_u_aniso = self.param_map[i].u_aniso > -1
use_u_iso = self.param_map[i].u_iso > -1
for j in range(6):
if use_u_aniso:
h = [0,0,0,0,0,0]
h[j] = eps
h = matrix.sym(sym_mat3=h)
u_star[i]=list((matrix.sym(sym_mat3=u_star[i]) + h).as_sym_mat3())
r = self.restraint(proxy, u_cart=flex.sym_mat3_double([
adptbx.u_star_as_u_cart(uc, u) for u in u_star]))
if isinstance(r, adp.rigid_bond):
d1 = r.delta_z()
elif isinstance(r, single_delta_classes):
d1 = r.delta()
else:
d1 = r.deltas()[n]
u_star[i]=list((matrix.sym(sym_mat3=u_star[i]) - 2*h).as_sym_mat3())
r = self.restraint(proxy, u_cart=flex.sym_mat3_double([
adptbx.u_star_as_u_cart(uc, u) for u in u_star]))
if isinstance(r, adp.rigid_bond):
d2 = r.delta_z()
elif isinstance(r, single_delta_classes):
d2 = r.delta()
else:
d2 = r.deltas()[n]
elif use_u_iso:
u_iso[i] += eps
r = self.restraint(proxy, u_iso=u_iso)
if isinstance(r, adp.rigid_bond):
d1 = r.delta_z()
elif isinstance(r, single_delta_classes):
d1 = r.delta()
else:
d1 = r.deltas()[n]
u_iso[i] -= 2*eps
r = self.restraint(proxy, u_iso=u_iso)
if isinstance(r, adp.rigid_bond):
d2 = r.delta_z()
elif isinstance(r, single_delta_classes):
d2 = r.delta()
else:
d2 = r.deltas()[n]
d_delta = (d1-d2)/(2*eps)
if not isinstance(r, adp.rigid_bond) and j > 2:
d_delta *= 2 # off diagonals count twice
if use_u_aniso:
grads[n][self.param_map[i].u_aniso+j] = d_delta
elif use_u_iso:
grads[n][self.param_map[i].u_iso] = d_delta
break
return grads
def __init__(self,
miller_array,
n_residues=None,
n_bases=None,
asu_contents=None,
prot_frac = 1.0,
nuc_frac= 0.0):
""" Maximum likelihood anisotropic wilson scaling"""
#Checking input
if (n_residues is None):
if (n_bases is None):
assert asu_contents is not None
assert (type(asu_contents) == type({}) )
if asu_contents is None:
assert ( (n_residues is not None) or (n_bases is not None) )
assert (prot_frac+nuc_frac<=1.0)
assert ( miller_array.is_real_array() )
self.info = miller_array.info()
if ( miller_array.is_xray_intensity_array() ):
miller_array = miller_array.f_sq_as_f()
work_array = miller_array.resolution_filter(
d_max=1.0/math.sqrt( scaling.get_d_star_sq_low_limit() ),
d_min=1.0/math.sqrt( scaling.get_d_star_sq_high_limit() ))
work_array = work_array.select(work_array.data()>0)
self.d_star_sq = work_array.d_star_sq().data()
self.scat_info = None
if asu_contents is None:
self.scat_info= scattering_information(
n_residues=n_residues,
n_bases = n_bases)
else:
self.scat_info = scattering_information(
asu_contents = asu_contents,
fraction_protein = prot_frac,
fraction_nucleic = nuc_frac)
self.scat_info.scat_data(self.d_star_sq)
self.b_cart = None
if (work_array.size() > 0 ):
self.hkl = work_array.indices()
self.f_obs = work_array.data()
self.unit_cell = uctbx.unit_cell(
miller_array.unit_cell().parameters() )
## Make sure sigma's are used when available
if (work_array.sigmas() is not None):
self.sigma_f_obs = work_array.sigmas()
else:
self.sigma_f_obs = flex.double(self.f_obs.size(),0.0)
if (flex.min( self.sigma_f_obs ) < 0):
self.sigma_f_obs = self.sigma_f_obs*0.0
## multiplicities
self.epsilon = work_array.epsilons().data().as_double()
## Determine Wilson parameters
self.gamma_prot = self.scat_info.gamma_tot
self.sigma_prot_sq = self.scat_info.sigma_tot_sq
## centric flags
self.centric = flex.bool(work_array.centric_flags().data())
## Symmetry stuff
self.sg = work_array.space_group()
self.adp_constraints = self.sg.adp_constraints()
self.dim_u = self.adp_constraints.n_independent_params()
## Setup number of parameters
assert self.dim_u <= 6
## Optimisation stuff
self.x = flex.double(self.dim_u+1, 0.0) ## B-values and scale factor!
exception_handling_params = scitbx.lbfgs.exception_handling_parameters(
ignore_line_search_failed_step_at_lower_bound = False,
ignore_line_search_failed_step_at_upper_bound = False,
ignore_line_search_failed_maxfev = False)
term_parameters = scitbx.lbfgs.termination_parameters(
max_iterations = 50)
minimizer = scitbx.lbfgs.run(target_evaluator=self,
termination_params=term_parameters,
exception_handling_params=exception_handling_params)
## Done refining
Vrwgk = math.pow(self.unit_cell.volume(),2.0/3.0)
self.p_scale = self.x[0]
self.u_star = self.unpack()
self.u_star = list( flex.double(self.u_star) / Vrwgk )
self.b_cart = adptbx.u_as_b(adptbx.u_star_as_u_cart(self.unit_cell,
self.u_star))
self.u_cif = adptbx.u_star_as_u_cif(self.unit_cell,
self.u_star)
#get eigenvalues of B-cart
eigen = eigensystem.real_symmetric( self.b_cart )
self.eigen_values = eigen.values()
self.eigen_vectors = eigen.vectors()
self.work_array = work_array # i need this for further analyses
self.analyze_aniso_correction()
# FIXME see 3ihm:IOBS4,SIGIOBS4
if (self.eigen_values[0] != 0) :
self.anirat = (abs(self.eigen_values[0] - self.eigen_values[2]) /
self.eigen_values[0])
else :
self.anirat = None
del self.x
del self.f_obs
del self.sigma_f_obs
del self.epsilon
del self.gamma_prot
del self.sigma_prot_sq
del self.centric
del self.hkl
del self.d_star_sq
del self.adp_constraints
def _ksol_bsol_grid_search(self):
# XXX HERE
start_r_factor = self.fmodel_kbu.r_factor()
final_ksol = self.fmodel_kbu.data.k_sols()
final_bsol = self.fmodel_kbu.data.b_sols()
final_b_cart = self.fmodel_kbu.b_cart()
final_r_factor = start_r_factor
k_sols = kb_range(0.6,
0.0,
0.1)
b_sols = kb_range(80.,
10,
5)
assert len(self.fmodel_kbu.f_masks)==1
o = bulk_solvent.k_sol_b_sol_k_anisotropic_scaler_twin(
f_obs = self.fmodel_kbu.f_obs.data(),
f_calc = self.fmodel_kbu.f_calc.data(),
f_mask = self.fmodel_kbu.f_masks[0].data(),
ss = self.fmodel_kbu.ss,
k_sol_range = flex.double(k_sols),
b_sol_range = flex.double(b_sols),
miller_indices = self.fmodel_kbu.f_obs.indices(),
r_ref = start_r_factor)
if(o.updated()):
assert o.r() < start_r_factor
final_r_factor = o.r()
final_ksol = o.k_sol()
final_bsol = o.b_sol()
final_b_cart = adptbx.u_as_b(adptbx.u_star_as_u_cart(
self.fmodel_kbu.f_obs.unit_cell(), o.u_star()))
self.fmodel_kbu.update(
k_sols=[final_ksol],
b_sols=[final_bsol],
b_cart=final_b_cart)
assert self.fmodel_kbu.r_factor() <= start_r_factor
if(final_ksol < 0.01):
final_ksol=0
self.fmodel_kbu.update(
k_sols=[final_ksol])
final_r_factor = self.fmodel_kbu.r_factor()
else:
o = k_sol_b_sol_b_cart_minimizer(
fmodel_kbu = self.fmodel_kbu,
refine_kbu = True)
if(o.kbu.r_factor() < final_r_factor):
final_b_cart = adptbx.u_as_b(adptbx.u_star_as_u_cart(
self.fmodel_kbu.f_obs.unit_cell(), o.kbu.u_star()))
final_ksol = list(o.kbu.k_sols())
final_bsol = list(o.kbu.b_sols())
self.fmodel_kbu.update(
k_sols=final_ksol,
b_sols=final_bsol,
b_cart=final_b_cart)
else:
self.fmodel_kbu.update(
k_sols=[final_ksol],
b_sols=[final_bsol],
b_cart=final_b_cart)
final_r_factor = self.fmodel_kbu.r_factor()
assert self.fmodel_kbu.r_factor() <= start_r_factor
self.fmodel_kbu.update(
k_sols = final_ksol,
b_sols = final_bsol,
b_cart = final_b_cart)
assert abs(self.fmodel_kbu.r_factor()-final_r_factor) < 1.e-6
assert self.fmodel_kbu.r_factor() <= start_r_factor
return final_ksol, final_bsol, final_b_cart, final_r_factor
def exercise_all_wyckoff(flags, space_group_info):
""" Set-up crystal and constraints """
crystal = space_group_info.any_compatible_crystal_symmetry(volume=1000)
unit_cell = crystal.unit_cell()
wyckoffs = space_group_info.wyckoff_table()
for i in xrange(wyckoffs.size()):
wyckoff_pos = wyckoffs.position(i)
print "%s," % wyckoff_pos.letter(),
special_op = wyckoff_pos.special_op()
exact_site = eval("(%s)" % special_op, {'x': 0.1, 'y': 0.2, 'z': 0.3})
site_symmetry = sgtbx.site_symmetry(crystal.unit_cell(),
crystal.space_group(), exact_site)
u_star_constraints = site_symmetry.adp_constraints()
u_cart_constraints = site_symmetry.cartesian_adp_constraints(unit_cell)
""" Compatibility of all_params for u* and u_cart """
n = u_cart_constraints.n_independent_params()
assert n == u_star_constraints.n_independent_params()
basis = []
for i in xrange(n):
v = [0] * n
v[i] = 1
basis.append(v)
u_cart_basis = [u_cart_constraints.all_params(v) for v in basis]
u_star_basis = [u_star_constraints.all_params(v) for v in basis]
u_cart_basis_bis = [
adptbx.u_star_as_u_cart(unit_cell, u) for u in u_star_basis
]
a_work = flex.double(u_cart_basis)
u_cart_basis_echelon = row_echelon_full_pivoting(a_work=a_work,
min_abs_pivot=1e-9)
# the vector subspaces spanned respectively by u_cart_basis and
# by u_cart_basis_bis should be equal
for u in u_cart_basis_bis:
assert u_cart_basis_echelon.is_in_row_space(x=flex.double(u),
epsilon=1e-9)
""" Test the independent gradient computation """
eps = 1e-4
v0 = tuple([random.random() for i in xrange(n)])
u_cart_0 = u_cart_constraints.all_params(v0)
grad_f_wrt_independent_u_cart = []
for i in xrange(n):
v_up = list(v0)
v_up[i] += eps
v_down = list(v0)
v_down[i] -= eps
der = (f(u_cart_constraints.all_params(v_up)) -
f(u_cart_constraints.all_params(v_down))) / (2 * eps)
grad_f_wrt_independent_u_cart.append(der)
grad_f_wrt_u_cart = []
for i in xrange(6):
u_cart_up = list(u_cart_0)
u_cart_up[i] += eps
u_cart_down = list(u_cart_0)
u_cart_down[i] -= eps
der = (f(u_cart_up) - f(u_cart_down)) / (2 * eps)
grad_f_wrt_u_cart.append(der)
grad_f_wrt_independent_u_cart_1 = (
u_cart_constraints.independent_gradients(tuple(grad_f_wrt_u_cart)))
assert flex.max(
flex.abs(
flex.double(grad_f_wrt_independent_u_cart_1) -
flex.double(grad_f_wrt_independent_u_cart))) < 5 * eps**2
""" Check independent_params """
v = tuple([random.random() for i in xrange(n)])
u_cart = u_cart_constraints.all_params(v)
w = u_cart_constraints.independent_params(u_cart)
assert approx_equal(v, w, eps=1e-12)
print
def exercise_interface():
episq = 8 * (math.pi**2)
assert approx_equal(adptbx.u_as_b(2.3), 2.3 * episq)
assert approx_equal(adptbx.b_as_u(adptbx.u_as_b(2.3)), 2.3)
u = (3, 4, 9, 2, 1, 7)
assert approx_equal(adptbx.u_as_b(u), [x * episq for x in u])
assert approx_equal(adptbx.b_as_u(adptbx.u_as_b(u)), u)
uc = uctbx.unit_cell((5, 4, 7, 80, 110, 100))
for fw, bw in ((adptbx.u_cif_as_u_star, adptbx.u_star_as_u_cif),
(adptbx.u_cart_as_u_star, adptbx.u_star_as_u_cart),
(adptbx.u_cart_as_u_cif, adptbx.u_cif_as_u_cart),
(adptbx.u_cart_as_beta, adptbx.beta_as_u_cart),
(adptbx.u_cif_as_beta, adptbx.beta_as_u_cif)):
assert approx_equal(bw(uc, fw(uc, u)), u)
assert approx_equal(adptbx.beta_as_u_star(adptbx.u_star_as_beta(u)), u)
assert approx_equal(adptbx.u_cart_as_u_iso(adptbx.u_iso_as_u_cart(2.3)),
2.3)
for fw, bw in ((adptbx.u_iso_as_u_star, adptbx.u_star_as_u_iso),
(adptbx.u_iso_as_u_cif, adptbx.u_cif_as_u_iso),
(adptbx.u_iso_as_beta, adptbx.beta_as_u_iso)):
assert approx_equal(bw(uc, fw(uc, 2.3)), 2.3)
fc = adptbx.factor_u_cart_u_iso(u_cart=u)
assert approx_equal(fc.u_iso, adptbx.u_cart_as_u_iso(u))
assert approx_equal(fc.u_cart_minus_u_iso,
[uii - fc.u_iso for uii in u[:3]] + list(u[3:]))
f = adptbx.factor_u_star_u_iso(unit_cell=uc,
u_star=adptbx.u_cart_as_u_star(uc, u))
assert approx_equal(f.u_iso, fc.u_iso)
assert approx_equal(f.u_star_minus_u_iso,
adptbx.u_cart_as_u_star(uc, fc.u_cart_minus_u_iso))
f = adptbx.factor_u_cif_u_iso(unit_cell=uc,
u_cif=adptbx.u_cart_as_u_cif(uc, u))
assert approx_equal(f.u_iso, fc.u_iso)
assert approx_equal(f.u_cif_minus_u_iso,
adptbx.u_cart_as_u_cif(uc, fc.u_cart_minus_u_iso))
f = adptbx.factor_beta_u_iso(unit_cell=uc,
beta=adptbx.u_cart_as_beta(uc, u))
assert approx_equal(f.u_iso, fc.u_iso)
assert approx_equal(f.beta_minus_u_iso,
adptbx.u_cart_as_beta(uc, fc.u_cart_minus_u_iso))
assert approx_equal(adptbx.debye_waller_factor_b_iso(0.25, 2.3),
math.exp(-2.3 * 0.25))
assert approx_equal(adptbx.debye_waller_factor_u_iso(0.25, 2.3),
math.exp(-2.3 * episq * 0.25))
assert approx_equal(
adptbx.debye_waller_factor_b_iso(uc, (1, 2, 3), 2.3),
adptbx.debye_waller_factor_u_iso(uc, (1, 2, 3), 2.3 / episq))
u_star = adptbx.u_cart_as_u_star(uc, u)
dw = adptbx.debye_waller_factor_u_star((1, 2, 3), u_star)
assert approx_equal(
dw,
adptbx.debye_waller_factor_beta((1, 2, 3),
adptbx.u_star_as_beta(u_star)))
assert approx_equal(
dw,
adptbx.debye_waller_factor_u_cif(uc, (1, 2, 3),
adptbx.u_star_as_u_cif(uc, u_star)))
assert approx_equal(
dw,
adptbx.debye_waller_factor_u_cart(uc, (1, 2, 3),
adptbx.u_star_as_u_cart(uc, u_star)))
for e in adptbx.eigenvalues(u):
check_eigenvalue(u, e)
assert not adptbx.is_positive_definite(adptbx.eigenvalues(u))
assert not adptbx.is_positive_definite(adptbx.eigenvalues(u), 0)
assert adptbx.is_positive_definite(adptbx.eigenvalues(u), 1.22)
assert not adptbx.is_positive_definite(u)
assert not adptbx.is_positive_definite(u, 0)
assert adptbx.is_positive_definite(u, 1.22)
up = (0.534, 0.812, 0.613, 0.0166, 0.134, -0.0124)
s = adptbx.eigensystem(up)
assert approx_equal(s.values(), (0.813132, 0.713201, 0.432668))
for i in xrange(3):
check_eigenvector(up, s.values()[i], s.vectors(i))
c = (1, 2, 3, 3, -4, 5, 4, 5, 6)
v = (198, 18, 1020, 116, 447, 269)
assert approx_equal(adptbx.c_u_c_transpose(c, u), v)
assert approx_equal(
adptbx.eigensystem(u).values(),
(14.279201519086316, 2.9369143826320214, -1.2161159017183376))
s = adptbx.eigensystem(up)
try:
s.vectors(4)
except RuntimeError, e:
assert str(e).endswith("Index out of range.")
def __init__(self,
miller_array,
n_residues=None,
n_bases=None,
asu_contents=None,
prot_frac=1.0,
nuc_frac=0.0):
""" Maximum likelihood anisotropic wilson scaling"""
#Checking input
if (n_residues is None):
if (n_bases is None):
assert asu_contents is not None
assert (type(asu_contents) == type({}))
if asu_contents is None:
assert ((n_residues is not None) or (n_bases is not None))
assert (prot_frac + nuc_frac <= 1.0)
assert (miller_array.is_real_array())
self.info = miller_array.info()
if (miller_array.is_xray_intensity_array()):
miller_array = miller_array.f_sq_as_f()
work_array = miller_array.resolution_filter(
d_max=1.0 / math.sqrt(scaling.get_d_star_sq_low_limit()),
d_min=1.0 / math.sqrt(scaling.get_d_star_sq_high_limit()))
work_array = work_array.select(work_array.data() > 0)
self.d_star_sq = work_array.d_star_sq().data()
self.scat_info = None
if asu_contents is None:
self.scat_info = scattering_information(n_residues=n_residues,
n_bases=n_bases)
else:
self.scat_info = scattering_information(asu_contents=asu_contents,
fraction_protein=prot_frac,
fraction_nucleic=nuc_frac)
self.scat_info.scat_data(self.d_star_sq)
self.b_cart = None
if (work_array.size() > 0):
self.hkl = work_array.indices()
self.f_obs = work_array.data()
self.unit_cell = uctbx.unit_cell(
miller_array.unit_cell().parameters())
## Make sure sigma's are used when available
if (work_array.sigmas() is not None):
self.sigma_f_obs = work_array.sigmas()
else:
self.sigma_f_obs = flex.double(self.f_obs.size(), 0.0)
if (flex.min(self.sigma_f_obs) < 0):
self.sigma_f_obs = self.sigma_f_obs * 0.0
## multiplicities
self.epsilon = work_array.epsilons().data().as_double()
## Determine Wilson parameters
self.gamma_prot = self.scat_info.gamma_tot
self.sigma_prot_sq = self.scat_info.sigma_tot_sq
## centric flags
self.centric = flex.bool(work_array.centric_flags().data())
## Symmetry stuff
self.sg = work_array.space_group()
self.adp_constraints = self.sg.adp_constraints()
self.dim_u = self.adp_constraints.n_independent_params()
## Setup number of parameters
assert self.dim_u <= 6
## Optimisation stuff
self.x = flex.double(self.dim_u + 1,
0.0) ## B-values and scale factor!
exception_handling_params = scitbx.lbfgs.exception_handling_parameters(
ignore_line_search_failed_step_at_lower_bound=False,
ignore_line_search_failed_step_at_upper_bound=False,
ignore_line_search_failed_maxfev=False)
term_parameters = scitbx.lbfgs.termination_parameters(
max_iterations=50)
minimizer = scitbx.lbfgs.run(
target_evaluator=self,
termination_params=term_parameters,
exception_handling_params=exception_handling_params)
## Done refining
Vrwgk = math.pow(self.unit_cell.volume(), 2.0 / 3.0)
self.p_scale = self.x[0]
self.u_star = self.unpack()
self.u_star = list(flex.double(self.u_star) / Vrwgk)
self.b_cart = adptbx.u_as_b(
adptbx.u_star_as_u_cart(self.unit_cell, self.u_star))
self.u_cif = adptbx.u_star_as_u_cif(self.unit_cell, self.u_star)
#get eigenvalues of B-cart
eigen = eigensystem.real_symmetric(self.b_cart)
self.eigen_values = eigen.values()
self.eigen_vectors = eigen.vectors()
self.work_array = work_array # i need this for further analyses
self.analyze_aniso_correction()
# FIXME see 3ihm:IOBS4,SIGIOBS4
if (self.eigen_values[0] != 0):
self.anirat = (
abs(self.eigen_values[0] - self.eigen_values[2]) /
self.eigen_values[0])
else:
self.anirat = None
del self.x
del self.f_obs
del self.sigma_f_obs
del self.epsilon
del self.gamma_prot
del self.sigma_prot_sq
del self.centric
del self.hkl
del self.d_star_sq
del self.adp_constraints
def update_solvent_and_scale_twin(self, refine_hd_scattering, log):
if (not self.twinned()): return
assert len(self.f_masks()) == 1
# Re-set all scales to unit or zero
self.show(prefix="update scales twin start", log=log)
self.reset_all_scales()
self.show(prefix="reset f_part, k_(total,mask)", log=log)
f_calc_data = self.f_calc().data()
f_calc_data_twin = self.f_calc_twin().data()
# Initial trial set
sc = 1000.
ksr = [
i / sc for i in range(ifloor(0 * sc),
iceil(0.6 * sc) + 1, int(0.05 * sc))
]
bsr = [
i / sc for i in range(ifloor(0 * sc),
iceil(150. * sc) + 1, int(10. * sc))
]
o_kbu_sol = bulk_solvent.k_sol_b_sol_k_anisotropic_scaler_twin(
f_obs=self.f_obs().data(),
f_calc_1=f_calc_data,
f_calc_2=f_calc_data_twin,
f_mask_1=self.arrays.core.f_masks[0].data(),
f_mask_2=self.arrays.core_twin.f_masks[0].data(),
ss=self.ss,
twin_fraction=self.twin_fraction,
k_sol_range=flex.double(ksr),
b_sol_range=flex.double(bsr),
miller_indices=self.f_obs().indices(
), #XXX ??? What about twin-related?
unit_cell=self.f_obs().unit_cell(),
r_ref=self.r_all())
if (o_kbu_sol.updated()):
self.update(k_mask=o_kbu_sol.k_mask(),
k_anisotropic=o_kbu_sol.k_anisotropic())
# Second (finer) trial set
k_min = max(o_kbu_sol.k_sol() - 0.05, 0)
k_max = min(o_kbu_sol.k_sol() + 0.05, 0.6)
ksr = [
i / sc for i in range(ifloor(k_min * sc),
iceil(k_max * sc) + 1, int(0.01 * sc))
]
b_min = max(o_kbu_sol.b_sol() - 10, 0)
b_max = min(o_kbu_sol.b_sol() + 10, 150)
bsr = [
i / sc for i in range(ifloor(b_min * sc),
iceil(b_max * sc) + 1, int(1. * sc))
]
o_kbu_sol = bulk_solvent.k_sol_b_sol_k_anisotropic_scaler_twin(
f_obs=self.f_obs().data(),
f_calc_1=f_calc_data,
f_calc_2=f_calc_data_twin,
f_mask_1=self.arrays.core.f_masks[0].data(),
f_mask_2=self.arrays.core_twin.f_masks[0].data(),
ss=self.ss,
twin_fraction=self.twin_fraction,
k_sol_range=flex.double(ksr),
b_sol_range=flex.double(bsr),
miller_indices=self.f_obs().indices(
), #XXX ??? What about twin-related?
unit_cell=self.f_obs().unit_cell(),
r_ref=o_kbu_sol.r())
if (o_kbu_sol.updated()):
self.update(k_mask=o_kbu_sol.k_mask(),
k_anisotropic=o_kbu_sol.k_anisotropic())
# Disable due to rare failures. Technically they should always match. But
# since different routines are used tiny disagreements are possible.
# See examples in : /net/anaconda/raid1/afonine/work/bugs/twin_refinement
#assert approx_equal(self.r_all(), o_kbu_sol.r(), 1.e-5)
##############
# use apply_back_trace in if below
if (self.xray_structure is not None):
o = mmtbx.bulk_solvent.scaler.tmp(
xray_structure=self.xray_structure,
k_anisotropic=o_kbu_sol.k_anisotropic(),
k_masks=[o_kbu_sol.k_mask()],
ss=self.ss)
self.update_xray_structure(xray_structure=o.xray_structure,
update_f_calc=True)
#############
self.update(k_mask=o.k_masks, k_anisotropic=o.k_anisotropic)
self.show(prefix="bulk-solvent and scaling", log=log)
#
# Add contribution from H (if present and riding). This goes to f_part2.
#
kh, bh = 0, 0
if (refine_hd_scattering
and self.need_to_refine_hd_scattering_contribution()):
hd_selection = self.xray_structure.hd_selection()
xrs_no_h = self.xray_structure.select(~hd_selection)
xrs_h = self.xray_structure.select(hd_selection)
# Accumulate all mask contributions: Fcalc_atoms+Fbulk_1+...+Fbulk_N
data = self.f_calc().data(
) + self.f_masks()[0].data() * self.k_masks()[0]
f_calc_plus_f_bulk_no_scales = self.f_calc().array(data=data)
data = self.f_calc_twin().data()+\
self.f_masks_twin()[0].data()*self.k_masks_twin()[0]
f_calc_plus_f_bulk_no_scales_twin = self.f_calc_twin().array(
data=data)
# Initial FH contribution
xrs_h = xrs_h.set_occupancies(value=1).set_b_iso(value=0)
f_h = self.compute_f_calc(xray_structure=xrs_h)
f_h_twin = self.compute_f_calc(xray_structure=xrs_h,
miller_array=self.f_calc_twin())
# Coarse sampling
b_mean = flex.mean(
xrs_no_h.extract_u_iso_or_u_equiv()) * adptbx.u_as_b(1.)
b_min = int(max(0, b_mean) * 0.5)
b_max = int(b_mean * 1.5)
sc = 1000.
kr = [
i / sc for i in range(ifloor(0 * sc),
iceil(1.5 * sc) + 1, int(0.1 * sc))
]
br = [
i / sc for i in range(ifloor(b_min * sc),
iceil(b_max * sc) + 1, int(5. * sc))
]
obj = bulk_solvent.k_sol_b_sol_k_anisotropic_scaler_twin(
f_obs=self.f_obs().data(),
f_calc_1=f_calc_plus_f_bulk_no_scales.data(),
f_calc_2=f_calc_plus_f_bulk_no_scales_twin.data(),
f_mask_1=f_h.data(),
f_mask_2=f_h_twin.data(),
ss=self.ss,
twin_fraction=self.twin_fraction,
k_sol_range=flex.double(kr),
b_sol_range=flex.double(br),
miller_indices=self.f_obs().indices(
), # XXX What about twin-related?
unit_cell=self.f_obs().unit_cell(),
r_ref=self.r_work())
if (obj.updated()):
f_part2 = f_h.array(data=obj.k_mask() * f_h.data())
f_part2_twin = f_h_twin.array(data=obj.k_mask() *
f_h_twin.data())
kh, bh = obj.k_sol(), obj.b_sol()
# Fine sampling
k_min = max(0, obj.k_sol() - 0.1)
k_max = obj.k_sol() + 0.1
b_min = max(0, obj.b_sol() - 5.)
b_max = obj.b_sol() + 5.
kr = [
i / sc for i in range(ifloor(k_min * sc),
iceil(k_max * sc) + 1, int(0.01 * sc))
]
br = [
i / sc for i in range(ifloor(b_min * sc),
iceil(b_max * sc) + 1, int(5. * sc))
]
obj = bulk_solvent.k_sol_b_sol_k_anisotropic_scaler_twin(
f_obs=self.f_obs().data(),
f_calc_1=f_calc_plus_f_bulk_no_scales.data(),
f_calc_2=f_calc_plus_f_bulk_no_scales_twin.data(),
f_mask_1=f_h.data(),
f_mask_2=f_h_twin.data(),
ss=self.ss,
twin_fraction=self.twin_fraction,
k_sol_range=flex.double(kr),
b_sol_range=flex.double(br),
miller_indices=self.f_obs().indices(
), # XXX What about twin-related?
unit_cell=self.f_obs().unit_cell(),
r_ref=obj.r())
if (obj.updated()):
f_part2 = f_h.array(data=obj.k_mask() * f_h.data())
f_part2_twin = f_h_twin.array(data=obj.k_mask() *
f_h_twin.data())
kh, bh = obj.k_sol(), obj.b_sol()
self.update_core(f_part2=f_part2,
f_part2_twin=f_part2_twin,
k_anisotropic=obj.k_anisotropic())
self.show(prefix="add H (%4.2f, %6.2f)" % (kh, bh), log=log)
b_cart = adptbx.u_as_b(
adptbx.u_star_as_u_cart(self.f_obs().unit_cell(),
o_kbu_sol.u_star()))
return group_args(k_sol=o_kbu_sol.k_sol(),
b_sol=o_kbu_sol.b_sol(),
b_cart=b_cart,
k_h=kh,
b_h=bh)
def anisotropic_scaling(self, r_start):
r_expanal, r_poly, r_expmin = None, None, None
k_anisotropic_expanal, k_anisotropic_poly, \
k_anisotropic_expmin = None, None, None
scale_matrix_expanal, scale_matrix_poly, scale_matrix_expmin = None, None, None
sel = self.selection_work.data()
f_model_abs = flex.abs(
self.core.f_model_no_aniso_scale.data().select(sel))
f_obs = self.f_obs.data().select(sel)
mi = self.f_obs.indices().select(sel)
uc = self.f_obs.unit_cell()
mi_all = self.f_obs.indices()
# try exp_anal
if (self.try_expanal):
obj = bulk_solvent.aniso_u_scaler(
f_model_abs=f_model_abs,
f_obs=f_obs,
miller_indices=mi,
adp_constraint_matrix=self.adp_constraints.gradient_sum_matrix(
))
u_star = self.adp_constraints.all_params(
tuple(obj.u_star_independent))
scale_matrix_expanal = adptbx.u_as_b(
adptbx.u_star_as_u_cart(uc, u_star))
k_anisotropic_expanal = ext.k_anisotropic(mi_all, u_star)
r_expanal = self.try_scale(k_anisotropic=k_anisotropic_expanal)
if (self.verbose):
print >> self.log, " r_expanal: %6.4f" % r_expanal
# try poly
if (self.try_poly):
obj = bulk_solvent.aniso_u_scaler(f_model_abs=f_model_abs,
f_obs=f_obs,
miller_indices=mi,
unit_cell=uc)
scale_matrix_poly = obj.a
k_anisotropic_poly = ext.k_anisotropic(mi_all, obj.a, uc)
r_poly = self.try_scale(k_anisotropic=k_anisotropic_poly)
if (self.verbose):
print >> self.log, " r_poly : %6.4f" % r_poly
# pre-analyze
force_to_use_expmin = False
if (k_anisotropic_poly is not None and self.auto and r_poly < r_expanal
and (k_anisotropic_poly <= 0).count(True) > 0):
force_to_use_expmin = True
self.try_expmin = True
# try expmin
if (self.try_expmin):
zero = self.f_obs.select(sel).customized_copy(
data=flex.complex_double(f_obs.size(), 0))
fm = mmtbx.f_model.manager_kbu(
f_obs=self.f_obs.select(sel),
f_calc=self.core.f_model_no_aniso_scale.select(sel),
f_masks=[zero],
f_part1=zero,
f_part2=zero,
ss=self.ss)
obj = kbu_refinery.tgc(
f_obs=self.f_obs.select(sel),
f_calc=self.core.f_model_no_aniso_scale.select(sel),
f_masks=[zero],
ss=self.ss,
k_sols=[
0,
],
b_sols=[
0,
],
u_star=[0, 0, 0, 0, 0, 0])
obj.minimize_u()
u_star = obj.kbu.u_star()
scale_matrix_expmin = adptbx.u_as_b(
adptbx.u_star_as_u_cart(uc, u_star))
k_anisotropic_expmin = ext.k_anisotropic(mi_all, u_star)
r_expmin = self.try_scale(k_anisotropic=k_anisotropic_expmin)
if (self.verbose):
print >> self.log, " r_expmin : %6.4f" % r_expmin
if (force_to_use_expmin):
self.core = self.core.update(
k_anisotropic=k_anisotropic_expmin)
if (self.verbose):
self.format_scale_matrix(m=scale_matrix_expmin)
return
# select best
r = [(r_expanal, k_anisotropic_expanal, scale_matrix_expanal),
(r_poly, k_anisotropic_poly, scale_matrix_poly),
(r_expmin, k_anisotropic_expmin, scale_matrix_expmin)]
r_best = r_start
k_anisotropic_best = None
scale_matrix_best = None
for result in r:
r_factor, k_anisotropic, scale_matrix = result
if (r_factor is not None and r_factor < r_best):
r_best = r_factor
k_anisotropic_best = k_anisotropic.deep_copy()
scale_matrix_best = scale_matrix[:]
if (scale_matrix_best is None):
if (self.verbose):
print >> self.log, " result rejected due to r-factor increase"
else:
self.scale_matrices = scale_matrix_best
self.core = self.core.update(k_anisotropic=k_anisotropic_best)
r_aniso = self.r_factor()
if (self.verbose):
self.format_scale_matrix()
print >> self.log, " r_final : %6.4f" % r_aniso
def build_scatterers(self,
elements,
sites_frac=None,
grid=None,
t_centre_of_inversion=None):
existing_sites = [scatterer.site for scatterer in self.scatterers()]
if (sites_frac is None):
all_sites = random_sites(
special_position_settings=self,
existing_sites=existing_sites,
n_new=len(elements),
min_hetero_distance=self.min_distance,
general_positions_only=self.general_positions_only,
grid=grid,
t_centre_of_inversion=t_centre_of_inversion)
else:
assert len(sites_frac) == len(elements)
all_sites = existing_sites + list(sites_frac)
assert len(all_sites) <= self.n_scatterers
sf_dict = {}
for element in elements:
if (not sf_dict.has_key(element)):
sf_dict[element] = eltbx.xray_scattering.best_approximation(
element)
fp = 0
fdp = 0
n_existing = self.scatterers().size()
i_label = n_existing
for element, site in zip(elements, all_sites[n_existing:]):
i_label += 1
scatterer = xray.scatterer(label=element + str(i_label),
scattering_type=element,
site=site)
site_symmetry = scatterer.apply_symmetry(
self.unit_cell(), self.space_group(),
self.min_distance_sym_equiv())
if (self.random_f_prime_d_min):
f0 = sf_dict[element].at_d_star_sq(
1. / self.random_f_prime_d_min**2)
assert f0 > 0
fp = -f0 * random.random() * self.random_f_prime_scale
if (self.random_f_double_prime):
f0 = sf_dict[element].at_d_star_sq(0)
fdp = f0 * random.random() * self.random_f_double_prime_scale
scatterer.fp = fp
scatterer.fdp = fdp
if (self.use_u_iso_):
scatterer.flags.set_use_u_iso_only()
u_iso = self.u_iso
if (not u_iso and self.random_u_iso):
u_iso = random.random() * self.random_u_iso_scale \
+ self.random_u_iso_min
scatterer.u_iso = u_iso
if (self.use_u_aniso):
scatterer.flags.set_use_u_aniso_only()
run_away_counter = 0
while 1:
run_away_counter += 1
assert run_away_counter < 100
u_cart = adptbx.random_u_cart(
u_scale=self.random_u_cart_scale)
scatterer.u_star = site_symmetry.average_u_star(
adptbx.u_cart_as_u_star(self.unit_cell(), u_cart))
u_cart = adptbx.u_star_as_u_cart(self.unit_cell(),
scatterer.u_star)
eigenvalues = adptbx.eigenvalues(u_cart)
if (min(eigenvalues) > 0.001):
break
if (self.random_occupancy):
scatterer.occupancy = self.random_occupancy_min \
+ (1-self.random_occupancy_min)*random.random()
self.add_scatterer(scatterer)
def u_star_minus_u_iso_ralf(unit_cell, u_star):
u_cart = adptbx.u_star_as_u_cart(unit_cell, u_star)
u_iso = adptbx.u_cart_as_u_iso(u_cart)
u_cart_minus_u_iso = [a - u_iso for a in u_cart[:3]] + list(u_cart[3:])
return adptbx.u_cart_as_u_star(unit_cell, u_cart_minus_u_iso)
def random_aniso_adp(space_group, unit_cell, u_scale=2, u_min=0):
return adptbx.u_star_as_u_cart(
unit_cell,
space_group.average_u_star(u_star=adptbx.u_cart_as_u_star(
unit_cell, adptbx.random_u_cart(u_scale=u_scale, u_min=u_min))))
def build_scatterers(self,
elements,
sites_frac=None,
grid=None,
t_centre_of_inversion=None):
existing_sites = [scatterer.site for scatterer in self.scatterers()]
if (sites_frac is None):
all_sites = random_sites(
special_position_settings=self,
existing_sites=existing_sites,
n_new=len(elements),
min_hetero_distance=self.min_distance,
general_positions_only=self.general_positions_only,
grid=grid,
t_centre_of_inversion=t_centre_of_inversion)
else:
assert len(sites_frac) == len(elements)
all_sites = existing_sites + list(sites_frac)
assert len(all_sites) <= self.n_scatterers
sf_dict = {}
for element in elements:
if (not sf_dict.has_key(element)):
sf_dict[element] = eltbx.xray_scattering.best_approximation(element)
fp = 0
fdp = 0
n_existing = self.scatterers().size()
i_label = n_existing
for element,site in zip(elements, all_sites[n_existing:]):
i_label += 1
scatterer = xray.scatterer(
label=element + str(i_label),
scattering_type=element,
site=site)
site_symmetry = scatterer.apply_symmetry(
self.unit_cell(),
self.space_group(),
self.min_distance_sym_equiv())
if (self.random_f_prime_d_min):
f0 = sf_dict[element].at_d_star_sq(1./self.random_f_prime_d_min**2)
assert f0 > 0
fp = -f0 * random.random() * self.random_f_prime_scale
if (self.random_f_double_prime):
f0 = sf_dict[element].at_d_star_sq(0)
fdp = f0 * random.random() * self.random_f_double_prime_scale
scatterer.fp = fp
scatterer.fdp = fdp
if (self.use_u_iso_):
scatterer.flags.set_use_u_iso_only()
u_iso = self.u_iso
if (not u_iso and self.random_u_iso):
u_iso = random.random() * self.random_u_iso_scale \
+ self.random_u_iso_min
scatterer.u_iso = u_iso
if (self.use_u_aniso):
scatterer.flags.set_use_u_aniso_only()
run_away_counter = 0
while 1:
run_away_counter += 1
assert run_away_counter < 100
u_cart = adptbx.random_u_cart(u_scale=self.random_u_cart_scale)
scatterer.u_star = site_symmetry.average_u_star(
adptbx.u_cart_as_u_star(
self.unit_cell(), u_cart))
u_cart = adptbx.u_star_as_u_cart(self.unit_cell(), scatterer.u_star)
eigenvalues = adptbx.eigenvalues(u_cart)
if (min(eigenvalues) > 0.001):
break
if (self.random_occupancy):
scatterer.occupancy = self.random_occupancy_min \
+ (1-self.random_occupancy_min)*random.random()
self.add_scatterer(scatterer)
def exercise(space_group_info,
n_elements = 10,
table = "wk1995",
d_min = 2.0,
k_sol = 0.35,
b_sol = 45.0,
b_cart = None,
quick=False,
verbose=0):
xray_structure = random_structure.xray_structure(
space_group_info = space_group_info,
elements =(("O","N","C")*(n_elements//3+1))[:n_elements],
volume_per_atom = 100,
min_distance = 1.5,
general_positions_only = True,
random_u_iso = False,
random_occupancy = False)
xray_structure.scattering_type_registry(table = table)
sg = xray_structure.space_group()
uc = xray_structure.unit_cell()
u_cart_1 = adptbx.random_u_cart(u_scale=5, u_min=5)
u_star_1 = adptbx.u_cart_as_u_star(uc, u_cart_1)
b_cart = adptbx.u_star_as_u_cart(uc, sg.average_u_star(u_star = u_star_1))
for anomalous_flag in [False, True]:
scatterers = xray_structure.scatterers()
if (anomalous_flag):
assert scatterers.size() >= 7
for i in [1,7]:
scatterers[i].fp = -0.2
scatterers[i].fdp = 5
have_non_zero_fdp = True
else:
for i in [1,7]:
scatterers[i].fp = 0
scatterers[i].fdp = 0
have_non_zero_fdp = False
f_obs = abs(xray_structure.structure_factors(
d_min = d_min,
anomalous_flag = anomalous_flag,
cos_sin_table = sfg_params.cos_sin_table,
algorithm = sfg_params.algorithm).f_calc())
f_obs_comp = f_obs.structure_factors_from_scatterers(
xray_structure = xray_structure,
algorithm = sfg_params.algorithm,
cos_sin_table = sfg_params.cos_sin_table).f_calc()
f_obs = abs(f_obs_comp)
flags = f_obs.generate_r_free_flags(fraction = 0.1,
max_free = 99999999)
#flags = flags.array(data = flex.bool(f_obs.data().size(), False))
xrs = xray_structure.deep_copy_scatterers()
xrs.shake_sites_in_place(rms_difference=0.3)
for target in mmtbx.refinement.targets.target_names:
if (quick):
if (target not in ["ls_wunit_k1", "ml", "mlhl", "ml_sad"]):
continue
if (target == "mlhl"):
if (have_non_zero_fdp): continue # XXX gradients not correct!
experimental_phases = generate_random_hl(miller_set=f_obs)
else:
experimental_phases = None
if (target == "ml_sad"
and (not anomalous_flag or mmtbx.refinement.targets.phaser is None)):
continue
print " ",target
xray.set_scatterer_grad_flags(
scatterers = xrs.scatterers(),
site = True)
ss = 1./flex.pow2(f_obs.d_spacings().data()) / 4.
u_star = adptbx.u_cart_as_u_star(
f_obs.unit_cell(), adptbx.b_as_u(b_cart))
k_anisotropic = mmtbx.f_model.ext.k_anisotropic(
f_obs.indices(), u_star)
k_mask = mmtbx.f_model.ext.k_mask(ss, k_sol, b_sol)
fmodel = mmtbx.f_model.manager(
xray_structure = xrs,
f_obs = f_obs,
r_free_flags = flags,
target_name = target,
abcd = experimental_phases,
sf_and_grads_accuracy_params = sfg_params,
k_mask = k_mask,
k_anisotropic = k_anisotropic,
mask_params = masks.mask_master_params.extract())
fmodel.update_xray_structure(
xray_structure=xrs,
update_f_calc=True,
update_f_mask=True)
xray.set_scatterer_grad_flags(
scatterers=fmodel.xray_structure.scatterers(),
site=True)
fmodel.update_xray_structure(update_f_calc=True)
t_f = fmodel.target_functor()
t_f.prepare_for_minimization()
gs = t_f(compute_gradients=True).d_target_d_site_cart().as_double()
gfd = finite_differences_site(target_functor=t_f)
cc = flex.linear_correlation(gs, gfd).coefficient()
if (0 or verbose):
print "ana:", list(gs)
print "fin:", list(gfd)
print "rat:", [f/a for a,f in zip(gs,gfd)]
print target, "corr:", cc, space_group_info
print
diff = gs - gfd
diff /= max(1, flex.max(flex.abs(gfd)))
tolerance = 1.2e-5
assert approx_equal(abs(flex.min(diff) ), 0.0, tolerance)
assert approx_equal(abs(flex.mean(diff)), 0.0, tolerance)
assert approx_equal(abs(flex.max(diff) ), 0.0, tolerance)
assert approx_equal(cc, 1.0, tolerance)
fmodel.model_error_ml()
def exercise_all_wyckoff(flags, space_group_info):
""" Set-up crystal and constraints """
crystal = space_group_info.any_compatible_crystal_symmetry(volume=1000)
unit_cell = crystal.unit_cell()
wyckoffs = space_group_info.wyckoff_table()
for i in xrange(wyckoffs.size()):
wyckoff_pos = wyckoffs.position(i)
print "%s," % wyckoff_pos.letter(),
special_op = wyckoff_pos.special_op()
exact_site = eval("(%s)" % special_op, {"x": 0.1, "y": 0.2, "z": 0.3})
site_symmetry = sgtbx.site_symmetry(crystal.unit_cell(), crystal.space_group(), exact_site)
u_star_constraints = site_symmetry.adp_constraints()
u_cart_constraints = site_symmetry.cartesian_adp_constraints(unit_cell)
""" Compatibility of all_params for u* and u_cart """
n = u_cart_constraints.n_independent_params()
assert n == u_star_constraints.n_independent_params()
basis = []
for i in xrange(n):
v = [0] * n
v[i] = 1
basis.append(v)
u_cart_basis = [u_cart_constraints.all_params(v) for v in basis]
u_star_basis = [u_star_constraints.all_params(v) for v in basis]
u_cart_basis_bis = [adptbx.u_star_as_u_cart(unit_cell, u) for u in u_star_basis]
a_work = flex.double(u_cart_basis)
u_cart_basis_echelon = row_echelon_full_pivoting(a_work=a_work, min_abs_pivot=1e-9)
# the vector subspaces spanned respectively by u_cart_basis and
# by u_cart_basis_bis should be equal
for u in u_cart_basis_bis:
assert u_cart_basis_echelon.is_in_row_space(x=flex.double(u), epsilon=1e-9)
""" Test the independent gradient computation """
eps = 1e-4
v0 = tuple([random.random() for i in xrange(n)])
u_cart_0 = u_cart_constraints.all_params(v0)
grad_f_wrt_independent_u_cart = []
for i in xrange(n):
v_up = list(v0)
v_up[i] += eps
v_down = list(v0)
v_down[i] -= eps
der = (f(u_cart_constraints.all_params(v_up)) - f(u_cart_constraints.all_params(v_down))) / (2 * eps)
grad_f_wrt_independent_u_cart.append(der)
grad_f_wrt_u_cart = []
for i in xrange(6):
u_cart_up = list(u_cart_0)
u_cart_up[i] += eps
u_cart_down = list(u_cart_0)
u_cart_down[i] -= eps
der = (f(u_cart_up) - f(u_cart_down)) / (2 * eps)
grad_f_wrt_u_cart.append(der)
grad_f_wrt_independent_u_cart_1 = u_cart_constraints.independent_gradients(tuple(grad_f_wrt_u_cart))
assert (
flex.max(
flex.abs(flex.double(grad_f_wrt_independent_u_cart_1) - flex.double(grad_f_wrt_independent_u_cart))
)
< 5 * eps ** 2
)
""" Check independent_params """
v = tuple([random.random() for i in xrange(n)])
u_cart = u_cart_constraints.all_params(v)
w = u_cart_constraints.independent_params(u_cart)
assert approx_equal(v, w, eps=1e-12)
print
def run_02():
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)
xrs.scattering_type_registry(table = "wk1995")
# 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
reg = xrs.scattering_type_registry(table="wk1995", d_min=1/12)
f_000 = reg.sum_of_scattering_factors_at_diffraction_angle_0()
F = xrs.structure_factors(d_min = 2.0).f_calc()
i = F.indices()
i.append([0,0,0])
d = F.data()
d.append(f_000)
F = F.customized_copy(indices = i, data = d)
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-4) # XXX can it be smaller?
assert overall_anisotropic_scale[len(overall_anisotropic_scale)-1]==1
print "Time (aniso_u_scaler only): %6.4f"%time_aniso_u_scaler
def __init__(self,
miller_native,
miller_derivative,
use_intensities=True,
scale_weight=False,
use_weights=False,
mask=[1,1],
start_values=None ):
## This mask allows one to refine only scale factor and only B values
self.mask = mask ## multiplier for gradients of [scale factor, u tensor]
## make deep copies just to avoid any possible problems
self.native = miller_native.deep_copy().set_observation_type(
miller_native)
if not self.native.is_real_array():
raise Sorry("A real array is need for ls scaling")
self.derivative = miller_derivative.deep_copy().set_observation_type(
miller_derivative)
if not self.derivative.is_real_array():
raise Sorry("A real array is need for ls scaling")
if use_intensities:
if not self.native.is_xray_intensity_array():
self.native = self.native.f_as_f_sq()
if not self.derivative.is_xray_intensity_array():
self.derivative = self.derivative.f_as_f_sq()
if not use_intensities:
if self.native.is_xray_intensity_array():
self.native = self.native.f_sq_as_f()
if self.derivative.is_xray_intensity_array():
self.derivative = self.derivative.f_sq_as_f()
## Get the common sets
self.native, self.derivative = self.native.map_to_asu().common_sets(
self.derivative.map_to_asu() )
## Get the required information
self.hkl = self.native.indices()
self.i_or_f_nat = self.native.data()
self.sig_nat = self.native.sigmas()
if self.sig_nat is None:
self.sig_nat = self.i_or_f_nat*0 + 1
self.i_or_f_der = self.derivative.data()
self.sig_der = self.derivative.sigmas()
if self.sig_der is None:
self.sig_der = self.i_or_f_der*0+1
self.unit_cell = self.native.unit_cell()
# Modifiy the weights if required
if not use_weights:
self.sig_nat = self.sig_nat*0.0 + 1.0
self.sig_der = self.sig_der*0.0
## Set up the minimiser 'cache'
self.minimizer_object = None
if use_intensities:
if scale_weight:
self.minimizer_object = scaling.least_squares_on_i_wt(
self.hkl,
self.i_or_f_nat,
self.sig_nat,
self.i_or_f_der,
self.sig_der,
0,
self.unit_cell,
[0,0,0,0,0,0])
else :
self.minimizer_object = scaling.least_squares_on_i(
self.hkl,
self.i_or_f_nat,
self.sig_nat,
self.i_or_f_der,
self.sig_der,
0,
self.unit_cell,
[0,0,0,0,0,0])
else:
if scale_weight:
self.minimizer_object = scaling.least_squares_on_f_wt(
self.hkl,
self.i_or_f_nat,
self.sig_nat,
self.i_or_f_der,
self.sig_der,
0,
self.unit_cell,
[0,0,0,0,0,0])
else :
self.minimizer_object = scaling.least_squares_on_f(
self.hkl,
self.i_or_f_nat,
self.sig_nat,
self.i_or_f_der,
self.sig_der,
0,
self.unit_cell,
[0,0,0,0,0,0])
## Symmetry related issues
self.sg = self.native.space_group()
self.adp_constraints = self.sg.adp_constraints()
self.dim_u = self.adp_constraints.n_independent_params
## Setup number of parameters
assert self.dim_u()<=6
## Optimisation stuff
x0 = flex.double(self.dim_u()+1, 0.0) ## B-values and scale factor!
if start_values is not None:
assert( start_values.size()==self.x.size() )
x0 = start_values
minimized = newton_more_thuente_1994(
function=self, x0=x0, gtol=0.9e-6, eps_1=1.e-6, eps_2=1.e-6,
matrix_symmetric_relative_epsilon=1.e-6)
Vrwgk = math.pow(self.unit_cell.volume(),2.0/3.0)
self.p_scale = minimized.x_star[0]
self.u_star = self.unpack( minimized.x_star )
self.u_star = list( flex.double(self.u_star) / Vrwgk )
self.b_cart = adptbx.u_as_b(adptbx.u_star_as_u_cart(self.unit_cell,
self.u_star))
self.u_cif = adptbx.u_star_as_u_cif(self.unit_cell,
self.u_star)
def update_solvent_and_scale_twin(self, refine_hd_scattering, log):
if(not self.twinned()): return
assert len(self.f_masks()) == 1
# Re-set all scales to unit or zero
self.show(prefix = "update scales twin start", log = log)
self.reset_all_scales()
self.show(prefix = "reset f_part, k_(total,mask)", log = log)
f_calc_data = self.f_calc().data()
f_calc_data_twin = self.f_calc_twin().data()
# Initial trial set
sc = 1000.
ksr = [i/sc for i in range(ifloor(0*sc), iceil(0.6*sc)+1, int(0.05*sc))]
bsr = [i/sc for i in range(ifloor(0*sc), iceil(150.*sc)+1, int(10.*sc))]
o_kbu_sol = bulk_solvent.k_sol_b_sol_k_anisotropic_scaler_twin(
f_obs = self.f_obs().data(),
f_calc_1 = f_calc_data,
f_calc_2 = f_calc_data_twin,
f_mask_1 = self.arrays.core.f_masks[0].data(),
f_mask_2 = self.arrays.core_twin.f_masks[0].data(),
ss = self.ss,
twin_fraction = self.twin_fraction,
k_sol_range = flex.double(ksr),
b_sol_range = flex.double(bsr),
miller_indices = self.f_obs().indices(), #XXX ??? What about twin-related?
unit_cell = self.f_obs().unit_cell(),
r_ref = self.r_all())
if(o_kbu_sol.updated()):
self.update(
k_mask = o_kbu_sol.k_mask(),
k_anisotropic = o_kbu_sol.k_anisotropic())
# Second (finer) trial set
k_min = max(o_kbu_sol.k_sol()-0.05, 0)
k_max = min(o_kbu_sol.k_sol()+0.05, 0.6)
ksr = [i/sc for i in range(ifloor(k_min*sc), iceil(k_max*sc)+1, int(0.01*sc))]
b_min = max(o_kbu_sol.b_sol()-10, 0)
b_max = min(o_kbu_sol.b_sol()+10, 150)
bsr = [i/sc for i in range(ifloor(b_min*sc), iceil(b_max*sc)+1, int(1.*sc))]
o_kbu_sol = bulk_solvent.k_sol_b_sol_k_anisotropic_scaler_twin(
f_obs = self.f_obs().data(),
f_calc_1 = f_calc_data,
f_calc_2 = f_calc_data_twin,
f_mask_1 = self.arrays.core.f_masks[0].data(),
f_mask_2 = self.arrays.core_twin.f_masks[0].data(),
ss = self.ss,
twin_fraction = self.twin_fraction,
k_sol_range = flex.double(ksr),
b_sol_range = flex.double(bsr),
miller_indices = self.f_obs().indices(), #XXX ??? What about twin-related?
unit_cell = self.f_obs().unit_cell(),
r_ref = o_kbu_sol.r())
if(o_kbu_sol.updated()):
self.update(
k_mask = o_kbu_sol.k_mask(),
k_anisotropic = o_kbu_sol.k_anisotropic())
assert approx_equal(self.r_all(), o_kbu_sol.r())
##############
# use apply_back_trace in if below
if(self.xray_structure is not None):
o = mmtbx.bulk_solvent.scaler.tmp(
xray_structure = self.xray_structure,
k_anisotropic = o_kbu_sol.k_anisotropic(),
k_masks = [o_kbu_sol.k_mask()],
ss = self.ss)
self.update_xray_structure(
xray_structure = o.xray_structure,
update_f_calc = True)
#############
self.update(
k_mask = o.k_masks,
k_anisotropic = o.k_anisotropic)
self.show(prefix = "bulk-solvent and scaling", log = log)
#
# Add contribution from H (if present and riding). This goes to f_part2.
#
kh, bh = 0, 0
if(refine_hd_scattering and
self.need_to_refine_hd_scattering_contribution()):
hd_selection = self.xray_structure.hd_selection()
xrs_no_h = self.xray_structure.select(~hd_selection)
xrs_h = self.xray_structure.select(hd_selection)
# Accumulate all mask contributions: Fcalc_atoms+Fbulk_1+...+Fbulk_N
data = self.f_calc().data()+self.f_masks()[0].data()*self.k_masks()[0]
f_calc_plus_f_bulk_no_scales = self.f_calc().array(data = data)
data = self.f_calc_twin().data()+\
self.f_masks_twin()[0].data()*self.k_masks_twin()[0]
f_calc_plus_f_bulk_no_scales_twin = self.f_calc_twin().array(data = data)
# Initial FH contribution
xrs_h = xrs_h.set_occupancies(value=1).set_b_iso(value = 0)
f_h = self.compute_f_calc(xray_structure = xrs_h)
f_h_twin = self.compute_f_calc(xray_structure = xrs_h,
miller_array = self.f_calc_twin())
# Coarse sampling
b_mean = flex.mean(xrs_no_h.extract_u_iso_or_u_equiv())*adptbx.u_as_b(1.)
b_min = int(max(0,b_mean)*0.5)
b_max = int(b_mean*1.5)
sc = 1000.
kr=[i/sc for i in range(ifloor(0*sc), iceil(1.5*sc)+1, int(0.1*sc))]
br=[i/sc for i in range(ifloor(b_min*sc), iceil(b_max*sc)+1, int(5.*sc))]
obj = bulk_solvent.k_sol_b_sol_k_anisotropic_scaler_twin(
f_obs = self.f_obs().data(),
f_calc_1 = f_calc_plus_f_bulk_no_scales.data(),
f_calc_2 = f_calc_plus_f_bulk_no_scales_twin.data(),
f_mask_1 = f_h.data(),
f_mask_2 = f_h_twin.data(),
ss = self.ss,
twin_fraction = self.twin_fraction,
k_sol_range = flex.double(kr),
b_sol_range = flex.double(br),
miller_indices = self.f_obs().indices(), # XXX What about twin-related?
unit_cell = self.f_obs().unit_cell(),
r_ref = self.r_work())
if(obj.updated()):
f_part2 = f_h.array( data = obj.k_mask()*f_h.data())
f_part2_twin = f_h_twin.array(data = obj.k_mask()*f_h_twin.data())
kh, bh = obj.k_sol(), obj.b_sol()
# Fine sampling
k_min = max(0,obj.k_sol()-0.1)
k_max = obj.k_sol()+0.1
b_min = max(0,obj.b_sol()-5.)
b_max = obj.b_sol()+5.
kr=[i/sc for i in range(ifloor(k_min*sc),iceil(k_max*sc)+1,int(0.01*sc))]
br=[i/sc for i in range(ifloor(b_min*sc),iceil(b_max*sc)+1,int(5.*sc))]
obj = bulk_solvent.k_sol_b_sol_k_anisotropic_scaler_twin(
f_obs = self.f_obs().data(),
f_calc_1 = f_calc_plus_f_bulk_no_scales.data(),
f_calc_2 = f_calc_plus_f_bulk_no_scales_twin.data(),
f_mask_1 = f_h.data(),
f_mask_2 = f_h_twin.data(),
ss = self.ss,
twin_fraction = self.twin_fraction,
k_sol_range = flex.double(kr),
b_sol_range = flex.double(br),
miller_indices = self.f_obs().indices(), # XXX What about twin-related?
unit_cell = self.f_obs().unit_cell(),
r_ref = obj.r())
if(obj.updated()):
f_part2 = f_h.array( data = obj.k_mask()*f_h.data())
f_part2_twin = f_h_twin.array(data = obj.k_mask()*f_h_twin.data())
kh, bh = obj.k_sol(), obj.b_sol()
self.update_core(
f_part2 = f_part2,
f_part2_twin = f_part2_twin,
k_anisotropic = obj.k_anisotropic())
self.show(prefix = "add H (%4.2f, %6.2f)"%(kh, bh), log = log)
b_cart = adptbx.u_as_b(adptbx.u_star_as_u_cart(
self.f_obs().unit_cell(), o_kbu_sol.u_star()))
return group_args(
k_sol = o_kbu_sol.k_sol(),
b_sol = o_kbu_sol.b_sol(),
b_cart = b_cart,
k_h = kh,
b_h = bh)
def anisotropic_scaling(self, r_start):
r_expanal, r_poly, r_expmin = None,None,None
k_anisotropic_expanal, k_anisotropic_poly, \
k_anisotropic_expmin = None, None, None
scale_matrix_expanal, scale_matrix_poly, scale_matrix_expmin= None,None,None
sel = self.selection_work.data()
f_model_abs = flex.abs(self.core.f_model_no_aniso_scale.data().select(sel))
f_obs = self.f_obs.data().select(sel)
mi = self.f_obs.indices().select(sel)
uc = self.f_obs.unit_cell()
mi_all = self.f_obs.indices()
# try exp_anal
if(self.try_expanal):
obj = bulk_solvent.aniso_u_scaler(
f_model_abs = f_model_abs,
f_obs = f_obs,
miller_indices = mi,
adp_constraint_matrix = self.adp_constraints.gradient_sum_matrix())
u_star = self.adp_constraints.all_params(tuple(obj.u_star_independent))
scale_matrix_expanal = adptbx.u_as_b(adptbx.u_star_as_u_cart(uc, u_star))
k_anisotropic_expanal = ext.k_anisotropic(mi_all, u_star)
r_expanal = self.try_scale(k_anisotropic = k_anisotropic_expanal)
if(self.verbose):
print >> self.log, " r_expanal: %6.4f"%r_expanal
# try poly
if(self.try_poly):
obj = bulk_solvent.aniso_u_scaler(
f_model_abs = f_model_abs,
f_obs = f_obs,
miller_indices = mi,
unit_cell = uc)
scale_matrix_poly = obj.a
k_anisotropic_poly = ext.k_anisotropic(mi_all, obj.a, uc)
r_poly = self.try_scale(k_anisotropic = k_anisotropic_poly)
if(self.verbose):
print >> self.log, " r_poly : %6.4f"%r_poly
# pre-analyze
force_to_use_expmin=False
if(k_anisotropic_poly is not None and self.auto and r_poly<r_expanal and
(k_anisotropic_poly<=0).count(True)>0):
force_to_use_expmin = True
self.try_expmin = True
# try expmin
if(self.try_expmin):
zero = self.f_obs.select(sel).customized_copy(data =
flex.complex_double(f_obs.size(), 0))
fm = mmtbx.f_model.manager_kbu(
f_obs = self.f_obs.select(sel),
f_calc = self.core.f_model_no_aniso_scale.select(sel),
f_masks = [zero],
f_part1 = zero,
f_part2 = zero,
ss = self.ss)
obj = kbu_refinery.tgc(
f_obs = self.f_obs.select(sel),
f_calc = self.core.f_model_no_aniso_scale.select(sel),
f_masks = [zero],
ss = self.ss,
k_sols = [0,],
b_sols = [0,],
u_star = [0,0,0,0,0,0])
obj.minimize_u()
u_star = obj.kbu.u_star()
scale_matrix_expmin = adptbx.u_as_b(adptbx.u_star_as_u_cart(uc, u_star))
k_anisotropic_expmin = ext.k_anisotropic(mi_all, u_star)
r_expmin = self.try_scale(k_anisotropic = k_anisotropic_expmin)
if(self.verbose): print >> self.log, " r_expmin : %6.4f"%r_expmin
if(force_to_use_expmin):
self.core = self.core.update(k_anisotropic = k_anisotropic_expmin)
if(self.verbose):
self.format_scale_matrix(m=scale_matrix_expmin)
return
# select best
r = [(r_expanal, k_anisotropic_expanal, scale_matrix_expanal),
(r_poly, k_anisotropic_poly, scale_matrix_poly),
(r_expmin, k_anisotropic_expmin, scale_matrix_expmin)]
r_best = r_start
k_anisotropic_best = None
scale_matrix_best = None
for result in r:
r_factor, k_anisotropic, scale_matrix = result
if(r_factor is not None and r_factor < r_best):
r_best = r_factor
k_anisotropic_best = k_anisotropic.deep_copy()
scale_matrix_best = scale_matrix[:]
if(scale_matrix_best is None):
if(self.verbose):
print >> self.log, " result rejected due to r-factor increase"
else:
self.scale_matrices = scale_matrix_best
self.core = self.core.update(k_anisotropic = k_anisotropic_best)
r_aniso = self.r_factor()
if(self.verbose):
self.format_scale_matrix()
print >> self.log, " r_final : %6.4f"%r_aniso
def exercise_interface():
episq = 8*(math.pi**2)
assert approx_equal(adptbx.u_as_b(2.3), 2.3*episq)
assert approx_equal(adptbx.b_as_u(adptbx.u_as_b(2.3)), 2.3)
u = (3,4,9, 2,1,7)
assert approx_equal(adptbx.u_as_b(u), [x*episq for x in u])
assert approx_equal(adptbx.b_as_u(adptbx.u_as_b(u)), u)
uc = uctbx.unit_cell((5,4,7,80,110,100))
for fw,bw in ((adptbx.u_cif_as_u_star, adptbx.u_star_as_u_cif),
(adptbx.u_cart_as_u_star, adptbx.u_star_as_u_cart),
(adptbx.u_cart_as_u_cif, adptbx.u_cif_as_u_cart),
(adptbx.u_cart_as_beta, adptbx.beta_as_u_cart),
(adptbx.u_cif_as_beta, adptbx.beta_as_u_cif)):
assert approx_equal(bw(uc, fw(uc, u)), u)
assert approx_equal(adptbx.beta_as_u_star(adptbx.u_star_as_beta(u)), u)
assert approx_equal(adptbx.u_cart_as_u_iso(adptbx.u_iso_as_u_cart(2.3)), 2.3)
for fw,bw in ((adptbx.u_iso_as_u_star, adptbx.u_star_as_u_iso),
(adptbx.u_iso_as_u_cif, adptbx.u_cif_as_u_iso),
(adptbx.u_iso_as_beta, adptbx.beta_as_u_iso)):
assert approx_equal(bw(uc, fw(uc, 2.3)), 2.3)
fc = adptbx.factor_u_cart_u_iso(u_cart=u)
assert approx_equal(fc.u_iso, adptbx.u_cart_as_u_iso(u))
assert approx_equal(
fc.u_cart_minus_u_iso,
[uii-fc.u_iso for uii in u[:3]]+list(u[3:]))
f = adptbx.factor_u_star_u_iso(
unit_cell=uc, u_star=adptbx.u_cart_as_u_star(uc, u))
assert approx_equal(f.u_iso, fc.u_iso)
assert approx_equal(
f.u_star_minus_u_iso,
adptbx.u_cart_as_u_star(uc, fc.u_cart_minus_u_iso))
f = adptbx.factor_u_cif_u_iso(
unit_cell=uc, u_cif=adptbx.u_cart_as_u_cif(uc, u))
assert approx_equal(f.u_iso, fc.u_iso)
assert approx_equal(
f.u_cif_minus_u_iso,
adptbx.u_cart_as_u_cif(uc, fc.u_cart_minus_u_iso))
f = adptbx.factor_beta_u_iso(
unit_cell=uc, beta=adptbx.u_cart_as_beta(uc, u))
assert approx_equal(f.u_iso, fc.u_iso)
assert approx_equal(
f.beta_minus_u_iso,
adptbx.u_cart_as_beta(uc, fc.u_cart_minus_u_iso))
assert approx_equal(adptbx.debye_waller_factor_b_iso(0.25,2.3),
math.exp(-2.3*0.25))
assert approx_equal(adptbx.debye_waller_factor_u_iso(0.25,2.3),
math.exp(-2.3*episq*0.25))
assert approx_equal(adptbx.debye_waller_factor_b_iso(uc, (1,2,3), 2.3),
adptbx.debye_waller_factor_u_iso(uc, (1,2,3), 2.3/episq))
u_star = adptbx.u_cart_as_u_star(uc, u)
dw = adptbx.debye_waller_factor_u_star((1,2,3), u_star)
assert approx_equal(dw, adptbx.debye_waller_factor_beta((1,2,3),
adptbx.u_star_as_beta(u_star)))
assert approx_equal(dw, adptbx.debye_waller_factor_u_cif(uc, (1,2,3),
adptbx.u_star_as_u_cif(uc, u_star)))
assert approx_equal(dw, adptbx.debye_waller_factor_u_cart(uc, (1,2,3),
adptbx.u_star_as_u_cart(uc, u_star)))
for e in adptbx.eigenvalues(u):
check_eigenvalue(u, e)
assert not adptbx.is_positive_definite(adptbx.eigenvalues(u))
assert not adptbx.is_positive_definite(adptbx.eigenvalues(u), 0)
assert adptbx.is_positive_definite(adptbx.eigenvalues(u), 1.22)
assert not adptbx.is_positive_definite(u)
assert not adptbx.is_positive_definite(u, 0)
assert adptbx.is_positive_definite(u, 1.22)
up = (0.534, 0.812, 0.613, 0.0166, 0.134, -0.0124)
s = adptbx.eigensystem(up)
assert approx_equal(s.values(), (0.813132, 0.713201, 0.432668))
for i in xrange(3):
check_eigenvector(up, s.values()[i], s.vectors(i))
c = (1,2,3, 3,-4,5, 4,5,6)
v = (198,18,1020,116,447,269)
assert approx_equal(adptbx.c_u_c_transpose(c, u), v)
assert approx_equal(adptbx.eigensystem(u).values(),
(14.279201519086316, 2.9369143826320214, -1.2161159017183376))
s = adptbx.eigensystem(up)
try: s.vectors(4)
except RuntimeError, e: assert str(e).endswith("Index out of range.")
else: raise Exception_expected
uf = adptbx.eigenvalue_filtering(u_cart=u, u_min=0)
assert approx_equal(uf, (3.0810418, 4.7950710, 9.3400030,
1.7461615, 1.1659954, 6.4800706))
uf = adptbx.eigenvalue_filtering(u_cart=u, u_min=0, u_max=3)
assert approx_equal(uf, (2.7430890, 1.0378360, 2.1559895,
0.6193215, -0.3921632, 1.2846854))
uf = adptbx.eigenvalue_filtering(u_cart=u, u_min=0, u_max=3)
assert approx_equal(scitbx.linalg.eigensystem.real_symmetric(u).values(),
(14.2792015, 2.9369144, -1.2161159))
assert approx_equal(scitbx.linalg.eigensystem.real_symmetric(uf).values(),
(3, 2.9369144, 0))
uf = adptbx.eigenvalue_filtering(up)
assert approx_equal(uf, up)
