| 1 |
#!/usr/bin/env python |
| 2 |
|
| 3 |
from ._version import __version__ |
| 4 |
import os, argparse |
| 5 |
import imp |
| 6 |
try: |
| 7 |
imp.find_module('matplotlib') |
| 8 |
matplotlib_found = True |
| 9 |
import matplotlib.pyplot as plt |
| 10 |
from matplotlib.colors import colorConverter as cc |
| 11 |
import matplotlib.gridspec as gridspec |
| 12 |
except ImportError: |
| 13 |
matplotlib_found = False |
| 14 |
|
| 15 |
def parse_arguments(parser,gnomdmax=None): |
| 16 |
|
| 17 |
parser.add_argument("--version", action="version",version="%(prog)s v{version}".format(version=__version__)) |
| 18 |
parser.add_argument("-f", "--file", type=str, help="SAXS data file for input (either .dat or .out)") |
| 19 |
parser.add_argument("-u", "--units", default="a", type=str, help="Angular units (\"a\" [1/angstrom] or \"nm\" [1/nanometer]; default=\"a\")") |
| 20 |
parser.add_argument("-d", "--dmax", default=None, type=float, help="Estimated maximum dimension") |
| 21 |
parser.add_argument("-v", "--voxel", default=None, type=float, help="Set desired voxel size, setting resolution of map") |
| 22 |
parser.add_argument("-os","--oversampling", default=3., type=float, help="Sampling ratio") |
| 23 |
parser.add_argument("-n", "--nsamples", default=None, type=int, help="Number of samples, i.e. grid points, along a single dimension. (Sets voxel size, overridden by --voxel. Best optimization with n=power of 2. Default=64)") |
| 24 |
parser.add_argument("--ne", default=10000, type=float, help="Number of electrons in object") |
| 25 |
parser.add_argument("-s", "--steps", default=None, help="Maximum number of steps (iterations)") |
| 26 |
parser.add_argument("-ncs", "--ncs", default=0, type=int, help="Rotational symmetry") |
| 27 |
parser.add_argument("-ncs_steps","--ncs_steps", default=[3000,5000,7000,9000], type=int, nargs='+', help="List of steps for applying NCS averaging (default=3000,5000,7000,9000)") |
| 28 |
parser.add_argument("-ncs_axis", "--ncs_axis", default=1, type=int, help="Rotational symmetry axis (options: 1, 2, or 3 corresponding to xyz principal axes)") |
| 29 |
parser.add_argument("-o", "--output", default=None, help="Output map filename") |
| 30 |
parser.add_argument("-m", "--mode", default="SLOW", type=str, help="Mode. F(AST) sets default options to run quickly for simple particle shapes. S(LOW) useful for more complex molecules. M(EMBRANE) mode allows for negative contrast. (default SLOW)") |
| 31 |
parser.add_argument("--seed", default=None, help="Random seed to initialize the map") |
| 32 |
parser.add_argument("-ld_on","--limit_dmax_on", dest="limit_dmax", action="store_true", help="Limit electron density to sphere of radius 0.6*Dmax from center of object.") |
| 33 |
parser.add_argument("-ld_off","--limit_dmax_off", dest="limit_dmax", action="store_false", help="Do not limit electron density to sphere of radius 0.6*Dmax from center of object. (default)") |
| 34 |
parser.add_argument("-ld_steps","--limit_dmax_steps", default=None, type=int, nargs='+', help="List of steps for limiting density to sphere of Dmax (default=500)") |
| 35 |
parser.add_argument("-rc_on", "--recenter_on", dest="recenter", action="store_true", help="Recenter electron density when updating support. (default)") |
| 36 |
parser.add_argument("-rc_off", "--recenter_off", dest="recenter", action="store_false", help="Do not recenter electron density when updating support.") |
| 37 |
parser.add_argument("-rc_steps", "--recenter_steps", default=None, type=int, nargs='+', help="List of steps to recenter electron density.") |
| 38 |
parser.add_argument("-rc_mode", "--recenter_mode", default="com", type=str, help="Recenter based on either center of mass (com, default) or maximum density value (max)") |
| 39 |
parser.add_argument("-p_on","--positivity_on", dest="positivity", action="store_true", help="Enforce positivity restraint inside support. (default)") |
| 40 |
parser.add_argument("-p_off","--positivity_off", dest="positivity", action="store_false", help="Do not enforce positivity restraint inside support.") |
| 41 |
parser.add_argument("-fld_on","--flatten_low_density_on", dest="flatten_low_density", action="store_true", help="Density values near zero (.01 e-/A3) will be set to zero. (default)") |
| 42 |
parser.add_argument("-fld_off","--flatten_low_density_off", dest="flatten_low_density", action="store_false", help="Density values near zero (.01 e-/A3) will be not set to zero.") |
| 43 |
parser.add_argument("-min","--minimum_density", default=None, type=float, help="Minimum density value in e-/angstrom^3 (must also set --ne to be meaningful)") |
| 44 |
parser.add_argument("-max","--maximum_density", default=None, type=float, help="Maximum density value in e-/angstrom^3 (must also set --ne to be meaningful)") |
| 45 |
parser.add_argument("-rho", "--rho_start", default=None, type=str, help="Starting electron density map filename (for use in denss.refine.py only)") |
| 46 |
parser.add_argument("--add_noise", default=None, type=float, help="Add noise to starting density map. Uniformly distributed random density is added to each voxel, by default from 0 to 1. The argument is a scale factor to multiply this by.") |
| 47 |
parser.add_argument("-e_on","--extrapolate_on", dest="extrapolate", action="store_true", help="Extrapolate data by Porod law to high resolution limit of voxels. (default)") |
| 48 |
parser.add_argument("-e_off","--extrapolate_off", dest="extrapolate", action="store_false", help="Do not extrapolate data by Porod law to high resolution limit of voxels.") |
| 49 |
parser.add_argument("-sw_on","--shrinkwrap_on", dest="shrinkwrap", action="store_true", help="Turn shrinkwrap on (default)") |
| 50 |
parser.add_argument("-sw_off","--shrinkwrap_off", dest="shrinkwrap", action="store_false", help="Turn shrinkwrap off") |
| 51 |
parser.add_argument("-sw_start","--shrinkwrap_sigma_start", default=3, type=float, help="Starting sigma for Gaussian blurring, in voxels") |
| 52 |
parser.add_argument("-sw_end","--shrinkwrap_sigma_end", default=1.5, type=float, help="Ending sigma for Gaussian blurring, in voxels") |
| 53 |
parser.add_argument("-sw_decay","--shrinkwrap_sigma_decay", default=0.99, type=float, help="Rate of decay of sigma, fraction") |
| 54 |
parser.add_argument("-sw_threshold","--shrinkwrap_threshold_fraction", default=0.20, type=float, help="Minimum threshold defining support, in fraction of maximum density") |
| 55 |
parser.add_argument("-sw_iter","--shrinkwrap_iter", default=20, type=int, help="Number of iterations between updating support with shrinkwrap") |
| 56 |
parser.add_argument("-sw_minstep","--shrinkwrap_minstep", default=None, type=int, help="First step to begin shrinkwrap") |
| 57 |
parser.add_argument("-ec_on","--enforce_connectivity_on", dest="enforce_connectivity", action="store_true", help="Enforce connectivity of support, i.e. remove extra blobs (default)") |
| 58 |
parser.add_argument("-ec_off","--enforce_connectivity_off", dest="enforce_connectivity", action="store_false", help="Do not enforce connectivity of support") |
| 59 |
parser.add_argument("-ec_steps","--enforce_connectivity_steps", default=None, type=int, nargs='+', help="List of steps to enforce connectivity") |
| 60 |
parser.add_argument("-cef", "--chi_end_fraction", default=0.001, type=float, help="Convergence criterion. Minimum threshold of chi2 std dev, as a fraction of the median chi2 of last 100 steps.") |
| 61 |
parser.add_argument("--write_xplor_format", default=False, action="store_true", help="Write out XPLOR map format (default only write MRC format).") |
| 62 |
parser.add_argument("--write_freq", default=100, type=int, help="How often to write out current density map (in steps, default 100).") |
| 63 |
parser.add_argument("--cutout_on", dest="cutout", action="store_true", help="When writing final map, cut out the particle to make smaller files.") |
| 64 |
parser.add_argument("--cutout_off", dest="cutout", action="store_false", help="When writing final map, do not cut out the particle to make smaller files (default).") |
| 65 |
parser.add_argument("--plot_on", dest="plot", action="store_true", help="Create simple plots of results (requires Matplotlib, default if module exists).") |
| 66 |
parser.add_argument("--plot_off", dest="plot", action="store_false", help="Do not create simple plots of results. (Default if Matplotlib does not exist)") |
| 67 |
parser.add_argument("-q", "--quiet", action="store_true", help="Do not display running statistics. (default False)") |
| 68 |
parser.add_argument("--force_run", action="store_true", help="Force denss to run even if q=0 does not exist. (default False)") |
| 69 |
parser.add_argument("-gpu", "--gpu", dest="DENSS_GPU", action="store_true", help="Use GPU acceleration (requires CuPy). (default False)") |
| 70 |
parser.set_defaults(limit_dmax=False) |
| 71 |
parser.set_defaults(shrinkwrap=True) |
| 72 |
parser.set_defaults(recenter=True) |
| 73 |
parser.set_defaults(positivity=True) |
| 74 |
parser.set_defaults(flatten_low_density=False) |
| 75 |
parser.set_defaults(extrapolate=True) |
| 76 |
parser.set_defaults(enforce_connectivity=True) |
| 77 |
parser.set_defaults(cutout=False) |
| 78 |
parser.set_defaults(quiet = False) |
| 79 |
parser.set_defaults(force_run = False) |
| 80 |
parser.set_defaults(DENSS_GPU = False) |
| 81 |
if matplotlib_found: |
| 82 |
parser.set_defaults(plot=True) |
| 83 |
else: |
| 84 |
parser.set_defaults(plot=False) |
| 85 |
args = parser.parse_args() |
| 86 |
|
| 87 |
if args.output is None: |
| 88 |
basename, ext = os.path.splitext(args.file) |
| 89 |
args.output = basename |
| 90 |
else: |
| 91 |
args.output = args.output |
| 92 |
|
| 93 |
#A bug appears to be present when disabling the porod extrapolation. |
| 94 |
#for now that option will be disabled until I come up with a fix |
| 95 |
if args.extrapolate is False: |
| 96 |
print ("There is currently a bug when disabling the Porod " |
| 97 |
"extrapolation (the -e_off option). \n For now, extrapolation " |
| 98 |
"has been re-enabled until a bug fix is released. ") |
| 99 |
args.extrapolate = True |
| 100 |
|
| 101 |
#for FAST or SLOW modes, set some default values for a few options |
| 102 |
if args.mode[0].upper() == "F": |
| 103 |
args.mode = "FAST" |
| 104 |
nsamples = 32 |
| 105 |
shrinkwrap_minstep = 1000 |
| 106 |
enforce_connectivity_steps = [2000] |
| 107 |
recenter_steps = list(range(501,2502,500)) |
| 108 |
elif args.mode[0].upper() == "S": |
| 109 |
args.mode = "SLOW" |
| 110 |
nsamples = 64 |
| 111 |
shrinkwrap_minstep = 5000 |
| 112 |
enforce_connectivity_steps = [6000] |
| 113 |
recenter_steps = list(range(501,8002,500)) |
| 114 |
elif args.mode[0].upper() == "M": |
| 115 |
args.mode = "MEMBRANE" |
| 116 |
nsamples = 64 |
| 117 |
args.positivity = False |
| 118 |
shrinkwrap_minstep = 0 |
| 119 |
shrinkwrap_threshold_fraction = 0.1 |
| 120 |
enforce_connectivity_steps = [300] |
| 121 |
recenter_steps = list(range(501,8002,500)) |
| 122 |
else: |
| 123 |
args.mode = "None" |
| 124 |
|
| 125 |
#allow user to explicitly modify those values by resetting them here to the user defined values |
| 126 |
if args.nsamples is not None: |
| 127 |
nsamples = args.nsamples |
| 128 |
|
| 129 |
if args.shrinkwrap_minstep is not None: |
| 130 |
shrinkwrap_minstep = args.shrinkwrap_minstep |
| 131 |
|
| 132 |
if args.shrinkwrap_threshold_fraction is not None: |
| 133 |
shrinkwrap_threshold_fraction = args.shrinkwrap_threshold_fraction |
| 134 |
|
| 135 |
if args.enforce_connectivity_steps is not None: |
| 136 |
enforce_connectivity_steps = args.enforce_connectivity_steps |
| 137 |
if not isinstance(enforce_connectivity_steps, list): |
| 138 |
enforce_connectivity_steps = [ enforce_connectivity_steps ] |
| 139 |
|
| 140 |
if args.recenter_steps is not None: |
| 141 |
recenter_steps = args.recenter_steps |
| 142 |
if not isinstance(recenter_steps, list): |
| 143 |
recenter_steps = [ recenter_steps ] |
| 144 |
|
| 145 |
if args.limit_dmax_steps is not None: |
| 146 |
limit_dmax_steps = args.limit_dmax_steps |
| 147 |
else: |
| 148 |
limit_dmax_steps = [502] |
| 149 |
if not isinstance(limit_dmax_steps, list): |
| 150 |
limit_dmax_steps = [ limit_dmax_steps ] |
| 151 |
|
| 152 |
if args.steps is not None: |
| 153 |
steps = args.steps |
| 154 |
|
| 155 |
if args.dmax is not None and args.dmax >= 0: |
| 156 |
dmax = args.dmax |
| 157 |
elif gnomdmax is not None: |
| 158 |
dmax = gnomdmax |
| 159 |
else: |
| 160 |
dmax = 100.0 |
| 161 |
|
| 162 |
if args.voxel is None and nsamples is None: |
| 163 |
voxel = 5. |
| 164 |
elif args.voxel is None and nsamples is not None: |
| 165 |
voxel = dmax * args.oversampling / nsamples |
| 166 |
else: |
| 167 |
voxel = args.voxel |
| 168 |
|
| 169 |
#now recollect all the edited options back into args |
| 170 |
args.nsamples = nsamples |
| 171 |
args.shrinkwrap_minstep = shrinkwrap_minstep |
| 172 |
args.shrinkwrap_threshold_fraction = shrinkwrap_threshold_fraction |
| 173 |
args.enforce_connectivity_steps = enforce_connectivity_steps |
| 174 |
args.recenter_steps = recenter_steps |
| 175 |
args.limit_dmax_steps = limit_dmax_steps |
| 176 |
args.dmax = dmax |
| 177 |
args.voxel = voxel |
| 178 |
|
| 179 |
return args |