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

servalcat/refmac/refmac_wrapper.py

@@ -15,6 +15,7 @@ import tempfile
 import subprocess
 import argparse
 from collections import OrderedDict
+import servalcat # for version
 from servalcat.utils import logger
 from servalcat.refmac import refmac_keywords
 from servalcat import utils
@@ -64,7 +65,7 @@ def read_stdin(stdin):
 
 def prepare_crd(st, crdout, ligand, make, monlib_path=None, h_pos="elec",
                 no_adjust_hydrogen_distances=False, fix_long_resnames=True,
-                keep_entities=False):
+                keep_entities=False, unre=False):
     assert h_pos in ("elec", "nucl")
     h_change = dict(a=gemmi.HydrogenChange.ReAddButWater,
                     y=gemmi.HydrogenChange.NoChange,
@@ -80,67 +81,85 @@ def prepare_crd(st, crdout, ligand, make, monlib_path=None, h_pos="elec",
                 if at.occ > 1: # XXX should I check special positions?
                     at.occ = 1.
 
-    if not keep_entities:
+    refmac_fixes = utils.refmac.FixForRefmac()
+    if keep_entities:
+        refmac_fixes.store_res_labels(st)
+    else:
         utils.model.setup_entities(st, clear=True, force_subchain_names=True, overwrite_entity_type=True)
-    # TODO read dictionary from xyzin (priority: user cif -> monlib -> xyzin
-    try:
-        monlib = utils.restraints.load_monomer_library(st,
-                                                       monomer_dir=monlib_path,
-                                                       cif_files=ligand,
-                                                       stop_for_unknowns=not make.get("newligand"))
-    except RuntimeError as e:
-        raise SystemExit("Error: {}".format(e))
 
-    use_cispeps = make.get("cispept", "y") != "y"
-    make_link = make.get("link", "n")
-    make_ss = make.get("ss", "y")
-    only_from = set()
-    if make_link == "y":
-        # add all links
-        add_found = True
-    elif make_ss == "y":
-        add_found = True
-        only_from.add("disulf")
+    if unre:
+        logger.writeln("Monomer library will not be loaded due to unrestrained refinement request")
+        monlib = gemmi.MonLib()
     else:
-        add_found = False
-    
-    utils.restraints.fix_elements_in_model(monlib, st)
-    utils.restraints.find_and_fix_links(st, monlib, add_found=add_found, find_symmetry_related=False, add_only_from=only_from)
-    for con in st.connections:
-        if con.link_id not in ("?", "", "gap") and con.link_id not in monlib.links:
-            logger.writeln(" removing unknown link id ({}). Ad-hoc link will be generated.".format(con.link_id))
-            con.link_id = ""
+        # TODO read dictionary from xyzin (priority: user cif -> monlib -> xyzin
+        try:
+            monlib = utils.restraints.load_monomer_library(st,
+                                                           monomer_dir=monlib_path,
+                                                           cif_files=ligand,
+                                                           stop_for_unknowns=not make.get("newligand"))
+        except RuntimeError as e:
+            raise SystemExit("Error: {}".format(e))
+
+        use_cispeps = make.get("cispept", "y") != "y"
+        make_link = make.get("link", "n")
+        make_ss = make.get("ss", "y")
+        only_from = set()
+        if make_link == "y":
+            # add all links
+            add_found = True
+        elif make_ss == "y":
+            add_found = True
+            only_from.add("disulf")
+        else:
+            add_found = False
+
+        utils.restraints.fix_elements_in_model(monlib, st)
+        utils.restraints.find_and_fix_links(st, monlib, add_found=add_found,
+                                            find_metal_links=(make_link == "y"),
+                                            find_symmetry_related=False, add_only_from=only_from)
+        for con in st.connections:
+            if con.link_id not in ("?", "", "gap") and con.link_id not in monlib.links:
+                logger.writeln(" removing unknown link id ({}). Ad-hoc link will be generated.".format(con.link_id))
+                con.link_id = ""
 
-    refmac_fixes = utils.refmac.FixForRefmac()
     max_seq_num = max([max(res.seqid.num for res in chain) for model in st for chain in model])
     if max_seq_num > 9999:
         logger.writeln("Max residue number ({}) exceeds 9999. Needs workaround.".format(max_seq_num))
-        topo = gemmi.prepare_topology(st, monlib, ignore_unknown_links=True)
+        topo = gemmi.prepare_topology(st, monlib, warnings=logger.silent(), ignore_unknown_links=True)
         refmac_fixes.fix_before_topology(st, topo, 
                                          fix_microheterogeneity=False,
                                          fix_resimax=True,
                                          fix_nonpolymer=False)
 
-    if make.get("hydr") == "a": logger.writeln("(re)generating hydrogen atoms")
-    try:
-        topo, metal_kws = utils.restraints.prepare_topology(st, monlib, h_change=h_change, ignore_unknown_links=False,
-                                                            check_hydrogen=(h_change==gemmi.HydrogenChange.NoChange),
-                                                            use_cispeps=use_cispeps)
-    except RuntimeError as e:
-        raise SystemExit("Error: {}".format(e))
+    if unre:
+        # Refmac5 does not seem to do anything to hydrogen when unre regardless of "make hydr"
+        topo = gemmi.prepare_topology(st, monlib, warnings=logger.silent(), ignore_unknown_links=True)
+        metal_kws = []
+    else:
+        if make.get("hydr") == "a": logger.writeln("(re)generating hydrogen atoms")
+        try:
+            topo, metal_kws = utils.restraints.prepare_topology(st, monlib, h_change=h_change, ignore_unknown_links=False,
+                                                                check_hydrogen=(h_change==gemmi.HydrogenChange.NoChange),
+                                                                use_cispeps=use_cispeps)
+        except RuntimeError as e:
+            raise SystemExit("Error: {}".format(e))
 
-    if make.get("hydr") != "n" and st[0].has_hydrogen():
-        if h_pos == "nucl" and (make.get("hydr") == "a" or not no_adjust_hydrogen_distances):
-            resnames = st[0].get_all_residue_names()
-            utils.restraints.check_monlib_support_nucleus_distances(monlib, resnames)
-            logger.writeln("adjusting hydrogen position to nucleus")
-            topo.adjust_hydrogen_distances(gemmi.Restraints.DistanceOf.Nucleus, default_scale=1.1)
-        elif h_pos == "elec" and make.get("hydr") == "y" and not no_adjust_hydrogen_distances:
-            logger.writeln("adjusting hydrogen position to electron cloud")
-            topo.adjust_hydrogen_distances(gemmi.Restraints.DistanceOf.ElectronCloud)
+        if make.get("hydr") != "n" and st[0].has_hydrogen():
+            if h_pos == "nucl" and (make.get("hydr") == "a" or not no_adjust_hydrogen_distances):
+                resnames = st[0].get_all_residue_names()
+                utils.restraints.check_monlib_support_nucleus_distances(monlib, resnames)
+                logger.writeln("adjusting hydrogen position to nucleus")
+                topo.adjust_hydrogen_distances(gemmi.Restraints.DistanceOf.Nucleus, default_scale=1.1)
+            elif h_pos == "elec" and make.get("hydr") == "y" and not no_adjust_hydrogen_distances:
+                logger.writeln("adjusting hydrogen position to electron cloud")
+                topo.adjust_hydrogen_distances(gemmi.Restraints.DistanceOf.ElectronCloud)
 
     if fix_long_resnames: refmac_fixes.fix_long_resnames(st)
 
+    # remove "given" ncs matrices
+    # TODO write them back to the output files
+    st.ncs = gemmi.NcsOpList(x for x in st.ncs if not x.given)
+
     # for safety
     if "_entry.id" in st.info:
         st.info["_entry.id"] = st.info["_entry.id"].replace(" ", "")
@@ -172,7 +191,7 @@ def prepare_crd(st, crdout, ligand, make, monlib_path=None, h_pos="elec",
         if st.name.lower() in block_names:
             st.name = st.name + str(i)
     doc = gemmi.prepare_refmac_crd(st, topo, monlib, h_change)
-    doc.write_file(crdout, style=gemmi.cif.Style.NoBlankLines)
+    doc.write_file(crdout, options=gemmi.cif.Style.NoBlankLines)
     logger.writeln("crd file written: {}".format(crdout))
     return refmac_fixes, [x+"\n" for x in metal_kws]
 # prepare_crd()
@@ -221,11 +240,22 @@ def modify_output(pdbout, cifout, fixes, hout, cispeps, keep_original_output=Fal
         # should we check metals and put MetalC?
 
     # fix entity (Refmac seems to make DNA non-polymer; as seen in 1fix)
-    utils.model.setup_entities(st, clear=True, overwrite_entity_type=True, force_subchain_names=True)
-    for e in st.entities:
-        if not e.full_sequence and e.entity_type == gemmi.EntityType.Polymer and e.subchains:
-            rspan = st[0].get_subchain(e.subchains[0])
-            e.full_sequence = [r.name for r in rspan]
+    if not fixes or not fixes.res_labels:
+        utils.model.setup_entities(st, clear=True, overwrite_entity_type=True, force_subchain_names=True)
+        for e in st.entities:
+            if not e.full_sequence and e.entity_type == gemmi.EntityType.Polymer and e.subchains:
+                rspan = st[0].get_subchain(e.subchains[0])
+                e.full_sequence = [r.name for r in rspan]
+
+        # fix label_seq_id
+        for chain in st[0]:
+            for res in chain:
+                res.label_seq = None
+        st.assign_label_seq_id()
+
+    # add servalcat version
+    if len(st.meta.software) > 0 and st.meta.software[-1].name == "refmac":
+        st.meta.software[-1].version += f" (refmacat {servalcat.__version__})"
     
     suffix = ".org"
     os.rename(cifout, cifout + suffix)
@@ -243,11 +273,6 @@ def modify_output(pdbout, cifout, fixes, hout, cispeps, keep_original_output=Fal
         logger.writeln("This structure cannot be saved as an official PDB format. Using hybrid-36. Header part may be inaccurate.")
     if not hout:
         st.remove_hydrogens() # remove hydrogen from pdb, while kept in mmcif
-    # Use short name in pdb
-    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)
     os.rename(pdbout, pdbout + suffix)
     utils.fileio.write_pdb(st, pdbout)
     if not keep_original_output:
@@ -292,11 +317,12 @@ def main(args):
     crdout = None
     refmac_fixes = None
     cispeps = []
-    if xyzin is not None and keywords["refi"].get("type") != "unre":
+    unre = keywords["refi"].get("type") == "unre"
+    if xyzin is not None:
         #tmpfd, crdout = tempfile.mkstemp(prefix="gemmi_", suffix=".crd") # TODO use dir=CCP4_SCR
         #os.close(tmpfd)
         st = utils.fileio.read_structure(xyzin)
-        if not st.cell.is_crystal():
+        if not st.cell.is_crystal() and not unre:
             if args.auto_box_with_padding is not None:
                 st.cell = utils.model.box_from_model(st[0], args.auto_box_with_padding)
                 st.spacegroup_hm = "P 1"
@@ -309,7 +335,8 @@ def main(args):
         refmac_fixes, metal_kws = prepare_crd(st, crdout, args.ligand, make=keywords["make"], monlib_path=args.monlib,
                                               h_pos="nucl" if keywords.get("source")=="ne" else "elec",
                                               no_adjust_hydrogen_distances=args.no_adjust_hydrogen_distances,
-                                              keep_entities=args.keep_entities)
+                                              keep_entities=args.keep_entities,
+                                              unre=unre)
         inputs = metal_kws + inputs # add metal exte first; otherwise it may be affected by user-defined inputs
         opts["xyzin"] = crdout
         cispeps = st.cispeps

servalcat/spa/fofc.py

@@ -44,9 +44,11 @@ def add_arguments(parser):
     parser.add_argument("--monlib",
                         help="Monomer library path. Default: $CLIBD_MON")
     parser.add_argument("--omit_proton", action='store_true',
-                        help="Omit proton from model in map calculation")
+                        #help="Omit hydrogen proton (leaving electrons) from model in map calculation")
+                        help=argparse.SUPPRESS)
     parser.add_argument("--omit_h_electron", action='store_true',
-                        help="Omit hydrogen electrons from model in map calculation")
+                        #help="Omit hydrogen electrons (leaving protons) from model in map calculation")
+                        help=argparse.SUPPRESS)
     parser.add_argument("--source", choices=["electron", "xray", "neutron"], default="electron")
     parser.add_argument('-o','--output_prefix', default="diffmap",
                         help='output file name prefix (default: %(default)s)')
@@ -377,6 +379,17 @@ def write_coot_script(py_out, model_file, mtz_file, contour_fo=1.2, contour_fofc
                 ofs.write("add_molecular_symmetry(imol, {})\n".format(",".join(str(x) for x in v)))
 # write_coot_script()
 
+def write_chimerax_script(cxc_out, model_file, fo_mrc_file, fofc_mrc_file):
+    with open(cxc_out, "w") as ofs:
+        ofs.write('open {}\n'.format(model_file))
+        ofs.write('open {}\n'.format(fo_mrc_file))
+        ofs.write('open {}\n'.format(fofc_mrc_file))
+        ofs.write('volume #3 level 4 level -4 color #00FF00 color #FF0000 squaremesh false cap false style mesh meshlighting false\n')
+        ofs.write('isolde start\n')
+        ofs.write('clipper associate #2 toModel #1\n')
+        ofs.write('clipper associate #3 toModel #1\n')
+# write_chimerax_script()
+
 def main(args):
     if not args.halfmaps and not args.map:
         raise SystemExit("Error: give --halfmaps or --map")
@@ -453,7 +466,11 @@ def main(args):
     logger.writeln("coot --script " + py_out)
     if mask is not None:
         logger.writeln("\nWant to list Fo-Fc map peaks? Try:")
-        logger.writeln("servalcat util map_peaks --map {}_normalized_fofc.mrc --model {} --abs_level 4.0".format(args.output_prefix, args.model))
+        if omit_h_electron:
+            logger.writeln("servalcat util map_peaks --map {}_normalized_fofc_flipsign.mrc --model {} --abs_level 4.0".format(args.output_prefix, args.model))
+        else:
+            logger.writeln("servalcat util map_peaks --map {}_normalized_fofc.mrc --model {} --abs_level 4.0".format(args.output_prefix, args.model))
+
 # main()
 
 if __name__ == "__main__":

servalcat/spa/fsc.py

@@ -20,13 +20,14 @@ def add_arguments(parser):
 
     parser.add_argument('--model',
                         help="")
-    parser.add_argument('--map',
+    group = parser.add_mutually_exclusive_group(required=True)
+    group.add_argument('--map',
                         help='Input map file(s)')
-    parser.add_argument('--mtz',
+    group.add_argument("--halfmaps",  nargs=2)
+    group.add_argument('--mtz',
                         help='Input mtz file.')
     parser.add_argument('--labin', nargs=2,
                         help='label (F and PHI) for mtz')
-    parser.add_argument("--halfmaps",  nargs=2)
     parser.add_argument('--pixel_size', type=float,
                         help='Override pixel size (A)')
     parser.add_argument('--mask', help='Mask file')
@@ -36,6 +37,8 @@ def add_arguments(parser):
     parser.add_argument('--mask_soft_edge',
                         type=float, default=0,
                         help='Add soft edge to model mask.')
+    parser.add_argument('--mask_model', action='store_true',
+                        help='Apply mask to model density')
     parser.add_argument("--b_before_mask", type=float,
                         help="when model-based mask is used: sharpening B value for sharpen-mask-unsharpen procedure. By default it is determined automatically.")
     parser.add_argument('--no_sharpen_before_mask', action='store_true',
@@ -66,13 +69,10 @@ def write_loggraph(stats, labs_fc, log_out):
     model_labs1 = [l for l in stats if any(l.startswith("fsc_"+fc) for fc in labs_fc)]
     model_labs2 = [l for l in stats if any(l.startswith(("cc_"+fc, "mcos_"+fc)) for fc in labs_fc)]
     power_labs = [l for l in stats if l.startswith("power_")]
-    half_labs1 = ["fsc_half_unmasked", "fsc_half_masked", "fsc_half_masked_rand", "fsc_half_masked_corrected"]
-    half_labs2 = ["cc_half", "mcos_half"]
-    if not all(l in stats for l in half_labs1):
-        if "fsc_half" in stats:
-            half_labs1 = ["fsc_half"]
-        else:
-            half_labs1 = []
+    half_labs1 = [l for l in ("fsc_half_unmasked", "fsc_half_masked", "fsc_half_masked_rand", "fsc_half_masked_corrected") if l in stats]
+    half_labs2 = [l for l in ("cc_half", "mcos_half") if l in stats]
+    if not half_labs1 and "fsc_half" in stats:
+        half_labs1 = ["fsc_half"]
 
     stats2 = stats.copy()
     stats2.insert(0, "bin", stats.index)
@@ -340,7 +340,7 @@ def main(args):
         labs_fc.append("FC")
         hkldata.df[labs_fc[-1]] = utils.model.calc_fc_fft(st_expanded, args.resolution - 1e-6, source="electron",
                                                           miller_array=hkldata.miller_array())
-        if mask is not None:
+        if args.mask_model and mask is not None:
             if args.b_before_mask is None:
                 normalizer = 1.
             else:

servalcat/spa/run_refmac.py

@@ -10,7 +10,6 @@ import gemmi
 import numpy
 import json
 import os
-import io
 import shutil
 import argparse
 from servalcat.utils import logger
@@ -58,7 +57,7 @@ def add_arguments(parser):
                         help='Sharpening or blurring B')
     utils.symmetry.add_symmetry_args(parser) # add --pg etc
     parser.add_argument('--contacting_only', action="store_true", help="Filter out non-contacting NCS")
-    parser.add_argument('--ignore_symmetry',
+    parser.add_argument('--ignore_symmetry', action='store_true',
                         help='Ignore symmetry information (MTRIX/_struct_ncs_oper) in the model file')
     parser.add_argument('--find_links', action='store_true', 
                         help='Automatically add links')
@@ -150,6 +149,7 @@ def calc_fsc(st, output_prefix, maps, d_min, mask, mask_radius, soft_edge, b_bef
         assert st_sr is None
     
     logger.writeln("Calculating map-model FSC..")
+    ret = {"summary": {}}
 
     if d_min_fsc is None:
         d_min_fsc = utils.maps.nyquist_resolution(maps[0][0])
@@ -220,12 +220,17 @@ def calc_fsc(st, output_prefix, maps, d_min, mask, mask_radius, soft_edge, b_bef
             s.drop(columns=[x for x in s if x.startswith("fsc_FC") and x.endswith(("half1","half2"))], inplace=True)
 
     # FSCaverages
+    ret["summary"]["d_min"] = d_min
+    ret["summary"]["FSCaverage"] = spa.fsc.fsc_average(stats2.ncoeffs, stats2.fsc_model)
+    if cross_validation:
+        ret["summary"]["FSCaverage_half1"] = spa.fsc.fsc_average(stats2.ncoeffs, stats2.fsc_model_half1)
+        ret["summary"]["FSCaverage_half2"] = spa.fsc.fsc_average(stats2.ncoeffs, stats2.fsc_model_half2)
     fscavg_text  = "Map-model FSCaverages (at {:.2f} A):\n".format(d_min)
-    fscavg_text += " FSCaverage(full) = {: .4f}\n".format(spa.fsc.fsc_average(stats2.ncoeffs, stats2.fsc_model))
+    fscavg_text += " FSCaverage(full) = {: .4f}\n".format(ret["summary"]["FSCaverage"])
     if cross_validation:
         fscavg_text += "Cross-validated map-model FSCaverages:\n"
-        fscavg_text += " FSCaverage(half1)= {: .4f}\n".format(spa.fsc.fsc_average(stats2.ncoeffs, stats2.fsc_model_half1))
-        fscavg_text += " FSCaverage(half2)= {: .4f}\n".format(spa.fsc.fsc_average(stats2.ncoeffs, stats2.fsc_model_half2))
+        fscavg_text += " FSCaverage(half1)= {: .4f}\n".format(ret["summary"]["FSCaverage_half1"])
+        fscavg_text += " FSCaverage(half2)= {: .4f}\n".format(ret["summary"]["FSCaverage_half2"])
     
     # for loggraph
     fsc_logfile = "{}_fsc.log".format(output_prefix)
@@ -269,8 +274,8 @@ def calc_fsc(st, output_prefix, maps, d_min, mask, mask_radius, soft_edge, b_bef
     json.dump(stats.to_dict("records"),
               open("{}_fsc.json".format(output_prefix), "w"),
               indent=True)
-
-    return fscavg_text
+    ret["binned"] = stats2.to_dict(orient="records")
+    return fscavg_text, ret
 # calc_fsc()
 
 def calc_fofc(st, st_expanded, maps, monlib, model_format, args, diffmap_prefix="diffmap"):
@@ -311,6 +316,12 @@ def calc_fofc(st, st_expanded, maps, monlib, model_format, args, diffmap_prefix=
                                contour_fo=None if mask is None else 1.2,
                                contour_fofc=None if mask is None else 3.0,
                                ncs_ops=st.ncs)
+
+    # Create ChimeraX script
+    spa.fofc.write_chimerax_script(cxc_out="{}_chimerax.cxc".format(args.output_prefix),
+                                   model_file="{}.mmcif".format(args.output_prefix), # ChimeraX handles mmcif just fine
+                                   fo_mrc_file="{}_normalized_fo.mrc".format(diffmap_prefix),
+                                   fofc_mrc_file="{}_normalized_fofc.mrc".format(diffmap_prefix))
 # calc_fofc()
 
 def write_final_summary(st, refmac_summary, fscavg_text, output_prefix, is_mask_given):
@@ -356,6 +367,9 @@ Weight used: {final_weight}
 Open refined model and diffmap.mtz with COOT:
 coot --script {prefix}_coot.py
 
+Open refined model, map and difference map with ChimeraX/ISOLDE:
+chimerax {prefix}_chimerax.cxc
+
 {map_peaks_msg}
 =============================================================================
 """.format(rmsbond=refmac_summary["cycles"][-1].get("rms_bond", "???"),
@@ -453,7 +467,7 @@ def process_input(st, maps, resolution, monlib, mask_in, args,
     unit_cell = maps[0][0].unit_cell
     spacegroup = gemmi.SpaceGroup(1)
     start_xyz = numpy.array(maps[0][0].get_position(*grid_start).tolist())
-    A = numpy.array(unit_cell.orthogonalization_matrix.tolist())
+    A = unit_cell.orth.mat.array
     center = numpy.sum(A, axis=1) / 2 #+ start_xyz
 
     # Create mask
@@ -584,7 +598,7 @@ def process_input(st, maps, resolution, monlib, mask_in, args,
             topo, metal_kws = utils.restraints.prepare_topology(st, monlib, h_change=h_change, raise_error=False)
             args.keywords = metal_kws + args.keywords
         elif not no_refmac_fix:
-            topo = gemmi.prepare_topology(st, monlib, warnings=io.StringIO(), ignore_unknown_links=True)
+            topo = gemmi.prepare_topology(st, monlib, warnings=logger.silent(), ignore_unknown_links=True)
         else:
             topo = None # not used
         if not no_refmac_fix:
@@ -609,7 +623,7 @@ def process_input(st, maps, resolution, monlib, mask_in, args,
         args.keywords.append("make cr prepared")
         gemmi.setup_for_crd(st)
         doc = gemmi.prepare_refmac_crd(st, topo, monlib, h_change)
-        doc.write_file(crdout, style=gemmi.cif.Style.NoBlankLines)
+        doc.write_file(crdout, options=gemmi.cif.Style.NoBlankLines)
         logger.writeln("crd file written: {}".format(crdout))
 
     hkldata = utils.maps.mask_and_fft_maps(maps, resolution, None, with_000=False)
@@ -681,8 +695,9 @@ def check_args(args):
     if args.keyword_file:
         args.keyword_file = sum(args.keyword_file, [])
         for f in args.keyword_file:
+            if not os.path.exists(f):
+                raise SystemExit(f"Error: keyword file was not found: {f}")
             logger.writeln("Keyword file: {}".format(f))
-            assert os.path.exists(f)
     else:
         args.keyword_file = []
 
@@ -945,7 +960,7 @@ def main(args):
                            monlib=monlib, cross_validation=args.cross_validation,
                            blur=args.blur,
                            d_min_fsc=args.fsc_resolution,
-                           cross_validation_method=args.cross_validation_method, st_sr=st_sr_expanded)
+                           cross_validation_method=args.cross_validation_method, st_sr=st_sr_expanded)[0]
 
     # Calc Fo-Fc (and updated) maps
     calc_fofc(st, st_expanded, maps, monlib, model_format, args)

servalcat/spa/translate.py

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