servalcat 0.4.131__cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl

servalcat/utils/symmetry.py

@@ -0,0 +1,298 @@
+"""
+Author: "Keitaro Yamashita, Garib N. Murshudov"
+MRC Laboratory of Molecular Biology
+    
+This software is released under the
+Mozilla Public License, version 2.0; see LICENSE.
+"""
+from __future__ import absolute_import, division, print_function, generators
+import gemmi
+import subprocess
+import numpy
+import re
+from servalcat.utils import logger
+from servalcat.utils import fileio
+from servalcat.utils import model
+from servalcat.utils import generate_operators
+
+def add_symmetry_args(parser, require_pg=False):
+    parser.add_argument('--pg', required=require_pg, help="Point group symbol")
+    parser.add_argument('--twist', type=float, help="Helical twist (degree)")
+    parser.add_argument('--rise', type=float, help="Helical rise (Angstrom)")
+    parser.add_argument('--center', type=float, nargs=3, help="Origin of symmetry. Default: center of the box")
+    parser.add_argument('--axis1', type=float, nargs=3, help="Axis1 (if I: 5-fold, O: 4-fold, T: 3-fold)")
+    parser.add_argument('--axis2', type=float, nargs=3, help="Axis2 (if I: 5-fold, O: 4-fold, T: 3-fold, Dn: 2-fold)")
+# add_symmetry_args()
+    
+def update_ncs_from_args(args, st, map_and_start=None, filter_contacting=False,
+                         helical_min_n=None, helical_max_n=None):
+    is_helical = args.twist is not None
+    if not is_helical and not args.pg:
+        if len(st.ncs) > 0:
+            logger.writeln("Strict NCS detected from model.")
+            show_ncs_operators_axis_angle(st.ncs)
+        return
+    
+    if len(st.ncs) > 0:
+        logger.writeln(" WARNING: NCS information in model file will be ignored")
+
+    ncsops = ncsops_from_args(args, st.cell, map_and_start=map_and_start, st=st,
+                              helical_min_n=helical_min_n, helical_max_n=helical_max_n)
+
+    st.ncs = [x for x in ncsops if not x.tr.is_identity()]
+    # To write identity op to the output model
+    idop_id = next((x.id for x in ncsops if x.tr.is_identity()), None)
+    if idop_id:
+        st.info["_struct_ncs_oper.id"] = idop_id
+
+    if filter_contacting:
+        model.filter_contacting_ncs(st)
+# update_ncs_from_args()
+
+def ncsops_from_args(args, cell, map_and_start=None, st=None, helical_min_n=None, helical_max_n=None):
+    is_helical = args.twist is not None
+    
+    if map_and_start is not None:
+        start_xyz = numpy.array(map_and_start[0].get_position(*map_and_start[1]).tolist())
+    else:
+        start_xyz = numpy.zeros(3)
+
+    if args.center is None:
+        A = cell.orth.mat.array
+        center = numpy.sum(A, axis=1) / 2 #+ start_xyz
+        logger.writeln("Center: {}".format(center))
+    else:
+        center = numpy.array(args.center)
+        
+    if is_helical:
+        ncsops = generate_helical_operators(start_xyz, center,
+                                            args.pg, args.twist, args.rise,
+                                            axis1=args.axis1, axis2=args.axis2,
+                                            st=st, min_n=helical_min_n, max_n=helical_max_n)
+        logger.writeln("{} helical operators found".format(len(ncsops)))
+    else:
+        _, _, ops = operators_from_symbol(args.pg, axis1=args.axis1, axis2=args.axis2)
+        logger.writeln("{} operators found for {}".format(len(ops), args.pg))
+        show_operators_axis_angle(ops)
+        ncsops = make_NcsOps_from_matrices(ops, cell=cell, center=center)
+
+    return ncsops
+# ncsops_from_args()
+
+def get_matrices_using_relion(sym):
+    ps = subprocess.check_output(["relion_refine", "--sym", sym.strip(), "--print_symmetry_ops"])
+
+    ret = []
+    read_flag = -1
+    for l in ps.splitlines():
+        if b"R(" in l:
+            ret.append(numpy.zeros((3,3)))
+            read_flag = 0
+        elif 0 <= read_flag < 3:
+            ret[-1][read_flag,:] = [float(x) for x in l.split()]
+            read_flag += 1
+        elif read_flag >= 3:
+            read_flag = -1
+
+    return ret
+# get_matrices_using_relion()
+
+def operators_from_symbol(op, axis1=None, axis2=None):
+    r = re.search("^([CDITO])([0-9]*)$", op.upper())
+    if not r:
+        raise RuntimeError("Invalid point group symbol: {}".format(op))
+    a, n = r.groups()
+    if n:
+        n = int(n)
+        if n <= 0:
+            raise RuntimeError("Non positive order given: {}".format(op))
+        elif a in ("T", "O"):
+            raise RuntimeError("You cannot give number after T,O: {}".format(op))
+        elif a == "I" and n > 4:
+            raise RuntimeError("Only I1-4 are supported for I variants: {}".format(op))
+
+    if axis1 is not None: axis1 = numpy.array(axis1)
+    if axis2 is not None: axis2 = numpy.array(axis2)
+
+    # RELION's conventions
+    if a == "I":
+        order1 = order2 = 5
+        if not n or n == 2:
+            if axis1 is None: axis1 = numpy.array([0, 0.85065, 0.52573])
+            if axis2 is None: axis2 = numpy.array([0.52573, 0, 0.85065])
+        elif n == 1:
+            if axis1 is None: axis1 = numpy.array([0.85065, 0., 0.52573])
+            if axis2 is None: axis2 = numpy.array([0.52573, 0.85065, 0.])
+        elif n == 3:
+            if axis1 is None: axis1 = numpy.array([0.723606, 0.525732, 0.447214])
+            if axis2 is None: axis2 = numpy.array([-0.276391, -0.850645, 0.447216])
+        elif n == 4:
+            if axis1 is None: axis1 = numpy.array([-0.723606, -0.525732, 0.447214])
+            if axis2 is None: axis2 = numpy.array([0., 0., 1.])
+    elif a == "O":
+        order1 = order2 = 4
+        if axis1 is None: axis1 = numpy.array([0,0,1.0])
+        if axis2 is None: axis2 = numpy.array([0,1.0,0])
+    elif a == "T":
+        order1 = order2 = 3
+        if axis1 is None: axis1 = numpy.array([0.0,0.0,1.0])
+        if axis2 is None: axis2 = numpy.array([0.0,0.94280904,-0.33333333])
+    elif a == "D":
+        order1 = n
+        if axis1 is None: axis1 = numpy.array([0,0,1.0])
+        order2 = 2
+        if axis2 is None: axis2 = numpy.array([1.,0.,0.])
+    elif a == "C":
+        order1 = n
+        if axis1 is None: axis1 = numpy.array([0,0,1.0])
+        order2 = 0
+        axis2 = None
+    return generate_operators.generate_all_elements(axis1, order1, axis2, order2)
+# operators_from_symbol()
+
+def show_operators_axis_angle(ops):
+    for i, op in enumerate(ops):
+        ax, ang = generate_operators.Rotation2AxisAngle_general(op)
+        logger.writeln(" operator {:3d} angle= {:7.3f} deg axis= {}".format(i+1, numpy.rad2deg(ang), numpy.array_str(ax)))
+# show_operators_axis_angle()
+
+def show_ncs_operators_axis_angle(ops):
+    # ops: List of gemmi.NcsOp
+    for i, op in enumerate(ops):
+        op2 = op.tr.mat.array
+        ax, ang = generate_operators.Rotation2AxisAngle_general(op2)
+        axlab = "[{: .4f}, {: .4f}, {: .4f}]".format(*ax)
+        trlab = "[{: 9.4f}, {: 9.4f}, {: 9.4f}]".format(*op.tr.vec.tolist())
+        logger.writeln(" operator {:3s} angle= {:7.3f} deg axis= {} trans= {} {}".format(op.id, numpy.rad2deg(ang),
+                                                                                       axlab, trlab,
+                                                                                       "given" if op.given else ""))
+# show_operators_axis_angle()
+
+def read_helical_parameters_from_mmcif(cif_in):
+    doc = fileio.read_cif_safe(cif_in)
+    b = list(filter(lambda b: b.find_loop("_atom_site.id"), doc))[0]
+    deltaphi = b.find_value("_em_helical_entity.angular_rotation_per_subunit")
+    deltaz = b.find_value("_em_helical_entity.axial_rise_per_subunit")
+    deltaphi, deltaz = float(deltaphi), float(deltaz)
+    axsym = b.find_value("_em_helical_entity.axial_symmetry")
+    return axsym, deltaphi, deltaz
+# read_helical_parameters_from_mmcif()
+
+def generate_helical_operators(start_xyz, center, axsym, deltaphi, deltaz, axis1=None, axis2=None,
+                               st=None, min_n=None, max_n=None, padding=2.):
+    if not axsym: axsym = "C1"
+    if axis1 is None: axis1 = numpy.array([0,0,1.])
+    else: axis1 /= numpy.linalg.norm(axis1)
+    _, _, axtrs = operators_from_symbol(axsym, axis1, axis2)
+    if min_n is None or max_n is None:
+        assert st is not None
+        all_z = numpy.dot([cra.atom.pos.tolist() for cra in st[0].all()], axis1)
+        min_z, max_z = numpy.min(all_z), numpy.max(all_z)
+        direc = numpy.argmax([numpy.dot(axis1, v) for v in ((1.,0,0), (0,1.,0), (0,0,1.))]) # assume axis1 along any of a,b,c axis
+        if min_n is None:
+            min_n = -int((min_z - padding - start_xyz[direc]) / deltaz)
+        if max_n is None:
+            max_n = int((st.cell.parameters[direc] + start_xyz[direc] - max_z - padding) / deltaz)
+    if min_n > max_n:
+        min_n, max_n = max_n, min_n
+    ops = []
+    for i in range(min_n, max_n+1):
+        deg = deltaphi*i
+        t = numpy.deg2rad(deg)
+        m = generate_operators.AngleAxis2rotatin(axis1, t)
+        s = numpy.array(axis1 * deltaz*i)
+        for a in axtrs:
+            mat = numpy.dot(m, a)
+            news = s + numpy.dot(mat, -center) + center
+            tr = gemmi.Transform(gemmi.Mat33(mat), gemmi.Vec3(*news))
+            newop = gemmi.NcsOp(tr, str(len(ops)+1), tr.is_identity())
+            ops.append(newop)
+
+    return ops
+# generate_helical_operators()
+
+def make_NcsOps_from_matrices(matrices, cell=None, center=None):
+    if center is None:
+        A = cell.orth.mat.array
+        center = numpy.sum(A,axis=1) / 2
+
+    center = gemmi.Vec3(*center)
+    ops = []
+    for i, m in enumerate(matrices):
+        m = gemmi.Mat33(m)
+        transl = m.multiply(-center) + center
+        op = gemmi.NcsOp(gemmi.Transform(m, transl), str(i+1), m.is_identity())
+        ops.append(op)
+        
+    return ops
+# make_NcsOps_from_matrices()
+
+def find_center_of_origin(mat, vec): # may not be unique.
+    tmp = numpy.identity(3) - numpy.array(mat.array)
+    ret = numpy.dot(numpy.linalg.pinv(tmp), vec.tolist())
+    resid = vec.tolist() - (numpy.dot(mat.array, -ret) + ret)
+    return gemmi.Vec3(*ret), gemmi.Vec3(*resid)
+# find_center_of_origin()
+
+def ncs_ops_for_refmac(ncs_ops):
+    def make_line(tr):
+        m = tr.mat.tolist()
+        m_str = " ".join([str(m[i][j]) for i in range(3) for j in range(3)])
+        t_str = " ".join([str(x) for x in tr.vec.tolist()])
+        return "ncsc matrix {} {}".format(m_str, t_str)
+    
+    ret = []
+    # REFMAC requires identity op
+    if not any(x.tr.is_identity() for x in ncs_ops):
+        ret.append(make_line(gemmi.Transform()))
+
+    for op in ncs_ops:
+        if not op.given: ret.append(make_line(op.tr))
+    return ret
+# ncs_ops_for_refmac()
+
+# TODO def euler2matrix(euler):
+# TODO def polar2matrix(polar):
+
+def parse_ncsc_keywords(kwd_str):
+    # FIXME handle lines ending with -
+    lines = kwd_str.splitlines()
+    ret = []
+    for l in lines:
+        l = l.split()
+        if len(l) < 3: continue
+        if l[0].lower().startswith("ncsc"):
+            if l[1].lower().startswith("matr"):
+                vals = [float(x) for x in l[2:]]
+                if len(vals) != 12:
+                    print("Bad nsc matrix line: {}".format(" ".join(l)))
+                    continue
+                op = gemmi.NcsOp()
+                op.tr.mat.fromlist([vals[3*x:3*x+3] for x in range(3)])
+                op.tr.vec.fromlist(vals[9:])
+                op.id = str(len(ret)+1)
+                op.given = op.tr.is_identity()
+                ret.append(op)
+            elif l[1].lower().startswith("eule"):
+                pass # TODO
+            elif l[1].lower().startswith("pola"):
+                pass # TODO
+    return ret
+# parse_ncsc_keywords()
+
+def apply_shift_for_ncsops(ncsops, shift):
+    new_ops = []
+    s = gemmi.Vec3(*shift)
+    for op in ncsops:
+        newt = op.tr.vec + s - op.tr.mat.multiply(s)
+        newop = gemmi.NcsOp(gemmi.Transform(op.tr.mat, newt), op.id, op.given)
+        new_ops.append(newop)
+
+    return new_ops
+# apply_shift_for_ncsops()
+
+def write_symmetry_expanded_model(st, prefix, pdb=False, cif=False, cif_ref=None):
+    st_new = st.clone()
+    model.expand_ncs(st_new)
+    fileio.write_model(st_new, prefix=prefix, pdb=pdb, cif=cif, cif_ref=cif_ref)
+# write_symmetry_expanded_model()

