servalcat 0.4.88__cp38-cp38-win_amd64.whl → 0.4.100__cp38-cp38-win_amd64.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/__init__.py,sha256=bOvfsOFrPkgPBtZIILjkf4hYnPjPRDQYcfbDpTzod3k,242
+servalcat/__main__.py,sha256=XUM193aDwZAEQY02VzvZasAzD6AYEM-_A4wqy93KDWE,4190
+servalcat/ext.cp38-win_amd64.pyd,sha256=LH6re0zSkTkpDdMcS5ibAhBJ49FUTTK6qV6CKWEnumY,1335296
+servalcat/refine/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+servalcat/refine/cgsolve.py,sha256=Xz7EwGI-mr4nnbfARyfFjAqbJbPWGH9qNWQ0GpltDuc,3172
+servalcat/refine/refine.py,sha256=P6epHQZLpz3Tl2fuGrdCp6WOxuzvik7YJJTBsd4zuHg,44941
+servalcat/refine/refine_geom.py,sha256=RMfhmBb-jlSFZoMhV3QONev9U2ZuHuPyjSslhECMYXo,11585
+servalcat/refine/refine_spa.py,sha256=tc1ZW-jJoIga5tfYA3DTLFg6QsgiN9xc_cDQKJQgtcc,19687
+servalcat/refine/refine_xtal.py,sha256=5qrLrUawTRuXVGoaBNpZeTJiHB6jYrJeNnARNFe9kvQ,14841
+servalcat/refine/spa.py,sha256=7aYSnSty0fSe46P_RQ79Bd_8RwD88k3uAaLHVsz6yHc,6616
+servalcat/refine/xtal.py,sha256=2GUcJZhY35CYr3P6StpjEnPdgBtLWG10mAuN-X4cXy4,14911
+servalcat/refmac/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+servalcat/refmac/exte.py,sha256=LRPej2yCZ4RoWJnEQldILEiUED6S_w1lgutWAdhu9_o,9201
+servalcat/refmac/refmac_keywords.py,sha256=WPLDQdk91i5yKZ0QcfaTQ6qL-_qBv7_91eUv4Is9j54,27288
+servalcat/refmac/refmac_wrapper.py,sha256=7FuYyWqN1UvSilFECWOSmWmYObXFLvO49PWkRbwBPHQ,18233
+servalcat/spa/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+servalcat/spa/fofc.py,sha256=DONPNvHPP9odKGNekpo781D_skjReUEytQ1wHBJxGwc,23592
+servalcat/spa/fsc.py,sha256=Rszx-zzJiX5iSY-Qp6q5uCrEhE3a5eyW-m_szT5itLA,17839
+servalcat/spa/localcc.py,sha256=FJMXiC0Po5eb1Le404mgNDj9VcxH5CRR9F5B7uDZn5w,8173
+servalcat/spa/realspcc_from_var.py,sha256=x3NaqGKpGmQyh3qp-SJ9kTA_hP2EvxBOIszYbV2EPKk,5403
+servalcat/spa/run_refmac.py,sha256=bHSj-8_RLdrfHTCyNWoMtXsrNT37AfpONZ8D3jR01ZE,50527
+servalcat/spa/shift_maps.py,sha256=G_EddBcdyncl2bhW7I-4YF0ZFtX9Q95a2SIJ9rpPeR4,13561
+servalcat/spa/shiftback.py,sha256=EtITj8Nllz-MWE6oJrxruDWeT0q7tS3RXCKtpWMuHNg,4801
+servalcat/spa/translate.py,sha256=PGf1vHh_b_mxDta_CAghY7QBRVPzHSaGLDhrnafqCdA,5228
+servalcat/utils/__init__.py,sha256=4umrD2fhG1QAQppDBQM95-6y8QYbtxr7Mi_-Nkc3XOA,1172
+servalcat/utils/commands.py,sha256=fEWF6HesIAuxnzbaKAPws_QaIPxJUQc6DVthHeex_Vk,72503
+servalcat/utils/fileio.py,sha256=3fyHTQ62sibP3cUYtX8D9G7cC6qelkfPKnbA47MqPOo,30246
+servalcat/utils/generate_operators.py,sha256=fCrcTcciRn-6fpFtHYvf1oPXAObjuqR3WQejz5d0RrA,10980
+servalcat/utils/hkl.py,sha256=pciLeh7dPxuF0-gmKRAI0h6zhYCA7QWH91LEBLzAHOA,30536
+servalcat/utils/logger.py,sha256=25uXUw8xCjvd9bnzIQ0Nq1C4MNIqEXSG-xScEnXGmLM,4727
+servalcat/utils/maps.py,sha256=1Gm54nEvPj4peCuo0Rx-8_gvRD1pr2qECq7U9N6mrVw,13570
+servalcat/utils/model.py,sha256=foNzqFxN306Ir40dpU4Djxx0sZ7Gbh0ZIJj-e3ifTPg,31345
+servalcat/utils/refmac.py,sha256=dY92UZo2orgZJOEmPacCek8PMj-ydCp6-pR0rdsAVG8,31682
+servalcat/utils/restraints.py,sha256=hclAJ3CKzIqeyC-I0rH8TSwikwQN1k8dUtYWKC0OAnU,37741
+servalcat/utils/symmetry.py,sha256=PSSD-S_j_t1m4E9F8Fd9RJqTWyKf92zLCjSED7iXFkU,12164
+servalcat/xtal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+servalcat/xtal/french_wilson.py,sha256=u4wzHuotO8-avPkhuEylg9WmMZYdGHYz1IvG07uqW3M,12045
+servalcat/xtal/run_refmac_small.py,sha256=_Rw7wz7_yAlQgDqjJ_njeK6ZqN_r7KAakoor9WeNhxI,10634
+servalcat/xtal/sigmaa.py,sha256=c2WuFu5cOew-TTJyYkJDaIykbRqFuKddGqTQblWfH6U,76904
+servalcat/xtal/twin.py,sha256=Z1WY3K61SFE4EcCo3C2lUxByhx68nkZMlruUNr5jimc,6325
+servalcat-0.4.100.dist-info/METADATA,sha256=fY8VFfVql5PFlkJdbmAFaPOH9WVm8MJ7oKedUyyL9ys,2742
+servalcat-0.4.100.dist-info/WHEEL,sha256=kwS-TzWMc793MQ545g1AsDhyMUJrOZEAGChkok6pUJs,104
+servalcat-0.4.100.dist-info/entry_points.txt,sha256=G1mDxhOCdF3umYz4k0kfwJbSdYSKqhvQdGCmrP8FRAY,111
+servalcat-0.4.100.dist-info/licenses/LICENSE,sha256=JoTeFzAOCkNGhvHsf4r2BFIHpLRXo_4EsrnOZV58XVA,17098
+servalcat-0.4.100.dist-info/RECORD,,

