servalcat 0.4.72__cp312-cp312-macosx_11_0_arm64.whl → 0.4.99__cp312-cp312-macosx_11_0_arm64.whl

servalcat/utils/commands.py

@@ -185,6 +185,17 @@ def add_arguments(p):
     parser.add_argument('-o', '--output_prefix', 
                         help="default: taken from input file")
 
+    # conf
+    parser = subparsers.add_parser("conf", description = 'Compare conformations')
+    parser.add_argument('models', nargs="+")
+    parser.add_argument("--min_diff", type=float, default=60.)
+    parser.add_argument('--ligand', nargs="*", action="append")
+    parser.add_argument("--monlib",
+                        help="Monomer library path. Default: $CLIBD_MON")
+    parser.add_argument("--same_chain", action='store_true', help="Only between same chains (more than one file)")
+    parser.add_argument('-o', '--output_prefix', default="conf",
+                        help="")
+
     # adp
     parser = subparsers.add_parser("adp", description = 'ADP analysis')
     parser.add_argument('model')
@@ -281,6 +292,9 @@ def add_arguments(p):
     parser = subparsers.add_parser("seq", description = 'Print/align model sequence')
     parser.add_argument("--model", required=True)
     parser.add_argument('--seq', nargs="*", action="append", help="Sequence file(s)")
+    parser.add_argument('--scoring', nargs=6, type=int, default=(1, 0, -1, -1, 0, -1),
+                        metavar=("match", "mismatch", "gapo", "gape", "good_gapo", "bad_gapo"),
+                        help="scoring function. default: %(default)s")
 
     # dnarna
     parser = subparsers.add_parser("dnarna", description = 'DNA to RNA or RNA to DNA model conversion')
@@ -919,6 +933,135 @@ def geometry(args):
         fileio.write_model(st, file_name="{}_per_atom_score{}".format(args.output_prefix, model_format))
 # geometry()
 