servalcat/xtal/french_wilson.py

@@ -0,0 +1,262 @@
+"""
+Author: "Keitaro Yamashita, Garib N. Murshudov"
+MRC Laboratory of Molecular Biology
+    
+This software is released under the
+Mozilla Public License, version 2.0; see LICENSE.
+"""
+from __future__ import absolute_import, division, print_function, generators
+import argparse
+import gemmi
+import numpy
+import pandas
+import time
+import os
+import scipy.special
+import scipy.optimize
+from servalcat.utils import logger
+from servalcat.xtal import sigmaa
+from servalcat import utils
+from servalcat import ext
+
+#import line_profiler
+#profile = line_profiler.LineProfiler()
+#import atexit
+#atexit.register(profile.print_stats)
+
+integr = sigmaa.integr
+
+def add_arguments(parser):
+    parser.description = 'Convert intensity to amplitude'
+    parser.add_argument('--hklin', required=True,
+                        help='Input MTZ file')
+    parser.add_argument('--hklin_index', type=int, default=0,
+                        help='block index if hklin is mmcif file (default: %(default)d)')
+    parser.add_argument('--labin', 
+                        help='MTZ column for I,SIGI')
+    parser.add_argument('--d_min', type=float)
+    parser.add_argument('--d_max', type=float)
+    parser.add_argument('--nbins', type=int,
+                        help="Number of bins (default: auto)")
+    parser.add_argument('-o','--output_prefix',
+                        help='output file name prefix')
+# add_arguments()
+
+def parse_args(arg_list):
+    parser = argparse.ArgumentParser()
+    add_arguments(parser)
+    return parser.parse_args(arg_list)
+# parse_args()
+
+def determine_Sigma_and_aniso(hkldata):
+    # initial estimate
+    hkldata.binned_df["ml"]["S"] = 1.
+    I_over_eps = hkldata.df.I.to_numpy() / hkldata.df.epsilon.to_numpy()
+    x = []
+    for i_bin, idxes in hkldata.binned("ml"):
+        #S = max(numpy.nanmean(I_over_eps[idxes]), 1e-3)
+        # var(I) = var_signal + var_noise, so this overestimates S,
+        # but it should be better than having negative values (in noisy shell)
+        S = numpy.nanstd(I_over_eps[idxes])
+        hkldata.binned_df["ml"].loc[i_bin, "S"] = S
+        x.append(S)
+    logger.writeln("Initial estimates:")
+    logger.writeln(hkldata.binned_df["ml"].to_string())
+
+    B = gemmi.SMat33d(0,0,0,0,0,0)
+    SMattolist = lambda B: [B.u11, B.u22, B.u33, B.u12, B.u13, B.u23]
+    adpdirs = utils.model.adp_constraints(hkldata.sg.operations(), hkldata.cell, tr0=True)
+    logger.writeln("ADP free parameters = {}".format(adpdirs.shape[0]))
+    ssqmat = hkldata.ssq_mat()
+    cycle_data = [[0] + SMattolist(B) + list(hkldata.binned_df["ml"].S)]
+    for icyc in range(100):
+        #logger.writeln("Refine B")
+        B_converged = False
+        t0 = time.time()
+        args=(ssqmat, hkldata, adpdirs)
+        for j in range(10):
+            x = numpy.dot(SMattolist(B), numpy.linalg.pinv(adpdirs))
+            f0 = ll_all_B(x, *args)
+            shift = ll_shift_B(x, *args)
+            for i in range(3):
+                ss = shift / 2**i
+                f1 = ll_all_B(x + ss, *args)
+                #logger.writeln("f0 = {:.3e} shift = {} df = {:.3e}".format(f0, ss, f1 - f0))
+                if f1 < f0:
+                    B = gemmi.SMat33d(*numpy.dot(x+ss, adpdirs))
+                    if numpy.max(numpy.abs(ss)) < 1e-4: B_converged = True
+                    break
+            else:
+                B_converged = True
+            if B_converged: break
+
+        #logger.writeln("time= {}".format(time.time() - t0))
+        #logger.writeln("B_aniso= {}".format(B))
+        #logger.writeln("Refine S")
+        S_converged = [False for _ in hkldata.binned("ml")]
+        k_ani = hkldata.debye_waller_factors(b_cart=B)
+        for i, (i_bin, idxes) in enumerate(hkldata.binned("ml")):
+            #logger.writeln("Bin {}".format(i_bin))
+            for j in range(10):
+                S = hkldata.binned_df["ml"].loc[i_bin, "S"]
+                f0 = numpy.nansum(integr.ll_int(hkldata.df.I.to_numpy()[idxes], hkldata.df.SIGI.to_numpy()[idxes], k_ani[idxes],
+                                                S * hkldata.df.epsilon.to_numpy()[idxes],
+                                                numpy.zeros(len(idxes)), hkldata.df.centric.to_numpy()[idxes]+1,
+                                                hkldata.df.llweight.to_numpy()[idxes]))
+                shift = numpy.exp(ll_shift_bin_S(hkldata.df.I.to_numpy()[idxes], hkldata.df.SIGI.to_numpy()[idxes], k_ani[idxes],
+                                                 S, hkldata.df.centric.to_numpy()[idxes]+1, hkldata.df.epsilon.to_numpy()[idxes],
+                                                 hkldata.df.llweight.to_numpy()[idxes]))
+                for k in range(3):
+                    ss = shift**(1. / 2**k)
+                    f1 = numpy.nansum(integr.ll_int(hkldata.df.I.to_numpy()[idxes], hkldata.df.SIGI.to_numpy()[idxes], k_ani[idxes],
+                                                    S * ss * hkldata.df.epsilon.to_numpy()[idxes],
+                                                    numpy.zeros(len(idxes)), hkldata.df.centric.to_numpy()[idxes]+1,
+                                                    hkldata.df.llweight.to_numpy()[idxes]))
+                    #logger.writeln("bin {:3d} f0 = {:.3e} shift = {:.3e} df = {:.3e}".format(i_bin, f0, ss, f1 - f0))
+                    if f1 < f0:
+                        hkldata.binned_df["ml"].loc[i_bin, "S"] = S * ss
+                        if ss > 0.9999: S_converged[i] = True
+                        break
+                else:
+                    S_converged[i] = True
+                if S_converged[i]: break
+
+        #logger.writeln("Refined estimates in cycle {}:".format(icyc))
+        #logger.writeln(hkldata.binned_df["ml"].to_string())
+        #logger.writeln("B_aniso= {}".format(B))
+        cycle_data.append([icyc] + SMattolist(B) + list(hkldata.binned_df["ml"].S))
+        if B_converged and all(S_converged):
+            logger.writeln("Converged in cycle {}".format(icyc))
+            logger.writeln("Refined estimates:")
+            logger.writeln(hkldata.binned_df["ml"].to_string())
+            logger.writeln("B_aniso= {}".format(B))
+            break
+
+    #with open("fw_cycles.dat", "w") as ofs:
+    #    ofs.write("cycle B11 B22 B33 B12 B13 B23 " + " ".join("S{}".format(i) for i in hkldata.binned_df["ml"].index) + "\n")
+    #    for data in cycle_data:
+    #        ofs.write("{:2d} ".format(data[0]+1))
+    #        ofs.write(" ".join("{:.4e}".format(x) for x in data[1:]))
+    #        ofs.write("\n")
+        
+    return B
+
+def ll_all_B(x, ssqmat, hkldata, adpdirs):
+    B = gemmi.SMat33d(*numpy.dot(x, adpdirs))
+    k_ani = hkldata.debye_waller_factors(b_cart=B)
+    ret = 0.
+    for i_bin, idxes in hkldata.binned("ml"):
+        ret += numpy.nansum(integr.ll_int(hkldata.df.I.to_numpy()[idxes], hkldata.df.SIGI.to_numpy()[idxes], k_ani[idxes],
+                                          hkldata.binned_df["ml"].S[i_bin] * hkldata.df.epsilon.to_numpy()[idxes],
+                                          numpy.zeros(len(idxes)), hkldata.df.centric.to_numpy()[idxes]+1,
+                                          hkldata.df.llweight.to_numpy()[idxes]))
+    return ret
+
+def ll_shift_bin_S(Io, sigIo, k_ani, S, c, eps, llw, exp_trans=True):
+    tmp = integr.ll_int_fw_der1_S(Io, sigIo, k_ani, S, c, eps, llw)
+    g = numpy.nansum(tmp)
+    H = numpy.nansum(tmp**2)
+    if exp_trans:
+        return -g / (H * S + g)
+    else:
+        return -g / H
+
+def ll_shift_B(x, ssqmat, hkldata, adpdirs):
+    b_aniso = gemmi.SMat33d(*numpy.dot(x, adpdirs))
+    k_ani = hkldata.debye_waller_factors(b_cart=b_aniso)
+    Io = hkldata.df.I.to_numpy()
+    sigIo = hkldata.df.SIGI.to_numpy()
+    c = hkldata.df.centric.to_numpy() + 1
+    epsilon = hkldata.df.epsilon.to_numpy()
+    llw = hkldata.df.llweight.to_numpy()
+    r = numpy.empty(len(Io)) * numpy.nan
+    for i_bin, idxes in hkldata.binned("ml"):
+        r[idxes] = integr.ll_int_fw_der1_ani(Io[idxes], sigIo[idxes],
+                                             k_ani[idxes], hkldata.binned_df["ml"].S[i_bin],
+                                             c[idxes], epsilon[idxes], llw[idxes])
+    g = -numpy.nansum(ssqmat * r, axis=1)
+    H = numpy.nansum(numpy.matmul(ssqmat[None,:].T, ssqmat.T[:,None]) * (r**2)[:,None,None], axis=0)
+    g, H = numpy.dot(g, adpdirs.T), numpy.dot(adpdirs, numpy.dot(H, adpdirs.T))
+    return -numpy.dot(g, numpy.linalg.pinv(H))
+
+def expected_F_from_int(Io, sigo, k_ani, eps, c, S):
+    to = Io / sigo - sigo / c / k_ani**2 / S / eps
+    tf = numpy.zeros(Io.size)
+    sig1 = numpy.ones(Io.size)
+    k_num = numpy.where(c == 1,  0.5, 0.)
+    F = numpy.sqrt(sigo) * ext.integ_J_ratio(k_num, k_num - 0.5, False, to, tf, sig1, c,
+                                             integr.exp2_threshold, integr.h, integr.N, integr.ewmax)
+    Fsq = sigo * ext.integ_J_ratio(k_num + 0.5, k_num - 0.5, False, to, tf, sig1, c,
+                                   integr.exp2_threshold, integr.h, integr.N, integr.ewmax)
+    varF = Fsq - F**2
+    return F, numpy.sqrt(varF)
+
+def french_wilson(hkldata, B_aniso, labout=None):
+    if labout is None: labout = ["F", "SIGF"]
+    k_ani = hkldata.debye_waller_factors(b_cart=B_aniso)
+    has_ano = "I(+)" in hkldata.df and "I(-)" in hkldata.df
+    if has_ano:
+        ano_data = hkldata.df[["I(+)", "SIGI(+)", "I(-)", "SIGI(-)"]].to_numpy()
+        if len(labout) == 2:
+            labout += [f"{labout[0]}(+)", f"{labout[1]}(+)", f"{labout[0]}(-)", f"{labout[1]}(-)"]
+    hkldata.df[labout] = numpy.nan
+    for i_bin, idxes in hkldata.binned("ml"):
+        S = hkldata.binned_df["ml"].S[i_bin]
+        c = hkldata.df.centric.to_numpy()[idxes] + 1 # 1 for acentric, 2 for centric
+        Io = hkldata.df.I.to_numpy()[idxes]
+        sigo = hkldata.df.SIGI.to_numpy()[idxes]
+        eps = hkldata.df.epsilon.to_numpy()[idxes]
+        F, sigF = expected_F_from_int(Io, sigo, k_ani[idxes], eps, c, S)
+        hkldata.df.loc[idxes, labout[0]] = F
+        hkldata.df.loc[idxes, labout[1]] = sigF
+        if has_ano:
+            Fp, sigFp = expected_F_from_int(ano_data[idxes,0], ano_data[idxes,1], k_ani[idxes], eps, c, S)
+            Fm, sigFm = expected_F_from_int(ano_data[idxes,2], ano_data[idxes,3], k_ani[idxes], eps, c, S)
+            hkldata.df.loc[idxes, labout[2]] = Fp
+            hkldata.df.loc[idxes, labout[3]] = sigFp
+            hkldata.df.loc[idxes, labout[4]] = Fm
+            hkldata.df.loc[idxes, labout[5]] = sigFm
+
+def main(args):
+    if not args.output_prefix:
+        args.output_prefix = utils.fileio.splitext(os.path.basename(args.hklin))[0] + "_fw"
+    try:
+        mtz = utils.fileio.read_mmhkl(args.hklin, cif_index=args.hklin_index)
+    except RuntimeError as e:
+        raise SystemExit("Error: {}".format(e))
+    if not args.labin:
+        labin = sigmaa.decide_mtz_labels(mtz, require=("K", "J"))
+    else:
+        labin = args.labin.split(",")
+    try:
+        hkldata, _, _, _, _ = sigmaa.process_input(hklin=mtz,
+                                                   labin=labin,
+                                                   n_bins_ml=args.nbins,
+                                                   free=None,
+                                                   xyzins=[],
+                                                   d_min=args.d_min,
+                                                   n_per_mlbin=500,
+                                                   max_mlbins=30,
+                                                   cif_index=args.hklin_index)
+    except RuntimeError as e:
+        raise SystemExit("Error: {}".format(e))
+    
+    B_aniso = determine_Sigma_and_aniso(hkldata)
+    french_wilson(hkldata, B_aniso)
+    mtz_out = args.output_prefix+".mtz"
+    lab_out = ["F", "SIGF", "I", "SIGI"]
+    labo_types = {"F":"F", "SIGF":"Q", "I":"J", "SIGI":"Q"}
+    if "I(+)" in hkldata.df and "I(-)" in hkldata.df:
+        lab_out += ["F(+)", "SIGF(+)", "F(-)", "SIGF(-)"]
+        labo_types.update({"F(+)":"G", "SIGF(+)":"L", "F(-)":"G", "SIGF(-)":"L"})
+    if len(labin) == 3:
+        lab_out.append("FREE")
+        labo_types[lab_out[-1]] = "I"
+    hkldata.write_mtz(mtz_out, lab_out, types=labo_types)
+    return B_aniso, hkldata
+# main()
+
+if __name__ == "__main__":
+    import sys
+    args = parse_args(sys.argv[1:])
+    main(args)