servalcat 0.4.72__cp39-cp39-macosx_11_0_arm64.whl → 0.4.99__cp39-cp39-macosx_11_0_arm64.whl

servalcat/__init__.py

@@ -6,5 +6,5 @@ This software is released under the
 Mozilla Public License, version 2.0; see LICENSE.
 """
 
-__version__ = '0.4.72'
-__date__ = '2024-06-06'
+__version__ = '0.4.99'
+__date__ = '2024-12-04'

servalcat/refine/refine.py

@@ -28,7 +28,7 @@ b_to_u = utils.model.b_to_u
 #atexit.register(profile.print_stats)
 
 class Geom:
-    def __init__(self, st, topo, monlib, adpr_w=1, shake_rms=0,
+    def __init__(self, st, topo, monlib, adpr_w=1, occr_w=1, shake_rms=0,
                  params=None, unrestrained=False, use_nucleus=False,
                  ncslist=None, atom_pos=None):
         self.st = st
@@ -40,7 +40,12 @@ class Geom:
             self.atom_pos = list(range(len(self.atoms)))
         self.n_refine_atoms = max(self.atom_pos) + 1
         self.lookup = {x.atom: x for x in self.st[0].all()}
-        self.geom = ext.Geometry(self.st, self.atom_pos, monlib.ener_lib)
+        try:
+            self.geom = ext.Geometry(self.st, self.atom_pos, monlib.ener_lib)
+        except TypeError as e:
+            raise SystemExit(f"An error occurred while creating the Geometry object:\n{e}\n\n"
+                             "This likely indicates an installation issue. "
+                             "Please verify that you have the correct version of gemmi installed and that both gemmi and servalcat were compiled in the same environment.")
         self.specs = utils.model.find_special_positions(self.st)
         #cs_count = len(self.st.find_spacegroup().operations())
         for atom, images, matp, mata in self.specs:
@@ -48,7 +53,7 @@ class Geom:
             n_sym = len(images) + 1
             self.geom.specials.append(ext.Geometry.Special(atom, matp, mata, n_sym))
         self.adpr_w = adpr_w
-        self.occr_w = 1.
+        self.occr_w = occr_w
         self.unrestrained = unrestrained
         if shake_rms > 0:
             numpy.random.seed(0)
@@ -58,7 +63,6 @@ class Geom:
         self.calc_kwds = {"use_nucleus": self.use_nucleus}
         if params is None:
             params = {}
-        exte.read_external_restraints(params.get("exte", []), self.st, self.geom)
         for k in ("wbond", "wangle", "wtors", "wplane", "wchir", "wvdw", "wncs"):
             if k in params:
                 self.calc_kwds[k] = params[k]
@@ -70,26 +74,13 @@ class Geom:
         self.group_occ = GroupOccupancy(self.st, params.get("occu"))
         if not self.unrestrained:
             self.geom.load_topo(topo)
-            self.check_chemtypes(os.path.join(monlib.path(), "ener_lib.cif"), topo)
+        exte.read_external_restraints(params.get("exte", []), self.st, self.geom)
         self.geom.finalize_restraints()
         self.outlier_sigmas = dict(bond=5, angle=5, torsion=5, vdw=5, ncs=5, chir=5, plane=5, staca=5, stacd=5, per_atom=5)
         self.parents = {}
         self.ncslist = ncslist
     # __init__()
 
-    def check_chemtypes(self, enerlib_path, topo):
-        block = gemmi.cif.read(enerlib_path).sole_block()
-        all_types = set(block.find_values("_lib_atom.type"))
-        for ci in topo.chain_infos:
-            for ri in ci.res_infos:
-                cc_all = {x: ri.get_final_chemcomp(x) for x in set(a.altloc for a in ri.res)}
-                for a in ri.res:
-                    cca = cc_all[a.altloc].find_atom(a.name)
-                    if cca is None: # I believe it won't happen..
-                        logger.writeln("WARNING: restraint for {} not found.".format(self.lookup[a]))
-                    elif cca.chem_type not in all_types:
-                        raise RuntimeError("Energy type {} of {} not found in ener_lib.".format(cca.chem_type,
-                                                                                                self.lookup[a]))
     def set_h_parents(self):
         self.parents = {}
         for bond in self.geom.bonds:
@@ -176,15 +167,16 @@ class Geom:
                         logger.writeln(df.to_string(float_format="{:.3f}".format, index=False) + "\n")
 
         # Per-atom score
-        peratom = self.geom.reporting.per_atom_score(len(self.atoms), self.use_nucleus, "mean")
-        df = pandas.DataFrame(peratom)
-        df.insert(0, "atom", [str(self.lookup[x]) for x in self.atoms])
-        df = df[df["total"] >= self.outlier_sigmas["per_atom"]]
-        if show_outliers and len(df.index) > 0:
-            df.sort_values("total", ascending=False, inplace=True)
-            ret["outliers"]["per_atom"] = df
-            logger.writeln(" *** Per-atom violations (Z >= {}) ***\n".format(self.outlier_sigmas["per_atom"]))
-            logger.writeln(df.to_string(float_format="{:.2f}".format, index=False) + "\n")
+        if 0:
+            peratom = self.geom.reporting.per_atom_score(len(self.atoms), self.use_nucleus, "mean")
+            df = pandas.DataFrame(peratom)
+            df.insert(0, "atom", [str(self.lookup[x]) for x in self.atoms])
+            df = df[df["total"] >= self.outlier_sigmas["per_atom"]]
+            if show_outliers and len(df.index) > 0:
+                df.sort_values("total", ascending=False, inplace=True)
+                ret["outliers"]["per_atom"] = df
+                logger.writeln(" *** Per-atom violations (Z >= {}) ***\n".format(self.outlier_sigmas["per_atom"]))
+                logger.writeln(df.to_string(float_format="{:.2f}".format, index=False) + "\n")
 
         df = pandas.DataFrame(self.geom.reporting.get_summary_table(self.use_nucleus))
         df = df.set_index("Restraint type").rename_axis(index=None)
@@ -233,6 +225,26 @@ def write_stats_json_safe(stats, json_out):
     logger.writeln(f"Refinement statistics saved: {json_out}")
 # write_stats_json_safe()
 
+def print_h_options(h_change, h_present, refine_h, hout, geom_only):
+    if not h_present:
+        h_change = gemmi.HydrogenChange.Remove
+    logger.writeln("Hydrogen related options")
+    logger.write(" use in refinement{}: hydrogen atoms ".format("" if geom_only else "/map calculation"))
+    logger.writeln({gemmi.HydrogenChange.ReAddButWater: "have been (re)generated",
+                    gemmi.HydrogenChange.ReAdd:         "(including water) have been (re)generated",
+                    gemmi.HydrogenChange.ReAddKnown:    "(except for rotatable) have been (re) generated",
+                    gemmi.HydrogenChange.NoChange:      "from the input model have been retained",
+                    gemmi.HydrogenChange.Remove:        "have either been removed or were not present"}[h_change])
+    if h_present:
+        logger.write(" target: hydrogen atoms will be ")
+        if geom_only or not refine_h:
+            logger.writeln("just optimized according to geometric restraints")
+        else:
+            logger.writeln("refined against experimental data")
+    logger.writeln(" in output model: " + ("written" if hout and h_present else "not written"))
+    logger.writeln("")
+# print_hydrogen_options()
+
 class GroupOccupancy:
     # TODO max may not be one. should check multiplicity
     def __init__(self, st, params):
@@ -301,6 +313,7 @@ class GroupOccupancy:
         vals = []
         for _, atoms in self.groups:
             occ = numpy.mean([a.occ for a in atoms])
+            occ = min(1, max(1e-3, occ))
             vals.append(occ)
         for is_comp, idxes in self.consts:
             sum_occ = sum(vals[i] for i in idxes)
@@ -319,6 +332,7 @@ class GroupOccupancy:
         for p, (_, atoms) in zip(x, self.groups):
             for a in atoms:
                 a.occ = p
+                #a.occ = max(1, min(1e-3, p))
 
     def target(self, x, ll, ls, u):
         self.set_x(x)
@@ -433,7 +447,7 @@ class Refine:
             self.geom.set_h_parents()
         if params and params.get("write_trajectory"):
             self.st_traj = self.st.clone()
-            self.st_traj[-1].name = "0"
+            self.st_traj[-1].num = 0
         assert self.geom.group_occ.groups or self.n_params() > 0
     # __init__()
     
@@ -450,6 +464,9 @@ class Refine:
                 logger.writeln("  sigmas: {}".format(" ".join("{:.2f}".format(x) for x in g.adpr_kl_sigs)))
             else:
                 raise LookupError("unknown adpr_mode")
+        if self.refine_occ:
+            logger.writeln(" Occupancy restraints")
+            logger.writeln("  weight: {}".format(self.geom.occr_w))
 
     def scale_shifts(self, dx, scale):
         n_atoms = self.geom.n_refine_atoms
@@ -533,7 +550,7 @@ class Refine:
             elif self.adp_mode == 2:
                 a = x[offset_b + 6 * j: offset_b + 6 * (j+1)]
                 a = gemmi.SMat33d(*a)
-                M = numpy.array(a.as_mat33())
+                M = a.as_mat33().array
                 v, Q = numpy.linalg.eigh(M) # eig() may return complex due to numerical precision?
                 v = numpy.maximum(v, 0.5) # avoid NPD with minimum B = 0.5
                 M2 = Q.dot(numpy.diag(v)).dot(Q.T)
@@ -556,6 +573,8 @@ class Refine:
         self.geom.setup_nonbonded(self.refine_xyz) # if refine_xyz=False, no need to do it every time
         self.geom.geom.setup_target(self.refine_xyz, self.adp_mode, self.refine_occ, self.use_occr)
         logger.writeln("vdws = {}".format(len(self.geom.geom.vdws)))
+        logger.writeln(f"atoms = {self.geom.geom.target.n_atoms()}")
+        logger.writeln(f"pairs = {self.geom.geom.target.n_pairs()}")
 
     def get_x(self):
         n_atoms = self.geom.n_refine_atoms
@@ -675,6 +694,8 @@ class Refine:
         self.geom.setup_nonbonded(self.refine_xyz)
         self.geom.geom.setup_target(self.refine_xyz, self.adp_mode, self.refine_occ, self.use_occr)
         logger.writeln("vdws = {}".format(len(self.geom.geom.vdws)))
+        logger.writeln(f"atoms = {self.geom.geom.target.n_atoms()}")
+        logger.writeln(f"pairs = {self.geom.geom.target.n_pairs()}")
         stats[-1]["geom"] = self.geom.show_model_stats(refine_xyz=self.refine_xyz and not self.unrestrained,
                                                        adp_mode=self.adp_mode,
                                                        use_occr=self.refine_occ,
@@ -683,9 +704,12 @@ class Refine:
             self.ll.update_fc()
             self.ll.overall_scale()
             self.ll.update_ml_params()
+            self.ll.prepare_target()
             llstats = self.ll.calc_stats(bin_stats=True)
             stats[-1]["data"] = {"summary": llstats["summary"],
                                  "binned": llstats["bin_stats"].to_dict(orient="records")}
+            if "twin_alpha" in llstats:
+                stats[-1]["twin_alpha"] = llstats["twin_alpha"]
             show_binstats(llstats["bin_stats"], 0)
         if self.adp_mode > 0:
             utils.model.adp_analysis(self.st)
@@ -713,12 +737,15 @@ class Refine:
                 self.ll.overall_scale()
                 f0 = self.ll.calc_target()
                 self.ll.update_ml_params()
+                self.ll.prepare_target()
                 llstats = self.ll.calc_stats(bin_stats=True)#(i==ncycles-1))
                 if llstats["summary"]["-LL"] > f0:
                     logger.writeln("WARNING: -LL has increased after ML parameter optimization:"
                                    "{} to {}".format(f0, llstats["summary"]["-LL"]))
                 stats[-1]["data"] = {"summary": llstats["summary"],
                                      "binned": llstats["bin_stats"].to_dict(orient="records")}
+                if "twin_alpha" in llstats:
+                    stats[-1]["twin_alpha"] = llstats["twin_alpha"]
                 show_binstats(llstats["bin_stats"], i+1)
             if self.adp_mode > 0:
                 utils.model.adp_analysis(self.st)
@@ -734,7 +761,7 @@ class Refine:
                     weight /= 1.1
             if self.st_traj is not None:
                 self.st_traj.add_model(self.st[0])
-                self.st_traj[-1].name = str(i+1)
+                self.st_traj[-1].num = len(self.st_traj)
             if stats_json_out:
                 write_stats_json_safe(stats, stats_json_out)
 
@@ -779,43 +806,101 @@ class Refine:
         lstr = utils.make_loggraph_str(df, "stats vs cycle", forplot,
                                        float_format="{:.4f}".format)
         logger.writeln(lstr)
-        self.update_meta(stats[-1])
         return stats
 
-    def update_meta(self, stats):
-        # TODO write stats. probably geom.reporting.get_summary_table should return with _refine_ls_restr.type names
-        # should remove st.mod_residues?
-        self.st.helices.clear()
-        self.st.sheets.clear()
-        raw_remarks = [f'REMARK   3',
-                       f'REMARK   3 REFINEMENT.',
-                       f'REMARK   3   PROGRAM     : SERVALCAT {servalcat.__version__}',
-                       f'REMARK   3   AUTHORS     : YAMASHITA,MURSHUDOV',
-                       f'REMARK   3',
-                       ]
-        si = gemmi.SoftwareItem()
-        si.classification = gemmi.SoftwareItem.Classification.Refinement
-        si.name = "Servalcat"
-        si.version = servalcat.__version__
-        si.date = servalcat.__date__
-        self.st.meta.software = [si]
-
-        ri = gemmi.RefinementInfo()
-        if "geom" in stats:
-            restr_stats = []
-            raw_remarks.append("REMARK   3  RMS DEVIATIONS FROM IDEAL VALUES        COUNT    RMS    WEIGHT")
-            for k, n, l, pl in (("r.m.s.d.", "Bond distances, non H", "s_bond_nonh_d", "BOND LENGTHS REFINED ATOMS        (A)"),
-                                ("r.m.s.d.", "Bond angles, non H", "s_angle_nonh_d", "BOND ANGLES REFINED ATOMS   (DEGREES)")):
-                if k in stats["geom"]["summary"] and n in stats["geom"]["summary"][k]:
-                    rr = gemmi.RefinementInfo.Restr(l)
-                    rr.dev_ideal = stats["geom"]["summary"][k].get(n)
-                    rr.count = stats["geom"]["summary"]["N restraints"].get(n)
-                    rr.weight = stats["geom"]["summary"]["Mn(sigma)"].get(n)
-                    restr_stats.append(rr)
-                    raw_remarks.append(f"REMARK   3   {pl}:{rr.count:6d} ;{rr.dev_ideal:6.3f} ;{rr.weight:6.3f}")
-            ri.restr_stats = restr_stats
-            raw_remarks.append("REMARK   3")
-        self.st.meta.refinement = [ri]
-        self.st.raw_remarks = raw_remarks
-
 # class Refine
+
+def update_meta(st, stats, ll=None):
+    # TODO write stats. probably geom.reporting.get_summary_table should return with _refine_ls_restr.type names
+    # should remove st.mod_residues?
+    st.helices.clear()
+    st.sheets.clear()
+    raw_remarks = [f'REMARK   3',
+                   f'REMARK   3 REFINEMENT.',
+                   f'REMARK   3   PROGRAM     : SERVALCAT {servalcat.__version__}',
+                   f'REMARK   3   AUTHORS     : YAMASHITA,MURSHUDOV',
+                   f'REMARK   3',
+                   ]
+    si = gemmi.SoftwareItem()
+    si.classification = gemmi.SoftwareItem.Classification.Refinement
+    si.name = "Servalcat"
+    si.version = servalcat.__version__
+    si.date = servalcat.__date__
+    st.meta.software = [si]
+
+    ri = gemmi.RefinementInfo()
+    if "geom" in stats:
+        restr_stats = []
+        raw_remarks.append("REMARK   3  RMS DEVIATIONS FROM IDEAL VALUES        COUNT    RMS    WEIGHT")
+        for k, n, l, pl in (("r.m.s.d.", "Bond distances, non H", "s_bond_nonh_d",             "BOND LENGTHS REFINED ATOMS        (A)"),
+                            ("r.m.s.d.", "Bond angles, non H", "s_angle_nonh_deg",             "BOND ANGLES REFINED ATOMS   (DEGREES)"),
+                            ("r.m.s.d.", "Torsion angles, period 1", "s_dihedral_angle_1_deg", "TORSION ANGLES, PERIOD 1    (DEGREES)"),
+                            ("r.m.s.d.", "Torsion angles, period 2", "s_dihedral_angle_2_deg", "TORSION ANGLES, PERIOD 2    (DEGREES)"),
+                            ("r.m.s.d.", "Torsion angles, period 3", "s_dihedral_angle_3_deg", "TORSION ANGLES, PERIOD 3    (DEGREES)"),
+                            ("r.m.s.d.", "Torsion angles, period 6", "s_dihedral_angle_6_deg", "TORSION ANGLES, PERIOD 6    (DEGREES)"),
+                            ("r.m.s.d.", "Chiral centres", "s_chiral_restr",                   "CHIRAL-CENTER RESTRAINTS       (A**3)"),
+                            ("r.m.s.d.", "Planar groups", "s_planes",                          "GENERAL PLANES REFINED ATOMS      (A)"),
+                            ("r.m.s.d.", "VDW nonbonded", "s_nbd",                             ""),
+                            ("r.m.s.d.", "VDW torsion", "s_nbtor",                             ""),
+                            ("r.m.s.d.", "VDW hbond", "s_hbond_nbd",                           ""),
+                            ("r.m.s.d.", "VDW metal", "s_metal_ion",                           ""),
+                            ("r.m.s.d.", "VDW dummy", "s_dummy_nbd",                           ""),
+                            ("r.m.s.d.", "VDW nonbonded, symmetry", "s_symmetry_nbd",          ""),
+                            ("r.m.s.d.", "VDW torsion, symmetry", "s_symmetry_nbtor",          ""),
+                            ("r.m.s.d.", "VDW hbond, symmetry", "s_symmetry_hbond_nbd",        ""),
+                            ("r.m.s.d.", "VDW metal, symmetry", "s_symmetry_metal_ion",        ""),
+                            ("r.m.s.d.", "VDW dummy, symmetry", "s_symmetry_dummy_nbd",        "")):
+            if k in stats["geom"]["summary"] and n in stats["geom"]["summary"][k]:
+                rr = gemmi.RefinementInfo.Restr(l)
+                rr.dev_ideal = round(stats["geom"]["summary"][k].get(n), 4)
+                rr.count = stats["geom"]["summary"]["N restraints"].get(n)
+                rr.weight = round(stats["geom"]["summary"]["Mn(sigma)"].get(n), 4)
+                restr_stats.append(rr)
+                if pl:
+                    raw_remarks.append(f"REMARK   3   {pl}:{rr.count:6d} ;{rr.dev_ideal:6.3f} ;{rr.weight:6.3f}")
+        ri.restr_stats = restr_stats
+        raw_remarks.append("REMARK   3")
+    if ll is not None:
+        ri.id = ll.refine_id()
+        ri.mean_b = round(numpy.mean([cra.atom.b_iso for cra in st[0].all()]), 2)
+        if ll.b_aniso is not None:
+            ri.aniso_b = ll.b_aniso
+        for k, kd, nd in (("Rwork", "r_work", 4), ("Rfree", "r_free", 4), ("R", "r_all", 4),
+                          ("FSCaverage", "fsc_work", 4),
+                          ("FSCaverage_half1", "fsc_work", 4), ("FSCaverage_half2", "fsc_free", 4)):
+            if k in stats["data"]["summary"]:
+                setattr(ri, kd, round(stats["data"]["summary"][k], nd))
+        bins = []
+        n_all = 0
+        for b in stats["data"]["binned"]:
+            bri = gemmi.BasicRefinementInfo()
+            bri.resolution_high = round(b["d_min"], 3)
+            bri.resolution_low = round(b["d_max"], 3)
+            for k, kd, nd in (("Rwork", "r_work", 4), ("Rfree", "r_free", 4),
+                              ("R1work", "r_work", 4), ("R1free", "r_free", 4),
+                              ("R", "r_all", 4), ("R1", "r_all", 4),
+                              ("CCI", "cc_intensity_work", 4), ("CCF", "cc_fo_fc_work", 4),
+                              ("CCIwork", "cc_intensity_work", 4), ("CCIfree", "cc_intensity_free", 4),
+                              ("CCFwork", "cc_fo_fc_work", 4), ("CCFfree", "cc_fo_fc_free", 4),
+                              ("fsc_FC_full", "fsc_work", 4), ("fsc_model", "fsc_work", 4),
+                              ("fsc_model_half1", "fsc_work", 4), ("fsc_model_half2", "fsc_free", 4),
+                              ("n_work", "work_set_count", 0), ("n_free", "rfree_set_count", 0),
+                              ("n_obs", "reflection_count", 0), ("ncoeffs", "reflection_count", 0)):
+                if k in b: setattr(bri, kd, round(b[k], nd))
+            if "n_all" in b and "n_obs" in b:
+                bri.completeness = round(b["n_obs"] / b["n_all"] * 100, 2)
+                n_all += b["n_all"]
+            bins.append(bri)
+        ri.rfree_set_count = max(-1, sum(b.rfree_set_count for b in bins))
+        ri.work_set_count = max(-1, sum(b.work_set_count for b in bins))
+        ri.reflection_count = max(-1, sum(b.reflection_count for b in bins))
+        ri.resolution_high = round(min(b.resolution_high for b in bins), 3)
+        ri.resolution_low = round(max(b.resolution_low for b in bins), 3)
+        if ri.reflection_count > 0 and n_all > 0:
+            ri.completeness = round(ri.reflection_count / n_all * 100, 2)
+        ri.bins = bins
+        if ri.rfree_set_count > 0:
+            ri.cross_validation_method = "THROUGHOUT"
+    st.meta.refinement = [ri]
+    st.raw_remarks = raw_remarks
+# update_meta()

servalcat/refine/refine_geom.py

@@ -14,7 +14,7 @@ import json
 import servalcat # for version
 from servalcat.utils import logger
 from servalcat import utils
-from servalcat.refine.refine import Geom, Refine, convert_stats_to_dicts
+from servalcat.refine.refine import Geom, Refine, convert_stats_to_dicts, update_meta, print_h_options
 from servalcat.refmac import refmac_keywords
 
 def add_arguments(parser):
@@ -44,6 +44,8 @@ def add_arguments(parser):
                         help="refmac keyword file(s)")
     parser.add_argument('-o','--output_prefix',
                         help="Output prefix")
+    parser.add_argument("--write_trajectory", action='store_true',
+                        help="Write all output from cycles")
 
 # add_arguments()
 
@@ -91,9 +93,14 @@ def refine_and_update_dictionary(cif_in, monomer_dir, output_prefix, randomize=0
         if len(st) > 0: break
     else:
         raise SystemExit("No model in the cif file")
-    monlib = utils.restraints.load_monomer_library(st, monomer_dir=monomer_dir, # monlib is needed for ener_lib
-                                                   cif_files=[cif_in],
-                                                   stop_for_unknowns=True)
+    for i in range(len(st)-1):
+        del st[1]
+    try:
+        monlib = utils.restraints.load_monomer_library(st, monomer_dir=monomer_dir, # monlib is needed for ener_lib
+                                                       cif_files=[cif_in],
+                                                       stop_for_unknowns=True)
+    except RuntimeError as e:
+        raise SystemExit("Error: {}".format(e))
     all_stats = []
     for i_macro in 0, 1:
         try:
@@ -119,16 +126,19 @@ def refine_and_update_dictionary(cif_in, monomer_dir, output_prefix, randomize=0
     for row in block.find("_chem_comp_atom.", ["atom_id", "?x", "?y", "?z",
                                                "?pdbx_model_Cartn_x_ideal",
                                                "?pdbx_model_Cartn_y_ideal",
-                                               "?pdbx_model_Cartn_z_ideal"]):
+                                               "?pdbx_model_Cartn_z_ideal",
+                                               "?model_Cartn_x", "?model_Cartn_y", "?model_Cartn_z"]):
         p = pos[row.str(0)]
         for i in range(3):
             if row.has(i+1):
                 row[i+1] = "{:.3f}".format(p[i])
             if row.has(i+4):
                 row[i+4] = "{:.3f}".format(p[i])
+            if row.has(i+7):
+                row[i+7] = "{:.3f}".format(p[i])
     # add description
     add_program_info_to_dictionary(block, st[0][0][0].name)
-    doc.write_file(output_prefix + "_updated.cif", style=gemmi.cif.Style.Aligned)
+    doc.write_file(output_prefix + "_updated.cif", options=gemmi.cif.Style.Aligned)
     logger.writeln("Updated dictionary saved: {}".format(output_prefix + "_updated.cif"))
     with open(output_prefix + "_stats.json", "w") as ofs:
         json.dump([convert_stats_to_dicts(x) for x in all_stats],
@@ -145,12 +155,15 @@ def refine_geom(model_in, monomer_dir, cif_files, h_change, ncycle, output_prefi
         logger.writeln("Take NCS constraints into account.")
         st2.expand_ncs(gemmi.HowToNameCopiedChain.Dup, merge_dist=0)
         utils.fileio.write_model(st2, file_name="input_expanded.pdb")
-
-    monlib = utils.restraints.load_monomer_library(st, monomer_dir=monomer_dir,
-                                                   cif_files=cif_files,
-                                                   stop_for_unknowns=True,
-                                                   params=params)
-    utils.restraints.find_and_fix_links(st, monlib, add_found=find_links) # should remove unknown id here?
+    try:
+        monlib = utils.restraints.load_monomer_library(st, monomer_dir=monomer_dir,
+                                                       cif_files=cif_files,
+                                                       stop_for_unknowns=True,
+                                                       params=params)
+    except RuntimeError as e:
+        raise SystemExit("Error: {}".format(e))
+    utils.restraints.find_and_fix_links(st, monlib, find_metal_links=find_links,
+                                        add_found=find_links) # should remove unknown id here?
     try:
         topo, _ = utils.restraints.prepare_topology(st, monlib, h_change=h_change,
                                                     check_hydrogen=(h_change==gemmi.HydrogenChange.NoChange),
@@ -158,16 +171,21 @@ def refine_geom(model_in, monomer_dir, cif_files, h_change, ncycle, output_prefi
     except RuntimeError as e:
         raise SystemExit("Error: {}".format(e))
 
+    print_h_options(h_change, st[0].has_hydrogen(), refine_h=True, hout=True, geom_only=True)
+        
     if use_ncsr:
         ncslist = utils.restraints.prepare_ncs_restraints(st)
     else:
         ncslist = False
     geom = Geom(st, topo, monlib, shake_rms=randomize, params=params, ncslist=ncslist)
-    refiner = Refine(st, geom)
+    refiner = Refine(st, geom, params=params)
     stats = refiner.run_cycles(ncycle,
                                stats_json_out=output_prefix + "_stats.json")
+    update_meta(st, stats[-1])
     refiner.st.name = output_prefix
     utils.fileio.write_model(refiner.st, output_prefix, pdb=True, cif=True)
+    if params["write_trajectory"]:
+        utils.fileio.write_model(refiner.st_traj, output_prefix + "_traj", cif=True)
 # refine_geom()
 
 def main(args):
@@ -177,6 +195,7 @@ def main(args):
     decide_prefix = lambda f: utils.fileio.splitext(os.path.basename(f))[0] + "_refined"
     if args.model:
         params = refmac_keywords.parse_keywords(keywords)
+        params["write_trajectory"] = args.write_trajectory
         if not args.output_prefix:
             args.output_prefix = decide_prefix(args.model)
         if args.ligand: