servalcat 0.4.131__cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl

servalcat/xtal/twin.py

@@ -0,0 +1,316 @@
+"""
+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 scipy.optimize
+from servalcat.utils import logger
+from servalcat import utils
+from servalcat import ext
+
+def calculate_obliquity(gv, twin_op):
+    """
+    Beforehand, the following calculation must be done
+    gv = gemmi.GruberVector(cell, sg.centring_type(), True)
+    gv.niggli_reduce()
+    """
+    def get_axis(r):
+        eigenvalues, eigenvectors = numpy.linalg.eig(r)
+        idx = numpy.argmin(numpy.abs(eigenvalues - 1))
+        return eigenvectors[:,idx].real
+    reduced_cell = gv.get_cell()
+    orth = numpy.array(reduced_cell.orth.mat.tolist())
+    frac = numpy.array(reduced_cell.frac.mat.tolist())
+    op = gv.change_of_basis.inverse().combine(twin_op.as_xyz()).combine(gv.change_of_basis)
+    r = numpy.array(op.rot) / op.DEN
+    u = get_axis(r)
+    h = get_axis(numpy.linalg.inv(r.transpose()))
+    tau = h.dot(frac)
+    t = orth.dot(u)
+    obl_deg = numpy.rad2deg(numpy.arccos(numpy.clip(t.dot(tau) / numpy.linalg.norm(t) / numpy.linalg.norm(tau), -1, 1)))
+    return obl_deg
+# calculate_obliquity()
+
+def find_twin_domains_from_data(hkldata, max_oblique=5, min_cc=0.2):
+    logger.writeln("Finding possible twin operators from data")
+    ops = gemmi.find_twin_laws(hkldata.cell, hkldata.sg, max_oblique, False)
+    logger.writeln(f" {len(ops)} possible twin operator(s) found")
+    #for op in ops:
+    #    logger.writeln(f"  {op.triplet()}")
+    if not ops:
+        logger.writeln("")
+        return None, None
+    gv = gemmi.GruberVector(hkldata.cell, hkldata.sg.centring_type(), True)
+    gv.niggli_reduce()
+    twin_data = ext.TwinData()
+    twin_data.setup(hkldata.miller_array(), hkldata.df.bin_ml, hkldata.sg, hkldata.cell, ops)
+    if "I" in hkldata.df:
+        Io = hkldata.df.I.to_numpy()
+    else:
+        Io = hkldata.df.FP.to_numpy()**2
+    ccs, nums = [], []
+    tmp = []
+    for i_bin, bin_idxes in hkldata.binned("ml"):
+        ccs.append([])
+        nums.append([])
+        rs = []
+        for i_op, op in enumerate(ops):
+            cc = r = numpy.nan
+            ii = numpy.array(twin_data.pairs(i_op, i_bin))
+            val = numpy.all(numpy.isfinite(Io[ii]), axis=1) if ii.size != 0 else []
+            if numpy.sum(val) != 0:
+                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])
+            ccs[-1].append(cc)
+            rs.append(r)
+            nums[-1].append(len(val))
+        tmp.append(rs + ccs[-1] + nums[-1])
+    df = pandas.DataFrame(tmp, columns=[f"{n}_op{i+1}" for n in ("R", "CC", "num") 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": "h,k,l",
+            "Obliquity": 0,
+            "R_twin_obs": 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)
+        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])
+        good = numpy.isfinite(ccs[:,i_op])
+        cc = numpy.sum(nums[good,i_op] * ccs[good,i_op]) / numpy.sum(nums[good,i_op])
+        tmp.append({"Operator": op.as_hkl().triplet(),
+                    "Obliquity": calculate_obliquity(gv, op),
+                    "CC_mean": cc, 
+                    "R_twin_obs": r_obs,
+                    })
+    df = pandas.DataFrame(tmp)
+    with logger.with_prefix(" "):
+        logger.writeln(df.to_string(float_format="%.2f"))
+
+    sel = df["CC_mean"].to_numpy() > min_cc
+    if sel[1:].sum() == 0:
+        logger.writeln(" No possible twinning detected\n")
+        return None, None
+    
+    if 0:#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 correlations (<= {min_cc})")
+        df = df[sel]
+        with logger.with_prefix(" "):
+            logger.writeln(df.to_string(float_format="%.2f"))
+        twin_data = ext.TwinData()
+        twin_data.setup(hkldata.miller_array(), hkldata.df.bin_ml, hkldata.sg, hkldata.cell, ops)
+    twin_data.alphas = [1. / len(twin_data.alphas) for _ in range(len(twin_data.alphas)) ]
+    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
+    logger.writeln("")
+    return twin_data, df
+
+# find_twin_domains_from_data()
+
+def estimate_twin_fractions_from_model(twin_data, hkldata, min_alpha=0.02):
+    logger.writeln("Estimating twin fractions")
+    Ic = numpy.abs(twin_data.f_calc.sum(axis=1))**2
+    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)
+    if "CC*" in hkldata.binned_df["ml"]:
+        logger.writeln(" data-correlations are corrected using CC*")
+    for i_bin, bin_idxes in hkldata.binned("ml"): # XXX
+        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) & numpy.all(rr[bin_idxes,:]>=0, axis=1)
+        iobs, ic_bin = iobs[val], ic_bin[val,:]
+        cc_star = hkldata.binned_df["ml"]["CC*"][i_bin] if "CC*" in hkldata.binned_df["ml"] else 1
+        if cc_star < 0.5:
+            break
+        cc_oc = [numpy.corrcoef(iobs, ic_bin[:,i])[0,1] / cc_star 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())
+
+    good = numpy.logical_and(numpy.isfinite(P_list).any(axis=(1,2)), numpy.isfinite(cc_oc_list).any(axis=1))
+    P_list = numpy.array(P_list)[good]
+    cc_oc_list = numpy.array(cc_oc_list)[good]
+    weight_list = numpy.array(weight_list)[good]
+    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("%.4f"%x for x in frac_est))
+    twin_data.alphas = frac_est
+
+    if numpy.logical_and(0 < frac_est, frac_est < min_alpha).any():
+        frac_est[frac_est < min_alpha] = 0.
+        frac_est /= frac_est.sum()
+        logger.write(" Small fraction removed: ")
+        logger.writeln(" ".join("%.4f"%x for x in frac_est))
+        twin_data.alphas = frac_est
+
+    return df
+
+def mlopt_twin_fractions(hkldata, twin_data, b_aniso):
+    k_ani2_inv = 1 / hkldata.debye_waller_factors(b_cart=b_aniso)**2
+    Io = hkldata.df.I.to_numpy(copy=True) * k_ani2_inv
+    sigIo = hkldata.df.SIGI.to_numpy(copy=True) * k_ani2_inv
+    def fun(x):
+        #x = numpy.clip(x, 0, 1)
+        #twin_data.alphas = x.tolist() + [1-x.sum()]
+        twin_data.alphas = x
+        twin_data.est_f_true(Io, sigIo, 10)
+        ret = twin_data.ll(Io, sigIo)
+        return ret
+    def grad(x):
+        #x = numpy.clip(x, 0, 1)
+        #twin_data.alphas = x.tolist() + [1-x.sum()]
+        twin_data.alphas = x
+        twin_data.est_f_true(Io, sigIo, 10)
+        return twin_data.ll_der_alpha(Io, sigIo, True)
+    if 0:
+        bak = [_ for _ in twin_data.alphas]
+        with open("alpha_ll.csv", "w") as ofs:
+            ofs.write("a,ll,ll_new,der1,der2,der_new1,der_new2\n")
+            for a in numpy.linspace(0., 1.0, 100):
+                x = [a, 1-a]
+                twin_data.alphas = x
+                twin_data.est_f_true(Io, sigIo, 100)
+                f_new = twin_data.ll(Io, sigIo)
+                f = twin_data.ll_rice()
+                der = twin_data.ll_der_alpha(Io, sigIo, False)
+                #der = [x - der[-1] for x in der[:-1]]
+                der_new = twin_data.ll_der_alpha(Io, sigIo, True)
+                #der_new = [x - der_new[-1] for x in der_new[:-1]]
+                ofs.write(f"{a},{f},{f_new},{der[0]},{der[1]},{der_new[0]},{der_new[1]}\n")
+            ofs.write("\n")
+        twin_data.alphas = bak
+        quit()
+    if 0:
+        x0 = [x for x in twin_data.alphas]
+        f0 = fun(x0)
+        ader = grad(x0)
+        
+        print(f"{ader=}")
+        for e in (1e-2, 1e-3, 1e-4, 1e-5):
+            nder = []
+            for i in range(len(x0)):
+                x = [_ for _ in x0]
+                x[i] += e
+                f1 = fun(x)
+                nder.append((f1 - f0) / e)
+            print(f"{e=} {nder=}")
+    
+    logger.writeln("ML twin fraction refinement..")
+    num_params = len(twin_data.alphas)
+    logger.writeln(" starting with " + " ".join("%.4f"%x for x in twin_data.alphas))
+    f0 = fun(numpy.asarray(twin_data.alphas))
+    logger.writeln(f" f0= {f0}")
+    if 0:
+        A = numpy.ones((1, num_params))
+        linear_constraint = scipy.optimize.LinearConstraint(A, 0., 1.)#[1.0], [1.0])
+        bounds = scipy.optimize.Bounds(numpy.zeros(num_params), numpy.ones(num_params))
+        res = scipy.optimize.minimize(fun=fun, x0=twin_data.alphas[:-1],
+                                      bounds=bounds,
+                                      constraints=[linear_constraint],
+                                      jac=grad,
+                                      method="trust-constr", #"SLSQP",
+                                      #callback=lambda *x: logger.writeln(f"callback {x}"),
+                                      )
+        logger.writeln(" finished in {} iterations ({} evaluations)".format(res.nit, res.nfev))
+        logger.writeln(f" f = {res.fun}")
+        logger.writeln(str(res))
+        # ensure constraints
+        alphas = numpy.clip(res.x, 0, 1)
+        twin_data.alphas = alphas.tolist() + [1-alphas.sum()] #list(alphas / alphas.sum())
+    else:
+        def x2alpha(x):
+            x = numpy.clip(x, 0, 1)
+            if x.sum() > 1: x /= x.sum()
+            return x.tolist() + [numpy.clip(1 - x.sum(), 0, 1)]
+        x = twin_data.alphas[:-1]
+        for cyc in range(200):
+            der1, tmp = twin_data.ll_der_alpha(Io, sigIo, True)
+            #print("Der:")
+            #print(der1)
+            #print(tmp)
+            #print(-der1.dot(numpy.linalg.pinv(tmp)))
+            if 0:
+                bak = [_ for _ in twin_data.alphas]
+                with open("alpha_ll.csv", "w") as ofs:
+                    ofs.write("a,ll,der1\n")
+                    for x in numpy.linspace(0., 1.0, 100):
+                        twin_data.alphas = x2alpha([x])
+                        twin_data.est_f_true(Io, sigIo, 100)
+                        f = twin_data.ll(Io, sigIo)
+                        der1, der2 = twin_data.ll_der_alpha(Io, sigIo, True)
+                        der1 = der1[:-1] - der1[-1]
+                        ofs.write(f"{x},{f},{der1[0]}\n")
+                #twin_data.alphas = bak
+            #numpy.nan_to_num(der, False)
+            #print(der)
+            #der1 = numpy.sum(der, axis=1)
+            der1 = der1[:-1] - der1[-1]
+            #tmp = der.dot(der.T)
+            der2 = tmp[:-1,:-1].copy()
+            N = der2.shape[0]
+            #der2[numpy.diag_indices(N)] += tmp[-1, -1]
+            der2 += tmp[-1, -1]
+            for i in range(N):
+                for j in range(N):
+                    der2[i, j] -= tmp[i, -1] + tmp[j, -1]
+            #rows, cols = numpy.indices((N, N))
+            #non_diag_rows, non_diag_cols = numpy.where(rows != cols)
+            #der2[non_diag_rows, non_diag_cols] -= tmp[:-1,-1][non_diag_rows]
+            shift = -der1.dot(numpy.linalg.pinv(der2))
+            x += shift
+            twin_data.alphas = x2alpha(x)
+            twin_data.est_f_true(Io, sigIo)
+            f = twin_data.ll(Io, sigIo)
+            logger.writeln(f"{cyc=} {shift=} alpha={twin_data.alphas} f={f} diff={f - f0}")
+            if f > f0:
+                x -= shift
+                twin_data.alphas = x2alpha(x)
+                twin_data.est_f_true(Io, sigIo)
+                break
+            if numpy.abs(shift).max() < 1e-4:
+                break
+            f0 = f
+            if 0:
+                with open("debug.csv", "w") as ofs:
+                    ofs.write("scale,f\n")
+                    for i in range(10):
+                        ofs.write(f"{i},{fun(x2alpha(x + i * shift))}\n")
+                quit()
+    logger.write(" ML twin fraction estimate: ")
+    logger.writeln(" ".join("%.4f"%x for x in twin_data.alphas))

servalcat-0.4.131.dist-info/METADATA

@@ -0,0 +1,60 @@
+Metadata-Version: 2.2
+Name: servalcat
+Version: 0.4.131
+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.8
+Requires-Dist: packaging
+Requires-Dist: numpy>=1.15
+Requires-Dist: scipy
+Requires-Dist: pandas>=1.1.0
+Requires-Dist: omegaconf==2.3.0
+Requires-Dist: gemmi==0.7.4
+Description-Content-Type: text/markdown
+
+# Servalcat
+[![Build](https://github.com/keitaroyam/servalcat/workflows/CI/badge.svg)](https://github.com/keitaroyam/servalcat/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/servalcat?color=blue)](https://pypi.org/project/servalcat/)
+
+**S**tructur**e** **r**efinement and **val**idation for **c**rystallography and single p**a**r**t**icle analysis
+
+Servalcat implements pipelines that use Refmac5:
+  * `servalcat refine_spa`: cryo-EM SPA refinement pipeline
+  * `servalcat refine_cx`: small molecule crystallography
+
+and a Refmac5 controller
+  * `refmacat`: behaves as Refmac, but uses GEMMI for restraint generation instead of MAKECIF
+
+Now “No Refmac5” refinement programs have been actively developed:
+  * `servalcat refine_geom`: geometry optimization
+  * `servalcat refine_spa_norefmac`: "No Refmac" version of refine\_spa
+  * `servalcat refine_xtal_norefmac`: crystallographic refinement
+
+Also, it has several utility commands: `servalcat util`.
+
+## Installation
+
+```shell
+# PyPI
+pip install servalcat
+
+# Conda
+conda install conda-forge::servalcat
+```
+will install the stable version.
+
+The required GEMMI version is now [v0.7.4](https://github.com/project-gemmi/gemmi/releases/tag/v0.7.4). 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.
+
+**Notice:**
+From ver. 0.4.6, Servalcat is no longer python-only package and has some C++ code. If you build Servalcat by yourself, probably you also need to build GEMMI using the same compiler.
+
+## Usage
+Please read the documentation: https://servalcat.readthedocs.io/en/latest/
+
+## References
+* [Yamashita, K., Wojdyr, M., Long, F., Nicholls, R. A., Murshudov, G. N. (2023) "GEMMI and Servalcat restrain REFMAC5" *Acta Cryst.* D**79**, 368-373](https://doi.org/10.1107/S2059798323002413)
+* [Yamashita, K., Palmer, C. M., Burnley, T., Murshudov, G. N. (2021) "Cryo-EM single particle structure refinement and map calculation using Servalcat" *Acta Cryst. D***77**, 1282-1291](https://doi.org/10.1107/S2059798321009475)

servalcat-0.4.131.dist-info/RECORD

@@ -0,0 +1,45 @@
+servalcat/__init__.py,sha256=6kexHM7ADiCenv62rmZRAByqIixrLdbL-PVl3wGZqTE,232
+servalcat/__main__.py,sha256=bNEZKrG5765uOp32UiBAJmeJi3O0sk4I5QjrXUbngIE,4070
+servalcat/ext.cpython-314t-x86_64-linux-gnu.so,sha256=cHJrKx7WTEM3412T3GDG-dRS9V-BLSKORIhaHodoA-I,1605416
+servalcat/refine/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+servalcat/refine/cgsolve.py,sha256=tHuWXr76x4sRAMUQ4dGVJzyHF_n1LiwKHTjAwh8iFMg,3072
+servalcat/refine/refine.py,sha256=wEFFkgbhBPTstnOLhd0u4GneGpgY9c1s5fn6TOg3NN0,54290
+servalcat/refine/refine_geom.py,sha256=TRmHs7EcpLyv9NVv1xMuIAeJ80F7fA16X4dNcofAyKg,12358
+servalcat/refine/refine_spa.py,sha256=UXgUKmzinkr3G9Oarr3UF9u2POm1PIWl8TuJYjEIUa8,20884
+servalcat/refine/refine_xtal.py,sha256=dpGtl4q9y9cpU2tekar3zLtwbYxF-jYyqxv64cXJ-_0,17755
+servalcat/refine/spa.py,sha256=GmNGB3h1ICJfm3WAFODlbfkvsefnXhJBhnpw0pBwgSk,6733
+servalcat/refine/xtal.py,sha256=pGmVHRE7DjFWH1U_R3_3kX7Ius9vrCnRl7G1FKNsFrY,16706
+servalcat/refmac/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+servalcat/refmac/exte.py,sha256=PdGKNt27pGlz_mYkbbEBU-xLg9FXu-2sHLwlzGCuUck,9613
+servalcat/refmac/refmac_keywords.py,sha256=rhlgRUD55P5y7AFmbeRJGb2HTkd6f9ARu5JVnyJz86Q,27553
+servalcat/refmac/refmac_wrapper.py,sha256=5cjyOdBGj20r01qaUS8nqVbPchMEwooaODn2AukBEl8,19582
+servalcat/spa/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+servalcat/spa/fofc.py,sha256=XN8Mwv0mMdstS-JvLEOm5TA5H-g1Z-fOkqvoYYXUQwU,23487
+servalcat/spa/fsc.py,sha256=LOwC98zgSoBNs1uMZJ6SfPiItgOvb7M0ZMvPstjjsXo,17792
+servalcat/spa/localcc.py,sha256=BffpHzPOjdjsw1EC5ym11ptUzhxCdIS-SQ-lEPBEXIM,8548
+servalcat/spa/realspcc_from_var.py,sha256=U8dK7f0LG8kDk4TsOVrZoClilIQ2wQ5qruV1V4gvjTU,5327
+servalcat/spa/run_refmac.py,sha256=xiZdDgOLRZWE6Co45GhrKrtShVXliZW_k23BhTkk-F8,49756
+servalcat/spa/shift_maps.py,sha256=rrD7GRjshERs_jHUBKs296GAIbbahkbmFVeK_6YRgt0,13286
+servalcat/spa/shiftback.py,sha256=A9OfaZ8r2BC6A2uGXxNNhmyBNORUB_MeqJC29ZRebnw,4664
+servalcat/spa/translate.py,sha256=Q4evxMHgLZYGNtDjbXH3jeBQvBtFWhQNdbC1LI4kVpo,5113
+servalcat/utils/__init__.py,sha256=j-fMAqHvzyMMQXb2Sf7Urnk4oQ31pT-g_NXf3K-NM4c,1137
+servalcat/utils/commands.py,sha256=F6ku-QusM_xjjEUXBqQNSFqdWOM1CgdV5ezYz3RBf9k,74882
+servalcat/utils/fileio.py,sha256=1PGCnJd16vtD-AjJIBdYMtaUbi1aIval_0DN8K_NsTM,33532
+servalcat/utils/generate_operators.py,sha256=fCrcTcciRn-6fpFtHYvf1oPXAObjuqR3WQejz5d0RrA,10980
+servalcat/utils/hkl.py,sha256=VfLUnF6reAtJacKgym4phVQ28QkEa3MCeDqVi4iqVcE,32751
+servalcat/utils/logger.py,sha256=eglkG7RxCJl4Q5P0aQGp4SVauoWh36nQgFvSJJLpyrM,4587
+servalcat/utils/maps.py,sha256=1bJye49GzIcjYqOIm9m8rn1iV5JDigc3GGM2uw_Mqwc,13297
+servalcat/utils/model.py,sha256=d_yAzQICAyQa33BNmOGpdcpeTKZglZwXVodJy2l2_mE,37168
+servalcat/utils/refmac.py,sha256=4HCdtWKtZZeLHlZUc-hoJu-7OR-2D7DV1KRAzL5OaZ4,31263
+servalcat/utils/restraints.py,sha256=8_Om2Mg8FA9GDFgukY7AhSUoeOh-P11DwXeHO6wtjgQ,42408
+servalcat/utils/symmetry.py,sha256=dEEEpbMAI-jetyxTSBM_63Pihy6h667_z8k6RtMe6aM,12038
+servalcat/xtal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+servalcat/xtal/french_wilson.py,sha256=9diaaXjViraRO6Yw1U5OQnR97s84bLdFe1Y3U0FROos,12242
+servalcat/xtal/run_refmac_small.py,sha256=Yg-bEPuOdQxCwdwY8StCvXabcWHrRl6A22gJgLsypeU,10394
+servalcat/xtal/sigmaa.py,sha256=tc7WhPgz7geKdNgpKLzBcvMrBQA83zj7scHp0XAER-w,92078
+servalcat/xtal/twin.py,sha256=d4T90RHxO_ISaMmcpBEARwbc_VxQD1ixTpHw5qzMYUE,13633
+servalcat-0.4.131.dist-info/METADATA,sha256=_X4MeLDi7rPj6lAmtPA8lwH18x2n2-IFN2VkkvF_tmI,2832
+servalcat-0.4.131.dist-info/WHEEL,sha256=A8s_KceazLtiI2uTXvhiIF6QDI48t_VVmqXP_wAag-g,159
+servalcat-0.4.131.dist-info/entry_points.txt,sha256=G1mDxhOCdF3umYz4k0kfwJbSdYSKqhvQdGCmrP8FRAY,111
+servalcat-0.4.131.dist-info/RECORD,,
+servalcat-0.4.131.dist-info/licenses/LICENSE,sha256=HyVuytGSiAUQ6ErWBHTqt1iSGHhLmlC8fO7jTCuR8dU,16725

servalcat-0.4.131.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: scikit-build-core 0.11.6
+Root-Is-Purelib: false
+Tag: cp314-cp314t-manylinux_2_27_x86_64
+Tag: cp314-cp314t-manylinux_2_28_x86_64
+

servalcat-0.4.131.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+servalcat = servalcat.__main__:main
+refmacat = servalcat.refmac.refmac_wrapper:command_line
+