+def compare_conf(args):
+    def angle_abs_diff(a, b, full=360.):
+        # from gemmi/math.hpp
+        d = abs(a - b)
+        if d > full:
+            d -= numpy.floor(d / full) * full
+        return min(d, full - d)
+    # angle_abs_diff()
+    
+    if args.ligand: args.ligand = sum(args.ligand, [])
+    st = None
+    for i, f in enumerate(args.models):
+        tmp = fileio.read_structure(f)
+        if len(args.models) > 1:
+            for chain in tmp[0]:
+                chain.name = f"{i+1}_{chain.name}"
+        if i == 0:
+            st = tmp
+        else:
+            for chain in tmp[0]:
+                st[0].add_chain(chain)
+    try:
+        monlib = restraints.load_monomer_library(st, monomer_dir=args.monlib, cif_files=args.ligand, 
+                                                 stop_for_unknowns=True)
+    except RuntimeError as e:
+        raise SystemExit(f"Error: {e}")
+
+    model.setup_entities(st, clear=True, force_subchain_names=True, overwrite_entity_type=True)
+    try:
+        topo, _ = restraints.prepare_topology(st, monlib, h_change=gemmi.HydrogenChange.NoChange,
+                                              check_hydrogen=False)
+    except RuntimeError as e:
+        raise SystemExit(f"Error: {e}")
+    ncslist = restraints.prepare_ncs_restraints(st)
+    lookup = {x.atom: x for x in st[0].all()}
+    ptypes = {x.name: x.polymer_type for x in st.entities}
+    resn_lookup = {(chain.name, res.seqid): res.name for chain in st[0] for res in chain}
+    confs = {}
+    for t in topo.torsions:
+        cra = lookup[t.atoms[0]]
+        ptype = ptypes[cra.residue.entity_id]
+        is_peptide = ptype in (gemmi.PolymerType.PeptideL, gemmi.PolymerType.PeptideD)
+        is_peptide_tors = t.restr.label.startswith("chi") or t.restr.label in ("omega", "phi", "psi")
+        is_na = ptype in (gemmi.PolymerType.Dna, gemmi.PolymerType.Rna, gemmi.PolymerType.DnaRnaHybrid)
+        is_na_tors = t.restr.label in ("C2e-chi", "alpha", "beta", "gamma", "C2e-nyu0", "epsilon", "zeta")
+        if (is_peptide and is_peptide_tors) or (is_na and is_na_tors):
+            confs.setdefault(cra.chain.name, {}).setdefault(cra.residue.seqid, {})[t.restr.label] = numpy.rad2deg(t.calculate())
+    fulls = {("ARG", "chi5"): 180., ("TYR", "chi2"): 180., ("PHE", "chi2"): 180., ("ASP", "chi2"): 180., ("GLU", "chi3"): 180.}
+    ret = []
+    for_coot = []
+    for ncs in ncslist.ncss:
+        c1, c2 = ncs.chains
+        if args.same_chain and len(args.models) > 1 and c1[c1.index("_"):] != c2[c2.index("_"):]:
+            continue
+        for s1, s2 in ncs.seqids:
+            if c1 in confs and s1 in confs[c1] and c2 in confs and s2 in confs[c2]:
+                conf1, conf2 = confs[c1][s1], confs[c2][s2]
+                resn = resn_lookup[(c1, s1)]
+                for t in conf1:
+                    if t in conf2:
+                        d = angle_abs_diff(conf1[t], conf2[t], fulls.get((resn, t), 360.))
+                        ret.append((c1, s1, c2, s2, resn, t, conf1[t], conf2[t], d))
+                        if d > args.min_diff:
+                            for_coot.append((c1, s1.num, c2, s2.num, resn, t, d))
+    df = pandas.DataFrame(ret, columns=["chain_1", "seq_1", "chain_2", "seq_2", "resn", "label", "conf_1", "conf_2", "diff"])
+    df.sort_values("diff", ascending=False, inplace=True)
+    logger.writeln(f"\nList of torsion angle differences (>{args.min_diff})")
+    logger.writeln(df[df["diff"] > args.min_diff].to_string(index=False))
+
+    for_coot.sort(key=lambda x:-x[-1])
+    coot_out = args.output_prefix + "_coot.py"
+    with open(coot_out, "w") as ofs:
+        # https://python-gtk-3-tutorial.readthedocs.io/en/latest/treeview.html
+        ofs.write("""\
+from __future__ import absolute_import, division, print_function
+import re
+import gtk
+class coot_serval_conf_list:
+  def __init__(self):
+    window = gtk.Window(gtk.WINDOW_TOPLEVEL)
+    window.set_title("Different conformations (Servalcat)")
+    window.set_default_size(600, 600)
+    scrolled_win = gtk.ScrolledWindow()
+    scrolled_win.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)
+    vbox = gtk.VBox(False, 2)
+    self.liststore = gtk.ListStore(str, int, str, int, str, str, float)
+    self.filter = self.liststore.filter_new()
+    self.treeview = gtk.TreeView(model=self.filter)
+    for i, column_title in enumerate(["chain_1", "seq_1", "chain_2", "seq_2", "resn", "label", "diff"]):
+      renderer = gtk.CellRendererText()
+      column = gtk.TreeViewColumn(column_title, renderer, text=i)
+      self.treeview.append_column(column)
+    self.data = {}
+    self.add_data()
+    scrolled_win.add_with_viewport(self.treeview)  # add?
+    vbox.pack_start(scrolled_win, True, True, 0)
+    window.add(vbox)
+    window.show_all()
+    self.treeview.connect("row-activated", self.on_row_activated)
+
+  def on_row_activated(self, treeview, path, column):
+    assert len(path) == 1
+    col_idx = [i for i, c in enumerate(treeview.get_columns()) if column == c][0]
+    row = self.liststore[path[0]]
+    if col_idx < 2:
+      chain, resi = row[0], row[1]
+    elif col_idx < 4:
+      chain, resi = row[2], row[3]
+    else:
+      return
+    if re.search("^[0-9]+_[0-9A-Za-z]", chain):
+      chain = chain[chain.index("_")+1:]
+    imol = active_atom_spec()[1][0]
+    for name in (" CA ", " C1'"):
+      a = get_atom(imol, chain, resi, "", name)
+      if a:
+        set_rotation_center(*a[2])
+        break
+
+  def add_data(self):
+    for i, d in enumerate(self.data):
+      self.liststore.append(d)
+
+gui = coot_serval_conf_list()
+""".format(for_coot))
+    logger.writeln("\nRun:")
+    logger.writeln(f"coot --script {coot_out}")
+# compare_conf()
+
 def adp_stats(args):
     if not args.output_prefix: args.output_prefix = fileio.splitext(os.path.basename(args.model))[0] + "_adp"
     st = fileio.read_structure(args.model)
