def accelerations(self):
self.stereochemistry_residuals = self.restraints_manager.energies_sites(
sites_cart=self.structure.sites_cart(), compute_gradients=True)
# Harmonic restraints
if self.er_data is not None:
if self.er_data.er_harmonic_restraints_info is not None:
harmonic_grads = self.restraints_manager.geometry.ta_harmonic_restraints(
sites_cart=self.structure.sites_cart(),
ta_harmonic_restraint_info=self.er_data.
er_harmonic_restraints_info,
weight=self.er_data.er_harmonic_restraints_weight,
slack=self.er_data.er_harmonic_restraints_slack)
assert self.stereochemistry_residuals.gradients.size(
) == harmonic_grads.size()
self.stereochemistry_residuals.gradients += harmonic_grads
result = self.stereochemistry_residuals.gradients
d_max = None
if (self.xray_structure_last_updated is not None
and self.shift_update > 0):
array_of_distances_between_each_atom = \
flex.sqrt(self.structure.difference_vectors_cart(
self.xray_structure_last_updated).dot())
d_max = flex.max(array_of_distances_between_each_atom)
if (self.fmodel is not None):
if (d_max is not None):
if (d_max > self.shift_update):
self.xray_structure_last_updated = self.structure.deep_copy_scatterers(
)
self.xray_gradient = self.xray_grads()
else:
self.xray_gradient = self.xray_grads()
result = self.xray_gradient * self.xray_target_weight \
+ self.stereochemistry_residuals.gradients * self.chem_target_weight
factor = 1.0
if (self.chem_target_weight is not None):
factor *= self.chem_target_weight
if (self.stereochemistry_residuals.normalization_factor is not None):
factor *= self.stereochemistry_residuals.normalization_factor
if (factor != 1.0):
result *= 1.0 / factor
#Store RMS non-solvent atom gradients for Xray and Geo
if self.er_data is not None:
self.wc = self.chem_target_weight / factor
self.wx = self.xray_target_weight / factor
self.gg = self.stereochemistry_residuals.gradients * self.wc
self.xg = self.xray_gradient * self.wx
gg_pro = self.gg.select(~self.er_data.solvent_sel)
xg_pro = self.xg.select(~self.er_data.solvent_sel)
self.er_data.geo_grad_rms += (flex.mean_sq(gg_pro.as_double())**
0.5) / self.n_steps
self.er_data.xray_grad_rms += (flex.mean_sq(xg_pro.as_double())**
0.5) / self.n_steps
return result
def accelerations(self):
self.stereochemistry_residuals = self.restraints_manager.energies_sites(
sites_cart=self.structure.sites_cart(), compute_gradients=True
)
# Harmonic restraints
if self.er_data is not None:
if self.er_data.er_harmonic_restraints_info is not None:
harmonic_grads = self.restraints_manager.geometry.ta_harmonic_restraints(
sites_cart=self.structure.sites_cart(),
ta_harmonic_restraint_info=self.er_data.er_harmonic_restraints_info,
weight=self.er_data.er_harmonic_restraints_weight,
slack=self.er_data.er_harmonic_restraints_slack,
)
assert self.stereochemistry_residuals.gradients.size() == harmonic_grads.size()
self.stereochemistry_residuals.gradients += harmonic_grads
result = self.stereochemistry_residuals.gradients
d_max = None
if self.xray_structure_last_updated is not None and self.shift_update > 0:
array_of_distances_between_each_atom = flex.sqrt(
self.structure.difference_vectors_cart(self.xray_structure_last_updated).dot()
)
d_max = flex.max(array_of_distances_between_each_atom)
if self.fmodel is not None:
if d_max is not None:
if d_max > self.shift_update:
self.xray_structure_last_updated = self.structure.deep_copy_scatterers()
self.xray_gradient = self.xray_grads()
else:
self.xray_gradient = self.xray_grads()
result = (
self.xray_gradient * self.xray_target_weight
+ self.stereochemistry_residuals.gradients * self.chem_target_weight
)
factor = 1.0
if self.chem_target_weight is not None:
factor *= self.chem_target_weight
if self.stereochemistry_residuals.normalization_factor is not None:
factor *= self.stereochemistry_residuals.normalization_factor
if factor != 1.0:
result *= 1.0 / factor
# Store RMS non-solvent atom gradients for Xray and Geo
if self.er_data is not None:
self.wc = self.chem_target_weight / factor
self.wx = self.xray_target_weight / factor
self.gg = self.stereochemistry_residuals.gradients * self.wc
self.xg = self.xray_gradient * self.wx
gg_pro = self.gg.select(~self.er_data.solvent_sel)
xg_pro = self.xg.select(~self.er_data.solvent_sel)
self.er_data.geo_grad_rms += (flex.mean_sq(gg_pro.as_double()) ** 0.5) / self.n_steps
self.er_data.xray_grad_rms += (flex.mean_sq(xg_pro.as_double()) ** 0.5) / self.n_steps
return result
def e_pot(O, sites_moved):
if ( O.last_sites_moved is None
or O.last_sites_moved.id() is not sites_moved.id()):
O.last_sites_moved = sites_moved
sites_cart = sites_moved
#
if (O.reduced_geo_manager is None):
flags = None
if (O.orca_experiments):
flags = cctbx.geometry_restraints.flags.flags(
nonbonded=False, default=True)
else:
# computing nonbonded interactions only with geo_manager,
# contributions from other restraints below with reduced_geo_manager
flags = cctbx.geometry_restraints.flags.flags(
nonbonded=True, default=False)
geo_energies = O.geo_manager.energies_sites(
sites_cart=sites_cart,
flags=flags,
custom_nonbonded_function=O.custom_nonbonded_function,
compute_gradients=True)
if (0): # XXX orca_experiments
print "geo_energies:"
geo_energies.show()
if (0): # XXX orca_experiments
O.geo_manager.show_sorted(site_labels=O.site_labels)
O.f = geo_energies.target
O.g = geo_energies.gradients
if (O.reduced_geo_manager is not None):
reduced_geo_energies = O.reduced_geo_manager.energies_sites(
sites_cart=sites_cart,
compute_gradients=True)
O.f += reduced_geo_energies.target
O.g += reduced_geo_energies.gradients
O.last_grms = group_args(geo=flex.mean_sq(O.g.as_double())**0.5)
#
if (O.density_map is not None):
rs_f = maptbx.real_space_target_simple(
unit_cell=O.geo_manager.crystal_symmetry.unit_cell(),
density_map=O.density_map,
sites_cart=sites_cart,
selection=flex.bool(sites_cart.size(),True))
rs_g = maptbx.real_space_gradients_simple(
unit_cell=O.geo_manager.crystal_symmetry.unit_cell(),
density_map=O.density_map,
sites_cart=sites_cart,
delta=O.real_space_gradients_delta,
selection=flex.bool(sites_cart.size(),True))
rs_f *= -O.real_space_target_weight
rs_g *= -O.real_space_target_weight
O.f += rs_f
O.g += rs_g
O.last_grms.real = flex.mean_sq(rs_g.as_double())**0.5
O.last_grms.real_or_xray = "real"
#
O.last_grms.total = flex.mean_sq(O.g.as_double())**0.5
return O.f
def e_pot(O, sites_moved):
if ( O.last_sites_moved is None
or O.last_sites_moved.id() != sites_moved.id()):
O.last_sites_moved = sites_moved
xs = O.fmodels.fmodel_xray().xray_structure
assert len(sites_moved) == xs.scatterers().size()
sites_cart = sites_moved
xs.set_sites_cart(sites_cart=sites_cart)
O.fmodels.update_xray_structure(update_f_calc=True)
xs.scatterers().flags_set_grads(state=False)
xs.scatterers().flags_set_grad_site(
iselection=flex.size_t_range(xs.scatterers().size()))
expected_g_size = len(sites_moved) * 3
if (O.xray_weight_factor is not None):
tg = O.fmodels.target_and_gradients(
weights=O.weights,
compute_gradients=True)
O.f = tg.target() * O.xray_weight_factor
O.g = tg.gradients() * O.xray_weight_factor
assert O.g.size() == expected_g_size
else:
O.f = 0.
O.g = flex.double(expected_g_size, 0)
if (O.reduced_geo_manager is None):
reduced_geo_energies = None
else:
reduced_geo_energies = O.reduced_geo_manager.energies_sites(
sites_cart=sites_cart,
compute_gradients=True)
other_energies = O.model.restraints_manager.energies_sites(
sites_cart=sites_cart,
geometry_flags=cctbx.geometry_restraints.flags.flags(nonbonded=True),
custom_nonbonded_function=O.custom_nonbonded_function,
compute_gradients=True)
nfw = other_energies.normalization_factor * O.weights.w
O.f += other_energies.target * O.weights.w
gg = other_energies.gradients * O.weights.w
if (reduced_geo_energies is not None):
O.f += reduced_geo_energies.target * nfw
gg += reduced_geo_energies.gradients * nfw
assert nfw != 0
scale = 1 / nfw
O.last_grms = group_args(
geo=scale*flex.mean_sq(gg.as_double())**0.5,
xray=scale*flex.mean_sq(O.g)**0.5,
real_or_xray="xray")
xray.minimization.add_gradients(
scatterers=xs.scatterers(),
xray_gradients=O.g,
site_gradients=gg)
O.f *= scale
O.g *= scale
O.last_grms.total = flex.mean_sq(O.g)**0.5
O.g = flex.vec3_double(O.g)
return O.f
def e_pot(O, sites_moved):
if (O.last_sites_moved is None
or O.last_sites_moved.id() != sites_moved.id()):
O.last_sites_moved = sites_moved
xs = O.fmodels.fmodel_xray().xray_structure
assert len(sites_moved) == xs.scatterers().size()
sites_cart = sites_moved
xs.set_sites_cart(sites_cart=sites_cart)
O.fmodels.update_xray_structure(update_f_calc=True)
xs.scatterers().flags_set_grads(state=False)
xs.scatterers().flags_set_grad_site(
iselection=flex.size_t_range(xs.scatterers().size()))
expected_g_size = len(sites_moved) * 3
if (O.xray_weight_factor is not None):
tg = O.fmodels.target_and_gradients(weights=O.weights,
compute_gradients=True)
O.f = tg.target() * O.xray_weight_factor
O.g = tg.gradients() * O.xray_weight_factor
assert O.g.size() == expected_g_size
else:
O.f = 0.
O.g = flex.double(expected_g_size, 0)
if (O.reduced_geo_manager is None):
reduced_geo_energies = None
else:
reduced_geo_energies = O.reduced_geo_manager.energies_sites(
sites_cart=sites_cart, compute_gradients=True)
other_energies = O.model.restraints_manager.energies_sites(
sites_cart=sites_cart,
geometry_flags=cctbx.geometry_restraints.flags.flags(
nonbonded=True),
custom_nonbonded_function=O.custom_nonbonded_function,
compute_gradients=True)
nfw = other_energies.normalization_factor * O.weights.w
O.f += other_energies.target * O.weights.w
gg = other_energies.gradients * O.weights.w
if (reduced_geo_energies is not None):
O.f += reduced_geo_energies.target * nfw
gg += reduced_geo_energies.gradients * nfw
assert nfw != 0
scale = 1 / nfw
O.last_grms = group_args(geo=scale *
flex.mean_sq(gg.as_double())**0.5,
xray=scale * flex.mean_sq(O.g)**0.5,
real_or_xray="xray")
xray.minimization.add_gradients(scatterers=xs.scatterers(),
xray_gradients=O.g,
site_gradients=gg)
O.f *= scale
O.g *= scale
O.last_grms.total = flex.mean_sq(O.g)**0.5
O.g = flex.vec3_double(O.g)
return O.f
def compute_functional_and_gradients(self):
self.apply_shifts()
self.compute_target(compute_gradients = True)
if(self.verbose > 1):
print "xray.minimization line search: f,rms(g):",
print self.f, math.sqrt(flex.mean_sq(self.g))
return self.f, self.g
def compute_functional_and_gradients(self):
u_iso_refinable_params = self.apply_shifts()
self.compute_target(compute_gradients=True)
self.f = self.target_result.target()
if (self.first_target_value is None):
self.first_target_value = self.f
if (self.occupancy_penalty is not None
and self.grad_flags_counts != 0):
occupancies = self.xray_structure.scatterers().extract_occupancies()
for occupancy in occupancies:
self.f += self.occupancy_penalty.functional(occupancy=occupancy)
self.g = self.structure_factor_gradients(
xray_structure=self.xray_structure,
u_iso_refinable_params=u_iso_refinable_params,
miller_set=self.target_functor.f_obs(),
d_target_d_f_calc=self.target_result.derivatives(),
n_parameters=self.x.size(),
algorithm=self.structure_factor_algorithm).packed()
if (self.occupancy_penalty is not None
and self.grad_flags_counts != 0):
g = flex.double()
for occupancy in occupancies:
g.append(self.occupancy_penalty.gradient(occupancy=occupancy))
del occupancies
add_gradients(
scatterers=self.xray_structure.scatterers(),
xray_gradients=self.g,
occupancy_gradients=g)
del g
if (self.verbose > 1):
print "xray.minimization line search: f,rms(g):",
print self.f, math.sqrt(flex.mean_sq(self.g))
return self.f, self.g
def get_rms_info(O):
if (O.reference_structure is None):
return None
xs = O.xray_structure
rs = O.reference_structure
xf = xs.sites_frac()
rf = rs.sites_frac()
cd = xf - rf
# TODO: use scattering power as weights, move to method of xray.structure
ave_csh = matrix.col(cd.mean())
ave_csh_perp = matrix.col(xs.space_group_info()
.subtract_continuous_allowed_origin_shifts(translation_frac=ave_csh))
caosh_corr = ave_csh_perp - ave_csh
ad = cd + caosh_corr
ud = xs.scatterers().extract_u_iso() \
- rs.scatterers().extract_u_iso()
omx = xs.unit_cell().orthogonalization_matrix()
O.crmsd = (omx * cd).rms_length()
O.armsd = (omx * ad).rms_length()
O.urmsd = flex.mean_sq(ud)**0.5
if (O.params.show_distances_to_reference_structure):
for sc, a, u in zip(xs.scatterers(), omx * ad, ud):
print " %-10s" % sc.label, \
" ".join(["%6.3f" % v for v in a]), \
"%6.3f" % u
return (O.crmsd, O.armsd, O.urmsd)
def get_rms_info(O):
if (O.reference_structure is None):
return None
xs = O.xray_structure
rs = O.reference_structure
xf = xs.sites_frac()
rf = rs.sites_frac()
cd = xf - rf
# TODO: use scattering power as weights, move to method of xray.structure
ave_csh = matrix.col(cd.mean())
ave_csh_perp = matrix.col(xs.space_group_info()
.subtract_continuous_allowed_origin_shifts(translation_frac=ave_csh))
caosh_corr = ave_csh_perp - ave_csh
ad = cd + caosh_corr
ud = xs.scatterers().extract_u_iso() \
- rs.scatterers().extract_u_iso()
omx = xs.unit_cell().orthogonalization_matrix()
O.crmsd = (omx * cd).rms_length()
O.armsd = (omx * ad).rms_length()
O.urmsd = flex.mean_sq(ud)**0.5
if (O.params.show_distances_to_reference_structure):
for sc, a, u in zip(xs.scatterers(), omx * ad, ud):
print " %-10s" % sc.label, \
" ".join(["%6.3f" % v for v in a]), \
"%6.3f" % u
return (O.crmsd, O.armsd, O.urmsd)
def compute_functional_and_gradients(self):
u_iso_refinable_params = self.apply_shifts()
self.compute_target(compute_gradients=True)
self.f = self.target_result.target()
if (self.first_target_value is None):
self.first_target_value = self.f
if (self.occupancy_penalty is not None
and self.grad_flags_counts != 0):
occupancies = self.xray_structure.scatterers().extract_occupancies(
)
for occupancy in occupancies:
self.f += self.occupancy_penalty.functional(
occupancy=occupancy)
self.g = self.structure_factor_gradients(
xray_structure=self.xray_structure,
u_iso_refinable_params=u_iso_refinable_params,
miller_set=self.target_functor.f_obs(),
d_target_d_f_calc=self.target_result.derivatives(),
n_parameters=self.x.size(),
algorithm=self.structure_factor_algorithm).packed()
if (self.occupancy_penalty is not None
and self.grad_flags_counts != 0):
g = flex.double()
for occupancy in occupancies:
g.append(self.occupancy_penalty.gradient(occupancy=occupancy))
del occupancies
add_gradients(scatterers=self.xray_structure.scatterers(),
xray_gradients=self.g,
occupancy_gradients=g)
del g
if (self.verbose > 1):
print "xray.minimization line search: f,rms(g):",
print self.f, math.sqrt(flex.mean_sq(self.g))
return self.f, self.g
def compute_functional_and_gradients(self):
u_iso_refinable_params = self.apply_shifts()
self.compute_target(compute_gradients = True,
u_iso_refinable_params = u_iso_refinable_params)
if (self.verbose > 1):
print "xray.minimization line search: f,rms(g):",
print self.f, math.sqrt(flex.mean_sq(self.g))
return self.f, self.g
def compute_functional_and_gradients(self):
u_iso_refinable_params = self.apply_shifts()
self.compute_target(compute_gradients = True,
u_iso_refinable_params = u_iso_refinable_params)
if (self.verbose > 1):
print("xray.minimization line search: f,rms(g):", end=' ')
print(self.f, math.sqrt(flex.mean_sq(self.g)))
return self.f, self.g
def __init__(O, curvs, lim_eps):
c_pos = curvs.select(curvs > 0)
O.c_lim = flex.max_default(c_pos, default=0) * lim_eps
if (O.c_lim == 0):
O.c_lim = 1
O.c_rms = 1
else:
O.c_rms = flex.mean_sq(c_pos)**0.5
O.n_below_limit = 0
O.n_above_limit = 0
def __init__(O, curvs, lim_eps):
c_pos = curvs.select(curvs > 0)
O.c_lim = flex.max_default(c_pos, default=0) * lim_eps
if (O.c_lim == 0):
O.c_lim = 1
O.c_rms = 1
else:
O.c_rms = flex.mean_sq(c_pos)**0.5
O.n_below_limit = 0
O.n_above_limit = 0
def calcskew(self, map_coeff, iparams):
real_map = map_coeff.fft_map().real_map()
ed_limit = iparams.fit_params.ed_sigma_thres*real_map.sample_standard_deviation()
ed_limit_up=ed_limit
ed_limit_dn=ed_limit*-1
#truncate the electron density beyond sigma limit
real_map.set_selected(real_map>ed_limit_up,ed_limit_up)
real_map.set_selected(real_map<ed_limit_dn,ed_limit_dn)
skew = flex.mean(flex.pow(real_map,3))/pow(flex.mean_sq(real_map),3/2)
return skew
def compute_functional_and_gradients(self):
u_iso_refinable_params = self.apply_shifts()
self.compute_target(compute_gradients=True)
self.f = self.target_result.target()
gradients = self.structure_factor_gradients(
xray_structure=self.xray_structure,
u_iso_refinable_params=u_iso_refinable_params,
miller_set=self.target_functor.f_obs(),
d_target_d_f_calc=self.target_result.derivatives(),
n_parameters=0, # so the gradients aren't packed
algorithm=self.structure_factor_algorithm)
if self.scatterer_grad_flags_counts.site:
d_target_d_site_frac = gradients.d_target_d_site_frac()
if self.scatterer_grad_flags_counts.u_iso:
d_target_d_u_iso = gradients.d_target_d_u_iso()
if self.scatterer_grad_flags_counts.u_aniso:
d_target_d_u_star = gradients.d_target_d_u_star()
if self.scatterer_grad_flags_counts.fp:
d_target_d_fp = gradients.d_target_d_fp()
if self.scatterer_grad_flags_counts.fdp:
d_target_d_fdp = gradients.d_target_d_fdp()
if self.scatterer_grad_flags_counts.occupancy:
d_target_d_occupancy = gradients.d_target_d_occupancy()
# pack the gradients ourselves - currently the constraints system assumes
# we are refining fractional coordinates and u_star
self.g = flex.double()
for i, sc in enumerate(self.xray_structure.scatterers()):
if sc.flags.grad_site():
for j in range(3):
self.g.append(d_target_d_site_frac[i][j])
if sc.flags.use_u_iso() and sc.flags.grad_u_iso():
self.g.append(d_target_d_u_iso[i])
if sc.flags.use_u_aniso() and sc.flags.grad_u_aniso():
for j in range(6):
self.g.append(d_target_d_u_star[i][j])
if sc.flags.grad_occupancy():
self.g.append(d_target_d_occupancy[i])
if sc.flags.grad_fp():
self.g.append(d_target_d_fp[i])
if sc.flags.grad_fdp():
self.g.append(d_target_d_fdp[i])
if self.verbose > 0:
print "xray.minimization line search: f,rms(g):",
print self.f, math.sqrt(flex.mean_sq(self.g))
jacobian = self.reparametrisation.jacobian_transpose_matching_grad_fc()
self.g = jacobian * self.g
return self.f, self.g
def compute_functional_and_gradients(self):
u_iso_refinable_params = self.apply_shifts()
self.compute_target(compute_gradients=True)
self.f = self.target_result.target()
gradients = self.structure_factor_gradients(
xray_structure=self.xray_structure,
u_iso_refinable_params=u_iso_refinable_params,
miller_set=self.target_functor.f_obs(),
d_target_d_f_calc=self.target_result.derivatives(),
n_parameters=0, # so the gradients aren't packed
algorithm=self.structure_factor_algorithm)
if self.scatterer_grad_flags_counts.site:
d_target_d_site_frac = gradients.d_target_d_site_frac()
if self.scatterer_grad_flags_counts.u_iso:
d_target_d_u_iso = gradients.d_target_d_u_iso()
if self.scatterer_grad_flags_counts.u_aniso:
d_target_d_u_star = gradients.d_target_d_u_star()
if self.scatterer_grad_flags_counts.fp:
d_target_d_fp = gradients.d_target_d_fp()
if self.scatterer_grad_flags_counts.fdp:
d_target_d_fdp = gradients.d_target_d_fdp()
if self.scatterer_grad_flags_counts.occupancy:
d_target_d_occupancy = gradients.d_target_d_occupancy()
# pack the gradients ourselves - currently the constraints system assumes
# we are refining fractional coordinates and u_star
self.g = flex.double()
for i, sc in enumerate(self.xray_structure.scatterers()):
if sc.flags.grad_site():
for j in range(3):
self.g.append(d_target_d_site_frac[i][j])
if sc.flags.use_u_iso() and sc.flags.grad_u_iso():
self.g.append(d_target_d_u_iso[i])
if sc.flags.use_u_aniso() and sc.flags.grad_u_aniso():
for j in range(6):
self.g.append(d_target_d_u_star[i][j])
if sc.flags.grad_occupancy():
self.g.append(d_target_d_occupancy[i])
if sc.flags.grad_fp():
self.g.append(d_target_d_fp[i])
if sc.flags.grad_fdp():
self.g.append(d_target_d_fdp[i])
if self.verbose > 0:
print "xray.minimization line search: f,rms(g):",
print self.f, math.sqrt(flex.mean_sq(self.g))
jacobian = self.reparametrisation.jacobian_transpose_matching_grad_fc()
self.g = jacobian * self.g
return self.f, self.g
def update_fgc(O, is_iterate=False):
if (len(O.xfgc_infos) != 0):
prev_xfgc = O.xfgc_infos[-1]
if (prev_xfgc.x.all_eq(O.x)):
if (not prev_xfgc.is_iterate):
prev_xfgc.is_iterate = is_iterate
return
tg = O.__unpack_variables_get_tg()
assert tg.target_work() is not None
gact = O.xray_structure.grads_and_curvs_target_simple(
miller_indices=O.f_obs.indices(),
da_db=tg.gradients_work(),
daa_dbb_dab=tg.hessians_work())
O.funcl = tg.target_work()
O.grads = gact.grads.select(O.gact_indices)
O.curvs = gact.curvs.select(O.gact_indices)
O.grads_mean_sq = flex.mean_sq(O.grads)
O.xfgc_infos.append(xfgc_info(work_obj=O, is_iterate=is_iterate))
def update_fgc(O, is_iterate=False):
if (len(O.xfgc_infos) != 0):
prev_xfgc = O.xfgc_infos[-1]
if (prev_xfgc.x.all_eq(O.x)):
if (not prev_xfgc.is_iterate):
prev_xfgc.is_iterate = is_iterate
return
tg = O.__unpack_variables_get_tg()
assert tg.target_work() is not None
gact = O.xray_structure.grads_and_curvs_target_simple(
miller_indices=O.f_obs.indices(),
da_db=tg.gradients_work(),
daa_dbb_dab=tg.hessians_work())
O.funcl = tg.target_work()
O.grads = gact.grads.select(O.gact_indices)
O.curvs = gact.curvs.select(O.gact_indices)
O.grads_mean_sq = flex.mean_sq(O.grads)
O.xfgc_infos.append(xfgc_info(work_obj=O, is_iterate=is_iterate))
def get_rms_info(O):
if (O.reference_structure is None):
return None
xs = O.xray_structure
rs = O.reference_structure
xf = xs.sites_frac()
rf = rs.sites_frac()
# TODO: use scattering power as weights, move to method of xray.structure
ave_csh = matrix.col((xf - rf).mean())
ave_csh_perp = matrix.col(
xs.space_group_info().subtract_continuous_allowed_origin_shifts(
translation_frac=ave_csh))
caosh_corr = ave_csh - ave_csh_perp
omx = xs.unit_cell().orthogonalization_matrix()
O.crmsd = (omx * (rf - xf)).rms_length()
O.armsd = (omx * (rf - xf + caosh_corr)).rms_length()
O.urmsd = flex.mean_sq(xs.scatterers().extract_u_iso() -
rs.scatterers().extract_u_iso())**0.5
return (O.crmsd, O.armsd, O.urmsd)
def get_rms_info(O):
if (O.reference_structure is None):
return None
xs = O.xray_structure
rs = O.reference_structure
xf = xs.sites_frac()
rf = rs.sites_frac()
# TODO: use scattering power as weights, move to method of xray.structure
ave_csh = matrix.col((xf-rf).mean())
ave_csh_perp = matrix.col(xs.space_group_info()
.subtract_continuous_allowed_origin_shifts(translation_frac=ave_csh))
caosh_corr = ave_csh - ave_csh_perp
omx = xs.unit_cell().orthogonalization_matrix()
O.crmsd = (omx * (rf - xf)).rms_length()
O.armsd = (omx * (rf - xf + caosh_corr)).rms_length()
O.urmsd = flex.mean_sq(
xs.scatterers().extract_u_iso()
- rs.scatterers().extract_u_iso())**0.5
return (O.crmsd, O.armsd, O.urmsd)
def show_f_g(label, f, g):
print >> out, label, "f, |g|:", f, flex.mean_sq(g)**0.5
def show_f_g(label, f, g):
print(label, "f, |g|:", f, flex.mean_sq(g)**0.5, file=out)
def show_f_g(label, f, g): print >> out, label, "f, |g|:", f, flex.mean_sq(g)**0.5
def run_coordinate_refinement(
geometry_restraints_manager,
selection_variable,
density_map,
real_space_gradients_delta,
work_params,
pdb_atoms=None,
sites_cart=None,
home_restraints_list=[],
work_scatterers=None,
unit_cell=None,
d_min=None,
weight_map=None,
write_pdb_callback=None,
log=None):
assert [pdb_atoms, sites_cart].count(None)==1
if (log is None): log = null_out()
if (work_scatterers is not None):
assert unit_cell is not None
assert d_min is not None
best_info = None
if (pdb_atoms is not None):
sites_cart_start = pdb_atoms.extract_xyz()
site_labels = [atom.id_str() for atom in pdb_atoms]
else:
sites_cart_start = sites_cart
site_labels = None
grmp = geometry_restraints_manager_plus(
manager=geometry_restraints_manager,
home_sites_cart=sites_cart_start,
home_restraints_list=home_restraints_list)
print >> log, "Before coordinate refinement:"
grmp.energies_sites(sites_cart=sites_cart_start).show(f=log)
print >> log
log.flush()
rstw_params = work_params.coordinate_refinement.real_space_target_weights
if (rstw_params.number_of_samples is None):
rstw_list = [work_params.real_space_target_weight]
else:
rstw_list = [rstw_params.first_sample + i * rstw_params.sampling_step
for i in xrange(rstw_params.number_of_samples)]
lbfgs_termination_params = scitbx.lbfgs.termination_parameters(
max_iterations=work_params.coordinate_refinement
.lbfgs_max_iterations)
lbfgs_exception_handling_params = \
scitbx.lbfgs.exception_handling_parameters(
ignore_line_search_failed_step_at_lower_bound=True)
bond_rmsd_list = []
for rstw in rstw_list:
refined = maptbx.real_space_refinement_simple.lbfgs(
sites_cart=sites_cart_start,
density_map=density_map,
weight_map=weight_map,
selection_variable=selection_variable,
geometry_restraints_manager=grmp,
real_space_target_weight=rstw,
real_space_gradients_delta=real_space_gradients_delta,
local_standard_deviations_radius=
work_params.local_standard_deviations_radius,
weight_map_scale_factor=work_params.weight_map_scale_factor,
lbfgs_termination_params=lbfgs_termination_params,
lbfgs_exception_handling_params=lbfgs_exception_handling_params)
print >> log, "After coordinate refinement" \
" with real-space target weight %.1f:" % rstw
grmp.energies_sites(sites_cart=refined.sites_cart).show(f=log)
bond_proxies = grmp.pair_proxies().bond_proxies
bond_proxies.show_sorted(
by_value="residual",
sites_cart=refined.sites_cart,
site_labels=site_labels,
f=log,
prefix=" ",
max_items=3)
print >> log
print >> log, " number_of_function_evaluations:", \
refined.number_of_function_evaluations
print >> log, " real+geo target start: %.6g" % refined.f_start
print >> log, " real+geo target final: %.6g" % refined.f_final
deltas = bond_proxies.deltas(sites_cart=refined.sites_cart)
deltas_abs = flex.abs(deltas)
deltas_abs_sorted = deltas_abs.select(
flex.sort_permutation(deltas_abs), reverse=True)
wabr_params = rstw_params.worst_acceptable_bond_rmsd
acceptable = (
flex.mean_default(deltas_abs_sorted[:wabr_params.pool_size],0)
< wabr_params.max_pool_average)
if(deltas.size()>0):
bond_rmsd = flex.mean_sq(deltas)**0.5
else: bond_rmsd=0
bond_rmsd_list.append(bond_rmsd)
print >> log, " Bond RMSD: %.3f" % bond_rmsd
#
if (work_scatterers is None):
region_cc = None
else:
region_cc = maptbx.region_density_correlation(
large_unit_cell=unit_cell,
large_d_min=d_min,
large_density_map=density_map,
sites_cart=refined.sites_cart_variable,
site_radii=flex.double(refined.sites_cart_variable.size(), 1),
work_scatterers=work_scatterers)
#
rmsd_diff = abs(rstw_params.bond_rmsd_target - bond_rmsd)
if ( best_info is None
or best_info.rmsd_diff > rmsd_diff
and (acceptable or not best_info.acceptable)):
best_info = group_args(
rstw=rstw,
refined=refined,
acceptable=acceptable,
rmsd_diff=rmsd_diff,
region_cc=region_cc,
sites_cart=refined.sites_cart)
print >> log
if (best_info is not None):
print >> log, "Table of real-space target weights vs. bond RMSD:"
print >> log, " weight RMSD"
for w,d in zip(rstw_list, bond_rmsd_list):
print >> log, " %6.1f %5.3f" % (w,d)
print >> log, "Best real-space target weight: %.1f" % best_info.rstw
print >> log, \
"Associated refined final value: %.6g" % best_info.refined.f_final
if (best_info.region_cc is not None):
print >> log, "Associated region correlation: %.4f" % best_info.region_cc
print >> log
if (pdb_atoms is not None):
pdb_atoms.set_xyz(new_xyz=refined.sites_cart)
if (write_pdb_callback is not None):
write_pdb_callback(situation="after_best_weight_determination")
#
fgm_params = work_params.coordinate_refinement \
.finishing_geometry_minimization
if (fgm_params.cycles_max is not None and fgm_params.cycles_max > 0):
print >> log, "As previously obtained with target weight %.1f:" \
% best_info.rstw
grmp.energies_sites(sites_cart=refined.sites_cart).show(
f=log, prefix=" ")
print >> log, "Finishing refinement to idealize geometry:"
print >> log, " number of function"
print >> log, " weight evaluations cycle RMSD"
number_of_fgm_cycles = 0
rstw = best_info.rstw * fgm_params.first_weight_scale
sites_cart_start = best_info.refined.sites_cart.deep_copy()
for i_cycle in xrange(fgm_params.cycles_max):
fgm_refined = maptbx.real_space_refinement_simple.lbfgs(
sites_cart=sites_cart_start,
density_map=density_map,
selection_variable=selection_variable,
geometry_restraints_manager=grmp,
energies_sites_flags=cctbx.geometry_restraints.flags.flags(
default=True, dihedral=fgm_params.dihedral_restraints),
real_space_target_weight=rstw,
real_space_gradients_delta=real_space_gradients_delta,
local_standard_deviations_radius=
work_params.local_standard_deviations_radius,
weight_map_scale_factor=work_params.weight_map_scale_factor,
lbfgs_termination_params=lbfgs_termination_params,
lbfgs_exception_handling_params=lbfgs_exception_handling_params)
cycle_rmsd = sites_cart_start.rms_difference(fgm_refined.sites_cart)
print >> log, " %6.1f %10d %6.3f" % (
rstw, fgm_refined.number_of_function_evaluations, cycle_rmsd)
number_of_fgm_cycles += 1
rstw *= fgm_params.cycle_weight_multiplier
if (cycle_rmsd < 1.e-4):
break
if (fgm_params.superpose_cycle_end_with_cycle_start):
fit = scitbx.math.superpose.least_squares_fit(
reference_sites=best_info.refined.sites_cart,
other_sites=fgm_refined.sites_cart)
fgm_refined.sites_cart = fit.other_sites_best_fit()
sites_cart_start = fgm_refined.sites_cart.deep_copy()
print >> log, "After %d refinements to idealize geometry:" % (
number_of_fgm_cycles)
grmp.energies_sites(sites_cart=fgm_refined.sites_cart).show(
f=log, prefix=" ")
if (work_scatterers is None):
fgm_region_cc = None
else:
fgm_region_cc = maptbx.region_density_correlation(
large_unit_cell=unit_cell,
large_d_min=d_min,
large_density_map=density_map,
sites_cart=fgm_refined.sites_cart_variable,
site_radii=flex.double(fgm_refined.sites_cart_variable.size(), 1),
work_scatterers=work_scatterers)
print >> log, " Associated region correlation: %.4f" % fgm_region_cc
print >> log
best_info.fgm_refined = fgm_refined
best_info.fgm_region_cc = fgm_region_cc
if (pdb_atoms is not None):
pdb_atoms.set_xyz(new_xyz=fgm_refined.sites_cart)
best_info.sites_cart = fgm_refined.sites_cart
if (write_pdb_callback is not None):
write_pdb_callback(situation="after_finishing_geo_min")
else:
best_info.fgm_refined = None
best_info.fgm_region_cc = None
return best_info
def exercise_statistics():
import scitbx.math
for flex_type in flex_types():
a = flex_type(flex.grid((3,5)))
s = maptbx.statistics(a)
assert s.min() == 0
assert s.max() == 0
assert s.mean() == 0
assert s.mean_sq() == 0
assert s.sigma() == 0
a = flex_type([random.random() for i in xrange(3*5)])
a.resize(flex.grid((3,5)))
s = maptbx.statistics(a)
assert approx_equal(flex.min(a), s.min())
assert approx_equal(flex.max(a), s.max())
assert approx_equal(flex.mean(a), s.mean())
assert approx_equal(flex.mean_sq(a), s.mean_sq())
assert approx_equal(flex.mean_sq(a)-flex.mean(a)**2, s.sigma()**2)
b = flex_type(flex.grid((4,6)).set_focus((3,5)))
for i in xrange(3):
for j in xrange(5):
b[(i,j)] = a[(i,j)]
b[(3,5)] = -1
b[(2,5)] = 2
b.resize(flex.grid((-2,3), (2,9)).set_focus((1,8)))
t = maptbx.statistics(b)
assert not_approx_equal(flex.min(b), t.min())
assert not_approx_equal(flex.max(b), t.max())
assert not_approx_equal(flex.mean(b), t.mean())
assert not_approx_equal(flex.mean_sq(b), t.mean_sq())
assert not_approx_equal(flex.mean_sq(b)-flex.mean(b)**2, t.sigma()**2)
assert approx_equal(s.min(), t.min())
assert approx_equal(s.max(), t.max())
assert approx_equal(s.mean(), t.mean())
assert approx_equal(s.mean_sq(), t.mean_sq())
assert approx_equal(s.sigma(), t.sigma())
a = flex.double(flex.grid(5,3))
s = maptbx.more_statistics(a)
assert s.min() == 0
assert s.max() == 0
assert s.mean() == 0
assert s.mean_sq() == 0
assert s.sigma() == 0
assert s.skewness() == 0
assert s.kurtosis() == 0
a = flex.random_double(5*3)
reference = scitbx.math.basic_statistics(a)
a.resize(flex.grid(5,3))
s = maptbx.more_statistics(a)
assert approx_equal(s.min(), reference.min)
assert approx_equal(s.max(), reference.max)
assert approx_equal(s.mean(), reference.mean)
assert approx_equal(s.sigma(), reference.biased_standard_deviation)
assert approx_equal(s.skewness(), reference.skew)
assert approx_equal(s.kurtosis(), reference.kurtosis)
b = flex.double(flex.grid((6,4)).set_focus((5,3)))
for i in xrange(5):
for j in xrange(3):
b[(i,j)] = a[(i,j)]
b[(5,3)] = -1
b[(5,2)] = 2
b.resize(flex.grid((3,-2), (9,2)).set_focus((8,1)))
t = maptbx.statistics(b)
assert approx_equal(s.min(), reference.min)
assert approx_equal(s.max(), reference.max)
assert approx_equal(s.mean(), reference.mean)
assert approx_equal(s.sigma(), reference.biased_standard_deviation)
assert approx_equal(s.skewness(), reference.skew)
assert approx_equal(s.kurtosis(), reference.kurtosis)
m = flex.double(flex.grid((6,4,8)).set_focus((5,3,7)))
