def exercise(flags, space_group_info):
# Prepare a structure compatible with the ShelX model
xs = random_structure.xray_structure(space_group_info,
elements="random",
n_scatterers=10,
use_u_iso=True,
random_u_iso=True,
use_u_aniso=True)
xs.apply_symmetry_sites()
xs.apply_symmetry_u_stars()
for isotropic, sc in itertools.izip(variate(bernoulli_distribution(0.4)),
xs.scatterers()):
sc.flags.set_grad_site(True)
if isotropic:
sc.flags.set_use_u_iso(True)
sc.flags.set_use_u_aniso(False)
sc.flags.set_grad_u_iso(True)
else:
sc.flags.set_use_u_iso(False)
sc.flags.set_use_u_aniso(True)
sc.flags.set_grad_u_aniso(True)
not_origin_centric = (xs.space_group().is_centric()
and not xs.space_group().is_origin_centric())
try:
ins = list(
shelx.writer.generator(xs,
full_matrix_least_squares_cycles=4,
weighting_scheme_params=(0, 0),
sort_scatterers=False))
except AssertionError:
if (not_origin_centric):
print(
"Omitted %s\n because it is centric but not origin centric" %
xs.space_group().type().hall_symbol())
return
raise
else:
if (not_origin_centric):
raise Exception_expected
ins = cStringIO.StringIO("".join(ins))
xs1 = xs.from_shelx(file=ins)
xs.crystal_symmetry().is_similar_symmetry(xs1.crystal_symmetry(),
relative_length_tolerance=1e-3,
absolute_angle_tolerance=1e-3)
uc = xs.unit_cell()
uc1 = xs1.unit_cell()
for sc, sc1 in itertools.izip(xs.scatterers(), xs1.scatterers()):
assert sc.label.upper() == sc1.label.upper()
assert sc.scattering_type == sc1.scattering_type
assert sc.flags.bits == sc1.flags.bits
assert approx_equal(sc.site, sc1.site, eps=1e-6)
if sc.flags.use_u_iso():
assert approx_equal(sc.u_iso, sc1.u_iso, eps=1e-5)
else:
assert approx_equal(adptbx.u_star_as_u_cif(uc, sc.u_star),
adptbx.u_star_as_u_cif(uc1, sc1.u_star),
eps=1e-5)
def exercise(flags, space_group_info):
# Prepare a structure compatible with the ShelX model
xs = random_structure.xray_structure(
space_group_info, elements="random", n_scatterers=10, use_u_iso=True, random_u_iso=True, use_u_aniso=True
)
xs.apply_symmetry_sites()
xs.apply_symmetry_u_stars()
for isotropic, sc in itertools.izip(variate(bernoulli_distribution(0.4)), xs.scatterers()):
sc.flags.set_grad_site(True)
if isotropic:
sc.flags.set_use_u_iso(True)
sc.flags.set_use_u_aniso(False)
sc.flags.set_grad_u_iso(True)
else:
sc.flags.set_use_u_iso(False)
sc.flags.set_use_u_aniso(True)
sc.flags.set_grad_u_aniso(True)
not_origin_centric = xs.space_group().is_centric() and not xs.space_group().is_origin_centric()
try:
ins = list(
shelx.writer.generator(
xs, full_matrix_least_squares_cycles=4, weighting_scheme_params=(0, 0), sort_scatterers=False
)
)
except AssertionError:
if not_origin_centric:
print("Omitted %s\n because it is centric but not origin centric" % xs.space_group().type().hall_symbol())
return
raise
else:
if not_origin_centric:
raise Exception_expected
ins = cStringIO.StringIO("".join(ins))
xs1 = xs.from_shelx(file=ins)
xs.crystal_symmetry().is_similar_symmetry(
xs1.crystal_symmetry(), relative_length_tolerance=1e-3, absolute_angle_tolerance=1e-3
)
uc = xs.unit_cell()
uc1 = xs1.unit_cell()
for sc, sc1 in itertools.izip(xs.scatterers(), xs1.scatterers()):
assert sc.label.upper() == sc1.label.upper()
assert sc.scattering_type == sc1.scattering_type
assert sc.flags.bits == sc1.flags.bits
assert approx_equal(sc.site, sc1.site, eps=1e-6)
if sc.flags.use_u_iso():
assert approx_equal(sc.u_iso, sc1.u_iso, eps=1e-5)
else:
assert approx_equal(
adptbx.u_star_as_u_cif(uc, sc.u_star), adptbx.u_star_as_u_cif(uc1, sc1.u_star), eps=1e-5
)
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 atoms(xray_structure, short_sfac):
if (short_sfac):
celcon = calculate_cell_content(xray_structure).keys()
lines = []
l = lines.append
i = 0
for scatterer in xray_structure.scatterers():
i += 1
lbl = scatterer.scattering_type + str(i)
if (short_sfac):
sfac = celcon.index(scatterer.scattering_type) + 1
else:
sfac = i
coor = []
for x in scatterer.site: coor.append(NOFIX(x))
coor = dot6fdot_list(coor)
sof = NOFIX(scatterer.weight())
if (not scatterer.flags.use_u_aniso()):
l("%-4s %d %s %s %s" % (lbl, sfac, coor, dot6gdot(sof),
dot6gdot(NOFIX(scatterer.u_iso))))
else:
u = adptbx.u_star_as_u_cif(xray_structure.unit_cell(), scatterer.u_star)
u_fix = []
for c in u: u_fix.append(NOFIX(c))
u = u_fix
l("%-4s %d %s %s %s =" % (lbl, sfac, coor, dot6gdot(sof),
dot6gdot_list(u[:2])))
l(" %s" % dot6gdot_list((u[2], u[5], u[4], u[3])))
return lines
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 atoms(xray_structure, short_sfac):
if (short_sfac):
celcon = calculate_cell_content(xray_structure).keys()
lines = []
l = lines.append
i = 0
for scatterer in xray_structure.scatterers():
i += 1
lbl = scatterer.scattering_type + str(i)
if (short_sfac):
sfac = celcon.index(scatterer.scattering_type) + 1
else:
sfac = i
coor = []
for x in scatterer.site:
coor.append(NOFIX(x))
coor = dot6fdot_list(coor)
sof = NOFIX(scatterer.weight())
if (not scatterer.flags.use_u_aniso()):
l("%-4s %d %s %s %s" % (lbl, sfac, coor, dot6gdot(sof),
dot6gdot(NOFIX(scatterer.u_iso))))
else:
u = adptbx.u_star_as_u_cif(xray_structure.unit_cell(),
scatterer.u_star)
u_fix = []
for c in u:
u_fix.append(NOFIX(c))
u = u_fix
l("%-4s %d %s %s %s =" %
(lbl, sfac, coor, dot6gdot(sof), dot6gdot_list(u[:2])))
l(" %s" % dot6gdot_list((u[2], u[5], u[4], u[3])))
return lines
def atoms(lapp, sfac_indices, xray_structure, encoded_sites):
spis = xray_structure.special_position_indices()
if (encoded_sites is None):
enc_dict = {}
else:
assert len(encoded_sites) == spis.size()
enc_dict = dict(zip(spis, encoded_sites))
ss = xray_structure.space_group_info().structure_seminvariants()
if (ss.number_of_continuous_allowed_origin_shifts() == 0):
caosh_flags = None
caosh_i_sc = None
else:
assert ss.continuous_shifts_are_principal()
caosh_flags = ss.principal_continuous_shift_flags()
reg = xray_structure.scattering_type_registry()
w_max = None
for i_sc,sc in enumerate(xray_structure.scatterers()):
gaussian = reg.gaussian(sc.scattering_type)
w = abs(sc.weight() * gaussian.at_stol(0))
if (w_max is None or w_max < w):
w_max = w
caosh_i_sc = i_sc
assert w_max is not None
for i_sc,sc in enumerate(xray_structure.scatterers()):
st = sc.scattering_type
lbl = "%s%02d" % (st, i_sc+1)
sfac = sfac_indices[st]
enc_site = enc_dict.get(i_sc)
coor = []
if (caosh_i_sc is None or i_sc != caosh_i_sc):
if (enc_site is None):
for x in sc.site: coor.append(NOFIX(x))
else:
coor = enc_site
else:
if (enc_site is None):
for x,f in zip(sc.site, caosh_flags):
if (f): fix = FIX
else: fix = NOFIX
coor.append(fix(x))
else:
for x,f in zip(enc_site, caosh_flags):
if (f):
coor.append(FIX(x))
else:
coor.append(x)
coor = dot6fdot_list(coor)
sof = FIX(sc.weight())
if (not sc.flags.use_u_aniso()):
lapp("%-4s %d %s %s %s" % (lbl, sfac, coor, dot6gdot(sof),
dot6gdot(NOFIX(sc.u_iso))))
else:
u = adptbx.u_star_as_u_cif(xray_structure.unit_cell(), sc.u_star)
u_fix = []
for c in u: u_fix.append(NOFIX(c))
u = u_fix
lapp("%-4s %d %s %s %s =" % (lbl, sfac, coor, dot6gdot(sof),
dot6gdot_list(u[:2])))
lapp(" %s" % dot6gdot_list((u[2], u[5], u[4], u[3])))
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 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 generator(xray_structure,
data_are_intensities=True,
title=None,
wavelength=None,
temperature=None,
full_matrix_least_squares_cycles=None,
conjugate_gradient_least_squares_cycles=None,
overall_scale_factor=None,
weighting_scheme_params=None,
sort_scatterers=True,
unit_cell_dims=None,
unit_cell_esds=None):
space_group = xray_structure.space_group()
assert not space_group.is_centric() or space_group.is_origin_centric(),\
centric_implies_centrosymmetric_error_msg
assert [
full_matrix_least_squares_cycles,
conjugate_gradient_least_squares_cycles
].count(None) in (0, 1)
if title is None:
title = '????'
if wavelength is None:
wavelength = wavelengths.characteristic('Mo').as_angstrom()
sgi = xray_structure.space_group_info()
uc = xray_structure.unit_cell()
yield 'TITL %s in %s\n' % (title, sgi.type().lookup_symbol())
if unit_cell_dims is None:
unit_cell_dims = uc.parameters()
yield 'CELL %.5f %s\n' % (wavelength,
' '.join(('%.4f ', ) * 3 +
('%.3f', ) * 3) % unit_cell_dims)
if unit_cell_esds:
yield 'ZERR %i %f %f %f %f %f %f\n' % (
(sgi.group().order_z(), ) + unit_cell_esds)
else:
yield 'ZERR %i 0. 0. 0. 0. 0. 0.\n' % sgi.group().order_z()
latt = 1 + 'PIRFABC'.find(sgi.group().conventional_centring_type_symbol())
if not space_group.is_origin_centric(): latt = -latt
yield 'LATT %i\n' % latt
for i in xrange(space_group.n_smx()):
rt_mx = space_group(0, 0, i)
if rt_mx.is_unit_mx(): continue
yield 'SYMM %s\n' % rt_mx
yield '\n'
uc_content = xray_structure.unit_cell_content()
for e in uc_content:
uc_content[e] = "%.1f" % uc_content[e]
sfac = []
unit = []
prior = ('C', 'H')
for e in prior:
if e in uc_content:
sfac.append(e)
unit.append(uc_content[e])
dsu = [(tiny_pse.table(e).atomic_number(), e) for e in uc_content]
dsu.sort()
sorted = [item[-1] for item in dsu]
for e in sorted:
if (e not in prior):
sfac.append(e)
unit.append(uc_content[e])
yield 'SFAC %s\n' % ' '.join(sfac)
for e in sfac:
yield 'DISP %s 0 0 0\n' % e
yield 'UNIT %s\n' % ' '.join(unit)
sf_idx = dict([(e, i + 1) for i, e in enumerate(sfac)])
yield '\n'
if temperature:
yield 'TEMP %.0f\n' % temperature
if full_matrix_least_squares_cycles:
yield 'L.S. %i\n' % full_matrix_least_squares_cycles
if conjugate_gradient_least_squares_cycles:
yield 'CGLS %i\n' % conjugate_gradient_least_squares_cycles
yield '\n'
if weighting_scheme_params is not None:
if (isinstance(weighting_scheme_params, str)):
yield 'WGHT %s\n' % weighting_scheme_params
else:
a, b = weighting_scheme_params
if b is None:
yield 'WGHT %.6f\n' % a
else:
yield 'WGHT %.6f %.6f\n' % (a, b)
if overall_scale_factor is not None:
yield 'FVAR %.8f\n' % overall_scale_factor
fmt_tmpl = ('%-4s', '%2i') + ('%11.6f', ) * 3 + ('%11.5f', )
fmt_iso = ' '.join(fmt_tmpl + ('%10.5f', ))
fmt_aniso = ' '.join(fmt_tmpl + ('%.5f', ) * 2 + ('=\n ', ) +
('%.5f', ) * 4)
if sort_scatterers:
dsu = [(tiny_pse.table(sc.scattering_type).atomic_number(), sc)
for sc in xray_structure.scatterers()]
dsu.sort(reverse=True)
scatterers = flex.xray_scatterer([item[-1] for item in dsu])
else:
scatterers = xray_structure.scatterers()
atomname_set = set()
for sc in scatterers:
assert sc.fp == 0 # not implemented
assert sc.fdp == 0 # not implemented
assert sc.flags.use_u_iso() ^ sc.flags.use_u_aniso(),\
both_iso_and_aniso_in_use_error_msg
atomname = sc.label.strip()
assert len(atomname) != 0
assert len(atomname) <= 4
if (atomname in atomname_set):
raise RuntimeError('Duplicate atom name: "%s"' % atomname)
atomname_set.add(atomname)
params = (atomname, sf_idx[sc.scattering_type]) + sc.site
occ = sc.weight()
if not sc.flags.grad_occupancy(): occ += 10
params += (occ, )
if sc.flags.use_u_iso():
yield fmt_iso % (params + (sc.u_iso, )) + "\n"
else:
u11, u22, u33, u12, u13, u23 = adptbx.u_star_as_u_cif(
uc, sc.u_star)
yield fmt_aniso % (params + (u11, u22, u33, u23, u13, u12)) + "\n"
if data_are_intensities: hklf = 4
else: hklf = 3
yield 'HKLF %i\n' % hklf
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 __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 __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 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)
def __init__(self,
xray_structure,
covariance_matrix=None,
cell_covariance_matrix=None):
crystal_symmetry_as_cif_block.__init__(
self,
xray_structure.crystal_symmetry(),
cell_covariance_matrix=cell_covariance_matrix)
scatterers = xray_structure.scatterers()
uc = xray_structure.unit_cell()
if covariance_matrix is not None:
param_map = xray_structure.parameter_map()
covariance_diagonal = covariance_matrix.matrix_packed_u_diagonal()
u_star_to_u_cif_linear_map_pow2 = flex.pow2(
flex.double(uc.u_star_to_u_cif_linear_map()))
u_star_to_u_iso_linear_form = matrix.row(
uc.u_star_to_u_iso_linear_form())
fmt = "%.6f"
# _atom_site_* loop
atom_site_loop = model.loop(
header=('_atom_site_label', '_atom_site_type_symbol',
'_atom_site_fract_x', '_atom_site_fract_y',
'_atom_site_fract_z', '_atom_site_U_iso_or_equiv',
'_atom_site_adp_type', '_atom_site_occupancy'))
for i_seq, sc in enumerate(scatterers):
# site
if covariance_matrix is not None and sc.flags.grad_site():
site = []
for i in range(3):
idx = param_map[i_seq].site
if idx > -1:
var = covariance_diagonal[idx + i]
else:
var = 0
if var > 0:
site.append(
format_float_with_su(sc.site[i], math.sqrt(var)))
else:
site.append(fmt % sc.site[i])
else:
site = [fmt % sc.site[i] for i in range(3)]
# u_eq
if (covariance_matrix is not None
and (sc.flags.grad_u_iso() or sc.flags.grad_u_aniso())):
if sc.flags.grad_u_iso():
u_iso_or_equiv = format_float_with_su(
sc.u_iso,
math.sqrt(
covariance.variance_for_u_iso(
i_seq, covariance_matrix, param_map)))
else:
cov = covariance.extract_covariance_matrix_for_u_aniso(
i_seq, covariance_matrix,
param_map).matrix_packed_u_as_symmetric()
var = (u_star_to_u_iso_linear_form *
matrix.sqr(cov)).dot(u_star_to_u_iso_linear_form)
u_iso_or_equiv = format_float_with_su(
sc.u_iso_or_equiv(uc), math.sqrt(var))
else:
u_iso_or_equiv = fmt % sc.u_iso_or_equiv(uc)
if sc.flags.use_u_aniso():
adp_type = 'Uani'
else:
adp_type = 'Uiso'
atom_site_loop.add_row(
(sc.label, sc.scattering_type, site[0], site[1], site[2],
u_iso_or_equiv, adp_type, fmt % sc.occupancy))
self.cif_block.add_loop(atom_site_loop)
# _atom_site_aniso_* loop
aniso_scatterers = scatterers.select(scatterers.extract_use_u_aniso())
if aniso_scatterers.size():
labels = list(scatterers.extract_labels())
aniso_loop = model.loop(
header=('_atom_site_aniso_label', '_atom_site_aniso_U_11',
'_atom_site_aniso_U_22', '_atom_site_aniso_U_33',
'_atom_site_aniso_U_12', '_atom_site_aniso_U_13',
'_atom_site_aniso_U_23'))
for sc in aniso_scatterers:
u_cif = adptbx.u_star_as_u_cif(uc, sc.u_star)
if covariance_matrix is not None:
row = [sc.label]
idx = param_map[labels.index(sc.label)].u_aniso
if idx > -1:
var = covariance_diagonal[
idx:idx + 6] * u_star_to_u_cif_linear_map_pow2
for i in range(6):
if var[i] > 0:
row.append(
format_float_with_su(
u_cif[i], math.sqrt(var[i])))
else:
row.append(fmt % u_cif[i])
else:
row = [sc.label] + [fmt % u_cif[i] for i in range(6)]
else:
row = [sc.label] + [fmt % u_cif[i] for i in range(6)]
aniso_loop.add_row(row)
self.cif_block.add_loop(aniso_loop)
self.cif_block.add_loop(atom_type_cif_loop(xray_structure))
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 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 generator(xray_structure,
data_are_intensities=True,
title=None,
wavelength=None,
temperature=None,
full_matrix_least_squares_cycles=None,
conjugate_gradient_least_squares_cycles=None,
overall_scale_factor=None,
weighting_scheme_params=None,
sort_scatterers=True,
unit_cell_dims=None,
unit_cell_esds=None
):
space_group = xray_structure.space_group()
assert not space_group.is_centric() or space_group.is_origin_centric(),\
centric_implies_centrosymmetric_error_msg
assert [full_matrix_least_squares_cycles,
conjugate_gradient_least_squares_cycles].count(None) in (0, 1)
if title is None:
title = '????'
if wavelength is None:
wavelength = wavelengths.characteristic('Mo').as_angstrom()
sgi = xray_structure.space_group_info()
uc = xray_structure.unit_cell()
yield 'TITL %s in %s\n' % (title, sgi.type().lookup_symbol())
if unit_cell_dims is None:
unit_cell_dims = uc.parameters()
yield 'CELL %.5f %s\n' % (
wavelength,
' '.join(('%.4f ',)*3 + ('%.3f',)*3) % unit_cell_dims)
if unit_cell_esds:
yield 'ZERR %i %f %f %f %f %f %f\n' % ((sgi.group().order_z(),) + unit_cell_esds)
else:
yield 'ZERR %i 0. 0. 0. 0. 0. 0.\n' % sgi.group().order_z()
latt = 1 + 'PIRFABC'.find(sgi.group().conventional_centring_type_symbol())
if not space_group.is_origin_centric(): latt = -latt
yield 'LATT %i\n' % latt
for i in xrange(space_group.n_smx()):
rt_mx = space_group(0, 0, i)
if rt_mx.is_unit_mx(): continue
yield 'SYMM %s\n' % rt_mx
yield '\n'
uc_content = xray_structure.unit_cell_content()
for e in uc_content:
uc_content[e] = "%.1f" % uc_content[e]
sfac = []
unit = []
prior = ('C', 'H')
for e in prior:
if e in uc_content:
sfac.append(e)
unit.append(uc_content[e])
dsu = [ (tiny_pse.table(e).atomic_number(), e) for e in uc_content ]
dsu.sort()
sorted = [ item[-1] for item in dsu ]
for e in sorted:
if (e not in prior):
sfac.append(e)
unit.append(uc_content[e])
yield 'SFAC %s\n' % ' '.join(sfac)
for e in sfac:
yield 'DISP %s 0 0 0\n' % e
yield 'UNIT %s\n' % ' '.join(unit)
sf_idx = dict([ (e, i + 1) for i, e in enumerate(sfac) ])
yield '\n'
if temperature:
yield 'TEMP %.0f\n' % temperature
if full_matrix_least_squares_cycles:
yield 'L.S. %i\n' % full_matrix_least_squares_cycles
if conjugate_gradient_least_squares_cycles:
yield 'CGLS %i\n' % conjugate_gradient_least_squares_cycles
yield '\n'
if weighting_scheme_params is not None:
if (isinstance(weighting_scheme_params, str)):
yield 'WGHT %s\n' % weighting_scheme_params
else:
a, b = weighting_scheme_params
if b is None:
yield 'WGHT %.6f\n' % a
else:
yield 'WGHT %.6f %.6f\n' % (a, b)
if overall_scale_factor is not None:
yield 'FVAR %.8f\n' % overall_scale_factor
fmt_tmpl = ('%-4s', '%2i') + ('%11.6f',)*3 + ('%11.5f',)
fmt_iso = ' '.join(fmt_tmpl + ('%10.5f',))
fmt_aniso = ' '.join(fmt_tmpl + ('%.5f',)*2 + ('=\n ',) + ('%.5f',)*4)
if sort_scatterers:
dsu = [ (tiny_pse.table(sc.scattering_type).atomic_number(), sc)
for sc in xray_structure.scatterers() ]
dsu.sort(reverse=True)
scatterers = flex.xray_scatterer([ item[-1] for item in dsu ])
else:
scatterers = xray_structure.scatterers()
atomname_set = set()
for sc in scatterers:
assert sc.fp == 0 # not implemented
assert sc.fdp == 0 # not implemented
assert sc.flags.use_u_iso() ^ sc.flags.use_u_aniso(),\
both_iso_and_aniso_in_use_error_msg
atomname = sc.label.strip()
assert len(atomname) != 0
assert len(atomname) <= 4
if (atomname in atomname_set):
raise RuntimeError('Duplicate atom name: "%s"' % atomname)
atomname_set.add(atomname)
params = (atomname, sf_idx[sc.scattering_type]) + sc.site
occ = sc.weight()
if not sc.flags.grad_occupancy(): occ += 10
params += (occ, )
if sc.flags.use_u_iso():
yield fmt_iso % (params + (sc.u_iso,)) + "\n"
else:
u11, u22, u33, u12, u13, u23 = adptbx.u_star_as_u_cif(uc, sc.u_star)
yield fmt_aniso % (params + (u11, u22, u33, u23, u13, u12)) + "\n"
if data_are_intensities: hklf = 4
else: hklf = 3
yield 'HKLF %i\n' % hklf
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, xray_structure, covariance_matrix=None, cell_covariance_matrix=None):
crystal_symmetry_as_cif_block.__init__(
self, xray_structure.crystal_symmetry(), cell_covariance_matrix=cell_covariance_matrix
)
scatterers = xray_structure.scatterers()
uc = xray_structure.unit_cell()
if covariance_matrix is not None:
param_map = xray_structure.parameter_map()
covariance_diagonal = covariance_matrix.matrix_packed_u_diagonal()
u_star_to_u_cif_linear_map_pow2 = flex.pow2(flex.double(uc.u_star_to_u_cif_linear_map()))
u_star_to_u_iso_linear_form = matrix.row(uc.u_star_to_u_iso_linear_form())
fmt = "%.6f"
# _atom_site_* loop
atom_site_loop = model.loop(
header=(
"_atom_site_label",
"_atom_site_type_symbol",
"_atom_site_fract_x",
"_atom_site_fract_y",
"_atom_site_fract_z",
"_atom_site_U_iso_or_equiv",
"_atom_site_adp_type",
"_atom_site_occupancy",
)
)
for i_seq, sc in enumerate(scatterers):
site = occu = u_iso_or_equiv = None
# site
if covariance_matrix is not None:
params = param_map[i_seq]
if sc.flags.grad_site() and params.site >= 0:
site = []
for i in range(3):
site.append(format_float_with_su(sc.site[i], math.sqrt(covariance_diagonal[params.site + i])))
# occupancy
if sc.flags.grad_occupancy() and params.occupancy >= 0:
occu = format_float_with_su(sc.occupancy, math.sqrt(covariance_diagonal[params.occupancy]))
# Uiso/eq
if sc.flags.grad_u_iso() or sc.flags.grad_u_aniso():
if sc.flags.grad_u_iso():
u_iso_or_equiv = format_float_with_su(
sc.u_iso, math.sqrt(covariance.variance_for_u_iso(i_seq, covariance_matrix, param_map))
)
else:
cov = covariance.extract_covariance_matrix_for_u_aniso(
i_seq, covariance_matrix, param_map
).matrix_packed_u_as_symmetric()
var = (u_star_to_u_iso_linear_form * matrix.sqr(cov)).dot(u_star_to_u_iso_linear_form)
u_iso_or_equiv = format_float_with_su(sc.u_iso_or_equiv(uc), math.sqrt(var))
if site is None:
site = [fmt % sc.site[i] for i in range(3)]
if occu is None:
occu = fmt % sc.occupancy
if u_iso_or_equiv is None:
u_iso_or_equiv = fmt % sc.u_iso_or_equiv(uc)
if sc.flags.use_u_aniso():
adp_type = "Uani"
else:
adp_type = "Uiso"
atom_site_loop.add_row(
(sc.label, sc.scattering_type, site[0], site[1], site[2], u_iso_or_equiv, adp_type, occu)
)
self.cif_block.add_loop(atom_site_loop)
# _atom_site_aniso_* loop
aniso_scatterers = scatterers.select(scatterers.extract_use_u_aniso())
if aniso_scatterers.size():
labels = list(scatterers.extract_labels())
aniso_loop = model.loop(
header=(
"_atom_site_aniso_label",
"_atom_site_aniso_U_11",
"_atom_site_aniso_U_22",
"_atom_site_aniso_U_33",
"_atom_site_aniso_U_12",
"_atom_site_aniso_U_13",
"_atom_site_aniso_U_23",
)
)
for sc in aniso_scatterers:
u_cif = adptbx.u_star_as_u_cif(uc, sc.u_star)
if covariance_matrix is not None:
row = [sc.label]
idx = param_map[labels.index(sc.label)].u_aniso
if idx > -1:
var = covariance_diagonal[idx : idx + 6] * u_star_to_u_cif_linear_map_pow2
for i in range(6):
if var[i] > 0:
row.append(format_float_with_su(u_cif[i], math.sqrt(var[i])))
else:
row.append(fmt % u_cif[i])
else:
row = [sc.label] + [fmt % u_cif[i] for i in range(6)]
else:
row = [sc.label] + [fmt % u_cif[i] for i in range(6)]
aniso_loop.add_row(row)
self.cif_block.add_loop(aniso_loop)
self.cif_block.add_loop(atom_type_cif_loop(xray_structure))