@@ -1242,6 +1385,9 @@ def seq(args):
         for sf in args.seq:
             seqs.extend(fileio.read_sequence_file(sf))
         
+    sc = gemmi.AlignmentScoring()
+    sc.match, sc.mismatch, sc.gapo, sc.gape, sc.good_gapo, sc.bad_gapo = args.scoring
+    
     st = fileio.read_structure(args.model) # TODO option to (or not to) expand NCS
     model.setup_entities(st, clear=True, force_subchain_names=True, overwrite_entity_type=True)    
     for chain in st[0]:
@@ -1257,17 +1403,20 @@ def seq(args):
                     gemmi.PolymerType.Rna: gemmi.ResidueKind.RNA}.get(p_type, gemmi.ResidueKind.AA)
             s = [gemmi.expand_one_letter(x, kind) for x in seq]
             if None in s: continue
-            results.append([name, gemmi.align_sequence_to_polymer(s, p, p_type), seq])
+            #als = [gemmi.align_sequence_to_polymer(s, p, p_type, gemmi.AlignmentScoring(x)) for x in ("s", "p")]
+            #results.append([name, max(als, key=lambda x: x.match_count), seq])
+            results.append([name, gemmi.align_sequence_to_polymer(s, p, p_type, sc), seq])
 
         if results:
             logger.writeln("Chain: {}".format(chain.name))
             logger.writeln(" polymer type: {}".format(str(p_type).replace("PolymerType.", "")))
-            name, al, s1 = max(results, key=lambda x: x[1].score)
+            name, al, s1 = max(results, key=lambda x: (x[1].match_count, x[1].score))
             logger.writeln(" match: {}".format(name))
+            logger.writeln(" aligned: {}".format(al.match_count))
             logger.writeln(" score: {}".format(al.score))
             p1, p2 = al.add_gaps(s1, 1), al.add_gaps(p_seq, 2)
-            unkseq = [x.start() for x in re.finditer("\-", p1)]
-            mismatches = [x.start() for x in re.finditer("\.", al.match_string)]
+            unkseq = [x.start() for x in re.finditer(r"\-", p1)]
+            mismatches = [x.start() for x in re.finditer(r"\.", al.match_string)]
             if mismatches or unkseq:
                 idxes = {x.start(): i for i, x in enumerate(re.finditer("[^-]", p2))}
                 seqnums = [str(x.seqid) for x in p]
@@ -1371,6 +1520,7 @@ def main(args):
                  merge_models=merge_models,
                  merge_dicts=merge_dicts,
                  geom=geometry,
+                 conf=compare_conf,
                  adp=adp_stats,
                  power=show_power,
                  fcalc=fcalc,

servalcat/utils/fileio.py

@@ -17,7 +17,6 @@ import re
 import subprocess
 import gemmi
 import numpy
-import numpy.lib.recfunctions
 import gzip
 
 def splitext(path):
@@ -83,9 +82,12 @@ def write_mmcif(st, cif_out, cif_ref=None):
         groups.scale = True
         groups.assembly = True
         groups.entity = True
+        groups.entity_poly = True
         groups.entity_poly_seq = True
         groups.cis = True
         groups.conn = True
+        groups.software = True
+        groups.auth_all = True
         # FIXME is this all? 
         try:
             doc = read_cif_safe(cif_ref)
@@ -106,23 +108,27 @@ def write_mmcif(st, cif_out, cif_ref=None):
         block.find_mmcif_category("_atom_sites.").erase()
         st_new.update_mmcif_block(block, groups)
         if "_entry.id" in st_new.info: st_new.info["_entry.id"] = st_new.info["_entry.id"][:78]
-        doc.write_file(cif_out, style=gemmi.cif.Style.Aligned)
+        doc.write_file(cif_out, options=gemmi.cif.Style.Aligned)
     else:
         st_new.name = st_new.name[:78] # this will become _entry.id
         if "_entry.id" in st_new.info: st_new.info["_entry.id"] = st_new.info["_entry.id"][:78]
