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)