{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: cp38-cp38-win_amd64
 

servalcat-0.4.88.dist-info/RECORD

@@ -1,45 +0,0 @@
-servalcat/__init__.py,sha256=J-eWO5IStrvYxM0WSIzvvyPYYjxss2eHwjvBI0SHvTc,241
-servalcat/__main__.py,sha256=XUM193aDwZAEQY02VzvZasAzD6AYEM-_A4wqy93KDWE,4190
-servalcat/ext.cp38-win_amd64.pyd,sha256=oP9kBKKEz23lRVcLqrEsZCHg1ZkAP9jl5p1_400TYdE,2032640
-servalcat/refine/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-servalcat/refine/cgsolve.py,sha256=Xz7EwGI-mr4nnbfARyfFjAqbJbPWGH9qNWQ0GpltDuc,3172
-servalcat/refine/refine.py,sha256=dnpIICEbhUehxuQXoJGuvYfvVGFAIAYp4pWZO5RT-Qs,39113
-servalcat/refine/refine_geom.py,sha256=z59FZdKL2Dll-VBKOVGd9xxz2WRjDF4XSa5fRdIAW3c,10977
-servalcat/refine/refine_spa.py,sha256=OFwyGV4JLYNh-xcRh9ate-bpDZ11YKEm0nPdK0YbFRM,18241
-servalcat/refine/refine_xtal.py,sha256=oLEmdFeVDB4UdzzghsSE7NkGDa3uyKcDF3sosp-vx_g,14111
-servalcat/refine/spa.py,sha256=uc3kFLVMlFT_EaSjzOWZ4tx9XzGcPswffSW1PZd1i5Q,6374
-servalcat/refine/xtal.py,sha256=CP71Ga3enWjJoW4u8xibtv9RJYah7MFmiwpROkrJR30,14657
-servalcat/refmac/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-servalcat/refmac/exte.py,sha256=LRPej2yCZ4RoWJnEQldILEiUED6S_w1lgutWAdhu9_o,9201
-servalcat/refmac/refmac_keywords.py,sha256=WPLDQdk91i5yKZ0QcfaTQ6qL-_qBv7_91eUv4Is9j54,27288
-servalcat/refmac/refmac_wrapper.py,sha256=ku6oNdUDJGXSjQFpPaaDM4vBbbNTIoFHzMOsz-Ahdyg,18533
-servalcat/spa/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-servalcat/spa/fofc.py,sha256=Ztg7RCmq7_fdnwZbjQAV3C1VgYaDVXof04CN9ZHX_SU,23235
-servalcat/spa/fsc.py,sha256=vsHDKfQpkHHhklTVP4Le_4Ry26Xg5a--wIIqWKrrGlI,17806
-servalcat/spa/localcc.py,sha256=FJMXiC0Po5eb1Le404mgNDj9VcxH5CRR9F5B7uDZn5w,8173
-servalcat/spa/realspcc_from_var.py,sha256=x3NaqGKpGmQyh3qp-SJ9kTA_hP2EvxBOIszYbV2EPKk,5403
-servalcat/spa/run_refmac.py,sha256=vfCLoN__6PM-c8cdx9tIZ4KzNjGwVR-f6XQedtSlGsU,50168
-servalcat/spa/shift_maps.py,sha256=G_EddBcdyncl2bhW7I-4YF0ZFtX9Q95a2SIJ9rpPeR4,13561
-servalcat/spa/shiftback.py,sha256=EtITj8Nllz-MWE6oJrxruDWeT0q7tS3RXCKtpWMuHNg,4801
-servalcat/spa/translate.py,sha256=8Cwxvxb_Ooi14ZcBaGu2xky0IFS92PHWzCzEDS6u2vY,5220
-servalcat/utils/__init__.py,sha256=4umrD2fhG1QAQppDBQM95-6y8QYbtxr7Mi_-Nkc3XOA,1172
-servalcat/utils/commands.py,sha256=7tE6fr8NZ7NR7-sIMU4YztU5aFb72ZApdLQ_q2x_IMk,65434
-servalcat/utils/fileio.py,sha256=mIcwHVZkUNeUzYrlHAK9JZ2mk2KMGt7eu4Y_1MCskII,29822
-servalcat/utils/generate_operators.py,sha256=fCrcTcciRn-6fpFtHYvf1oPXAObjuqR3WQejz5d0RrA,10980
-servalcat/utils/hkl.py,sha256=w11Y8vK5w5Kv6RoW3neDk9irwp8MSDOdXaSugj3NzYg,28882
-servalcat/utils/logger.py,sha256=2XKMrcc-COGBscVsLNqY9VEHN-AEJW_qFc8xJxs7W7U,3944
-servalcat/utils/maps.py,sha256=UXOGPr-uELKiHCbm6OHNBzTALpfDxm1TZFQjYFOQzcw,13562
-servalcat/utils/model.py,sha256=UdnKyVhVbPzVhWYXvLhY0DITbdAQkmECYDnEll7unw8,31054
-servalcat/utils/refmac.py,sha256=NlpvU9Sk4VhK0We9eN6OCsC9gxZgjU8Lpwxekw23R_A,31681
-servalcat/utils/restraints.py,sha256=djrGTrcaMddPrfJVsQSCmOpo5Eqh2PUPks8dgStckIc,37693
-servalcat/utils/symmetry.py,sha256=vDzGPza7PhmohTNf6OPTsMyUHvHJx7CEyl5Ob8OhukY,12232
-servalcat/xtal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-servalcat/xtal/french_wilson.py,sha256=fAGbAeWUri83ELmzIdldsK1cMp1G_oACHq2Mv5LUTlg,11912
-servalcat/xtal/run_refmac_small.py,sha256=_Rw7wz7_yAlQgDqjJ_njeK6ZqN_r7KAakoor9WeNhxI,10634
-servalcat/xtal/sigmaa.py,sha256=8yQREli__FXR4FJprdg-Y-4zzqQMaRW86o53KDFFgPA,75807
-servalcat/xtal/twin.py,sha256=Gf7mmm3dHvrZBSjj-6CaRqnnJHMlWJb-dzJAopZjc8Q,4856
-servalcat-0.4.88.dist-info/METADATA,sha256=B0VVGu-KUJy9euhZEeDrZ_mIlwvMBeKh3e8Pz8zm_ww,2741
-servalcat-0.4.88.dist-info/WHEEL,sha256=UbVlwiZDGQxa8scCrLI_i5XYOEPPbzP6AL-ZVrjp7nk,104
-servalcat-0.4.88.dist-info/entry_points.txt,sha256=G1mDxhOCdF3umYz4k0kfwJbSdYSKqhvQdGCmrP8FRAY,111
-servalcat-0.4.88.dist-info/licenses/LICENSE,sha256=JoTeFzAOCkNGhvHsf4r2BFIHpLRXo_4EsrnOZV58XVA,17098
-servalcat-0.4.88.dist-info/RECORD,,