def __init__(self,
xray_structure,
obs_,
exti=None,
connectivity_table=None):
if exti is None:
exti = xray.dummy_extinction_correction()
adopt_init_args(self, locals())
assert obs_.fo_sq.anomalous_flag()
assert not (obs_.twin_fractions and obs_.merohedral_components)
xray_structure = xray_structure.deep_copy_scatterers()
for sc in xray_structure.scatterers():
f = xray.scatterer_flags()
f.set_use_u_aniso(sc.flags.use_u_aniso())
f.set_use_u_iso(sc.flags.use_u_iso())
f.set_use_fp_fdp(True)
sc.flags = f
twin_fractions = ()
it = xray.twin_component(sgtbx.rot_mx((-1, 0, 0, 0, -1, 0, 0, 0, -1)),
0.2, True)
twin_components = (it, )
obs = observations.customized_copy(obs_, twin_fractions,
twin_components)
# reparameterisation needs all fractions
twin_fractions += twin_components
if connectivity_table is None:
connectivity_table = smtbx.utils.connectivity_table(xray_structure)
reparametrisation = constraints.reparametrisation(
xray_structure, [],
connectivity_table,
twin_fractions=twin_fractions,
extinction=exti)
normal_eqns = least_squares.crystallographic_ls(obs, reparametrisation)
cycles = normal_eqns_solving.naive_iterations(normal_eqns,
n_max_iterations=10,
gradient_threshold=1e-7,
step_threshold=1e-4)
self.flack_x = it.value
self.sigma_x = math.sqrt(
normal_eqns.covariance_matrix(
jacobian_transpose=reparametrisation.
jacobian_transpose_matching(
reparametrisation.mapping_to_grad_fc_independent_scalars))
[0])
def __init__(self, xray_structure, obs_, exti=None, connectivity_table=None):
if exti is None:
exti = xray.dummy_extinction_correction()
adopt_init_args(self, locals())
assert obs_.fo_sq.anomalous_flag()
xray_structure = xray_structure.deep_copy_scatterers()
flags = xray_structure.scatterer_flags()
for sc in xray_structure.scatterers():
f = xray.scatterer_flags()
f.set_use_u_aniso(sc.flags.use_u_aniso())
f.set_use_u_iso(sc.flags.use_u_iso())
f.set_use_fp_fdp(True)
sc.flags = f
twin_fractions = obs_.twin_fractions
twin_components = obs_.merohedral_components
for tw in twin_fractions: tw.grad = False
for tc in twin_components: tc.grad = False
it = xray.twin_component(sgtbx.rot_mx((-1,0,0,0,-1,0,0,0,-1)), 0.2, True)
twin_components += (it,)
obs = observations.customized_copy(obs_, twin_fractions, twin_components)
# reparameterisation needs all fractions
twin_fractions += twin_components
if connectivity_table is None:
connectivity_table = smtbx.utils.connectivity_table(xray_structure)
reparametrisation = constraints.reparametrisation(
xray_structure, [], connectivity_table,
twin_fractions=twin_fractions,
extinction=exti
)
normal_eqns = least_squares.crystallographic_ls(obs,
reparametrisation)
cycles = normal_eqns_solving.naive_iterations(
normal_eqns, n_max_iterations=10,
gradient_threshold=1e-7,
step_threshold=1e-4)
self.flack_x = it.value
self.sigma_x = math.sqrt(normal_eqns.covariance_matrix(
jacobian_transpose=reparametrisation.jacobian_transpose_matching(
reparametrisation.mapping_to_grad_fc_independent_scalars))[0])
def build_up(self, objective_only=False):
if self.f_mask is not None:
f_mask = self.f_mask.data()
else:
f_mask = flex.complex_double()
extinction_correction = self.reparametrisation.extinction
if extinction_correction is None:
extinction_correction = xray.dummy_extinction_correction()
def build_normal_eqns(scale_factor, weighting_scheme,
objective_only):
return ext.build_normal_equations(
self, self.observations, f_mask, weighting_scheme,
scale_factor, self.one_h_linearisation,
self.reparametrisation.jacobian_transpose_matching_grad_fc(
), extinction_correction, objective_only,
self.may_parallelise)
if not self.finalised: #i.e. never been called
self.reparametrisation.linearise()
self.reparametrisation.store()
scale_factor = self.initial_scale_factor
if scale_factor is None: # we haven't got one from previous refinement
result = build_normal_eqns(
scale_factor=None,
weighting_scheme=sigma_weighting(),
objective_only=True)
scale_factor = self.scale_factor()
else: # use scale factor from the previous step
scale_factor = self.scale_factor()
self.reset()
result = build_normal_eqns(scale_factor, self.weighting_scheme,
objective_only)
self.f_calc = self.observations.fo_sq.array(data=result.f_calc(),
sigmas=None)
self.fc_sq = self.observations.fo_sq.array(
data=result.observables(), sigmas=None)\
.set_observation_type_xray_intensity()
self.weights = result.weights()
self.objective_data_only = self.objective()
self.chi_sq_data_only = self.chi_sq()
if self.restraints_manager is not None:
# Here we determine a normalisation factor to place the restraints on the
# same scale as the average residual. This is the normalisation
# factor suggested in Giacovazzo and similar to that used by shelxl.
# (shelx manual, page 5-1).
# The factor 2 comes from the fact that we minimize 1/2 sum w delta^2
if self.restraints_normalisation_factor is None:
self.restraints_normalisation_factor \
= 2 * self.objective_data_only/(self.n_equations-self.n_parameters)
linearised_eqns = self.restraints_manager.build_linearised_eqns(
self.xray_structure,
self.reparametrisation.parameter_map())
jacobian = \
self.reparametrisation.jacobian_transpose_matching(
self.reparametrisation.mapping_to_grad_fc_all).transpose()
self.reduced_problem().add_equations(
linearised_eqns.deltas,
linearised_eqns.design_matrix * jacobian,
linearised_eqns.weights *
self.restraints_normalisation_factor,
optimise_for_tall_matrix=False)
self.n_restraints = linearised_eqns.n_restraints()
self.chi_sq_data_and_restraints = self.chi_sq()
if not objective_only:
self.origin_fixing_restraint.add_to(
self.step_equations(),
self.reparametrisation.jacobian_transpose_matching_grad_fc(
), self.reparametrisation.asu_scatterer_parameters)
def build_up(self, objective_only=False):
if self.f_mask is not None:
f_mask = self.f_mask.data()
else:
f_mask = flex.complex_double()
extinction_correction = self.reparametrisation.extinction
if extinction_correction is None:
extinction_correction = xray.dummy_extinction_correction()
def args(scale_factor, weighting_scheme, objective_only):
args = (self,
self.observations,
f_mask,
weighting_scheme,
scale_factor,
self.one_h_linearisation,
self.reparametrisation.jacobian_transpose_matching_grad_fc(),
extinction_correction
)
if objective_only:
args += (True,)
return args
if not self.finalised: #i.e. never been called
self.reparametrisation.linearise()
self.reparametrisation.store()
scale_factor = self.initial_scale_factor
if scale_factor is None: # we haven't got one from previous refinement
result = ext.build_normal_equations(
*args(scale_factor=None, weighting_scheme=sigma_weighting(),
objective_only=True))
scale_factor = self.scale_factor()
else: # use scale factor from the previous step
scale_factor = self.scale_factor()
self.reset()
result = ext.build_normal_equations(*args(scale_factor,
self.weighting_scheme,
objective_only))
self.f_calc = self.observations.fo_sq.array(
data=result.f_calc(), sigmas=None)
self.fc_sq = self.observations.fo_sq.array(
data=result.observables(), sigmas=None)\
.set_observation_type_xray_intensity()
self.weights = result.weights()
self.objective_data_only = self.objective()
self.chi_sq_data_only = self.chi_sq()
if self.restraints_manager is not None:
# Here we determine a normalisation factor to place the restraints on the
# same scale as the average residual. This is the normalisation
# factor suggested in Giacovazzo and similar to that used by shelxl.
# (shelx manual, page 5-1).
# The factor 2 comes from the fact that we minimize 1/2 sum w delta^2
if self.restraints_normalisation_factor is None:
self.restraints_normalisation_factor \
= 2 * self.objective_data_only/(self.n_equations-self.n_parameters)
linearised_eqns = self.restraints_manager.build_linearised_eqns(
self.xray_structure, self.reparametrisation.parameter_map())
jacobian = \
self.reparametrisation.jacobian_transpose_matching(
self.reparametrisation.mapping_to_grad_fc_all).transpose()
self.reduced_problem().add_equations(
linearised_eqns.deltas,
linearised_eqns.design_matrix * jacobian,
linearised_eqns.weights * self.restraints_normalisation_factor)
self.n_restraints = linearised_eqns.n_restraints()
self.chi_sq_data_and_restraints = self.chi_sq()
if not objective_only:
self.origin_fixing_restraint.add_to(
self.step_equations(),
self.reparametrisation.jacobian_transpose_matching_grad_fc(),
self.reparametrisation.asu_scatterer_parameters)