servalcat 0.4.88__cp313-cp313-macosx_11_0_arm64.whl → 0.4.100__cp313-cp313-macosx_11_0_arm64.whl

servalcat/xtal/sigmaa.py

@@ -30,6 +30,8 @@ def add_arguments(parser):
     parser.description = 'Sigma-A parameter estimation for crystallographic data'
     parser.add_argument('--hklin', required=True,
                         help='Input MTZ file')
+    parser.add_argument('--spacegroup',
+                        help='Override space group')
     parser.add_argument('--labin',
                         help='MTZ column for F,SIGF,FREE')
     parser.add_argument('--free', type=int,
@@ -77,7 +79,7 @@ def calc_r_and_cc(hkldata, centric_and_selections, twin_data=None):
     has_int = "I" in hkldata.df
     has_free = "FREE" in hkldata.df
     stats = hkldata.binned_df.copy()
-    stats["n_obs"] = 0
+    stats[["n_obs", "n_all"]] = 0
     if has_free:
         stats[["n_work", "n_free"]] = 0
     rlab = "R1" if has_int else "R"
@@ -105,6 +107,7 @@ def calc_r_and_cc(hkldata, centric_and_selections, twin_data=None):
 
     for i_bin, idxes in hkldata.binned():
         stats.loc[i_bin, "n_obs"] = numpy.sum(numpy.isfinite(obs[idxes]))
+        stats.loc[i_bin, "n_all"] = len(idxes)
         if has_free:
             for j, suf in ((1, "work"), (2, "free")):
                 idxes2 = numpy.concatenate([sel[j] for sel in centric_and_selections[i_bin]])
@@ -1018,10 +1021,9 @@ def smooth_params(hkldata, D_labs, smoothing): # XXX twin_data
 # smooth_params()
 
 def expected_F_from_int(Io, sigIo, k_ani, DFc, eps, c, S):
-    if c == 0: # acentric
-        k_num, k_den = 0.5, 0.
-    else:
-        k_num, k_den = 0., -0.5
+    k_num = numpy.repeat(0.5 if c == 0 else 0., Io.size) # 0.5 if acentric
+    k_den = k_num - 0.5
+    if numpy.isscalar(c): c = numpy.repeat(c, Io.size)
     to = Io / sigIo - sigIo / (c+1) / k_ani**2 / S / eps
     tf = k_ani * numpy.abs(DFc) / numpy.sqrt(sigIo)
     sig1 = k_ani**2 * S * eps / sigIo
@@ -1054,10 +1056,7 @@ def calculate_maps_int(hkldata, b_aniso, fc_labs, D_labs, centric_and_selections
             S = hkldata.df["S"].to_numpy()[cidxes]
             f, m_proxy = expected_F_from_int(Io[cidxes], sigIo[cidxes], k_ani[cidxes], DFc[cidxes], eps[cidxes], c, S)
             exp_ip = numpy.exp(numpy.angle(DFc[cidxes])*1j)
-            if c == 0:
-                hkldata.df.loc[cidxes, "FWT"] = 2 * f * exp_ip - DFc[cidxes]
-            else:
-                hkldata.df.loc[cidxes, "FWT"] = f * exp_ip
+            hkldata.df.loc[cidxes, "FWT"] = 2 * f * exp_ip - DFc[cidxes]
             hkldata.df.loc[cidxes, "DELFWT"] = f * exp_ip - DFc[cidxes]
             hkldata.df.loc[cidxes, "FOM"] = m_proxy
             if has_ano:
@@ -1088,15 +1087,23 @@ def calculate_maps_twin(hkldata, b_aniso, fc_labs, D_labs, twin_data, centric_an
                 Io[tohide] = numpy.nan
     
     twin_data.est_f_true(Io, sigIo)
-    F_true = numpy.asarray(twin_data.f_true_max)
     Ds = twin_data.ml_scale_array()
     DFc = (twin_data.f_calc * Ds).sum(axis=1)
     exp_ip = numpy.exp(numpy.angle(DFc)*1j)
     Ft = numpy.asarray(twin_data.f_true_max)
     m = twin_data.calc_fom()
-    fwt = numpy.where(numpy.asarray(twin_data.centric) == 0,
-                      2 * m * Ft * exp_ip - DFc, m * Ft * exp_ip)
-    delfwt = m * Ft * exp_ip - DFc
+    Fexp = twin_data.expected_F(Io, sigIo)
+    if 1:
+        fwt = numpy.where(numpy.asarray(twin_data.centric) == 0,
+                          2 * m * Ft * exp_ip - DFc,
+                          m * Ft * exp_ip)
+        delfwt = m * Ft * exp_ip - DFc
+    else: # based on "more accurate" evaluation of <m|F|>
+        fwt = numpy.where(numpy.asarray(twin_data.centric) == 0,
+                          2 * Fexp * exp_ip - DFc,
+                          m * Fexp * exp_ip)
+        delfwt = Fexp * exp_ip - DFc
+
     sel = numpy.isnan(fwt)
     fwt[sel] = DFc[sel]
     
@@ -1105,7 +1112,8 @@ def calculate_maps_twin(hkldata, b_aniso, fc_labs, D_labs, twin_data, centric_an
     hkldata2.df["FWT"] = fwt
     hkldata2.df["DELFWT"] = delfwt
     hkldata2.df["FOM"] = m
-    hkldata2.df["F_est"] = F_true
+    hkldata2.df["F_est"] = Ft
+    hkldata2.df["F_exp"] = Fexp
     hkldata2.df["FC"] = twin_data.f_calc.sum(axis=1)
     hkldata2.df["DFC"] = DFc
     hkldata2.df[D_labs] = Ds
@@ -1116,7 +1124,7 @@ def calculate_maps_twin(hkldata, b_aniso, fc_labs, D_labs, twin_data, centric_an
 def merge_models(sts): # simply merge models. no fix in chain ids etc.
     st2 = sts[0].clone()
     del st2[:]
-    model = gemmi.Model("1")
+    model = gemmi.Model(1)
     for st in sts:
         for m in st:
             for c in m:
@@ -1153,10 +1161,9 @@ def decide_mtz_labels(mtz, find_free=True, require=None):
 
 def process_input(hklin, labin, n_bins, free, xyzins, source, d_max=None, d_min=None,
                   n_per_bin=None, use="all", max_bins=None, cif_index=0, keep_charges=False,
-                  allow_unusual_occupancies=False):
+                  allow_unusual_occupancies=False, space_group=None):
     if labin: assert 1 < len(labin) < 6
     assert use in ("all", "work", "test")
-    assert n_bins or n_per_bin #if n_bins not set, n_per_bin should be given
 
     if len(xyzins) > 0 and type(xyzins[0]) is gemmi.Structure:
         sts = xyzins
@@ -1194,6 +1201,7 @@ def process_input(hklin, labin, n_bins, free, xyzins, source, d_max=None, d_min=
     logger.writeln("Observation type: {}".format(name))
     if len(newlabels) < len(labin): newlabels.append("FREE")
     hkldata = utils.hkl.hkldata_from_mtz(mtz, labin, newlabels=newlabels, require_types=require_types)
+    hkldata.mask_invalid_obs_values(newlabels)
     if newlabels[0] == "F(+)":
         hkldata.merge_anomalous(newlabels[:4], ["FP", "SIGFP"])
         newlabels = ["FP", "SIGFP"] + newlabels[4:]
@@ -1204,6 +1212,12 @@ def process_input(hklin, labin, n_bins, free, xyzins, source, d_max=None, d_min=
     if hkldata.df.empty:
         raise RuntimeError("No data in hkl data")
     
+    if space_group is None:
+        sg_use = None
+    else:
+        sg_use = gemmi.SpaceGroup(space_group)
+        logger.writeln(f"Space group overridden by user. Using {sg_use.xhm()}")
+    
     if sts:
         assert source in ["electron", "xray", "neutron"]
         for st in sts:
@@ -1216,39 +1230,40 @@ def process_input(hklin, labin, n_bins, free, xyzins, source, d_max=None, d_min=
         for st in sts: st.cell = hkldata.cell # mtz cell is used in any case
 
         sg_st = sts[0].find_spacegroup() # may be None
-        sg_use = hkldata.sg
-        if hkldata.sg != sg_st:
-            if st.cell.is_crystal() and sg_st and sg_st.laue_str() != hkldata.sg.laue_str():
-                raise RuntimeError("Crystal symmetry mismatch between model and data")
-            logger.writeln("Warning: space group mismatch between model and mtz")
-            if sg_st and sg_st.laue_str() == hkldata.sg.laue_str():
-                logger.writeln("         using space group from model")
-                sg_use = sg_st
-            else:
-                logger.writeln("         using space group from mtz")
-            logger.writeln("")
-
+        if sg_use is None:
+            sg_use = hkldata.sg
+            if hkldata.sg != sg_st:
+                if st.cell.is_crystal() and sg_st and sg_st.laue_str() != hkldata.sg.laue_str():
+                    raise RuntimeError("Crystal symmetry mismatch between model and data")
+                logger.writeln("Warning: space group mismatch between model and mtz")
+                if sg_st and sg_st.laue_str() == hkldata.sg.laue_str():
+                    logger.writeln("         using space group from model")
+                    sg_use = sg_st
+                else:
+                    logger.writeln("         using space group from mtz")
+                logger.writeln("")
+            
         for st in sts:
             st.spacegroup_hm = sg_use.xhm()
             st.setup_cell_images()
-        hkldata.sg = sg_use
 
         if not keep_charges:
             utils.model.remove_charge(sts)
         utils.model.check_atomsf(sts, source)
 
-    if newlabels[0] == "FP":
-        hkldata.remove_nonpositive(newlabels[0])
-    hkldata.remove_nonpositive(newlabels[1])
+    if sg_use is not None:
+        hkldata.sg = sg_use
     hkldata.switch_to_asu()
     hkldata.remove_systematic_absences()
     #hkldata.df = hkldata.df.astype({name: 'float64' for name in ["I","SIGI","FP","SIGFP"] if name in hkldata.df})
-
+    d_min_data = hkldata.d_min_max(newlabels)[0]
+    if d_min is None and hkldata.d_min_max()[0] != d_min_data:
+        d_min = d_min_data
+        logger.writeln(f"Changing resolution to {d_min:.3f} A")
     if (d_min, d_max).count(None) != 2:
         hkldata = hkldata.copy(d_min=d_min, d_max=d_max)
     if hkldata.df.empty:
         raise RuntimeError("No data left in hkl data")
-    d_min, d_max = hkldata.d_min_max()
         
     hkldata.complete()
     hkldata.sort_by_resolution()
@@ -1259,6 +1274,17 @@ def process_input(hklin, labin, n_bins, free, xyzins, source, d_max=None, d_min=
         free = hkldata.guess_free_number(newlabels[0])
 
     if n_bins is None:
+        if n_per_bin is None:
+            if use == "all" or "FREE" not in hkldata.df:
+                n_per_bin = 100
+                use = "all"
+            elif use == "work":
+                n_per_bin = 100
+            elif use == "test":
+                n_per_bin = 50
+            else:
+                raise RuntimeError(f"should not happen: {use=}")
+        
         sel = hkldata.df[newlabels[0]].notna()
         if use == "work":
             sel &= hkldata.df.FREE != free
@@ -1452,13 +1478,11 @@ def calculate_maps(hkldata, b_aniso, centric_and_selections, fc_labs, D_labs, lo
                 Sigma = 2 * SigFo**2 + epsilon * S
                 X = 2 * Fo * DFc_abs / Sigma
                 m = gemmi.bessel_i1_over_i0(X)
-                hkldata.df.loc[cidxes, "FWT"] = (2 * m * Fo - DFc_abs) * expip
             else:
                 Sigma = SigFo**2 + epsilon * S
                 X = Fo * DFc_abs / Sigma
                 m = numpy.tanh(X)
-                hkldata.df.loc[cidxes, "FWT"] = (m * Fo) * expip
-
+            hkldata.df.loc[cidxes, "FWT"] = (2 * m * Fo - DFc_abs) * expip
             hkldata.df.loc[cidxes, "DELFWT"] = (m * Fo - DFc_abs) * expip
             hkldata.df.loc[cidxes, "FOM"] = m
             hkldata.df.loc[cidxes, "X"] = X
@@ -1479,7 +1503,8 @@ def calculate_maps(hkldata, b_aniso, centric_and_selections, fc_labs, D_labs, lo
         Fc = hkldata.df.FC.to_numpy()[idxes] * k_ani[idxes]
         Fo = hkldata.df.FP.to_numpy()[idxes]
         mean_DFc2 = numpy.nanmean(numpy.abs((Ds[idxes,:] * Fcs[idxes,:]).sum(axis=1) * k_ani[idxes])**2)
-        mean_log_DFcs = numpy.log(numpy.nanmean(numpy.abs(Ds[idxes,:] * Fcs[idxes,:] * k_ani[idxes,None]), axis=0)).tolist()
+        with numpy.errstate(divide="ignore"):
+            mean_log_DFcs = numpy.log(numpy.nanmean(numpy.abs(Ds[idxes,:] * Fcs[idxes,:] * k_ani[idxes,None]), axis=0)).tolist()
         mean_Ds = numpy.nanmean(Ds[idxes,:], axis=0).tolist()
         if sum(nrefs) > 0:
             r = numpy.nansum(numpy.abs(numpy.abs(Fc)-Fo)) / numpy.nansum(Fo)
@@ -1514,7 +1539,6 @@ def calculate_maps(hkldata, b_aniso, centric_and_selections, fc_labs, D_labs, lo
 # calculate_maps()
 
 def main(args):
-    n_per_bin = {"all": 500, "work": 500, "test": 50}[args.use]
     try:
         hkldata, sts, fc_labs, centric_and_selections,free = process_input(hklin=args.hklin,
                                                                            labin=args.labin.split(",") if args.labin else None,
@@ -1524,15 +1548,15 @@ def main(args):
                                                                            source=args.source,
                                                                            d_max=args.d_max,
                                                                            d_min=args.d_min,
-                                                                           n_per_bin=n_per_bin,
                                                                            use=args.use,
                                                                            max_bins=30,
-                                                                           keep_charges=args.keep_charges)
+                                                                           keep_charges=args.keep_charges,
+                                                                           space_group=args.spacegroup)
     except RuntimeError as e:
         raise SystemExit("Error: {}".format(e))
 
     if args.twin:
-        twin_data = find_twin_domains_from_data(hkldata)
+        twin_data, _ = find_twin_domains_from_data(hkldata)
     else:
         twin_data = None
     if twin_data:
@@ -1597,7 +1621,7 @@ def main(args):
 
     # Write mtz file
     if twin_data:
-        labs = ["F_est"]
+        labs = ["F_est", "F_exp"]
     elif is_int:
         labs = ["I", "SIGI"]
     else:
@@ -1613,7 +1637,7 @@ def main(args):
         labs.append("F_true_est")
     labs += D_labs + ["S"]
     mtz_out = args.output_prefix+".mtz"
-    hkldata.write_mtz(mtz_out, labs=labs, types={"FOM": "W", "FP":"F", "SIGFP":"Q", "F_est": "F"})
+    hkldata.write_mtz(mtz_out, labs=labs, types={"FOM": "W", "FP":"F", "SIGFP":"Q", "F_est": "F", "F_exp": "F"})
     return hkldata
 # main()
 if __name__ == "__main__":

servalcat/xtal/twin.py

@@ -21,95 +21,124 @@ def find_twin_domains_from_data(hkldata, max_oblique=5, min_alpha=0.05):
     #for op in ops:
     #    logger.writeln(f"  {op.triplet()}")
     if not ops:
-        return
+        logger.writeln("")
+        return None, None
     twin_data = ext.TwinData()
-    twin_data.setup(hkldata.miller_array().to_numpy(), hkldata.df.bin, hkldata.sg, hkldata.cell, ops)
+    twin_data.setup(hkldata.miller_array(), hkldata.df.bin, hkldata.sg, hkldata.cell, ops)
     if "I" in hkldata.df:
         Io = hkldata.df.I.to_numpy()
     else:
         Io = hkldata.df.FP.to_numpy()**2
-    alphas = []
     ccs, nums = [], []
+    tmp = []
     for i_bin, bin_idxes in hkldata.binned():
         ratios = [1.]
         ccs.append([])
         nums.append([])
+        rs = []
         for i_op, op in enumerate(ops):
             ii = numpy.array(twin_data.pairs(i_op, i_bin))
             val = numpy.all(numpy.isfinite(Io[ii]), axis=1)
-            cc = numpy.corrcoef(Io[ii][val].T)[0,1]
-            rr = (1 - numpy.sqrt(1 - cc**2)) / cc
-            ratios.append(rr)
+            if numpy.sum(val) == 0:
+                cc = r = numpy.nan
+            else:
+                cc = numpy.corrcoef(Io[ii][val].T)[0,1]
+                r = numpy.sum(numpy.abs(Io[ii][val, 0] - Io[ii][val, 1])) / numpy.sum(Io[ii][val])
+            ratio = (1 - numpy.sqrt(1 - cc**2)) / cc
+            ratios.append(ratio)
             ccs[-1].append(cc)
+            rs.append(r)
             nums[-1].append(len(val))
-        alphas.append(numpy.array(ratios) / sum(ratios))
-    alphas = numpy.maximum(0, numpy.mean(alphas, axis=0))
-    alphas /= numpy.sum(alphas)
+        tmp.append(rs + ccs[-1] + nums[-1] + (numpy.array(ratios) / numpy.nansum(ratios)).tolist()[1:])
+    df = pandas.DataFrame(tmp, columns=[f"{n}_op{i+1}" for n in ("R", "CC", "num", "raw_est") for i in range(len(ops))])
+    with logger.with_prefix(" "):
+        logger.writeln(df.to_string(float_format="%.4f"))
     ccs = numpy.array(ccs)
     nums = numpy.array(nums)
     tmp = [{"Operator": gemmi.Op().triplet(),
             "R_twin_obs": 0,
-            "CC_mean": 1,
-            "Alpha_from_CC": alphas[0]}]
+            "CC_mean": 1}]
     for i_op, op in enumerate(ops):
         ii = numpy.array(twin_data.pairs(i_op))
         val = numpy.all(numpy.isfinite(Io[ii]), axis=1)
-        r_obs = numpy.sum(numpy.abs(Io[ii][val, 0] - Io[ii][val, 1])) / numpy.sum(Io[ii][val])
+        if numpy.sum(val) == 0:
+            r_obs = numpy.nan
+        else:
+            r_obs = numpy.sum(numpy.abs(Io[ii][val, 0] - Io[ii][val, 1])) / numpy.sum(Io[ii][val])
+        cc = numpy.sum(nums[:,i_op] * ccs[:,i_op]) / numpy.sum(nums[:,i_op])
         tmp.append({"Operator": op.triplet(),
-                    "CC_mean": numpy.sum(nums[:,i_op] * ccs[:,i_op]) / numpy.sum(nums[:,i_op]),
+                    "CC_mean": cc, 
                     "R_twin_obs": r_obs,
-                    "Alpha_from_CC": alphas[i_op+1],
                     })
     df = pandas.DataFrame(tmp)
-    logger.writeln(df.to_string(float_format="%.2f"))
+    df["Alpha_from_CC"] = (1 - numpy.sqrt(1 - df["CC_mean"]**2)) / df["CC_mean"]
+    df["Alpha_from_CC"] /= numpy.nansum(df["Alpha_from_CC"])
+    logger.writeln("\n Initial twin fraction estimates:")
+    with logger.with_prefix(" "):
+        logger.writeln(df.to_string(float_format="%.2f"))
 
-    sel_idxes = [i for i, a in enumerate(alphas) if i > 0 and a > min_alpha]
-    if not sel_idxes:
-        logger.writeln(" No twinning detected")
-        return
+    sel = df["Alpha_from_CC"].to_numpy() > min_alpha
+    if sel[1:].sum() == 0:
+        logger.writeln(" No twinning detected\n")
+        return None, None
     
-    if len(sel_idxes) + 1 != len(alphas):
-        ops = [ops[i-1] for i in sel_idxes]
-        logger.writeln(" Twin operators after filtering small fractions")
-        alphas = numpy.array([alphas[0]] + [alphas[i] for i in sel_idxes])
-        alphas /= numpy.sum(alphas)
-        df = pandas.DataFrame({"Operator": [x.triplet() for x in [gemmi.Op()]+ops],
-                               "Alpha": alphas})
-        logger.writeln(df.to_string(float_format="%.2f"))
+    if not sel.all():
+        ops = [ops[i] for i in range(len(ops)) if sel[i+1]]
+        logger.writeln(f"\n Twin operators after filtering small fractions (<= {min_alpha})")
+        df = df[sel]
+        df["Alpha_from_CC"] /= numpy.nansum(df["Alpha_from_CC"])
+        with logger.with_prefix(" "):
+            logger.writeln(df.to_string(float_format="%.2f"))
         twin_data = ext.TwinData()
-        twin_data.setup(hkldata.miller_array().to_numpy(), hkldata.df.bin, hkldata.sg, hkldata.cell, ops)
-    twin_data.alphas = alphas
+        twin_data.setup(hkldata.miller_array(), hkldata.df.bin, hkldata.sg, hkldata.cell, ops)
+    twin_data.alphas = df["Alpha_from_CC"].tolist()
     if "I" not in hkldata.df:
         logger.writeln('Generating "observed" intensities for twin refinement: Io = Fo**2, SigIo = 2*F*SigFo')
         hkldata.df["I"] = hkldata.df.FP**2
         hkldata.df["SIGI"] = 2 * hkldata.df.FP * hkldata.df.SIGFP
-    return twin_data
+    logger.writeln("")
+    return twin_data, df
 
 # find_twin_domains_from_data()
 
 def estimate_twin_fractions_from_model(twin_data, hkldata):
     logger.writeln("Estimating twin fractions")
     Ic = numpy.abs(twin_data.f_calc.sum(axis=1))**2
-    Ic_all = Ic[twin_data.twin_related(hkldata.sg)]
+    idx_all = twin_data.twin_related(hkldata.sg)
+    Ic_all = Ic[idx_all]
+    Ic_all[(idx_all < 0).any(axis=1)] = numpy.nan
     rr = twin_data.obs_related_asu()
     tmp = []
+    P_list, cc_oc_list, weight_list = [], [], []
+    n_ops = len(twin_data.ops) + 1
+    tidxes = numpy.triu_indices(n_ops, 1)
     for i_bin, bin_idxes in hkldata.binned():
-        cc_o_c = []
         i_tmp = Ic_all[numpy.asarray(twin_data.bin)==i_bin,:]
+        i_tmp = i_tmp[numpy.isfinite(i_tmp).all(axis=1)]
         P = numpy.corrcoef(i_tmp.T)
         iobs = hkldata.df.I.to_numpy()[bin_idxes]
         ic_bin = Ic[rr[bin_idxes,:]]
-        val = numpy.isfinite(iobs) & numpy.isfinite(ic_bin).all(axis=1)
+        val = numpy.isfinite(iobs) & numpy.isfinite(ic_bin).all(axis=1) & numpy.all(rr[bin_idxes,:]>=0, axis=1)
         iobs, ic_bin = iobs[val], ic_bin[val,:]
-        cc_o_c = [numpy.corrcoef(iobs, ic_bin[:,i])[0,1] for i in range(len(twin_data.ops)+1)]
-        frac_est = numpy.dot(numpy.linalg.pinv(P), cc_o_c)
-        tmp.append(frac_est.tolist())
-
-    df = pandas.DataFrame(tmp)
-    df.iloc[:,:] /= df.sum(axis=1).to_numpy()[:,None]
-    mean_alphas = numpy.maximum(0, df.mean())
-    mean_alphas /= numpy.sum(mean_alphas)
-    logger.write(" Estimated fractions from data-model correlations: ")
-    logger.writeln(" ".join("%.2f"%x for x in mean_alphas))
-    twin_data.alphas = mean_alphas
+        cc_oc = [numpy.corrcoef(iobs, ic_bin[:,i])[0,1] for i in range(n_ops)]
+        P_list.append(P)
+        cc_oc_list.append(cc_oc)
+        weight_list.append(numpy.sum(val))
+        frac_est = numpy.dot(numpy.linalg.pinv(P), cc_oc)
+        frac_est /= frac_est.sum()
+        tmp.append(P[tidxes].tolist() + cc_oc + [weight_list[-1]] + frac_est.tolist())
 
+    P = numpy.average(P_list, axis=0, weights=weight_list)
+    cc_oc = numpy.average(cc_oc_list, axis=0, weights=weight_list)
+    frac_est = numpy.dot(numpy.linalg.pinv(P), cc_oc)
+    frac_est = numpy.maximum(0, frac_est)
+    frac_est /= frac_est.sum()
+    df = pandas.DataFrame(tmp, columns=[f"cc_{i+1}_{j+1}" for i, j in zip(*tidxes)] +
+                          [f"cc_o_{i+1}" for i in range(n_ops)] +
+                          ["nref"] + [f"raw_est_{i+1}" for i in range(n_ops)])
+    with logger.with_prefix(" "):
+        logger.writeln(df.to_string(float_format="%.4f"))
+    logger.write(" Final twin fraction estimate: ")
+    logger.writeln(" ".join("%.2f"%x for x in frac_est))
+    twin_data.alphas = frac_est
+    return df

{servalcat-0.4.88.dist-info → servalcat-0.4.100.dist-info}/METADATA

@@ -1,16 +1,16 @@
 Metadata-Version: 2.1
 Name: servalcat
-Version: 0.4.88
+Version: 0.4.100
 Summary: Structure refinement and validation for crystallography and single particle analysis
 Author: Keitaro Yamashita, Garib N. Murshudov
 License: MPL-2.0
 Project-URL: Repository, https://github.com/keitaroyam/servalcat
-Requires-Python: >=3.7
+Requires-Python: >=3.8
 Requires-Dist: packaging
 Requires-Dist: numpy>=1.15
 Requires-Dist: scipy
 Requires-Dist: pandas>=1.1.0
-Requires-Dist: gemmi==0.6.7
+Requires-Dist: gemmi==0.7.0
 Description-Content-Type: text/markdown
 
 # Servalcat
@@ -40,7 +40,7 @@ pip install servalcat
 ```
 will install the stable version.
 
-The required GEMMI version is now [v0.6.7](https://github.com/project-gemmi/gemmi/releases/tag/v0.6.7). It may not work with the latest gemmi code from the github. The policy is in the main branch I only push the code that works with the latest package of GEMMI.
+The required GEMMI version is now [v0.7.0](https://github.com/project-gemmi/gemmi/releases/tag/v0.7.0). It may not work with the latest gemmi code from the github. The policy is in the main branch I only push the code that works with the latest package of GEMMI.
 
 To use the Refmac5 related commands, you also need to install [CCP4](https://www.ccp4.ac.uk/). For "No Refmac5" commands, you may just need [the monomer library](https://github.com/MonomerLibrary/monomers) if CCP4 is not installed.
 

servalcat-0.4.100.dist-info/RECORD

@@ -0,0 +1,45 @@
+servalcat-0.4.100.dist-info/RECORD,,
+servalcat-0.4.100.dist-info/WHEEL,sha256=PJzLOGr1UQbVJ9ClJnwqiFhnlyWYjSsyNgebnLgIQKg,114
+servalcat-0.4.100.dist-info/entry_points.txt,sha256=G1mDxhOCdF3umYz4k0kfwJbSdYSKqhvQdGCmrP8FRAY,111
+servalcat-0.4.100.dist-info/METADATA,sha256=fY8VFfVql5PFlkJdbmAFaPOH9WVm8MJ7oKedUyyL9ys,2742
+servalcat-0.4.100.dist-info/licenses/LICENSE,sha256=HyVuytGSiAUQ6ErWBHTqt1iSGHhLmlC8fO7jTCuR8dU,16725
+servalcat/__init__.py,sha256=QKT0vTBwtQtat3LpKrUkOQ5o2aA_FjjhNjTdQPhyes8,232
+servalcat/__main__.py,sha256=bNEZKrG5765uOp32UiBAJmeJi3O0sk4I5QjrXUbngIE,4070
+servalcat/ext.cpython-313-darwin.so,sha256=RD8t3hM02Jf50Km9p97-thsCHwrICTQMNcOQ9sMcz18,1219592
+servalcat/refmac/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+servalcat/refmac/refmac_keywords.py,sha256=yzYSJELMjdTnf4pT0_8EdIOjCDncqkjpPJ3VNcsFDrU,26649
+servalcat/refmac/exte.py,sha256=HtmlTHRzCeCN-vSJZdKCD1GIhQO6zTe1OKLUObC3gZ8,9019
+servalcat/refmac/refmac_wrapper.py,sha256=euuhBv2F_ArmUvlfAA9fld4oCDkWMZENP73ioTtv118,17838
+servalcat/xtal/twin.py,sha256=FfmVIdwve7MCCFXu019MYKSeWX8_Vy0SrHjqh1_sxBs,6181
+servalcat/xtal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+servalcat/xtal/sigmaa.py,sha256=ZkswqjUw-ISOjsRiwJC4FcsR_RlRvv6eYIzBbeKVTIc,75258
+servalcat/xtal/french_wilson.py,sha256=GE3WEPhuizDVSPq1Afyb1O-OPTlzKDXYhkDCIELWI_0,11787
+servalcat/xtal/run_refmac_small.py,sha256=Yg-bEPuOdQxCwdwY8StCvXabcWHrRl6A22gJgLsypeU,10394
+servalcat/utils/symmetry.py,sha256=ahMiaEDMyfV2YW0BkikF_ldMtIN4-usAGsNRCXGVbug,11869
+servalcat/utils/generate_operators.py,sha256=fCrcTcciRn-6fpFtHYvf1oPXAObjuqR3WQejz5d0RrA,10980
+servalcat/utils/maps.py,sha256=0hen0Pt9IxbGQOLZyZaGiNWBAttc6aMqb6NzrCKkZMQ,13225
+servalcat/utils/__init__.py,sha256=j-fMAqHvzyMMQXb2Sf7Urnk4oQ31pT-g_NXf3K-NM4c,1137
+servalcat/utils/logger.py,sha256=eglkG7RxCJl4Q5P0aQGp4SVauoWh36nQgFvSJJLpyrM,4587
+servalcat/utils/model.py,sha256=78flu7sl-MmlN_ItY4YSWxyvTxuSsRMgBPotzh9MHqc,30556
+servalcat/utils/restraints.py,sha256=V2QBfgSH636upbLtGany4QyBk3r05CLxqvJYiM1SLSQ,36960
+servalcat/utils/refmac.py,sha256=LKwgCtLg7R5D8mjI7yCGd2lrjcjTeEJVAo1pey2u3IU,30922
+servalcat/utils/commands.py,sha256=dxsbPMZl-1BVKKr0rXzGF08k-Aco5qwzEHRWxZlcxek,70956
+servalcat/utils/hkl.py,sha256=dPwHxCRx33j_Egd9lKRWlUbk5MecziSiqW6vJz_eeUk,29787
+servalcat/utils/fileio.py,sha256=YytwlL0SeaxHCgIzFEjfS_tRpLDmvhVDjwEnkDXw1_E,29502
+servalcat/spa/shiftback.py,sha256=A9OfaZ8r2BC6A2uGXxNNhmyBNORUB_MeqJC29ZRebnw,4664
+servalcat/spa/localcc.py,sha256=0otKfGKH33cFsD6Qvh8iL1mINlWqb3gqAbVKqy8fQPY,7985
+servalcat/spa/translate.py,sha256=BwmVcyDbqDehjtH7kA4wQFF4hJb9c1gcHu7JbGREUTU,5099
+servalcat/spa/run_refmac.py,sha256=tX0a37-aTJgADZ_NCdKbT8aE4P9Bnmm1qrFW2jc9Hw4,49550
+servalcat/spa/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+servalcat/spa/fsc.py,sha256=ISsBOl5JJZA6yT2yuDHNQ4I780TrmuYW6CPvimCwDqo,17454
+servalcat/spa/realspcc_from_var.py,sha256=VpdvNEY4zRza08Vz727JI6Seq-ix-oujx4Gvzy_VkYI,5275
+servalcat/spa/shift_maps.py,sha256=iP1w4LNXETvZblElJ64AFMcE-lPrhx1s4SfacGktg4o,13268
+servalcat/spa/fofc.py,sha256=Q97XkJX_4KWmxCIzq16R5BTMUY28V_4CPdbzF6p5Oxo,23113
+servalcat/refine/xtal.py,sha256=F_inGxiUJ1FabeJe2IMZiqJbJRuDrvJedYAoCwWnDSY,14635
+servalcat/refine/refine.py,sha256=W3oduNRNgc05mqMO1wYUdgN3pRrUuR9kEJ3yhAJd9jQ,44035
+servalcat/refine/refine_spa.py,sha256=nTNw2c1HU6sCbdfjR7gPyWiKDpvhep8wNnL4d5Mfjnc,19318
+servalcat/refine/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+servalcat/refine/spa.py,sha256=lmh4P6nQNFIdaZUKFIc_ES6B6X-FG-JkxyfpqHgtk9g,6472
+servalcat/refine/cgsolve.py,sha256=tHuWXr76x4sRAMUQ4dGVJzyHF_n1LiwKHTjAwh8iFMg,3072
+servalcat/refine/refine_geom.py,sha256=uATaTCEVkPJw3DjpVX66j7mhYs9Mp21rDwBfumrpwfw,11352
+servalcat/refine/refine_xtal.py,sha256=dxJsS73frNbjgQOwiMopv4ijed23-AXxmhZv5v0-kGk,14564

{servalcat-0.4.88.dist-info → servalcat-0.4.100.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: scikit-build-core 0.10.6
+Generator: scikit-build-core 0.10.7
 Root-Is-Purelib: false
 Tag: cp313-cp313-macosx_11_0_arm64
 

servalcat-0.4.88.dist-info/RECORD

@@ -1,45 +0,0 @@
-servalcat-0.4.88.dist-info/RECORD,,
-servalcat-0.4.88.dist-info/WHEEL,sha256=ULmZMDTYkGtY4RRvuVnUViaZ4lRrvEqSp2J4UKfolWA,114
-servalcat-0.4.88.dist-info/entry_points.txt,sha256=G1mDxhOCdF3umYz4k0kfwJbSdYSKqhvQdGCmrP8FRAY,111
-servalcat-0.4.88.dist-info/METADATA,sha256=B0VVGu-KUJy9euhZEeDrZ_mIlwvMBeKh3e8Pz8zm_ww,2741
-servalcat-0.4.88.dist-info/licenses/LICENSE,sha256=HyVuytGSiAUQ6ErWBHTqt1iSGHhLmlC8fO7jTCuR8dU,16725
-servalcat/__init__.py,sha256=6hLXc7c2AoM0dJqaoKHAGlmleut4b6M7aAbDE0byRG4,231
-servalcat/__main__.py,sha256=bNEZKrG5765uOp32UiBAJmeJi3O0sk4I5QjrXUbngIE,4070
-servalcat/ext.cpython-313-darwin.so,sha256=Sq-7TQ8Bw8lu2KTlT5XfefOtoS6mpUI1Eh0TwIbGfL0,2131880
-servalcat/refmac/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-servalcat/refmac/refmac_keywords.py,sha256=yzYSJELMjdTnf4pT0_8EdIOjCDncqkjpPJ3VNcsFDrU,26649
-servalcat/refmac/exte.py,sha256=HtmlTHRzCeCN-vSJZdKCD1GIhQO6zTe1OKLUObC3gZ8,9019
-servalcat/refmac/refmac_wrapper.py,sha256=iZvHZRpFKrdxx0ggT9AFUmjnuBXyfZBdJ69ZnN0_zkQ,18130
-servalcat/xtal/twin.py,sha256=Q1lbYm17w75KohvOS5blyp8TEGviWJ9zJlmmy8zSnU8,4741
-servalcat/xtal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-servalcat/xtal/sigmaa.py,sha256=LvRu76y0AqrT_n7LpDQnqcKm4NDkslroCkWowmIs5lk,74185
-servalcat/xtal/french_wilson.py,sha256=pL97K22WIkHHy_IexGPFhCan2WRHHemdWO0x7glTT7s,11656
-servalcat/xtal/run_refmac_small.py,sha256=Yg-bEPuOdQxCwdwY8StCvXabcWHrRl6A22gJgLsypeU,10394
-servalcat/utils/symmetry.py,sha256=H-5RBiQOp0MlWJE8LGJWvqe-YzmtzzrXfLO_2E_OpZU,11937
-servalcat/utils/generate_operators.py,sha256=fCrcTcciRn-6fpFtHYvf1oPXAObjuqR3WQejz5d0RrA,10980
-servalcat/utils/maps.py,sha256=ZoB3wwZZTLHYuwC4HBGFAYX4zmkZ8CdxD9wSLftL48c,13217
-servalcat/utils/__init__.py,sha256=j-fMAqHvzyMMQXb2Sf7Urnk4oQ31pT-g_NXf3K-NM4c,1137
-servalcat/utils/logger.py,sha256=oQcoKcM81fSsoQt_dKgwfUekJN5CcLMbti_kLb2loXM,3828
-servalcat/utils/model.py,sha256=_XpYd1WKtI1ErCXzNCxIukYClhJWl8BcFUfTgu-NB4E,30272
-servalcat/utils/restraints.py,sha256=IookRqipmUQlEgYRbt9lhzSuRHPuIq0QputfN87cEms,36911
-servalcat/utils/refmac.py,sha256=SFIReNexBpBBMgBUX67V_63NY8Yy8mOmAn9rYBPiDIo,30921
-servalcat/utils/commands.py,sha256=zkSFmdXIthC4ogvxgiHsVUyhBLZaiwflJAwP0CCBnZ8,64037
-servalcat/utils/hkl.py,sha256=3sw5NVJTKAp-7KzZmKsgGCpeRLKih4Wdf1kPK1JR4fM,28170
-servalcat/utils/fileio.py,sha256=NROzr_mpgc5qbvhaoEsIOHEFnN0uthabqKUiINE8Xnw,29085
-servalcat/spa/shiftback.py,sha256=A9OfaZ8r2BC6A2uGXxNNhmyBNORUB_MeqJC29ZRebnw,4664
-servalcat/spa/localcc.py,sha256=0otKfGKH33cFsD6Qvh8iL1mINlWqb3gqAbVKqy8fQPY,7985
-servalcat/spa/translate.py,sha256=InePz9d38KaUK4wr8uk06_6v4y80T3HYcURWp8c21zM,5091
-servalcat/spa/run_refmac.py,sha256=KWl7Cc6MLlsJdEsJ6MXBP8_2FiWeDZ66xmk04Ka-cVY,49196
-servalcat/spa/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-servalcat/spa/fsc.py,sha256=lRkNRRBSIcVlnoF5mvCKNXTxasp73a7SCLth4hTnWzE,17419
-servalcat/spa/realspcc_from_var.py,sha256=VpdvNEY4zRza08Vz727JI6Seq-ix-oujx4Gvzy_VkYI,5275
-servalcat/spa/shift_maps.py,sha256=iP1w4LNXETvZblElJ64AFMcE-lPrhx1s4SfacGktg4o,13268
-servalcat/spa/fofc.py,sha256=7ZG7wXtbcaeHG9dVZvYofNb75cbqthhE7O_XTVx-y70,22762
-servalcat/refine/xtal.py,sha256=YRZusmJXcMp1HtrKZiUd6JF-igS6MbHvOIuyFSPOVv0,14384
-servalcat/refine/refine.py,sha256=4ly66LSUNHbT6hqRnp-J-0G0CXOwLu_UKHW0LzT9CUw,38290
-servalcat/refine/refine_spa.py,sha256=J6LS8efSQ6sHEp5VH4It8TT734CQ5SVknP5AiQW9p0U,17896
-servalcat/refine/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-servalcat/refine/spa.py,sha256=P_IkA291ocl92SpZ8Uagcab_Usqj2JzW8cAw_aCPmpg,6238
-servalcat/refine/cgsolve.py,sha256=tHuWXr76x4sRAMUQ4dGVJzyHF_n1LiwKHTjAwh8iFMg,3072
-servalcat/refine/refine_geom.py,sha256=GNVyll5LVoEmAzzenikg-nKjJXCtJ8B8Gd13q5nMtCk,10757
-servalcat/refine/refine_xtal.py,sha256=tW4AC1O8esxls6MS6YMiya-R41-daIROGxZscLf2b4c,13843