def direct_space_squaring(start, selection_fixed):
    map_gridding = miller.index_span(
        miller.set.expand_to_p1(start).indices()).map_grid()
    if (selection_fixed is None):
        fixed = start
        var = start
    else:
        fixed = start.select(selection_fixed)
        var = start.select(~selection_fixed)
    rfft = fftpack.real_to_complex_3d([n * 3 // 2 for n in map_gridding])
    conjugate_flag = True
    structure_factor_map = maptbx.structure_factors.to_map(
        space_group=fixed.space_group(),
        anomalous_flag=fixed.anomalous_flag(),
        miller_indices=fixed.indices(),
        structure_factors=fixed.data(),
        n_real=rfft.n_real(),
        map_grid=flex.grid(rfft.n_complex()),
        conjugate_flag=conjugate_flag)
    real_map = rfft.backward(structure_factor_map.complex_map())
    squared_map = flex.pow2(real_map)
    squared_sf_map = rfft.forward(squared_map)
    allow_miller_indices_outside_map = False
    from_map = maptbx.structure_factors.from_map(
        anomalous_flag=var.anomalous_flag(),
        miller_indices=var.indices(),
        complex_map=squared_sf_map,
        conjugate_flag=conjugate_flag,
        allow_miller_indices_outside_map=allow_miller_indices_outside_map)
    if (selection_fixed is None):
        return from_map.data()
    result = start.data().deep_copy()
    result.set_selected(~selection_fixed, from_map.data())
    assert result.select(selection_fixed).all_eq(fixed.data())
    return result
Exemple #2
0
    def generate_cif(crystal, refiner, filename):
        logger.info("Saving CIF information to %s", filename)
        from cctbx import miller
        import iotbx.cif.model

        block = iotbx.cif.model.block()
        block["_audit_creation_method"] = dials_version()
        block["_audit_creation_date"] = datetime.date.today().isoformat()
        #   block["_publ_section_references"] = '' # once there is a reference...

        for cell, esd, cifname in zip(
            crystal.get_unit_cell().parameters(),
            crystal.get_cell_parameter_sd(),
            [
                "length_a",
                "length_b",
                "length_c",
                "angle_alpha",
                "angle_beta",
                "angle_gamma",
            ],
        ):
            block["_cell_%s" % cifname] = format_float_with_standard_uncertainty(
                cell, esd
            )
        block["_cell_volume"] = format_float_with_standard_uncertainty(
            crystal.get_unit_cell().volume(), crystal.get_cell_volume_sd()
        )

        used_reflections = refiner.get_matches()
        block["_cell_measurement_reflns_used"] = len(used_reflections)
        block["_cell_measurement_theta_min"] = (
            flex.min(used_reflections["2theta_obs.rad"]) * 180 / math.pi / 2
        )
        block["_cell_measurement_theta_max"] = (
            flex.max(used_reflections["2theta_obs.rad"]) * 180 / math.pi / 2
        )
        block["_diffrn_reflns_number"] = len(used_reflections)
        miller_span = miller.index_span(used_reflections["miller_index"])
        min_h, min_k, min_l = miller_span.min()
        max_h, max_k, max_l = miller_span.max()
        block["_diffrn_reflns_limit_h_min"] = min_h
        block["_diffrn_reflns_limit_h_max"] = max_h
        block["_diffrn_reflns_limit_k_min"] = min_k
        block["_diffrn_reflns_limit_k_max"] = max_k
        block["_diffrn_reflns_limit_l_min"] = min_l
        block["_diffrn_reflns_limit_l_max"] = max_l
        block["_diffrn_reflns_theta_min"] = (
            flex.min(used_reflections["2theta_obs.rad"]) * 180 / math.pi / 2
        )
        block["_diffrn_reflns_theta_max"] = (
            flex.max(used_reflections["2theta_obs.rad"]) * 180 / math.pi / 2
        )

        cif = iotbx.cif.model.cif()
        cif["two_theta_refine"] = block
        with open(filename, "w") as fh:
            cif.show(out=fh)
    def generate_mmcif(crystal, refiner, filename):
        logger.info("Saving mmCIF information to %s", filename)

        block = iotbx.cif.model.block()
        block["_audit.revision_id"] = 1
        block["_audit.creation_method"] = dials_version()
        block["_audit.creation_date"] = datetime.date.today().isoformat()
        block["_entry.id"] = "two_theta_refine"
        #   block["_publ.section_references"] = '' # once there is a reference...

        block["_cell.entry_id"] = "two_theta_refine"
        for cell, esd, cifname in zip(
                crystal.get_unit_cell().parameters(),
                crystal.get_cell_parameter_sd(),
            [
                "length_a",
                "length_b",
                "length_c",
                "angle_alpha",
                "angle_beta",
                "angle_gamma",
            ],
        ):
            block["_cell.%s" % cifname] = "%.8f" % cell
            block["_cell.%s_esd" % cifname] = "%.8f" % esd
        block["_cell.volume"] = "%f" % crystal.get_unit_cell().volume()
        block["_cell.volume_esd"] = "%f" % crystal.get_cell_volume_sd()

        used_reflections = refiner.get_matches()
        block["_cell_measurement.entry_id"] = "two_theta_refine"
        block["_cell_measurement.reflns_used"] = len(used_reflections)
        block["_cell_measurement.theta_min"] = (
            flex.min(used_reflections["2theta_obs.rad"]) * 180 / math.pi / 2)
        block["_cell_measurement.theta_max"] = (
            flex.max(used_reflections["2theta_obs.rad"]) * 180 / math.pi / 2)
        block["_exptl_crystal.id"] = 1
        block["_diffrn.id"] = "two_theta_refine"
        block["_diffrn.crystal_id"] = 1
        block["_diffrn_reflns.diffrn_id"] = "two_theta_refine"
        block["_diffrn_reflns.number"] = len(used_reflections)
        miller_span = miller.index_span(used_reflections["miller_index"])
        min_h, min_k, min_l = miller_span.min()
        max_h, max_k, max_l = miller_span.max()
        block["_diffrn_reflns.limit_h_min"] = min_h
        block["_diffrn_reflns.limit_h_max"] = max_h
        block["_diffrn_reflns.limit_k_min"] = min_k
        block["_diffrn_reflns.limit_k_max"] = max_k
        block["_diffrn_reflns.limit_l_min"] = min_l
        block["_diffrn_reflns.limit_l_max"] = max_l
        block["_diffrn_reflns.theta_min"] = (
            flex.min(used_reflections["2theta_obs.rad"]) * 180 / math.pi / 2)
        block["_diffrn_reflns.theta_max"] = (
            flex.max(used_reflections["2theta_obs.rad"]) * 180 / math.pi / 2)

        cif = iotbx.cif.model.cif()
        cif["two_theta_refine"] = block
        with open(filename, "w") as fh:
            cif.show(out=fh)
def exercise_index_span():
  miller_indices = flex.miller_index(((1,-2,3), (-3,5,0)))
  s = miller.index_span(miller_indices)
  assert s.min() == (-3,-2,0)
  assert s.max() == (1,5,3)
  assert s.abs_range() == (4,6,4)
  assert s.map_grid() == (7,11,7)
  assert s.is_in_domain((-1,2,1))
  assert not s.is_in_domain((0,6,0))
  assert tuple(s.pack(miller_indices)) == (131, 28)
Exemple #5
0
def exercise_index_span():
  miller_indices = flex.miller_index(((1,-2,3), (-3,5,0)))
  s = miller.index_span(miller_indices)
  assert s.min() == (-3,-2,0)
  assert s.max() == (1,5,3)
  assert s.abs_range() == (4,6,4)
  assert s.map_grid() == (7,11,7)
  assert s.is_in_domain((-1,2,1))
  assert not s.is_in_domain((0,6,0))
  assert tuple(s.pack(miller_indices)) == (131, 28)
Exemple #6
0
    def generate_mmcif(crystal, refiner, file):
        logger.info('Saving mmCIF information to %s' % file)
        from cctbx import miller
        import datetime
        import iotbx.cif.model
        import math

        block = iotbx.cif.model.block()
        block["_audit.creation_method"] = dials_version()
        block["_audit.creation_date"] = datetime.date.today().isoformat()
        #   block["_publ.section_references"] = '' # once there is a reference...

        for cell, esd, cifname in zip(
                crystal.get_unit_cell().parameters(),
                crystal.get_cell_parameter_sd(), [
                    'length_a', 'length_b', 'length_c', 'angle_alpha',
                    'angle_beta', 'angle_gamma'
                ]):
            block['_cell.%s' % cifname] = "%.8f" % cell
            block['_cell.%s_esd' % cifname] = "%.8f" % esd
        block['_cell.volume'] = "%f" % crystal.get_unit_cell().volume()
        block['_cell.volume_esd'] = "%f" % crystal.get_cell_volume_sd()

        used_reflections = refiner.get_matches()
        block['_cell_measurement.reflns_used'] = len(used_reflections)
        block['_cell_measurement.theta_min'] = flex.min(
            used_reflections['2theta_obs.rad']) * 180 / math.pi / 2
        block['_cell_measurement.theta_max'] = flex.max(
            used_reflections['2theta_obs.rad']) * 180 / math.pi / 2
        block['_diffrn_reflns.number'] = len(used_reflections)
        miller_span = miller.index_span(used_reflections['miller_index'])
        min_h, min_k, min_l = miller_span.min()
        max_h, max_k, max_l = miller_span.max()
        block['_diffrn_reflns.limit_h_min'] = min_h
        block['_diffrn_reflns.limit_h_max'] = max_h
        block['_diffrn_reflns.limit_k_min'] = min_k
        block['_diffrn_reflns.limit_k_max'] = max_k
        block['_diffrn_reflns.limit_l_min'] = min_l
        block['_diffrn_reflns.limit_l_max'] = max_l
        block['_diffrn_reflns.theta_min'] = flex.min(
            used_reflections['2theta_obs.rad']) * 180 / math.pi / 2
        block['_diffrn_reflns.theta_max'] = flex.max(
            used_reflections['2theta_obs.rad']) * 180 / math.pi / 2

        cif = iotbx.cif.model.cif()
        cif['two_theta_refine'] = block
        with open(file, 'w') as fh:
            cif.show(out=fh)
Exemple #7
0
  def generate_mmcif(crystal, refiner, file):
    logger.info('Saving mmCIF information to %s' % file)
    from cctbx import miller
    import datetime
    import iotbx.cif.model
    import math

    block = iotbx.cif.model.block()
    block["_audit.creation_method"] = dials_version()
    block["_audit.creation_date"] = datetime.date.today().isoformat()
#   block["_publ.section_references"] = '' # once there is a reference...

    for cell, esd, cifname in zip(crystal.get_unit_cell().parameters(),
                                  crystal.get_cell_parameter_sd(),
                                  ['length_a', 'length_b', 'length_c', 'angle_alpha', 'angle_beta', 'angle_gamma']):
      block['_cell.%s' % cifname] = "%.8f" % cell
      block['_cell.%s_esd' % cifname] = "%.8f" % esd
    block['_cell.volume'] = "%f" % crystal.get_unit_cell().volume()
    block['_cell.volume_esd'] = "%f" % crystal.get_cell_volume_sd()

    used_reflections = refiner.get_matches()
    block['_cell_measurement.reflns_used'] = len(used_reflections)
    block['_cell_measurement.theta_min'] = flex.min(used_reflections['2theta_obs.rad']) * 180 / math.pi / 2
    block['_cell_measurement.theta_max'] = flex.max(used_reflections['2theta_obs.rad']) * 180 / math.pi / 2
    block['_diffrn_reflns.number'] = len(used_reflections)
    miller_span = miller.index_span(used_reflections['miller_index'])
    min_h, min_k, min_l = miller_span.min()
    max_h, max_k, max_l = miller_span.max()
    block['_diffrn_reflns.limit_h_min'] = min_h
    block['_diffrn_reflns.limit_h_max'] = max_h
    block['_diffrn_reflns.limit_k_min'] = min_k
    block['_diffrn_reflns.limit_k_max'] = max_k
    block['_diffrn_reflns.limit_l_min'] = min_l
    block['_diffrn_reflns.limit_l_max'] = max_l
    block['_diffrn_reflns.theta_min'] = flex.min(used_reflections['2theta_obs.rad']) * 180 / math.pi / 2
    block['_diffrn_reflns.theta_max'] = flex.max(used_reflections['2theta_obs.rad']) * 180 / math.pi / 2

    cif = iotbx.cif.model.cif()
    cif['two_theta_refine'] = block
    with open(file, 'w') as fh:
      cif.show(out=fh)
def direct_space_squaring(start, selection_fixed):
    map_gridding = miller.index_span(miller.set.expand_to_p1(start).indices()).map_grid()
    if selection_fixed is None:
        fixed = start
        var = start
    else:
        fixed = start.select(selection_fixed)
        var = start.select(~selection_fixed)
    rfft = fftpack.real_to_complex_3d([n * 3 // 2 for n in map_gridding])
    conjugate_flag = True
    structure_factor_map = maptbx.structure_factors.to_map(
        space_group=fixed.space_group(),
        anomalous_flag=fixed.anomalous_flag(),
        miller_indices=fixed.indices(),
        structure_factors=fixed.data(),
        n_real=rfft.n_real(),
        map_grid=flex.grid(rfft.n_complex()),
        conjugate_flag=conjugate_flag,
    )
    real_map = rfft.backward(structure_factor_map.complex_map())
    squared_map = flex.pow2(real_map)
    squared_sf_map = rfft.forward(squared_map)
    allow_miller_indices_outside_map = False
    from_map = maptbx.structure_factors.from_map(
        anomalous_flag=var.anomalous_flag(),
        miller_indices=var.indices(),
        complex_map=squared_sf_map,
        conjugate_flag=conjugate_flag,
        allow_miller_indices_outside_map=allow_miller_indices_outside_map,
    )
    if selection_fixed is None:
        return from_map.data()
    result = start.data().deep_copy()
    result.set_selected(~selection_fixed, from_map.data())
    assert result.select(selection_fixed).all_eq(fixed.data())
    return result
Exemple #9
0
def run(args):
    assert args in [[], ["python"], ["c++"]]
    #
    sgno_list_by_index_list_by_cs = {}
    from cctbx import sgtbx
    from cctbx import miller
    for symbols in sgtbx.space_group_symbol_iterator():
        psgi = sgtbx.space_group_info(symbols.universal_hermann_mauguin()) \
          .primitive_setting()
        p_indices = miller.index_generator(space_group_type=psgi.type(),
                                           anomalous_flag=False,
                                           max_index=[4] * 3).to_array()
        # 4 is the smallest value leading to correct results; any larger
        # value will work, too, but will make this procedure slower
        p1_indices = miller.expand_to_p1_iselection(
            space_group=psgi.group(),
            anomalous_flag=False,
            indices=p_indices,
            build_iselection=False).indices
        from cctbx.array_family import flex
        sort_perm = flex.sort_permutation(
            data=miller.index_span(p1_indices).pack(p1_indices))
        p1_indices = p1_indices.select(sort_perm)
        index_list = tuple(p1_indices)
        sgno = psgi.type().number()
        sgno_list_by_index_list = sgno_list_by_index_list_by_cs \
          .setdefault(symbols.crystal_system(), {})
        sgno_list_by_index_list.setdefault(index_list, []).append(sgno)
    from scitbx.graph import tardy_tree
    cluster_manager = tardy_tree.cluster_manager(n_vertices=231)
    for cs, sgno_list_by_index_list in sgno_list_by_index_list_by_cs.items():
        for sgno_list in sgno_list_by_index_list.values():
            i = sgno_list[0]
            for j in sgno_list[1:]:
                cluster_manager.connect_vertices(i=i, j=j, optimize=True)
    cluster_manager.tidy()
    #
    # everything below is just to format the results
    #
    if (args == []):
        for cluster in cluster_manager.clusters:
            if (len(cluster) == 1): break
            print(cluster)
    else:
        note = ("""\
Output of: cctbx/examples/find_sys_abs_equiv_space_groups.py %s
If you have to edit this table, please send email to: [email protected]
""" % args[0]).splitlines()
        #
        if (args == ["python"]):
            print("space_group_numbers = [")
            for line in note:
                print("  #", line)
            ci = cluster_manager.cluster_indices
            cl = cluster_manager.clusters
            for sgno in range(231):
                cluster = list(cl[ci[sgno]])
                cluster.remove(sgno)
                if (len(cluster) == 0): s = "None"
                else: s = str(tuple(cluster))
                if (sgno == 230): comma = ""
                else: comma = ","
                print("  %s%s" % (s, comma))
            print("]")
        else:
            print("""\
#ifndef CCTBX_SGTBX_SYS_ABS_EQUIV_H
#define CCTBX_SGTBX_SYS_ABS_EQUIV_H

namespace cctbx { namespace sgtbx { namespace sys_abs_equiv {
""")
            data = []
            ci = cluster_manager.cluster_indices
            cl = cluster_manager.clusters
            for line in note:
                print("  //", line)
            for sgno in range(231):
                cluster = list(cl[ci[sgno]])
                cluster.remove(sgno)
                if (len(cluster) == 0):
                    data.append("0")
                else:
                    cid = "data_%03d" % sgno
                    data.append(cid)
                    print("  static const unsigned %s[] = {%d, %s};" %
                          (cid, len(cluster), ", ".join(
                              [str(i) for i in cluster])))
            print("")
            print("  static const unsigned* space_group_numbers[] = {")
            print("   ", ",\n    ".join(data))
            print("""\
    };

}}}

#endif // GUARD""")
def show_split_stats(stream, nindexed, symm, params, anoref=None, ref=None, out_prefix="out", start_at=0):
    random.seed(params.random_seed)
    nstep = nindexed // params.nsplit

    out = open(out_prefix + ".dat", "w")

    out_byres = open(out_prefix + "_byres.dat", "w")
    print >>out_byres, ("%"+str(len(str(nindexed)))+"s")%"nframes",
    print >>out_byres, "dmin  dmax   red  cmpl acmpl  rsplit    rano   cc1/2   ccano  snr  rano/split CCanoref CCref"

    #formatstr_for_eachout = out_prefix+"_to%."+str(len(str(nindexed)))+"d_byres.dat"
    #indices1, iobs1, sel1 = [], [], []
    #indices2, iobs2, sel2 = [], [], []

    indices1, indices2 = flex.miller_index(), flex.miller_index()
    iobs1, iobs2 = flex.double(), flex.double()
    sel1, sel2 = flex.bool(), flex.bool()

    print >>out, "   nframes     red  Rsplit    Rano   CC1/2   CCano  snr  Rano/Rsplit CCanoref CCref"

    chunks = read_stream(stream, start_at)

    for i in xrange(params.nsplit):
        e = (i+1)*nstep
        if i == params.nsplit-1: e = nindexed

        read_all = (i == params.nsplit-1)

        slc = []
        for j, c in enumerate(chunks):
            sys.stderr.write("\rprocessed: %d" % (i*nstep+j))
            sys.stderr.flush()
            slc.append(c)
            if not read_all and j >= nstep-1:
                break
            if nindexed <= i*nstep+j:
                break

        if params.halve_method == "alternate":
            slc1 = slc[0::2]
            slc2 = slc[1::2]
        elif params.halve_method == "random":
            perm = range(len(slc))
            random.shuffle(perm)
            nhalf = len(slc)//2
            slc1 = [slc[r] for r in perm[:nhalf]]
            slc2 = [slc[r] for r in perm[nhalf:]]
        else:
            raise "Not-supported:", params.halve_method

        i1, o1, s1 = [], [], []
        for x in slc1:
            i1.extend(x.indices)
            o1.extend(x.iobs)
            if params.adu_cutoff is not None:
                s1.extend((a <= params.adu_cutoff for a in x.peak))

        i2, o2, s2 = [], [], []
        for x in slc2:
            i2.extend(x.indices)
            o2.extend(x.iobs)
            if params.adu_cutoff is not None:
                s2.extend((a <= params.adu_cutoff for a in x.peak))

        # Concatenate and sort
        indices1 = indices1.concatenate(flex.miller_index(i1))
        iobs1 = iobs1.concatenate(flex.double(o1))
        sel1 = sel1.concatenate(flex.bool(s1))
        indices2 = indices2.concatenate(flex.miller_index(i2))
        iobs2 = iobs2.concatenate(flex.double(o2))
        sel2 = sel2.concatenate(flex.bool(s2))
        perm1 = flex.sort_permutation(data=miller.index_span(indices1).pack(indices1), reverse=False)
        perm2 = flex.sort_permutation(data=miller.index_span(indices2).pack(indices2), reverse=False)
        indices1 = indices1.select(perm1)
        indices2 = indices2.select(perm2)
        iobs1 = iobs1.select(perm1)
        iobs2 = iobs2.select(perm2)
        if params.adu_cutoff is not None:
            sel1 = sel1.select(perm1)
            sel2 = sel2.select(perm2)

        # Merge
        m = merge_obs(indices1.concatenate(indices2), iobs1.concatenate(iobs2), sel1.concatenate(sel2), symm, anomalous_flag=params.anomalous, d_min=params.dmin, d_max=params.dmax)

        m1 = merge_obs(indices1, iobs1, sel1, symm, anomalous_flag=params.anomalous, d_min=params.dmin, d_max=params.dmax)
        m2 = merge_obs(indices2, iobs2, sel2, symm, anomalous_flag=params.anomalous, d_min=params.dmin, d_max=params.dmax)

        a1, a2 = m1.array().common_sets(m2.array())

        red = flex.sum(m.redundancies().data()) / m.array().data().size() if m.array().data().size()>0 else 0
        rsplit = split_stats.calc_rsplit(a1, a2)
        rano = split_stats.calc_rano(a1, a2) if params.anomalous else float("nan")
        cc = split_stats.calc_cc(a1, a2)
        ccano = split_stats.calc_ccano(a1, a2) if params.anomalous else float("nan")
        ccanoref = split_stats.calc_ccano(m.array(), anoref, take_common=True) if params.anomalous and anoref is not None else float("nan")
        ccref = split_stats.calc_cc(m.array(), ref, take_common=True) if ref is not None else float("nan")
        snr = flex.mean(m.array().data()/m.array().sigmas())
        print >>out, "%10d %7.2f %7.4f %7.4f % .4f % .4f %.2f %.4f % .4f % .4f" % (e, red, rsplit, rano, cc, ccano, snr, rano/rsplit, ccanoref, ccref)
        out.flush()

        byresolution_stats(params, a1, a2, m, anoref, ref, ("%"+str(len(str(nindexed)))+"d")%e, out_byres)
        print >>out_byres, "#"
def run(args):
  assert args in [[], ["python"], ["c++"]]
  #
  sgno_list_by_index_list_by_cs = {}
  from cctbx import sgtbx
  from cctbx import miller
  for symbols in sgtbx.space_group_symbol_iterator():
    psgi = sgtbx.space_group_info(symbols.universal_hermann_mauguin()) \
      .primitive_setting()
    p_indices = miller.index_generator(
      space_group_type=psgi.type(),
      anomalous_flag=False,
      max_index=[4]*3).to_array()
        # 4 is the smallest value leading to correct results; any larger
        # value will work, too, but will make this procedure slower
    p1_indices = miller.expand_to_p1_iselection(
      space_group=psgi.group(),
      anomalous_flag=False,
      indices=p_indices,
      build_iselection=False).indices
    from cctbx.array_family import flex
    sort_perm = flex.sort_permutation(
      data=miller.index_span(p1_indices).pack(p1_indices))
    p1_indices = p1_indices.select(sort_perm)
    index_list = tuple(p1_indices)
    sgno = psgi.type().number()
    sgno_list_by_index_list = sgno_list_by_index_list_by_cs \
      .setdefault(symbols.crystal_system(), {})
    sgno_list_by_index_list.setdefault(index_list, []).append(sgno)
  from scitbx.graph import tardy_tree
  cluster_manager = tardy_tree.cluster_manager(n_vertices=231)
  for cs,sgno_list_by_index_list in sgno_list_by_index_list_by_cs.items():
    for sgno_list in sgno_list_by_index_list.values():
      i = sgno_list[0]
      for j in sgno_list[1:]:
        cluster_manager.connect_vertices(i=i, j=j, optimize=True)
  cluster_manager.tidy()
  #
  # everything below is just to format the results
  #
  if (args == []):
    for cluster in cluster_manager.clusters:
      if (len(cluster) == 1): break
      print cluster
  else:
    note = ("""\
Output of: cctbx/examples/find_sys_abs_equiv_space_groups.py %s
If you have to edit this table, please send email to: [email protected]
""" % args[0]).splitlines()
    #
    if (args == ["python"]):
      print "space_group_numbers = ["
      for line in note:
        print "  #", line
      ci = cluster_manager.cluster_indices
      cl = cluster_manager.clusters
      for sgno in xrange(231):
        cluster = list(cl[ci[sgno]])
        cluster.remove(sgno)
        if (len(cluster) == 0): s = "None"
        else:                   s = str(tuple(cluster))
        if (sgno == 230): comma = ""
        else:             comma = ","
        print "  %s%s" % (s, comma)
      print "]"
    else:
      print """\
#ifndef CCTBX_SGTBX_SYS_ABS_EQUIV_H
#define CCTBX_SGTBX_SYS_ABS_EQUIV_H

namespace cctbx { namespace sgtbx { namespace sys_abs_equiv {
"""
      data = []
      ci = cluster_manager.cluster_indices
      cl = cluster_manager.clusters
      for line in note:
        print "  //", line
      for sgno in xrange(231):
        cluster = list(cl[ci[sgno]])
        cluster.remove(sgno)
        if (len(cluster) == 0):
          data.append("0")
        else:
          cid = "data_%03d" % sgno
          data.append(cid)
          print "  static const unsigned %s[] = {%d, %s};" % (
            cid, len(cluster), ", ".join([str(i) for i in cluster]))
      print ""
      print "  static const unsigned* space_group_numbers[] = {"
      print "   ", ",\n    ".join(data)
      print """\
Exemple #12
0
def show_split_stats(stream,
                     nindexed,
                     symm,
                     params,
                     anoref=None,
                     ref=None,
                     out_prefix="out",
                     start_at=0):
    random.seed(params.random_seed)
    nstep = nindexed // params.nsplit

    out = open(out_prefix + ".dat", "w")

    out_byres = open(out_prefix + "_byres.dat", "w")
    print >> out_byres, ("%" + str(len(str(nindexed))) + "s") % "nframes",
    print >> out_byres, "dmin  dmax   red  cmpl acmpl  rsplit    rano   cc1/2   ccano  snr  rano/split CCanoref CCref"

    #formatstr_for_eachout = out_prefix+"_to%."+str(len(str(nindexed)))+"d_byres.dat"
    #indices1, iobs1, sel1 = [], [], []
    #indices2, iobs2, sel2 = [], [], []

    indices1, indices2 = flex.miller_index(), flex.miller_index()
    iobs1, iobs2 = flex.double(), flex.double()
    sel1, sel2 = flex.bool(), flex.bool()

    print >> out, "   nframes     red  Rsplit    Rano   CC1/2   CCano  snr  Rano/Rsplit CCanoref CCref"

    chunks = read_stream(stream, start_at)

    for i in xrange(params.nsplit):
        e = (i + 1) * nstep
        if i == params.nsplit - 1: e = nindexed

        read_all = (i == params.nsplit - 1)

        slc = []
        for j, c in enumerate(chunks):
            sys.stderr.write("\rprocessed: %d" % (i * nstep + j))
            sys.stderr.flush()
            slc.append(c)
            if not read_all and j >= nstep - 1:
                break
            if nindexed <= i * nstep + j:
                break

        if params.halve_method == "alternate":
            slc1 = slc[0::2]
            slc2 = slc[1::2]
        elif params.halve_method == "random":
            perm = range(len(slc))
            random.shuffle(perm)
            nhalf = len(slc) // 2
            slc1 = [slc[r] for r in perm[:nhalf]]
            slc2 = [slc[r] for r in perm[nhalf:]]
        else:
            raise "Not-supported:", params.halve_method

        i1, o1, s1 = [], [], []
        for x in slc1:
            i1.extend(x.indices)
            o1.extend(x.iobs)
            if params.adu_cutoff is not None:
                s1.extend((a <= params.adu_cutoff for a in x.peak))

        i2, o2, s2 = [], [], []
        for x in slc2:
            i2.extend(x.indices)
            o2.extend(x.iobs)
            if params.adu_cutoff is not None:
                s2.extend((a <= params.adu_cutoff for a in x.peak))

        # Concatenate and sort
        indices1 = indices1.concatenate(flex.miller_index(i1))
        iobs1 = iobs1.concatenate(flex.double(o1))
        sel1 = sel1.concatenate(flex.bool(s1))
        indices2 = indices2.concatenate(flex.miller_index(i2))
        iobs2 = iobs2.concatenate(flex.double(o2))
        sel2 = sel2.concatenate(flex.bool(s2))
        perm1 = flex.sort_permutation(
            data=miller.index_span(indices1).pack(indices1), reverse=False)
        perm2 = flex.sort_permutation(
            data=miller.index_span(indices2).pack(indices2), reverse=False)
        indices1 = indices1.select(perm1)
        indices2 = indices2.select(perm2)
        iobs1 = iobs1.select(perm1)
        iobs2 = iobs2.select(perm2)
        if params.adu_cutoff is not None:
            sel1 = sel1.select(perm1)
            sel2 = sel2.select(perm2)

        # Merge
        m = merge_obs(indices1.concatenate(indices2),
                      iobs1.concatenate(iobs2),
                      sel1.concatenate(sel2),
                      symm,
                      anomalous_flag=params.anomalous,
                      d_min=params.dmin,
                      d_max=params.dmax)

        m1 = merge_obs(indices1,
                       iobs1,
                       sel1,
                       symm,
                       anomalous_flag=params.anomalous,
                       d_min=params.dmin,
                       d_max=params.dmax)
        m2 = merge_obs(indices2,
                       iobs2,
                       sel2,
                       symm,
                       anomalous_flag=params.anomalous,
                       d_min=params.dmin,
                       d_max=params.dmax)

        a1, a2 = m1.array().common_sets(m2.array())

        red = flex.sum(m.redundancies().data()) / m.array().data().size(
        ) if m.array().data().size() > 0 else 0
        rsplit = split_stats.calc_rsplit(a1, a2)
        rano = split_stats.calc_rano(a1,
                                     a2) if params.anomalous else float("nan")
        cc = split_stats.calc_cc(a1, a2)
        ccano = split_stats.calc_ccano(
            a1, a2) if params.anomalous else float("nan")
        ccanoref = split_stats.calc_ccano(
            m.array(), anoref, take_common=True
        ) if params.anomalous and anoref is not None else float("nan")
        ccref = split_stats.calc_cc(
            m.array(), ref,
            take_common=True) if ref is not None else float("nan")
        snr = flex.mean(m.array().data() / m.array().sigmas())
        print >> out, "%10d %7.2f %7.4f %7.4f % .4f % .4f %.2f %.4f % .4f % .4f" % (
            e, red, rsplit, rano, cc, ccano, snr, rano / rsplit, ccanoref,
            ccref)
        out.flush()

        byresolution_stats(params, a1, a2, m, anoref, ref,
                           ("%" + str(len(str(nindexed))) + "d") % e,
                           out_byres)
        print >> out_byres, "#"
Exemple #13
0
def get_unit_cell_errors(stop_after=None):
  '''Actually process something...'''
  wd = os.getcwd()

  all_miller_indices, all_two_thetas_obs, reference_cell, reference_lattice, reference_wavelength = load_sweeps_with_common_indexing()

  Chatter.banner('Unit cell sampling')
  Debug.banner('Unit cell sampling')
  span = miller.index_span(all_miller_indices)
  Chatter.write("Found %d reflections in 2theta range %.3f - %.3f deg" % (len(all_miller_indices), min(all_two_thetas_obs), max(all_two_thetas_obs)))
  Chatter.write("Miller index range: %s - %s" % (str(span.min()), str(span.max())))
  unit_cell_info = { 'reflections':
                     { 'count': len(all_miller_indices),
                       'min_2theta': min(all_two_thetas_obs),
                       'max_2theta': max(all_two_thetas_obs),
                       'min_miller': list(span.min()),
                       'max_miller': list(span.max())
                     } }

  # Exclude 1% of reflections to remove potential outliers
  # eg. indexed/integrated high angle noise
  two_theta_cutoff = sorted(all_two_thetas_obs)[-int(len(all_two_thetas_obs) * 0.01)-1]
  Chatter.write("Excluding outermost 1%% of reflections (2theta >= %.3f)" % two_theta_cutoff)
  two_thetas_select = all_two_thetas_obs < two_theta_cutoff
  all_two_thetas_obs = all_two_thetas_obs.select(two_thetas_select)
  all_miller_indices = all_miller_indices.select(two_thetas_select)
  Chatter.write("Kept %d reflections in 2theta range %.3f - %.3f deg" % (len(all_miller_indices), min(all_two_thetas_obs), max(all_two_thetas_obs)))
  span = miller.index_span(all_miller_indices)
  unit_cell_info['reflections_filtered'] = \
                     { 'count': len(all_miller_indices),
                       'min_2theta': min(all_two_thetas_obs),
                       'max_2theta': max(all_two_thetas_obs),
                       'min_miller': list(span.min()),
                       'max_miller': list(span.max())
                     }

  # prepare MonteCarlo sampling
  mc_runs = 50
  sample_size = min(len(all_miller_indices) // 2, 100)
  unit_cell_info['sampling'] = { 'method': 'montecarlo', 'runs': mc_runs, 'used_per_run': sample_size }
  unit_cell_info['reference'] = { 'cell': reference_cell.parameters(), 'cell_volume': reference_cell.volume(),
                                  'lattice': reference_lattice, 'wavelength': reference_wavelength }

  Chatter.write("\nRandomly sampling %d x %d reflections for Monte Carlo iterations" % (mc_runs, sample_size))
  Debug.write("Refinements start with reference unit cell: %s" % reference_cell)

  MC = []
  MCconstrained = []
  used_index_range = flex.miller_index()
  used_two_theta_range_min = 1e300
  used_two_theta_range_max = 0
  used_reflections = set()

  for n in range(mc_runs): # MC sampling
    # Select sample_size reflections
    sample = flex.size_t(random.sample(range(len(all_miller_indices)), sample_size))
    used_reflections = used_reflections.union(set(sample))
    miller_indices = all_miller_indices.select(sample)
    two_thetas_obs = all_two_thetas_obs.select(sample)

    # Record
    span = miller.index_span(miller_indices)
    used_index_range.append(span.min())
    used_index_range.append(span.max())
    used_two_theta_range_min = min(used_two_theta_range_min, min(two_thetas_obs))
    used_two_theta_range_max = max(used_two_theta_range_max, max(two_thetas_obs))

    refined = _refinery(two_thetas_obs, miller_indices, reference_wavelength, reference_cell)
    MC.append(refined.unit_cell().parameters() + (refined.unit_cell().volume(),))
    Debug.write('Run %d refined to: %s' % (n, str(refined.unit_cell())))
    if reference_lattice is not None and reference_lattice is not 'aP':
      refined = _refinery(two_thetas_obs, miller_indices, reference_wavelength, reference_cell, reference_lattice[0])
      MCconstrained.append(refined.unit_cell().parameters() + (refined.unit_cell().volume(),))
      Debug.write('Run %d (constrained %s) refined to: %s' % (n, reference_lattice[0], str(refined.unit_cell())))

    if (n % 50) == 0:
      sys.stdout.write("\n%5s ." % (str(n) if n > 0 else ''))
    else:
      sys.stdout.write(".")
    sys.stdout.flush()

  assert used_two_theta_range_min < used_two_theta_range_max

  def stats_summary(l):
    mean = sum(l) / len(l)
    var = 0
    for y in l:
      var = var + ((y - mean) ** 2)
    popvar = var / (len(l)-1)
    popstddev = math.sqrt(popvar)
    stderr = popstddev / math.sqrt(len(l))
    return { 'mean': mean, 'variance': var, 'population_variance': popvar,
        'population_standard_deviation': popstddev, 'standard_error': stderr }

  print
  Chatter.write("")
  Chatter.write("Unit cell estimation based on %d Monte Carlo runs," % len(MC))
  span = miller.index_span(used_index_range)
  Chatter.write("drawn from miller indices between %s and %s" % (str(span.min()), str(span.max())))
  Chatter.write("with associated 2theta angles between %.3f and %.3f deg" % (used_two_theta_range_min, used_two_theta_range_max))
  unit_cell_info['sampling'].update({
      'used_reflections': len(used_reflections),
      'used_max_2theta': used_two_theta_range_max,
      'used_min_2theta': used_two_theta_range_min,
      'used_max_miller': span.max(),
      'used_min_miller': span.min() })
  unit_cell_info['solution_unconstrained'] = {}
  unit_cell_info['solution_constrained'] = { 'lattice': reference_lattice }
  if reference_lattice is None or reference_lattice == 'aP':
    Chatter.write("\n  Unconstrained estimate:", strip=False)
    for dimension, estimate in zip(['a', 'b', 'c', 'alpha', 'beta', 'gamma', 'volume'], zip(*MC)):
      est_stats = stats_summary(estimate)
      unit_cell_info['solution_unconstrained'][dimension] = est_stats
      unit_cell_info['solution_constrained'][dimension] = est_stats
      Chatter.write(" %6s =%10.5f (SD: %.5f, SE: %.5f)" % (dimension,
        est_stats['mean'],
        est_stats['population_standard_deviation'],
        est_stats['standard_error']), strip=False)
  else:
    Chatter.write("\n    Unconstrained estimate:                     |     Constrained estimate (%s):" % reference_lattice, strip=False)
    for dimension, estimate, constrained in zip(['a', 'b', 'c', 'alpha', 'beta', 'gamma', 'volume'], zip(*MC), zip(*MCconstrained)):
      est_stats = stats_summary(estimate)
      rest_stats = stats_summary(constrained)
      unit_cell_info['solution_unconstrained'][dimension] = est_stats
      unit_cell_info['solution_constrained'][dimension] = rest_stats
      Chatter.write(" %6s =%10.5f (SD: %.5f, SE: %.5f)  |  %6s =%10.5f (SD: %.5f, SE: %.5f)" %
        (dimension,
         est_stats['mean'],
         est_stats['population_standard_deviation'],
         est_stats['standard_error'],
         dimension,
         rest_stats['mean'],
         rest_stats['population_standard_deviation'],
         rest_stats['standard_error']), strip=False)

  with open(os.path.join(wd, 'xia2.get_unit_cell_errors.json'), 'w') as fh:
    json.dump(unit_cell_info, fh, indent = 2, sort_keys=True)