-        groups = gemmi.MmcifOutputGroups(True)
+        groups = gemmi.MmcifOutputGroups(True, auth_all=True)
         doc = gemmi.cif.Document()
         block = doc.add_new_block("new")
         st_new.update_mmcif_block(block, groups)
-        doc.write_file(cif_out, style=gemmi.cif.Style.Aligned)
+        doc.write_file(cif_out, options=gemmi.cif.Style.Aligned)
 # write_mmcif()
 
 def write_pdb(st, pdb_out):
     logger.writeln("Writing PDB file: {}".format(pdb_out))
+    st = st.clone()
     chain_id_lens = [len(x) for x in model.all_chain_ids(st)]
     if chain_id_lens and max(chain_id_lens) > 2:
-        st = st.clone()
         st.shorten_chain_names()
+    st.shorten_ccd_codes()
+    if st.shortened_ccd_codes:
+        msg = " ".join("{}->{}".format(o,n) for o,n in st.shortened_ccd_codes)
+        logger.writeln(" Using shortened residue names in the output pdb file: " + msg)
     st.write_pdb(pdb_out, use_linkr=True)
 # write_pdb()
 
@@ -306,7 +312,7 @@ def read_cif_safe(cif_in):
     return doc
 # read_cif_safe()
 
-def read_structure(xyz_in, assign_het_flags=True):
+def read_structure(xyz_in, assign_het_flags=True, merge_chain_parts=True):
     spext = splitext(xyz_in)
     st = None
     if spext[1].lower() in (".pdb", ".ent"):
@@ -338,6 +344,8 @@ def read_structure(xyz_in, assign_het_flags=True):
                 if st is None:
                     logger.writeln("Reading chemical component file: {}".format(xyz_in))
                     st = gemmi.make_structure_from_chemcomp_block(block)
+                    for i in range(len(st)-1):
+                        del st[1]
     elif spext[1].lower() in (".ins", ".res"):
         logger.writeln("Reading SHELX ins/res file: {}".format(xyz_in))
         st = model.cx_to_mx(read_shelx_ins(ins_in=xyz_in)[0])
@@ -354,6 +362,8 @@ def read_structure(xyz_in, assign_het_flags=True):
         logger.writeln("")
     if assign_het_flags:
         st.assign_het_flags()
+    if merge_chain_parts:
+        st.merge_chain_parts()
     return st
 # read_structure()
 
@@ -453,7 +463,7 @@ def merge_ligand_cif(cifs_in, cif_out):
             if b.name not in list_names:
                 doc.add_copied_block(b)
 
-    doc.write_file(cif_out, style=gemmi.cif.Style.Aligned)
+    doc.write_file(cif_out, options=gemmi.cif.Style.Aligned)
 # merge_ligand_cif()
 
 def read_shelx_ins(ins_in=None, lines_in=None, ignore_q_peaks=True): # TODO support gz?
@@ -568,7 +578,7 @@ def read_shelx_ins(ins_in=None, lines_in=None, ignore_q_peaks=True): # TODO supp
         symms.extend([x*gemmi.Op("-x,-y,-z") for x in symms])
 
     ss.symops = [op.triplet() for op in set(symms)]
-    ss.set_spacegroup("s")
+    ss.determine_and_set_spacegroup("s")
     # in case of non-regular setting, gemmi.SpaceGroup cannot be constructed anyway.
     if ss.spacegroup is None:
         raise RuntimeError("Cannot construct space group from symbols: {}".format(ss.symops))
@@ -595,7 +605,7 @@ def read_shelx_hkl(cell, sg, hklf, file_in=None, lines_in=None):
         # wavelength = l[32:40]
 
     ints = gemmi.Intensities()
