def test_1(): tstart = time.time() fraction_missing = 0.1 d_min = 1.5 # create dummy model symmetry = crystal.symmetry(unit_cell=(15.67, 25.37, 35.68, 90, 90, 90), space_group_symbol="P 21 21 21") structure = xray.structure(crystal_symmetry=symmetry) for k in range(1000): scatterer = xray.scatterer( site = ((1.+k*abs(math.sin(k)))/1000.0, (1.+k*abs(math.cos(k)))/1000.0, (1.+ k)/1000.0), u = abs(math.cos(k))*100./(8.*math.pi**2), occupancy = 1.0, scattering_type = "C") structure.add_scatterer(scatterer) # partial model n_keep = int(round(structure.scatterers().size() * (1-fraction_missing))) partial_structure = xray.structure(special_position_settings=structure) partial_structure.add_scatterers(structure.scatterers()[:n_keep]) # fcalc (partial model), fobs (fcalc full model) f_calc = structure.structure_factors(d_min=d_min, anomalous_flag=False).f_calc() f_calc_partial = partial_structure.structure_factors(d_min=d_min, anomalous_flag=False).f_calc() f_obs = abs(f_calc) f_calc= abs(f_calc_partial) d_star_sq = 1./flex.pow2(f_obs.d_spacings().data()) assert approx_equal(flex.max(f_calc.data()),6810.19834824) assert approx_equal(flex.min(f_calc.data()),0.019589341727) assert approx_equal(flex.mean(f_calc.data()),76.651506629) assert approx_equal(flex.max(f_obs.data()),6962.58343229) assert approx_equal(flex.min(f_obs.data()),0.00111552904935) assert approx_equal(flex.mean(f_obs.data()),74.5148786464) assert f_obs.size() == f_calc.size() # define test set reflections flags=flex.bool(f_calc_partial.indices().size(), False) k=0 for i in range(f_calc_partial.indices().size()): k=k+1 if (k !=10): flags[i]=False else: k=0 flags[i]=True assert flags.count(True) == 250 assert flags.count(False) == 2258 assert flags.size() == 2508 # *********************************************************TEST = 1 alpha, beta = maxlik.alpha_beta_est_manager( f_obs = f_obs, f_calc = f_calc, free_reflections_per_bin = 1000, flags = flags, interpolation = False, epsilons = f_obs.epsilons().data().as_double()).alpha_beta() assert alpha.data().size() == beta.data().size() assert alpha.data().size() == f_obs.size() assert approx_equal(flex.min(alpha.data()),0.914152454693) assert approx_equal(flex.max(alpha.data()),0.914152454693) assert approx_equal(flex.min(beta.data()),818.503411782) assert approx_equal(flex.max(beta.data()),818.503411782) # *********************************************************TEST = 2 alpha, beta = maxlik.alpha_beta_est_manager( f_obs = f_obs, f_calc = f_calc, free_reflections_per_bin = 50, flags = flags, interpolation = False, epsilons = f_obs.epsilons().data().as_double()).alpha_beta() assert alpha.data().size() == beta.data().size() assert alpha.data().size() == f_obs.size() assert approx_equal(flex.min(alpha.data()), 0.910350007113) assert approx_equal(flex.max(alpha.data()), 1.07104387776) assert approx_equal(flex.min(beta.data()), 21.7374310013) assert approx_equal(flex.max(beta.data()), 4222.81104745) # *********************************************************TEST = 3 alpha, beta = maxlik.alpha_beta_calc( f = f_obs, n_atoms_absent = 100, n_atoms_included= 900, bf_atoms_absent = 25.0, final_error = 0.0, absent_atom_type = "C").alpha_beta() fom = max_lik.fom_and_phase_error( f_obs = f_obs.data(), f_model = flex.abs(f_calc.data()), alpha = alpha.data(), beta = beta.data(), epsilons = f_obs.epsilons().data().as_double(), centric_flags = f_obs.centric_flags().data()).fom() assert flex.max(fom) <= 1.0 assert flex.min(fom) >= 0.0 assert flex.min(alpha.data()) == flex.max(alpha.data()) == 1.0 assert approx_equal(flex.min(beta.data()),7.964134920) assert approx_equal(flex.max(beta.data()),13695.1589364) # *********************************************************TEST = 4 xs = crystal.symmetry((3,4,5), "P 2 2 2") mi = flex.miller_index(((1,-2,3), (0,0,-4))) ms = miller.set(xs, mi) fc = flex.double((1.,2.)) fo = flex.double((1.,2.)) mso = miller.set(xs, mi) mac = miller.array(ms, fc) mao = miller.array(ms, fo) alp = flex.double(2,0.0) bet = flex.double(2,1e+9) fom = max_lik.fom_and_phase_error( f_obs = mao.data(), f_model = mac.data(), alpha = alp, beta = bet, epsilons = mao.epsilons().data().as_double(), centric_flags = mao.centric_flags().data()).fom() assert approx_equal(fom,[0.0, 0.0]) alp = flex.double(2,1.0) bet = flex.double(2,1e+9) fom = max_lik.fom_and_phase_error( f_obs = mao.data(), f_model = mac.data(), alpha = alp, beta = bet, epsilons = mao.epsilons().data().as_double(), centric_flags = mao.centric_flags().data()).fom() assert approx_equal(fom,[0.0, 0.0]) alp = flex.double(2,0.0) bet = flex.double(2,1e-9) fom = max_lik.fom_and_phase_error( f_obs = mao.data(), f_model = mac.data(), alpha = alp, beta = bet, epsilons = mao.epsilons().data().as_double(), centric_flags = mao.centric_flags().data()).fom() assert approx_equal(fom,[0.0, 0.0]) alp = flex.double(2,1.0) bet = flex.double(2,1e-9) fom = max_lik.fom_and_phase_error( f_obs = mao.data(), f_model = mac.data(), alpha = alp, beta = bet, epsilons = mao.epsilons().data().as_double(), centric_flags = mao.centric_flags().data()).fom() assert approx_equal(fom,[1.0, 1.0])
def test_2(): n_sites = 1000 d_min = 2.0 volume_per_atom = 50 fraction_missing = (0.0,) scale = 5.0 # create dummy model space_group_info = sgtbx.space_group_info("P212121") structure = random_structure.xray_structure( space_group_info = space_group_info, elements = ["N"]*(n_sites), volume_per_atom = volume_per_atom, random_u_iso = False) structure.scattering_type_registry(table="wk1995") f_calc = structure.structure_factors(d_min = d_min, anomalous_flag = False, algorithm = "direct").f_calc() f_obs = abs(f_calc) for fm in fraction_missing: # partial model n_keep = int(round(structure.scatterers().size() * (1-fm))) partial_structure = xray.structure(special_position_settings=structure) partial_structure.add_scatterers(structure.scatterers()[:n_keep]) # fcalc (partial model), fobs (fcalc full model) f_calc_partial = partial_structure.structure_factors(d_min=d_min, anomalous_flag=False, algorithm = "direct").f_calc() f_calc= abs(f_calc_partial) # define test set reflections flags=flex.bool(f_calc_partial.indices().size(), False) k=0 for i in range(f_calc_partial.indices().size()): k=k+1 if (k !=10): flags[i]=False else: k=0 flags[i]=True # *********************************************************TEST = 1 alpha, beta = maxlik.alpha_beta_est_manager( f_obs = f_obs, f_calc = f_calc, free_reflections_per_bin = f_obs.data().size(), flags = flags, interpolation = False, epsilons = f_obs.epsilons().data().as_double()).alpha_beta() assert alpha.size() == beta.size() assert alpha.size() == f_obs.size() assert approx_equal(flex.min(alpha.data()),1.0, 1.e-2) assert approx_equal(flex.max(alpha.data()),1.0, 1.e-2) assert approx_equal(flex.min(beta.data()) ,0.0, 1.e-2) assert approx_equal(flex.max(beta.data()) ,0.0, 1.e-2) alpha, beta = maxlik.alpha_beta_est_manager( f_obs = f_obs, f_calc = f_calc, free_reflections_per_bin = f_obs.data().size(), flags = flags, interpolation = True, epsilons = f_obs.epsilons().data().as_double()).alpha_beta() assert alpha.size() == beta.size() assert alpha.size() == f_obs.size() assert approx_equal(flex.min(alpha.data()),1.0, 1.e-2) assert approx_equal(flex.max(alpha.data()),1.0, 1.e-2) assert approx_equal(flex.min(beta.data()) ,0.0, 1.e-2) assert approx_equal(flex.max(beta.data()) ,0.0, 1.e-2) # *********************************************************TEST = 2 alpha, beta = maxlik.alpha_beta_est_manager( f_obs = miller.array(miller_set = f_obs, data = f_obs.data() * scale), f_calc = f_calc, free_reflections_per_bin = 200, flags = flags, interpolation = False, epsilons = f_obs.epsilons().data().as_double()).alpha_beta() assert alpha.size() == beta.size() assert alpha.size() == f_obs.size() assert approx_equal(flex.min(alpha.data()),1.0/scale, 1.e-2) assert approx_equal(flex.max(alpha.data()),1.0/scale, 1.e-2) assert approx_equal(flex.min(beta.data()) ,0.0, 1.e-2) assert approx_equal(flex.max(beta.data()) ,0.0, 1.e-2) alpha, beta = maxlik.alpha_beta_est_manager( f_obs = miller.array(miller_set = f_obs, data = f_obs.data() * scale), f_calc = f_calc, free_reflections_per_bin = 200, flags = flags, interpolation = True, epsilons = f_obs.epsilons().data().as_double()).alpha_beta() assert alpha.size() == beta.size() assert alpha.size() == f_obs.size() assert approx_equal(flex.min(alpha.data()),1.0/scale, 1.e-2) assert approx_equal(flex.max(alpha.data()),1.0/scale, 1.e-2) assert approx_equal(flex.min(beta.data()) ,0.0, 1.e-2) assert approx_equal(flex.max(beta.data()) ,0.0, 1.e-2) # *********************************************************TEST = 3 alpha, beta = maxlik.alpha_beta_est_manager( f_obs = miller.array(miller_set = f_obs, data = f_obs.data() * scale), f_calc = f_calc, free_reflections_per_bin = 200, flags = flex.bool(f_obs.data().size(), True), interpolation = False, epsilons = f_obs.epsilons().data().as_double()).alpha_beta() assert alpha.size() == beta.size() assert alpha.size() == f_obs.size() assert approx_equal(flex.min(alpha.data()),1.0/scale, 1.e-2) assert approx_equal(flex.max(alpha.data()),1.0/scale, 1.e-2) assert approx_equal(flex.min(beta.data()) ,0.0, 1.e-2) assert approx_equal(flex.max(beta.data()) ,0.0, 1.e-2) alpha, beta = maxlik.alpha_beta_est_manager( f_obs = miller.array(miller_set = f_obs, data = f_obs.data() * scale), f_calc = f_calc, free_reflections_per_bin = 200, flags = flex.bool(f_obs.data().size(), True), interpolation = True, epsilons = f_obs.epsilons().data().as_double()).alpha_beta() assert alpha.size() == beta.size() assert alpha.size() == f_obs.size() assert approx_equal(flex.min(alpha.data()),1.0/scale, 1.e-2) assert approx_equal(flex.max(alpha.data()),1.0/scale, 1.e-2) assert approx_equal(flex.min(beta.data()) ,0.0, 1.e-2) assert approx_equal(flex.max(beta.data()) ,0.0, 1.e-2) # *********************************************************TEST = 4 alpha, beta = maxlik.alpha_beta_est_manager( f_obs = miller.array(miller_set = f_obs, data = f_obs.data() * scale), f_calc = f_calc, free_reflections_per_bin = 200, flags = flex.bool(f_obs.data().size(), False), interpolation = False, epsilons = f_obs.epsilons().data().as_double()).alpha_beta() assert alpha.size() == beta.size() assert alpha.size() == f_obs.size() assert approx_equal(flex.min(alpha.data()),1.0/scale, 1.e-2) assert approx_equal(flex.max(alpha.data()),1.0/scale, 1.e-2) assert approx_equal(flex.min(beta.data()) ,0.0, 1.e-2) assert approx_equal(flex.max(beta.data()) ,0.0, 1.e-2) alpha, beta = maxlik.alpha_beta_est_manager( f_obs = miller.array(miller_set = f_obs, data = f_obs.data() * scale), f_calc = f_calc, free_reflections_per_bin = 200, flags = flex.bool(f_obs.data().size(), False), interpolation = True, epsilons = f_obs.epsilons().data().as_double()).alpha_beta() assert alpha.size() == beta.size() assert alpha.size() == f_obs.size() assert approx_equal(flex.min(alpha.data()),1.0/scale, 1.e-2) assert approx_equal(flex.max(alpha.data()),1.0/scale, 1.e-2) assert approx_equal(flex.min(beta.data()) ,0.0, 1.e-2) assert approx_equal(flex.max(beta.data()) ,0.0, 1.e-2)
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)
def test_1(): tstart = time.time() fraction_missing = 0.1 d_min = 1.5 # create dummy model symmetry = crystal.symmetry(unit_cell=(15.67, 25.37, 35.68, 90, 90, 90), space_group_symbol="P 21 21 21") structure = xray.structure(crystal_symmetry=symmetry) for k in xrange(1000): scatterer = xray.scatterer( site = ((1.+k*abs(math.sin(k)))/1000.0, (1.+k*abs(math.cos(k)))/1000.0, (1.+ k)/1000.0), u = abs(math.cos(k))*100./(8.*math.pi**2), occupancy = 1.0, scattering_type = "C") structure.add_scatterer(scatterer) # partial model n_keep = int(round(structure.scatterers().size() * (1-fraction_missing))) partial_structure = xray.structure(special_position_settings=structure) partial_structure.add_scatterers(structure.scatterers()[:n_keep]) # fcalc (partial model), fobs (fcalc full model) f_calc = structure.structure_factors(d_min=d_min, anomalous_flag=False).f_calc() f_calc_partial = partial_structure.structure_factors(d_min=d_min, anomalous_flag=False).f_calc() f_obs = abs(f_calc) f_calc= abs(f_calc_partial) d_star_sq = 1./flex.pow2(f_obs.d_spacings().data()) assert approx_equal(flex.max(f_calc.data()),6810.19834824) assert approx_equal(flex.min(f_calc.data()),0.019589341727) assert approx_equal(flex.mean(f_calc.data()),76.651506629) assert approx_equal(flex.max(f_obs.data()),6962.58343229) assert approx_equal(flex.min(f_obs.data()),0.00111552904935) assert approx_equal(flex.mean(f_obs.data()),74.5148786464) assert f_obs.size() == f_calc.size() # define test set reflections flags=flex.bool(f_calc_partial.indices().size(), False) k=0 for i in xrange(f_calc_partial.indices().size()): k=k+1 if (k !=10): flags[i]=False else: k=0 flags[i]=True assert flags.count(True) == 250 assert flags.count(False) == 2258 assert flags.size() == 2508 # *********************************************************TEST = 1 alpha, beta = maxlik.alpha_beta_est_manager( f_obs = f_obs, f_calc = f_calc, free_reflections_per_bin = 1000, flags = flags, interpolation = False, epsilons = f_obs.epsilons().data().as_double()).alpha_beta() assert alpha.data().size() == beta.data().size() assert alpha.data().size() == f_obs.size() assert approx_equal(flex.min(alpha.data()),0.914152454693) assert approx_equal(flex.max(alpha.data()),0.914152454693) assert approx_equal(flex.min(beta.data()),818.503411782) assert approx_equal(flex.max(beta.data()),818.503411782) # *********************************************************TEST = 2 alpha, beta = maxlik.alpha_beta_est_manager( f_obs = f_obs, f_calc = f_calc, free_reflections_per_bin = 50, flags = flags, interpolation = False, epsilons = f_obs.epsilons().data().as_double()).alpha_beta() assert alpha.data().size() == beta.data().size() assert alpha.data().size() == f_obs.size() assert approx_equal(flex.min(alpha.data()), 0.910350007113) assert approx_equal(flex.max(alpha.data()), 1.07104387776) assert approx_equal(flex.min(beta.data()), 21.7374310013) assert approx_equal(flex.max(beta.data()), 4222.81104745) # *********************************************************TEST = 3 alpha, beta = maxlik.alpha_beta_calc( f = f_obs, n_atoms_absent = 100, n_atoms_included= 900, bf_atoms_absent = 25.0, final_error = 0.0, absent_atom_type = "C").alpha_beta() fom = max_lik.fom_and_phase_error( f_obs = f_obs.data(), f_model = flex.abs(f_calc.data()), alpha = alpha.data(), beta = beta.data(), epsilons = f_obs.epsilons().data().as_double(), centric_flags = f_obs.centric_flags().data()).fom() assert flex.max(fom) <= 1.0 assert flex.min(fom) >= 0.0 assert flex.min(alpha.data()) == flex.max(alpha.data()) == 1.0 assert approx_equal(flex.min(beta.data()),7.964134920) assert approx_equal(flex.max(beta.data()),13695.1589364) # *********************************************************TEST = 4 xs = crystal.symmetry((3,4,5), "P 2 2 2") mi = flex.miller_index(((1,-2,3), (0,0,-4))) ms = miller.set(xs, mi) fc = flex.double((1.,2.)) fo = flex.double((1.,2.)) mso = miller.set(xs, mi) mac = miller.array(ms, fc) mao = miller.array(ms, fo) alp = flex.double(2,0.0) bet = flex.double(2,1e+9) fom = max_lik.fom_and_phase_error( f_obs = mao.data(), f_model = mac.data(), alpha = alp, beta = bet, epsilons = mao.epsilons().data().as_double(), centric_flags = mao.centric_flags().data()).fom() assert approx_equal(fom,[0.0, 0.0]) alp = flex.double(2,1.0) bet = flex.double(2,1e+9) fom = max_lik.fom_and_phase_error( f_obs = mao.data(), f_model = mac.data(), alpha = alp, beta = bet, epsilons = mao.epsilons().data().as_double(), centric_flags = mao.centric_flags().data()).fom() assert approx_equal(fom,[0.0, 0.0]) alp = flex.double(2,0.0) bet = flex.double(2,1e-9) fom = max_lik.fom_and_phase_error( f_obs = mao.data(), f_model = mac.data(), alpha = alp, beta = bet, epsilons = mao.epsilons().data().as_double(), centric_flags = mao.centric_flags().data()).fom() assert approx_equal(fom,[0.0, 0.0]) alp = flex.double(2,1.0) bet = flex.double(2,1e-9) fom = max_lik.fom_and_phase_error( f_obs = mao.data(), f_model = mac.data(), alpha = alp, beta = bet, epsilons = mao.epsilons().data().as_double(), centric_flags = mao.centric_flags().data()).fom() assert approx_equal(fom,[1.0, 1.0])
def test_2(): n_sites = 1000 d_min = 2.0 volume_per_atom = 50 fraction_missing = (0.0,) scale = 5.0 # create dummy model space_group_info = sgtbx.space_group_info("P212121") structure = random_structure.xray_structure( space_group_info = space_group_info, elements = ["N"]*(n_sites), volume_per_atom = volume_per_atom, random_u_iso = False) structure.scattering_type_registry(table="wk1995") f_calc = structure.structure_factors(d_min = d_min, anomalous_flag = False, algorithm = "direct").f_calc() f_obs = abs(f_calc) for fm in fraction_missing: # partial model n_keep = int(round(structure.scatterers().size() * (1-fm))) partial_structure = xray.structure(special_position_settings=structure) partial_structure.add_scatterers(structure.scatterers()[:n_keep]) # fcalc (partial model), fobs (fcalc full model) f_calc_partial = partial_structure.structure_factors(d_min=d_min, anomalous_flag=False, algorithm = "direct").f_calc() f_calc= abs(f_calc_partial) # define test set reflections flags=flex.bool(f_calc_partial.indices().size(), False) k=0 for i in xrange(f_calc_partial.indices().size()): k=k+1 if (k !=10): flags[i]=False else: k=0 flags[i]=True # *********************************************************TEST = 1 alpha, beta = maxlik.alpha_beta_est_manager( f_obs = f_obs, f_calc = f_calc, free_reflections_per_bin = f_obs.data().size(), flags = flags, interpolation = False, epsilons = f_obs.epsilons().data().as_double()).alpha_beta() assert alpha.size() == beta.size() assert alpha.size() == f_obs.size() assert approx_equal(flex.min(alpha.data()),1.0, 1.e-2) assert approx_equal(flex.max(alpha.data()),1.0, 1.e-2) assert approx_equal(flex.min(beta.data()) ,0.0, 1.e-2) assert approx_equal(flex.max(beta.data()) ,0.0, 1.e-2) alpha, beta = maxlik.alpha_beta_est_manager( f_obs = f_obs, f_calc = f_calc, free_reflections_per_bin = f_obs.data().size(), flags = flags, interpolation = True, epsilons = f_obs.epsilons().data().as_double()).alpha_beta() assert alpha.size() == beta.size() assert alpha.size() == f_obs.size() assert approx_equal(flex.min(alpha.data()),1.0, 1.e-2) assert approx_equal(flex.max(alpha.data()),1.0, 1.e-2) assert approx_equal(flex.min(beta.data()) ,0.0, 1.e-2) assert approx_equal(flex.max(beta.data()) ,0.0, 1.e-2) # *********************************************************TEST = 2 alpha, beta = maxlik.alpha_beta_est_manager( f_obs = miller.array(miller_set = f_obs, data = f_obs.data() * scale), f_calc = f_calc, free_reflections_per_bin = 200, flags = flags, interpolation = False, epsilons = f_obs.epsilons().data().as_double()).alpha_beta() assert alpha.size() == beta.size() assert alpha.size() == f_obs.size() assert approx_equal(flex.min(alpha.data()),1.0/scale, 1.e-2) assert approx_equal(flex.max(alpha.data()),1.0/scale, 1.e-2) assert approx_equal(flex.min(beta.data()) ,0.0, 1.e-2) assert approx_equal(flex.max(beta.data()) ,0.0, 1.e-2) alpha, beta = maxlik.alpha_beta_est_manager( f_obs = miller.array(miller_set = f_obs, data = f_obs.data() * scale), f_calc = f_calc, free_reflections_per_bin = 200, flags = flags, interpolation = True, epsilons = f_obs.epsilons().data().as_double()).alpha_beta() assert alpha.size() == beta.size() assert alpha.size() == f_obs.size() assert approx_equal(flex.min(alpha.data()),1.0/scale, 1.e-2) assert approx_equal(flex.max(alpha.data()),1.0/scale, 1.e-2) assert approx_equal(flex.min(beta.data()) ,0.0, 1.e-2) assert approx_equal(flex.max(beta.data()) ,0.0, 1.e-2) # *********************************************************TEST = 3 alpha, beta = maxlik.alpha_beta_est_manager( f_obs = miller.array(miller_set = f_obs, data = f_obs.data() * scale), f_calc = f_calc, free_reflections_per_bin = 200, flags = flex.bool(f_obs.data().size(), True), interpolation = False, epsilons = f_obs.epsilons().data().as_double()).alpha_beta() assert alpha.size() == beta.size() assert alpha.size() == f_obs.size() assert approx_equal(flex.min(alpha.data()),1.0/scale, 1.e-2) assert approx_equal(flex.max(alpha.data()),1.0/scale, 1.e-2) assert approx_equal(flex.min(beta.data()) ,0.0, 1.e-2) assert approx_equal(flex.max(beta.data()) ,0.0, 1.e-2) alpha, beta = maxlik.alpha_beta_est_manager( f_obs = miller.array(miller_set = f_obs, data = f_obs.data() * scale), f_calc = f_calc, free_reflections_per_bin = 200, flags = flex.bool(f_obs.data().size(), True), interpolation = True, epsilons = f_obs.epsilons().data().as_double()).alpha_beta() assert alpha.size() == beta.size() assert alpha.size() == f_obs.size() assert approx_equal(flex.min(alpha.data()),1.0/scale, 1.e-2) assert approx_equal(flex.max(alpha.data()),1.0/scale, 1.e-2) assert approx_equal(flex.min(beta.data()) ,0.0, 1.e-2) assert approx_equal(flex.max(beta.data()) ,0.0, 1.e-2) # *********************************************************TEST = 4 alpha, beta = maxlik.alpha_beta_est_manager( f_obs = miller.array(miller_set = f_obs, data = f_obs.data() * scale), f_calc = f_calc, free_reflections_per_bin = 200, flags = flex.bool(f_obs.data().size(), False), interpolation = False, epsilons = f_obs.epsilons().data().as_double()).alpha_beta() assert alpha.size() == beta.size() assert alpha.size() == f_obs.size() assert approx_equal(flex.min(alpha.data()),1.0/scale, 1.e-2) assert approx_equal(flex.max(alpha.data()),1.0/scale, 1.e-2) assert approx_equal(flex.min(beta.data()) ,0.0, 1.e-2) assert approx_equal(flex.max(beta.data()) ,0.0, 1.e-2) alpha, beta = maxlik.alpha_beta_est_manager( f_obs = miller.array(miller_set = f_obs, data = f_obs.data() * scale), f_calc = f_calc, free_reflections_per_bin = 200, flags = flex.bool(f_obs.data().size(), False), interpolation = True, epsilons = f_obs.epsilons().data().as_double()).alpha_beta() assert alpha.size() == beta.size() assert alpha.size() == f_obs.size() assert approx_equal(flex.min(alpha.data()),1.0/scale, 1.e-2) assert approx_equal(flex.max(alpha.data()),1.0/scale, 1.e-2) assert approx_equal(flex.min(beta.data()) ,0.0, 1.e-2) assert approx_equal(flex.max(beta.data()) ,0.0, 1.e-2)