def lsq_scale(names, miller_arrays, xray_structure, parameters, out):
if parameters.input_data_1 is None:
raise Sorry("Please define input_data_1")
if parameters.input_data_2 is None:
raise Sorry("Please define input_data_2")
input_data_1 = None
input_data_2 = None
if names.has_key(parameters.input_data_1):
input_data_1 = miller_arrays[names[
parameters.input_data_1]].deep_copy()
else:
raise Sorry("Unknown data name: >>%s<<" % (parameters.input_data_1))
if names.has_key(parameters.input_data_2):
input_data_2 = miller_arrays[names[
parameters.input_data_2]].deep_copy()
else:
raise Sorry("Unknown data name: >>%s<<" % (parameters.input_data_2))
scaler = relative_scaling.ls_rel_scale_driver(
miller_native=input_data_1,
miller_derivative=input_data_2,
use_intensities=parameters.use_intensities,
scale_weight=parameters.scale_weight,
use_weights=parameters.use_weights)
#
scaler.show(out=out)
return scaler.scaled_original_derivative.deep_copy()
def lsq_scale(names, miller_arrays, xray_structure, parameters, out):
if parameters.input_data_1 is None:
raise Sorry("Please define input_data_1")
if parameters.input_data_2 is None:
raise Sorry("Please define input_data_2")
input_data_1 = None
input_data_2 = None
if names.has_key( parameters.input_data_1 ):
input_data_1 = miller_arrays[ names[parameters.input_data_1] ].deep_copy()
else:
raise Sorry("Unknown data name: >>%s<<"%(parameters.input_data_1) )
if names.has_key( parameters.input_data_2 ):
input_data_2 = miller_arrays[ names[parameters.input_data_2] ].deep_copy()
else:
raise Sorry("Unknown data name: >>%s<<"%(parameters.input_data_2) )
scaler = relative_scaling.ls_rel_scale_driver(
miller_native = input_data_1,
miller_derivative = input_data_2,
use_intensities = parameters.use_intensities,
scale_weight = parameters.scale_weight,
use_weights = parameters.use_weights)
#
scaler.show(out=out)
return scaler.scaled_original_derivative.deep_copy()
def perform_least_squares_scaling(self):
print >> self.out
print >> self.out, "Least squares scaling"
print >> self.out, "---------------------"
print >> self.out
##-----Get options-----
use_exp_sigmas=self.lsq_options.use_experimental_sigmas
use_int = True
if self.lsq_options.scale_data=='amplitudes':
use_int=False
use_wt=True
if self.lsq_options.scale_target == 'basic':
use_wt=False
##-------------------------------------------
ls_scaling = relative_scaling.ls_rel_scale_driver(
self.x1,
self.x2,
use_intensities=use_int,
scale_weight=use_wt,
use_weights=use_exp_sigmas)
ls_scaling.show(out=self.out)
##----- Update the miller arrays please-------
self.x1 = ls_scaling.native.deep_copy()
self.x2 = ls_scaling.derivative.deep_copy()
def perform_least_squares_scaling(self):
print >> self.out
print >> self.out, "Least squares scaling"
print >> self.out, "---------------------"
print >> self.out
##-----Get options-----
use_exp_sigmas = self.lsq_options.use_experimental_sigmas
use_int = True
if self.lsq_options.scale_data == 'amplitudes':
use_int = False
use_wt = True
if self.lsq_options.scale_target == 'basic':
use_wt = False
##-------------------------------------------
ls_scaling = relative_scaling.ls_rel_scale_driver(
self.x1,
self.x2,
use_intensities=use_int,
scale_weight=use_wt,
use_weights=use_exp_sigmas)
ls_scaling.show(out=self.out)
##----- Update the miller arrays please-------
self.x1 = ls_scaling.native.deep_copy()
self.x2 = ls_scaling.derivative.deep_copy()
def get_diso(names, miller_arrays, xray_structure, parameters, out):
#first scale please
if parameters.native is None:
raise Sorry("Please define native data name")
if parameters.derivative is None:
raise Sorry("Please define derivative data name")
native=None
derivative=None
if names.has_key( parameters.native ):
native = miller_arrays[ names[parameters.native] ].deep_copy()
else:
raise Sorry("Unknown data name: >>%s<<"%(parameters.native) )
if names.has_key( parameters.derivative ):
derivative = miller_arrays[ names[parameters.derivative] ].deep_copy()
else:
raise Sorry("Unknown data name: >>%s<<"%(parameters.derivative) )
scaler = relative_scaling.ls_rel_scale_driver(
miller_native = native,
miller_derivative = derivative,
use_intensities = parameters.use_intensities,
scale_weight = parameters.scale_weight,
use_weights = parameters.use_weights)
#
scaler.show(out=out)
if native.is_xray_intensity_array():
native = native.f_sq_as_f()
if derivative.is_xray_intensity_array():
derivative = derivative.f_sq_as_f()
delta_gen = pair_analyses.delta_generator( derivative,
native )
deltas = delta_gen.delta_f.deep_copy()
return deltas
def get_diso(names, miller_arrays, xray_structure, parameters, out):
#first scale please
if parameters.native is None:
raise Sorry("Please define native data name")
if parameters.derivative is None:
raise Sorry("Please define derivative data name")
native = None
derivative = None
if names.has_key(parameters.native):
native = miller_arrays[names[parameters.native]].deep_copy()
else:
raise Sorry("Unknown data name: >>%s<<" % (parameters.native))
if names.has_key(parameters.derivative):
derivative = miller_arrays[names[parameters.derivative]].deep_copy()
else:
raise Sorry("Unknown data name: >>%s<<" % (parameters.derivative))
scaler = relative_scaling.ls_rel_scale_driver(
miller_native=native,
miller_derivative=derivative,
use_intensities=parameters.use_intensities,
scale_weight=parameters.scale_weight,
use_weights=parameters.use_weights)
#
scaler.show(out=out)
if native.is_xray_intensity_array():
native = native.f_sq_as_f()
if derivative.is_xray_intensity_array():
derivative = derivative.f_sq_as_f()
delta_gen = pair_analyses.delta_generator(derivative, native)
deltas = delta_gen.delta_f.deep_copy()
return deltas
def compute_map_coefficients(self):
f_obs = self.f_obs_complete.select(
self.f_obs_complete.d_spacings().data() >= self.d_min)
f_calc = f_obs.structure_factors_from_map(self.map, use_sg=True)
f_obs_active = f_obs.select_indices(self.active_indices)
minimized = relative_scaling.ls_rel_scale_driver(
f_obs_active,
f_calc.as_amplitude_array().select_indices(self.active_indices),
use_intensities=False,
use_weights=False)
#minimized.show()
f_calc = f_calc.customized_copy(data=f_calc.data()\
* math.exp(-minimized.p_scale)\
* adptbx.debye_waller_factor_u_star(
f_calc.indices(), minimized.u_star))
f_calc_active = f_calc.common_set(f_obs_active)
matched_indices = f_obs.match_indices(self.f_obs_active)
lone_indices_selection = matched_indices.single_selection(0)
from mmtbx.max_lik import maxlik
alpha_beta_est = maxlik.alpha_beta_est_manager(
f_obs=f_obs_active,
f_calc=f_calc_active,
free_reflections_per_bin=140,
flags=flex.bool(f_obs_active.size()),
interpolation=True,
epsilons=f_obs_active.epsilons().data().as_double())
alpha, beta = alpha_beta_est.alpha_beta_for_each_reflection(
f_obs=self.f_obs_complete.select(
self.f_obs_complete.d_spacings().data() >= self.d_min))
f_obs.data().copy_selected(lone_indices_selection.iselection(),
flex.abs(f_calc.data()))
t = maxlik.fo_fc_alpha_over_eps_beta(f_obs=f_obs,
f_model=f_calc,
alpha=alpha,
beta=beta)
hl_coeff = flex.hendrickson_lattman(
t * flex.cos(f_calc.phases().data()),
t * flex.sin(f_calc.phases().data()))
dd = alpha.data()
#
hl_array = f_calc.array(
data=self.hl_coeffs_start.common_set(f_calc).data() + hl_coeff)
self.compute_phase_source(hl_array)
fom = flex.abs(self.phase_source.data())
mFo = hl_array.array(data=f_obs.data() * self.phase_source.data())
DFc = hl_array.array(data=dd *
f_calc.as_amplitude_array().phase_transfer(
self.phase_source).data())
centric_flags = f_obs.centric_flags().data()
acentric_flags = ~centric_flags
fo_scale = flex.double(centric_flags.size())
fc_scale = flex.double(centric_flags.size())
fo_scale.set_selected(acentric_flags, 2)
fo_scale.set_selected(centric_flags, 1)
fc_scale.set_selected(acentric_flags, 1)
fc_scale.set_selected(centric_flags, 0)
fo_scale.set_selected(lone_indices_selection, 0)
fc_scale.set_selected(lone_indices_selection, -1)
self.map_coeffs = hl_array.array(data=mFo.data() * fo_scale -
DFc.data() * fc_scale)
self.fom = hl_array.array(data=fom)
self.hl_coeffs = hl_array
# statistics
self.r1_factor = f_obs_active.r1_factor(f_calc_active)
fom = fom.select(matched_indices.pair_selection(0))
self.r1_factor_fom = flex.sum(
fom * flex.abs(f_obs_active.data() - f_calc_active.as_amplitude_array().data())) \
/ flex.sum(fom * f_obs_active.data())
phase_source, phase_source_previous = self.phase_source.common_sets(
self.phase_source_previous)
self.mean_delta_phi = phase_error(
flex.arg(phase_source.data()),
flex.arg(phase_source_previous.data()))
phase_source, phase_source_initial = self.phase_source.common_sets(
self.phase_source_initial)
self.mean_delta_phi_initial = phase_error(
flex.arg(phase_source.data()),
flex.arg(phase_source_initial.data()))
self.mean_fom = flex.mean(fom)
fom = f_obs_active.array(data=fom)
if fom.data().size() < 1000: # 2013-12-14 was hard-wired at 1000 tt
reflections_per_bin = fom.data().size()
else:
reflections_per_bin = 1000
fom.setup_binner(reflections_per_bin=reflections_per_bin)
self.mean_fom_binned = fom.mean(use_binning=True)
def compute_map_coefficients(self):
f_obs = self.f_obs_complete.select(self.f_obs_complete.d_spacings().data() >= self.d_min)
f_calc = f_obs.structure_factors_from_map(self.map, use_sg=True)
f_obs_active = f_obs.select_indices(self.active_indices)
minimized = relative_scaling.ls_rel_scale_driver(
f_obs_active,
f_calc.as_amplitude_array().select_indices(self.active_indices),
use_intensities=False,
use_weights=False)
#minimized.show()
f_calc = f_calc.customized_copy(data=f_calc.data()\
* math.exp(-minimized.p_scale)\
* adptbx.debye_waller_factor_u_star(
f_calc.indices(), minimized.u_star))
f_calc_active = f_calc.common_set(f_obs_active)
matched_indices = f_obs.match_indices(self.f_obs_active)
lone_indices_selection = matched_indices.single_selection(0)
from mmtbx.max_lik import maxlik
alpha_beta_est = maxlik.alpha_beta_est_manager(
f_obs=f_obs_active,
f_calc=f_calc_active,
free_reflections_per_bin=140,
flags=flex.bool(f_obs_active.size()),
interpolation=True,
epsilons=f_obs_active.epsilons().data().as_double())
alpha, beta = alpha_beta_est.alpha_beta_for_each_reflection(
f_obs=self.f_obs_complete.select(self.f_obs_complete.d_spacings().data() >= self.d_min))
f_obs.data().copy_selected(
lone_indices_selection.iselection(), flex.abs(f_calc.data()))
t = maxlik.fo_fc_alpha_over_eps_beta(
f_obs=f_obs,
f_model=f_calc,
alpha=alpha,
beta=beta)
hl_coeff = flex.hendrickson_lattman(
t * flex.cos(f_calc.phases().data()),
t * flex.sin(f_calc.phases().data()))
dd = alpha.data()
#
hl_array = f_calc.array(
data=self.hl_coeffs_start.common_set(f_calc).data()+hl_coeff)
self.compute_phase_source(hl_array)
fom = flex.abs(self.phase_source.data())
mFo = hl_array.array(data=f_obs.data()*self.phase_source.data())
DFc = hl_array.array(data=dd*f_calc.as_amplitude_array().phase_transfer(
self.phase_source).data())
centric_flags = f_obs.centric_flags().data()
acentric_flags = ~centric_flags
fo_scale = flex.double(centric_flags.size())
fc_scale = flex.double(centric_flags.size())
fo_scale.set_selected(acentric_flags, 2)
fo_scale.set_selected(centric_flags, 1)
fc_scale.set_selected(acentric_flags, 1)
fc_scale.set_selected(centric_flags, 0)
fo_scale.set_selected(lone_indices_selection, 0)
fc_scale.set_selected(lone_indices_selection, -1)
self.map_coeffs = hl_array.array(
data=mFo.data()*fo_scale - DFc.data()*fc_scale)
self.fom = hl_array.array(data=fom)
self.hl_coeffs = hl_array
# statistics
self.r1_factor = f_obs_active.r1_factor(f_calc_active)
fom = fom.select(matched_indices.pair_selection(0))
self.r1_factor_fom = flex.sum(
fom * flex.abs(f_obs_active.data() - f_calc_active.as_amplitude_array().data())) \
/ flex.sum(fom * f_obs_active.data())
phase_source, phase_source_previous = self.phase_source.common_sets(
self.phase_source_previous)
self.mean_delta_phi = phase_error(
flex.arg(phase_source.data()), flex.arg(phase_source_previous.data()))
phase_source, phase_source_initial = self.phase_source.common_sets(
self.phase_source_initial)
self.mean_delta_phi_initial = phase_error(
flex.arg(phase_source.data()), flex.arg(phase_source_initial.data()))
self.mean_fom = flex.mean(fom)
fom = f_obs_active.array(data=fom)
if fom.data().size()<1000: # 2013-12-14 was hard-wired at 1000 tt
reflections_per_bin=fom.data().size()
else:
reflections_per_bin=1000
fom.setup_binner(reflections_per_bin=reflections_per_bin)
self.mean_fom_binned = fom.mean(use_binning=True)