-    ints.set_data(cell, sg, hkls, vals, sigs)
+    ints.set_data(cell, sg, numpy.asarray(hkls), numpy.asarray(vals), numpy.asarray(sigs))
     ints.merge_in_place(gemmi.DataType.Anomalous)
     if not (ints.isign_array < 0).any(): ints.type = gemmi.DataType.Mean
     logger.writeln(" Multiplicity: max= {} mean= {:.1f} min= {}".format(numpy.max(ints.nobs_array),
@@ -712,7 +722,7 @@ def read_small_molecule_files(files):
                 logger.writeln("reflection data read from: {}".format(filename))
             elif b.find_loop("_refln_index_h"):
                 mtz = read_smcif_hkl(filename, st.cell, st.find_spacegroup())
-        except RuntimeError: # not a cif file
+        except ValueError: # not a cif file
             if ext == ".hkl":
                 mtz = read_shelx_hkl(st.cell, st.find_spacegroup(), hklf, file_in=filename)
                 logger.writeln("reflection data read from: {}".format(filename))

servalcat/utils/hkl.py

@@ -7,7 +7,6 @@ Mozilla Public License, version 2.0; see LICENSE.
 """
 from __future__ import absolute_import, division, print_function, generators
 import numpy
-import numpy.lib.recfunctions
 import scipy.optimize
 import pandas
 import gemmi
@@ -17,27 +16,28 @@ dtypes64 = dict(i=numpy.int64, u=numpy.uint64, f=numpy.float64, c=numpy.complex1
 to64 = lambda x: x.astype(dtypes64.get(x.dtype.kind, x.dtype))
 
 def r_factor(fo, fc):
-    if fo.size == 0:
+    denom = numpy.nansum(fo)
+    if denom == 0:
         return numpy.nan
-    return numpy.nansum(numpy.abs(fo-fc)) / numpy.nansum(fo)
+    return numpy.nansum(numpy.abs(fo-fc)) / denom
 def correlation(obs, calc):
-    if obs.size == 0:
-        return numpy.nan
     sel = numpy.isfinite(obs)
+    if obs.size == 0 or numpy.all(~sel):
+        return numpy.nan
     return numpy.corrcoef(obs[sel], calc[sel])[0,1]
 
 def df_from_asu_data(asu_data, label):
-    df = pandas.DataFrame(data=asu_data.miller_array,
+    df = pandas.DataFrame(data=asu_data.miller_array.astype(numpy.int32),
                           columns=["H","K","L"])
-    if asu_data.value_array.dtype.names == ('value', 'sigma'):
-        df[label] = to64(asu_data.value_array["value"])
-        df["SIG"+label] = to64(asu_data.value_array["sigma"])
+    if type(asu_data) is gemmi.ValueSigmaAsuData:
+        df[label] = to64(asu_data.value_array[:,0])
+        df["SIG"+label] = to64(asu_data.value_array[:,1])
     else:
         df[label] = to64(asu_data.value_array)
     return df
 
 def df_from_raw(miller_array, value_array, label):
-    df = pandas.DataFrame(data=miller_array,
+    df = pandas.DataFrame(data=miller_array.astype(numpy.int32),
                           columns=["H","K","L"])
     df[label] = to64(value_array)
     return df
@@ -93,7 +93,7 @@ def hkldata_from_mtz(mtz, labels, newlabels=None, require_types=None):
         if mismatches:
             raise RuntimeError("MTZ column types mismatch: {}".format(" ".join(mismatches)))
 
-    df = pandas.DataFrame(data=numpy.array(mtz, copy=False), columns=mtz.column_labels())
+    df = pandas.DataFrame(data=mtz.array, columns=mtz.column_labels())
     df = df.astype({col: 'int32' for col in col_types if col_types[col] == "H"})
     df = df.astype({col: 'Int64' for col in col_types if col_types[col] in ("B", "Y", "I")}) # pandas's nullable int
     for lab in set(mtz.column_labels()).difference(labels+["H","K","L"]):
@@ -114,6 +114,12 @@ def hkldata_from_mtz(mtz, labels, newlabels=None, require_types=None):
     return HklData(mtz.cell, mtz.spacegroup, df)
 # hkldata_from_mtz()
 
+def df_from_twin_data(twin_data, fc_labs):
+    df = pandas.DataFrame(data=twin_data.asu,
+                          columns=["H","K","L"])
+    df[fc_labs] = twin_data.f_calc
+    return df
+
 def blur_mtz(mtz, B):
     # modify given mtz object
     
@@ -170,7 +176,7 @@ def mtz_selected(mtz, columns):
                         dataset_id=col_dict[col].dataset_id, expand_data=False)
 
     idxes = [col_idxes[col] for col in columns]
-    data = numpy.array(mtz, copy=False)[:, idxes]
+    data = mtz.array[:, idxes]
     mtz2.set_data(data)
     return mtz2
 # mtz_selected()
@@ -190,6 +196,19 @@ def decide_n_bins(n_per_bin, s_array, power=2, min_bins=1, max_bins=50):
     return n_bins
 # decide_n_bins()
 
+def fft_map(cell, sg, miller_array, data, grid_size=None, sample_rate=3):
+    if data is not None:
+        data = data.astype(numpy.complex64) # we may want to keep complex128?
+    if type(data) is pandas.core.series.Series:
+        data = data.to_numpy()
+    asu = gemmi.ComplexAsuData(cell, sg, miller_array, data)
+    if grid_size is None:
+        ma = asu.transform_f_phi_to_map(sample_rate=sample_rate, exact_size=(0, 0, 0)) # half_l=True
+    else:
+        ma = gemmi.transform_f_phi_grid_to_map(asu.get_f_phi_on_grid(grid_size)) # half_l=False
+    return ma
+# fft_map()
+
 class HklData:
     def __init__(self, cell, sg, df=None, binned_df=None):
         self.cell = cell
@@ -206,7 +225,7 @@ class HklData:
     def switch_to_asu(self):
         # Need to care phases
         assert not any(numpy.iscomplexobj(self.df[x]) for x in self.df)
-        hkl = self.miller_array().to_numpy()
+        hkl = self.miller_array()
         self.sg.switch_to_asu(hkl)
         self.df[["H","K","L"]] = hkl
         # in some environment type changes to int64 even though hkl's dtype is int32
@@ -248,11 +267,11 @@ class HklData:
     # merge_asu_data()
 
     def miller_array(self):
-        return self.df[["H","K","L"]]
+        return self.df[["H","K","L"]].to_numpy()
 
     def s_array(self):
         hkl = self.miller_array()
-        return numpy.dot(hkl, self.cell.fractionalization_matrix)
+        return numpy.dot(hkl, self.cell.frac.mat.array)
 
     def ssq_mat(self):
         # k_aniso = exp(-s^T B_aniso s / 4)
@@ -271,8 +290,8 @@ class HklData:
             s2 = 1 / self.d_spacings()**2
             return numpy.exp(-b_iso / 4 * s2)
         if b_cart is not None:
-            b_star = b_cart.transformed_by(self.cell.fractionalization_matrix)
-            return numpy.exp(-b_star.r_u_r(self.miller_array().to_numpy()) / 4)
+            b_star = b_cart.transformed_by(self.cell.frac.mat)
+            return numpy.exp(-b_star.r_u_r(self.miller_array()) / 4)
     
     def calc_d(self):
         self.df["d"] = self.cell.calculate_d_array(self.miller_array())
@@ -297,8 +316,10 @@ class HklData:
         self.df.sort_values("d", ascending=ascending, inplace=True)
     # sort_by_resolution()
 
-    def d_min_max(self):
+    def d_min_max(self, labs=None):
         d = self.d_spacings()
+        if labs:
+            d = d[~self.df[labs].isna().any(axis=1)]
         return numpy.min(d), numpy.max(d)
     # d_min_max()
 
@@ -494,9 +515,7 @@ class HklData:
         if label_sigma is not None:
             assert data is None
             assert not numpy.iscomplexobj(self.df[label])
-            sigma = self.df[label_sigma]
-            data = numpy.lib.recfunctions.unstructured_to_structured(self.df[[label,label_sigma]].to_numpy(),
-                                                                     numpy.dtype([("value", numpy.float32), ("sigma", numpy.float32)]))
+            data = self.df[[label,label_sigma]].to_numpy()
         elif data is None:
             data = self.df[label]
             
@@ -514,14 +533,9 @@ class HklData:
     # as_asu_data()
 
     def fft_map(self, label=None, data=None, grid_size=None, sample_rate=3):
-        if data is not None: data = data.astype(numpy.complex64) # we may want to keep complex128?
-        asu = self.as_asu_data(label=label, data=data)
-        if grid_size is None:
-            ma = asu.transform_f_phi_to_map(sample_rate=sample_rate, exact_size=(0, 0, 0)) # half_l=True
-        else:
-            ma = gemmi.transform_f_phi_grid_to_map(asu.get_f_phi_on_grid(grid_size)) # half_l=False
-            
-        return ma
+        if data is None:
+            data = self.df[label].to_numpy()
+        return fft_map(self.cell, self.sg, self.miller_array(), data, grid_size, sample_rate)
     # fft_map()
 
     def d_eff(self, label):

servalcat/utils/logger.py

@@ -18,12 +18,15 @@ class Logger(object):
     def __init__(self, file_out=None, append=True):
         self.ofs = None
         self.stopped = False
+        self.prefix = ""
         if file_out:
             self.set_file(file_out, append)
     # __init__()
     def stop_logging(self): self.stopped = True
     def start_logging(self): self.stopped = False
-
+    def set_prefix(self, p): self.prefix = p
+    def clear_prefix(self): self.prefix = ""
+    
     def set_file(self, file_out, append=True):
         try:
             self.ofs = open(file_out, "a" if append else "w")
@@ -33,6 +36,8 @@ class Logger(object):
 
     def write(self, l, end="", flush=True, fs=None, print_fs=sys.stdout):
         if self.stopped: return
+        if self.prefix:
+            l = "\n".join(self.prefix + x for x in l.splitlines(keepends=True))
         print(l, end=end, file=print_fs, flush=flush)
         for f in (self.ofs, fs):
             if f is not None:
@@ -69,6 +74,25 @@ close = _logger.close
 flush = _logger.flush
 stop = _logger.stop_logging
 start = _logger.start_logging
+set_prefix = _logger.set_prefix
+clear_prefix = _logger.clear_prefix
+
+def with_prefix(prefix):
+    class WithPrefix(object): # should keep original prefix and restore?
+        def __enter__(self):
+            _logger.set_prefix(prefix)
+            return _logger
+        def __exit__(self, exc_type, exc_val, exc_tb):
+            _logger.clear_prefix()
+    return WithPrefix()
+
+def silent():
+    class Silent(object):
+        def write(self, *args, **kwargs):
+            pass
+        def flush(self):
+            pass
+    return Silent()
 
 def dependency_versions():
     import gemmi

servalcat/utils/maps.py

@@ -268,9 +268,9 @@ def optimize_peak(grid, ini_pos):
     logger.writeln("Finding peak using interpolation..")
     x = grid.unit_cell.fractionalize(ini_pos)
     logger.writeln("       x0: [{}, {}, {}]".format(*x.tolist()))
-    logger.writeln("       f0: {}".format(-grid.tricubic_interpolation(x)))
+    logger.writeln("       f0: {}".format(-grid.interpolate_value(x, order=3)))
 
-    res = scipy.optimize.minimize(fun=lambda x:-grid.tricubic_interpolation(gemmi.Fractional(*x)),
+    res = scipy.optimize.minimize(fun=lambda x:-grid.interpolate_value(gemmi.Fractional(*x), order=3),
                                   x0=x.tolist(),
                                   jac=lambda x:-numpy.array(grid.tricubic_interpolation_der(gemmi.Fractional(*x))[1:])
                                   )

servalcat/utils/model.py

@@ -347,8 +347,8 @@ def translate_into_box(st, origin=None, apply_shift=True):
     if origin is None: origin = gemmi.Position(0,0,0)
     
     # apply unit cell translations to put model into a box (unit cell)
-    omat = numpy.array(st.cell.orthogonalization_matrix)
-    fmat = numpy.array(st.cell.fractionalization_matrix).transpose()
+    omat = st.cell.orth.mat.array
+    fmat = st.cell.frac.mat.array.transpose()
     com = numpy.array((st[0].calculate_center_of_mass() - origin).tolist())
     shift = sum([omat[:,i]*numpy.floor(1-numpy.dot(com, fmat[:,i])) for i in range(3)])
     tr = gemmi.Transform(gemmi.Mat33(), gemmi.Vec3(*shift))
@@ -389,6 +389,19 @@ def cra_to_atomaddress(cra):
     return aa
 # cra_to_atomaddress()
 
+def check_occupancies(st, raise_error=False):
+    bad = []
+    for cra in st[0].all():
+        if not 0 <= cra.atom.occ <= 1 + 1e-6:
+            bad.append(cra)
+    if bad:
+        logger.writeln("Bad occupancies:")
+        for cra in bad:
+            logger.writeln(f" {cra} occ= {cra.atom.occ:.4f}")
+        if raise_error:
+            raise RuntimeError("Please check your model and fix bad occupancies")
+# check_occupancies()
+
 def find_special_positions(st, special_pos_threshold=0.2, fix_occ=True, fix_pos=True, fix_adp=True):
     ns = gemmi.NeighborSearch(st[0], st.cell, 3).populate()
     cs = gemmi.ContactSearch(special_pos_threshold * 2)
@@ -430,7 +443,7 @@ def find_special_positions(st, special_pos_threshold=0.2, fix_occ=True, fix_pos=
             logger.writeln("  correcting aniso= {}".format(tostr(atom.aniso.elements_pdb())))
             logger.writeln("        aniso_viol= {}".format(tostr(diff)))
 
-        mats = [st.cell.orth.combine(st.cell.images[i-1]).combine(st.cell.frac).mat for i in images]
+        mats = [st.cell.orth.combine(st.cell.images[i-1]).combine(st.cell.frac).mat.array for i in images]
         mat_total = (numpy.identity(3) + sum(numpy.array(m) for m in mats)) / n_images
         mat_total_aniso = (numpy.identity(6) + sum(mat33_as66(m.tolist()) for m in mats)) / n_images
         mat_total_aniso = numpy.linalg.pinv(mat_total_aniso)
@@ -617,7 +630,7 @@ def to_dataframe(st):
         for cra in m.all():
             c,r,a = cra.chain, cra.residue, cra.atom
             # TODO need support r.het_flag, r.flag, a.calc_flag, a.flag, a.serial?
-            app("model", m.name)
+            app("model", m.num)
             app("chain", c.name)
             app("resn", r.name)
             app("subchain", r.subchain)
@@ -652,8 +665,8 @@ def from_dataframe(df, st=None): # Slow!
         for i in range(len(st)):
             del st[0]
         
-    for m_name, dm in df.groupby("model"):
-        st.add_model(gemmi.Model(m_name))
+    for m_num, dm in df.groupby("model"):
+        st.add_model(gemmi.Model(m_num))
         m = st[-1]
         for c_name, dc in dm.groupby("chain"):
             m.add_chain(gemmi.Chain(c_name))
@@ -691,7 +704,7 @@ def from_dataframe(df, st=None): # Slow!
 
 def st_from_positions(positions, bs=None, qs=None):
     st = gemmi.Structure()
-    st.add_model(gemmi.Model("1"))
+    st.add_model(gemmi.Model(1))
     st[0].add_chain(gemmi.Chain("A"))
     c = st[0][0]
     if bs is None: bs = (0. for _ in range(len(positions)))
@@ -714,7 +727,7 @@ def st_from_positions(positions, bs=None, qs=None):
             
 def invert_model(st):
     # invert x-axis
-    A = numpy.array(st.cell.orthogonalization_matrix.tolist())
+    A = st.cell.orth.mat.array
     center = numpy.sum(A,axis=1) / 2
     center = gemmi.Vec3(*center)
     mat = gemmi.Mat33([[-1,0,0],[0,1,0],[0,0,1]]) 
@@ -729,14 +742,14 @@ def cx_to_mx(ss): #SmallStructure to Structure
     st = gemmi.Structure()
     st.spacegroup_hm = ss.spacegroup.xhm()
     st.cell = ss.cell
-    st.add_model(gemmi.Model("1"))
+    st.add_model(gemmi.Model(1))
     st[-1].add_chain(gemmi.Chain("A"))
     st[-1][-1].add_residue(gemmi.Residue())
     st[-1][-1][-1].seqid.num = 1
     st[-1][-1][-1].name = "00"
 
     ruc = ss.cell.reciprocal()
-    cif2cart = ss.cell.orthogonalization_matrix.multiply_by_diagonal(gemmi.Vec3(ruc.a, ruc.b, ruc.c))
+    cif2cart = ss.cell.orth.mat.multiply_by_diagonal(gemmi.Vec3(ruc.a, ruc.b, ruc.c))
     as_smat33f = lambda x: gemmi.SMat33f(x.u11, x.u22, x.u33, x.u12, x.u13, x.u23)
     
     for site in ss.sites: