servalcat 0.4.99__cp39-cp39-macosx_10_14_x86_64.whl

servalcat/__init__.py

@@ -0,0 +1,10 @@
+"""
+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.
+"""
+
+__version__ = '0.4.99'
+__date__ = '2024-12-04'

servalcat/__main__.py

@@ -0,0 +1,120 @@
+"""
+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 sys
+import traceback
+import platform
+import gemmi
+import numpy
+import scipy
+import pandas
+import servalcat.spa.shiftback
+import servalcat.spa.run_refmac
+import servalcat.spa.fsc
+import servalcat.spa.fofc
+import servalcat.spa.shift_maps
+import servalcat.spa.translate
+import servalcat.spa.localcc
+import servalcat.xtal.run_refmac_small
+import servalcat.xtal.sigmaa
+import servalcat.refmac.refmac_wrapper
+import servalcat.xtal.french_wilson
+import servalcat.utils.commands
+import servalcat.refine.refine_geom
+import servalcat.refine.refine_spa
+import servalcat.refine.refine_xtal
+
+from servalcat.utils import logger
+
+def test_installation():
+    import packaging.version
+    vers = logger.dependency_versions()
+    pandas_ver = packaging.version.parse(vers["pandas"])
+    numpy_ver = packaging.version.parse(vers["numpy"])
+    msg_unknown = "Unexpected error occurred (related to numpy+pandas). Please report to authors with the result of servalcat -v."
+    msg_skip = "If you want to ignore this error, please specify --skip_test."
+    ret = True
+    
+    try:
+        x = pandas.DataFrame(dict(x=[2j]))
+        x.merge(x)
+    except TypeError:
+        ret = False
+        if pandas_ver >= packaging.version.parse("1.3.0") and numpy_ver < packaging.version.parse("1.19.1"):
+            print("There is a problem in pandas+numpy. Please update numpy to 1.19.1 or newer (or use pandas < 1.3.0).")
+        else:
+            print(traceback.format_exc())
+            print(msg_unknown)
+    except:
+        print(traceback.format_exc())
+        print(msg_unknown)
+        ret = False
+
+    if not ret:
+        print(msg_skip)
+        
+    return ret
+# test_installation()        
+
+def main():
+    parser = argparse.ArgumentParser(prog="servalcat",
+                                     description="A tool for model refinement and map calculation for crystallography and cryo-EM SPA.")
+    parser.add_argument("--skip_test", action="store_true", help="Skip installation test")
+    parser.add_argument("-v", "--version", action="version",
+                        version=logger.versions_str())
+    parser.add_argument("--logfile", default="servalcat.log")
+    subparsers = parser.add_subparsers(dest="command")
+
+    modules = dict(shiftback=servalcat.spa.shiftback,
+                   refine_spa=servalcat.spa.run_refmac,
+                   refine_cx=servalcat.xtal.run_refmac_small,
+                   fsc=servalcat.spa.fsc,
+                   fofc=servalcat.spa.fofc,
+                   trim=servalcat.spa.shift_maps,
+                   translate=servalcat.spa.translate,
+                   localcc=servalcat.spa.localcc,
+                   sigmaa=servalcat.xtal.sigmaa,
+                   fw=servalcat.xtal.french_wilson,
+                   #show=servalcat.utils.show,
+                   util=servalcat.utils.commands,
+                   refmac5=servalcat.refmac.refmac_wrapper,
+                   refine_geom=servalcat.refine.refine_geom,
+                   refine_spa_norefmac=servalcat.refine.refine_spa,
+                   refine_xtal_norefmac=servalcat.refine.refine_xtal,
+                   )
+
+    for n in modules:
+        p = subparsers.add_parser(n)
+        modules[n].add_arguments(p)
+
+    args = parser.parse_args()
+    
+    if not args.skip_test and not test_installation():
+        return
+    
+    if args.command == "util" and not args.subcommand:
+        print("specify subcommand.")    
+    elif args.command in modules:
+        logger.set_file(args.logfile)
+        logger.write_header()
+        try:
+            modules[args.command].main(args)
+        except SystemExit as e:
+            logger.error(str(e))
+            sys.exit(1)
+        logger.exit_success()
+        logger.close()
+    else:
+        parser.print_help()
+
+# main()
+
+if __name__ == "__main__":
+    main()
+

servalcat/refine/cgsolve.py

@@ -0,0 +1,100 @@
+"""
+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
+from servalcat.utils import logger
+import numpy
+
+def cgsolve_rm(A, v, M, gamma=0., ncycl=2000, toler=1.e-4):
+    gamma_save = None
+    step_flag = False
+    gamma_flag = False
+    conver_flag = False
+    #f = numpy.zeros(len(v))
+    dv = numpy.zeros(len(v))
+    dv_save = numpy.zeros(len(v))
+    
+    # preconditioning
+    A = M.T.dot(A).dot(M)
+    #print("precond_A=")
+    #print(A.toarray())
+    v = M.T.dot(v)
+
+    vnorm = numpy.sqrt(numpy.dot(v, v))
+    test_lim = toler * vnorm
+    max_gamma_cyc = 500
+    step = 0.05
+
+    for gamma_cyc in range(max_gamma_cyc):
+        if gamma_cyc != 0: gamma += step
+
+        logger.writeln("Trying gamma equal {:.4e}".format(gamma))
+        r = v - (A.dot(dv) + gamma * dv)
+        rho = [numpy.dot(r, r)]
+        if rho[0] < toler:
+            break
+        
+        exit_flag = False
+        for itr in range(ncycl):
+            if itr == 0:
+                p = r
+                beta = 0.
+            else:
+                beta = rho[-1] / rho[-2]
+                p = r + beta * p
+
+            f = A.dot(p) + gamma * p
+            alpha = rho[-1] / numpy.dot(p, f)
+            dv += alpha * p
+            if itr%20 == 0:
+                r = v - (A.dot(dv) + gamma * dv)
+            else:
+                r = r - alpha * f
+
+            rho.append(numpy.dot(r, r))
+            #print("rho=", rho)
+            if numpy.sqrt(rho[-1]) > 2 * numpy.sqrt(rho[-2]):
+                logger.writeln("Not converging with gamma equal {:.4e}".format(gamma))
+                step *= 1.05
+                break
+
+            if numpy.sqrt(rho[-1]) < test_lim:
+                if not gamma_flag:
+                    logger.writeln("Convergence reached with no gamma cycles")
+                    exit_flag = True
+                    break # goto 120
+                elif conver_flag:
+                    logger.writeln("Convergence reached with gamma equal {:.4e}".format(gamma))
+                    step *= 1.01
+                    exit_flag = True
+                    break # goto 120
+                else:
+                    conver_flag = True
+                    step_flag = True
+                    gamma_save = gamma
+                    dv_save = numpy.copy(dv)
+                    gamma = max(0, gamma - step/5.)
+                    step = max(step/1.1, 0.0001)
+                    logger.writeln("Gamma decreased to {:.4e}".format(gamma))
+                    exit_flag = True
+                    break
+        # end of inner loop
+        if exit_flag: break
+        
+        gamma_flag = True
+        if not conver_flag:
+            dv[:] = 0.
+        else:
+            dv = numpy.copy(dv_save)
+            gamma = gamma_save
+            logger.writeln("Back to gamma equal {:.4e}".format(gamma))
+
+
+    # postconditioning
+    dv = M.dot(dv)
+    return dv, gamma
+# cgsolve_rm()