Ejemplo n.º 1
0
def test_determine_space_group(space_group):

    sgi = sgtbx.space_group_info(symbol=space_group)
    sg = sgi.group()
    cs = sgi.any_compatible_crystal_symmetry(volume=10000)
    cs = cs.best_cell()
    cs = cs.minimum_cell()
    intensities = (
        generate_intensities(cs, d_min=1.0)
        .generate_bijvoet_mates()
        .set_observation_type_xray_intensity()
    )
    intensities = intensities.expand_to_p1()
    # needed to give vaguely sensible E_cc_true values
    intensities = intensities.customized_copy(sigmas=intensities.data() / 50)
    intensities.set_info(miller.array_info(source="fake", source_type="mtz"))
    result = LaueGroupAnalysis([intensities], normalisation=None)
    print(result)
    assert (
        result.best_solution.subgroup["best_subsym"].space_group()
        == sg.build_derived_patterson_group()
    )
    assert result.best_solution.likelihood > 0.8
    for score in result.subgroup_scores[1:]:
        assert score.likelihood < 0.1
Ejemplo n.º 2
0
def generate_reflections_in_sg(space_group, id_=0, assign_id=False):
    """Generate reflections with intensities consistent with space group"""
    sgi = sgtbx.space_group_info(symbol=space_group)
    cs = sgi.any_compatible_crystal_symmetry(volume=3000)
    cs = cs.best_cell()
    cs = cs.minimum_cell()
    intensities = (
        generate_intensities(cs, d_min=2.0)
        .generate_bijvoet_mates()
        .set_observation_type_xray_intensity()
    )
    intensities = intensities.expand_to_p1()
    # needed to give vaguely sensible E_cc_true values
    reflections = flex.reflection_table()
    reflections["intensity.sum.value"] = intensities.data()
    reflections["intensity.sum.variance"] = flex.pow2(intensities.sigmas())
    reflections["miller_index"] = intensities.indices()
    reflections["d"] = intensities.d_spacings().data()
    reflections["id"] = flex.int(reflections.size(), id_)
    if assign_id:
        reflections.experiment_identifiers()[id_] = str(id_)
    reflections.set_flags(
        flex.bool(reflections.size(), True), reflections.flags.integrated
    )
    return reflections
Ejemplo n.º 3
0
def generate_fake_intensities(crystal_symmetry):
    intensities = (generate_intensities(crystal_symmetry,
                                        d_min=1.0).generate_bijvoet_mates().
                   set_observation_type_xray_intensity())
    intensities = intensities.expand_to_p1()
    # needed to give vaguely sensible E_cc_true values
    intensities = intensities.customized_copy(sigmas=intensities.data() / 50)
    intensities.set_info(miller.array_info(source="fake", source_type="mtz"))
    return intensities
Ejemplo n.º 4
0
def test_score_symmetry_element_subgroup(space_group):
    sgi = sgtbx.space_group_info(symbol=space_group)
    cs = sgi.any_compatible_crystal_symmetry(volume=10000)
    cs = cs.best_cell()
    cs = cs.minimum_cell()
    intensities = (
        generate_intensities(cs, d_min=1.0)
        .generate_bijvoet_mates()
        .set_observation_type_xray_intensity()
    )
    intensities = intensities.expand_to_p1()

    subgroups = metric_subgroups(
        intensities.crystal_symmetry(), max_delta=2.0, bravais_types_only=False
    )
    intensities = intensities.change_basis(subgroups.cb_op_inp_minimum)
    cs = cs.change_basis(subgroups.cb_op_inp_minimum)

    cb_op_inp_best = subgroups.result_groups[0]["cb_op_inp_best"]
    lattice_group = subgroups.result_groups[0]["best_subsym"].space_group()
    lattice_group = lattice_group.change_basis(cb_op_inp_best.inverse())

    lattice_group = subgroups.result_groups[0]["subsym"].space_group()

    sym_op_scores = []
    for sym_op in lattice_group.smx():
        if sym_op.r().info().sense() < 0:
            continue
        score = ScoreSymmetryElement(intensities, sym_op, 1.0, 1.0)
        sym_op_scores.append(score)
        if sym_op in cs.space_group():
            assert score.likelihood > 0.9
            assert score.cc.coefficient() > 0.9
        else:
            assert score.likelihood < 0.2
            assert score.cc.coefficient() < 0.3

    subgroup_scores = [
        ScoreSubGroup(subgrp, sym_op_scores) for subgrp in subgroups.result_groups
    ]
    total_likelihood = sum(score.likelihood for score in subgroup_scores)
    for score in subgroup_scores:
        score.likelihood /= total_likelihood
    true_patterson_group = (
        cs.space_group_info()
        .as_reference_setting()
        .group()
        .build_derived_patterson_group()
    )
    for score in subgroup_scores:
        if score.subgroup["best_subsym"].space_group() == true_patterson_group:
            assert score.likelihood > 0.8
        else:
            assert score.likelihood < 0.1