def main():
progname = optparse.os.path.basename(sys.argv[0])
usage = progname + " stack_in stack_out"
parser = optparse.OptionParser(usage, version=sp_global_def.SPARXVERSION)
(options, args) = parser.parse_args()
if sp_global_def.CACHE_DISABLE:
sp_utilities.disable_bdb_cache()
# check length of arguments list. less than 2 is illegal
if len(args) < 2:
sp_global_def.sxprint("usage: " + usage)
sp_global_def.sxprint("Please run '" + progname +
" -h' for detailed options")
# 2 is file to file copying
elif 2 == len(args):
# print "file to file"
sp_applications.cpy(args[0], args[1])
# more than 2, this means a wildcard is transformed to a list of filenams
else:
# print "list to file"
#
# XXX: note that wildcards only work for filenames! wildcards in files
# are processed by the shell and read in as a space-delimited list
# of filenames. however, this does NOT work for bdb:image1 type names,
# since these will not be found and processed by the shell, not being
# normal files. globbing of db objects will have to be done here!
#
# make sure we only pass the last entry of args as output file name,
# since [-1:] pass a list containing only the last entry....
#
# application.cpy
sp_applications.cpy(args[:-1], args[-1:][0])
def main():
progname = os.path.basename(sys.argv[0])
usage = progname + " stack outdir <maskfile> --ou=outer_radius --br=brackets --center=center_type --eps=epsilon --maxit=max_iter --CTF --snr=SNR --function=user_function_name"
parser = OptionParser(usage,version=SPARXVERSION)
parser.add_option("--ou", type="float", default=-1, help=" outer radius for a 2-D mask within which the alignment is performed")
parser.add_option("--br", type="float", default=1.75, help=" brackets for the search of orientation parameters (each parameter will be checked +/- bracket (set to 1.75)")
parser.add_option("--center", type="float", default=1, help=" 0 - if you do not want the average to be centered, 1 - center the average (default=1)")
parser.add_option("--eps", type="float", default=0.001, help=" stopping criterion, program will terminate when the relative increase of the criterion is less than epsilon ")
parser.add_option("--maxit", type="float", default=10, help=" maximum number of iterations (set to 10) ")
parser.add_option("--CTF", action="store_true", default=False, help=" Consider CTF correction during the alignment ")
parser.add_option("--snr", type="float", default=1.0, help=" Signal-to-Noise Ratio of the data")
parser.add_option("--function", type="string", default="ref_ali2d", help=" name of the reference preparation function")
(options, args) = parser.parse_args()
if len(args) < 2 or len(args) >3:
sxprint( "Usage: " + usage )
sxprint( "Please run '" + progname + " -h' for detailed options" )
ERROR( "Invalid number of parameters used. Please see usage information above." )
return
else:
if len(args) == 2:
mask = None
else:
mask = args[2]
from sp_applications import local_ali2d
if sp_global_def.CACHE_DISABLE:
from sp_utilities import disable_bdb_cache
disable_bdb_cache()
sp_global_def.BATCH = True
local_ali2d(args[0], args[1], mask, options.ou, options.br, options.center, options.eps, options.maxit, options.CTF, options.snr, options.function)
sp_global_def.BATCH = False
def main():
progname = os.path.basename(sys.argv[0])
usage = progname + "2Dprojections plot_output Read projection angles from 2Dprojections file or from a text file and write a 2D image file containing their distribution on a hemisphere."
parser = OptionParser(usage, version=SPARXVERSION)
parser.add_option("--wnx",
type="int",
default=256,
help="plot image size (default = 256)")
(options, args) = parser.parse_args()
if len(args) != 2:
sxprint("Usage: " + usage)
sxprint("Please run \'" + progname + " -h\' for detailed options")
ERROR(
"Invalid number of parameters used. Please see usage information above."
)
return
else:
if sp_global_def.CACHE_DISABLE:
from sp_utilities import disable_bdb_cache
disable_bdb_cache()
from sp_applications import plot_projs_distrib
sp_global_def.BATCH = True
plot_projs_distrib(args[0], args[1], options.wnx)
sp_global_def.BATCH = False
def main():
progname = os.path.basename(sys.argv[0])
usage = progname + " input_stack output_stack average --avg --CTF"
parser = OptionParser(usage, version=SPARXVERSION)
parser.add_option(
"--avg",
action="store_true",
default=True,
help=
" Subtract averages computed within corners of individual images, default False"
)
parser.add_option(
"--CTF",
action="store_true",
default=False,
help=" Consider CTF correction during the alignment, dafault False")
(options, args) = parser.parse_args()
if len(args) != 3:
sxprint("Usage: " + usage)
sxprint("Please run \'" + progname + " -h\' for detailed options")
ERROR(
"Invalid number of parameters used. Please see usage information above."
)
return
else:
if sp_global_def.CACHE_DISABLE:
from sp_utilities import disable_bdb_cache
disable_bdb_cache()
from sp_applications import prepare_2d_forPCA
sp_global_def.BATCH = True
prepare_2d_forPCA(args[0], args[1], args[2], options.avg, options.CTF)
sp_global_def.BATCH = False
def main():
arglist = []
for arg in sys.argv:
arglist.append( arg )
progname = os.path.basename( arglist[0] )
usage = progname + " stack1 <stack2> <mask> --ccc --fsc file --inf --rad=r"
parser = OptionParser(usage, version=SPARXVERSION)
parser.add_option( "--ccc", action="store_true", default=False, help="print cross corelation coefficient" )
parser.add_option( "--fsc", type="string", default="", help="calculate resolution curve" )
parser.add_option( "--inf", action="store_true", default=False, help="print basic infomation of the img" )
parser.add_option( "--rad", type="int", default=-1, help="radius of operation" )
(options,args) = parser.parse_args( arglist[1:] )
if len(args)<1 or len(args)>3:
sxprint("usage: " + usage)
sxprint("Please run '" + progname + " -h' for detailed options")
ERROR( "Invalid number of parameters. Please see usage information above" )
return
if sp_global_def.CACHE_DISABLE:
from sp_utilities import disable_bdb_cache
disable_bdb_cache()
from sp_applications import imgstat
sp_global_def.BATCH = True
imgstat( args, options.ccc, options.fsc, options.inf, options.rad )
def main():
progname = os.path.basename(sys.argv[0])
usage = progname + " input_stack output_stack --subavg=average_image --rad=mask_radius --nvec=number_of_eigenvectors --incore --mask=maskfile --shuffle --usebuf --MPI"
parser = OptionParser(usage, version=SPARXVERSION)
parser.add_option("--subavg",
type="string",
default="",
help="subtract average")
parser.add_option("--rad", type="int", default=-1, help="radius of mask")
parser.add_option("--nvec",
type="int",
default=1,
help="number of eigenvectors")
parser.add_option("--mask", type="string", default="", help="mask file")
parser.add_option("--genbuf",
action="store_true",
default=False,
help="use existing buffer")
parser.add_option("--shuffle",
action="store_true",
default=False,
help="use shuffle")
parser.add_option("--incore",
action="store_true",
default=False,
help="no buffer on a disk")
parser.add_option("--MPI",
action="store_true",
default=False,
help="run mpi version")
(options, args) = parser.parse_args()
input_stacks = args[0:-1]
output_stack = args[-1]
if options.nvec is None:
ERROR("Error: number of components is not given")
return
isRoot = True
if options.MPI:
isRoot = (mpi.mpi_comm_rank(mpi.MPI_COMM_WORLD) == 0)
if sp_global_def.CACHE_DISABLE:
from sp_utilities import disable_bdb_cache
disable_bdb_cache()
from sp_applications import pca
sp_global_def.BATCH = True
vecs = []
vecs = pca(input_stacks, options.subavg, options.rad, options.nvec,
options.incore, options.shuffle, not (options.genbuf),
options.mask, options.MPI)
if isRoot:
for i in range(len(vecs)):
vecs[i].write_image(output_stack, i)
sp_global_def.BATCH = False
def main():
progname = os.path.basename(sys.argv[0])
usage = progname + " stack dendoname averages_name --K=number_of_groups"
parser = OptionParser(usage, version=SPARXVERSION)
parser.add_option("--K",
type="int",
default=2,
help="Number of classes (default 2)")
(options, args) = parser.parse_args()
if len(args) != 3:
sxprint("Usage: " + usage)
sxprint("Please run \'" + progname + " -h\' for detailed options")
ERROR(
"Invalid number of parameters used. Please see usage information above."
)
return
else:
if sp_global_def.CACHE_DISABLE:
from sp_utilities import disable_bdb_cache
disable_bdb_cache()
from sp_applications import HAC_averages
sp_global_def.BATCH = True
HAC_averages(args[0], args[1], args[2], options.K)
sp_global_def.BATCH = False
def main():
progname = os.path.basename(sys.argv[0])
usage = progname + " input_stack start end output_stack <mask> --rad=mask_radius"
parser = OptionParser(usage, version=SPARXVERSION)
parser.add_option("--rad", type="int", default=-1, help="radius of mask")
parser.add_option("--verbose", type="int", default=0, help="verbose level (0|1)")
(options, args) = parser.parse_args()
if len(args) < 4:
sxprint("Usage: " + usage)
sxprint("Please run \'" + progname + " -h\' for details")
ERROR( "Invalid number of parameters used. Please see usage information above." )
return
else:
from string import atoi
input_stack = args[0]
imgstart = atoi( args[1] )
imgend = atoi( args[2] ) +1
output_stack = args[3]
if(len(args) == 5):
mask = args[4]
else:
mask = None
if sp_global_def.CACHE_DISABLE:
from sp_utilities import disable_bdb_cache
disable_bdb_cache()
from sp_applications import varimax
sp_global_def.BATCH = True
varimax(input_stack, list(range(imgstart, imgend)), output_stack, mask, options.rad, options.verbose)
sp_global_def.BATCH = False
def main():
progname = os.path.basename(sys.argv[0])
usage = progname + " input_filename output_filename --sym=Symmetry group --phi --theta --psi=The 3 Eulerian angles in degrees --r=Radius of mask --phirange --thetarange --psirange=A search scale for each angle --ftol --xtol = convergence criterion the function and angles values"
parser = OptionParser(usage,version=SPARXVERSION)
parser.add_option("--sym", type="string", default="c1", help=" String that specifies the point group symmetry. default = 'c1'")
parser.add_option("--phi", type='float',default=0.0, help=" phi angle, default = 0")
parser.add_option("--theta", type='float',default=0.0, help=" theta angle, default=0")
parser.add_option("--psi", type='float',default=0.0, help=" phi angle, default=0")
parser.add_option("--r", type='float',default=None,help=" Input the radius of the mask. default=None")
parser.add_option("--phirange", type='float',default=20.0,help=" The search scale for phi angle...default=20")
parser.add_option("--thetarange", type='float',default=20.0,help=" The search scale for theta angle...default=20")
parser.add_option("--psirange", type='float',default=20.0,help=" The search scale for psi angle...default=20")
parser.add_option("--ftol", type='float',default=1.e-4,help=" convergence criterion on the function values...default = 1.e-4")
parser.add_option("--xtol", type='float',default=1.e-4,help=" convergence criterion on the variable values...default = 1.e-4")
(options, args) = parser.parse_args()
if len(args) != 2:
sxprint("Usage: " + usage)
sxprint("Please run \'" + progname + " -h\' for detailed options")
ERROR( "Invalid number of parameters used. Please see usage information above." )
return
else:
if sp_global_def.CACHE_DISABLE:
from sp_utilities import disable_bdb_cache
disable_bdb_cache()
from sp_applications import rot_sym
sp_global_def.BATCH = True
rot_sym(args[0],args[1],options.sym,options.r,options.phi,options.theta,options.psi,options.phirange,options.thetarange,options.psirange,options.ftol,options.xtol)
sp_global_def.write_command('.')
sp_global_def.BATCH = False
def main():
progname = os.path.basename(sys.argv[0])
usage = progname + " stack montagefile --N=image_per_row --gx=gap_on_x_axis --gy=gap_on_y_axis --bg=background_option --scale --number --begin_zero"
parser = OptionParser(usage, version=SPARXVERSION)
parser.add_option("--N",
type="int",
default=10,
help="number of images per row (default = 10)")
parser.add_option(
"--gx",
type="int",
default=0,
help="number of pixels of the gap on x-axis (default = 0)")
parser.add_option(
"--gy",
type="int",
default=-1,
help="number of pixels of the gap on y-axis (default = gx)")
parser.add_option(
"--bg",
type="int",
default=0,
help=
"background option: 0. use minimum as background; 1. use maximum as background; 2. use 0 as background; 3. use average as background (default = 0)"
)
parser.add_option("--scale",
action="store_true",
default=False,
help="whether to scale all particles to (0, 1) ")
parser.add_option("--number",
action="store_true",
default=False,
help="whether to show particle number on the particle")
parser.add_option("--begin_zero",
action="store_true",
default=False,
help="whether to use zero as the starting point")
(options, args) = parser.parse_args()
if len(args) != 2:
sxprint("Usage: " + usage)
sxprint("Please run '" + progname + " -h' for detailed options")
RROR(
"Invalid number of parameters used. Please see usage information above."
)
return
else:
if sp_global_def.CACHE_DISABLE:
from sp_utilities import disable_bdb_cache
disable_bdb_cache()
sp_global_def.BATCH = True
write_montage_file(args[0], args[1], options.N, options.gx, options.gy,
options.bg, options.scale, options.number,
options.begin_zero)
sp_global_def.BATCH = False
def main():
progname = os.path.basename(sys.argv[0])
usage = progname + " stack dendoname <maskfile> --link=kind_of_link --dist=kind_of_dist --dissimilar"
parser = OptionParser(usage, version=SPARXVERSION)
parser.add_option(
"--link",
type='string',
default="single",
help="Kind of linkage: single, complete, average (default single)")
parser.add_option("--dist",
type='string',
default="sim_SqEuc",
help="Kind of distance: SqEuc, CCC (default SqEuc)")
parser.add_option(
"--dissimilar",
action='store_true',
default=False,
help="Change the distance to the negative value (default False)")
chk_link = ['single', 'complete', 'average']
chk_dist = ['SqEuc', 'CCC']
(options, args) = parser.parse_args()
if len(args) < 2 or len(args) > 3:
sxprint("Usage: " + usage)
sxprint("Please run '" + progname + " -h' for detailed options")
ERROR(
"Invalid number of parameters. Please see usage information above."
)
return
elif options.link not in chk_link:
ERROR("Kind of linkage unknown")
return
elif options.dist not in chk_dist:
ERROR("Kind of distance unknown")
return
else:
if len(args) == 2: maskname = None
else: maskname = args[2]
if sp_global_def.CACHE_DISABLE:
from sp_utilities import disable_bdb_cache
disable_bdb_cache()
from sp_applications import HAC_clustering
sp_global_def.BATCH = True
HAC_clustering(args[0], args[1], maskname, options.link, options.dist,
options.dissimilar)
sp_global_def.BATCH = False
def main():
progname = os.path.basename(sys.argv[0])
# # horatio active_refactoring Jy51i1EwmLD4tWZ9_00003_1
# usage = progname + " stack <name_output> --ali --active --set_size=param_name_with_size --set_members=param_name_with_id"
# # horatio active_refactoring Jy51i1EwmLD4tWZ9_00003_2
usage = progname + " stack <name_output> --ali --set_size=param_name_with_size --set_members=param_name_with_id"
parser = OptionParser(usage,version=SPARXVERSION)
parser.add_option("--ali" , action = "store_true", default=False, help="Perform average using alignment parameters")
# # horatio active_refactoring Jy51i1EwmLD4tWZ9_00004_1
# parser.add_option("--active" , action = "store_true", default=False, help="Perform average only for active images")
parser.add_option("--set_size" , type = "string" , default=None , help="Save number of input images to parameter with given name")
parser.add_option("--set_members", type = "string" , default=None , help="Save list of id of input images to parameter named \"members\", id of input images are taken from parameter with given name")
parser.add_option("--filament" , action = "store_true", default=False, help="Calculate stack of averages according to filament membership")
(options, args) = parser.parse_args()
if len(args) < 1 or len(args) > 2:
sxprint( "Usage: " + usage )
sxprint( "Please run \'" + progname + " -h\' for detailed options" )
sp_global_def.ERROR( "Invalid number of parameters used. Please see usage information above." )
return
else:
if len(args) == 1:
name_output = None
else:
name_output = args[1]
if options.filament:
from sp_development import ave_ali_filament
if sp_global_def.CACHE_DISABLE:
from sp_utilities import disable_bdb_cache
disable_bdb_cache()
sp_global_def.BATCH = True
ave_ali_filament(args[0], name_output, options.ali)
sp_global_def.BATCH = False
else:
from sp_applications import ave_ali
if sp_global_def.CACHE_DISABLE:
from sp_utilities import disable_bdb_cache
disable_bdb_cache()
sp_global_def.BATCH = True
ave_ali(args[0], name_output, options.ali, options.set_size, options.set_members)
sp_global_def.BATCH = False
def main():
arglist = []
for arg in sys.argv:
arglist.append( arg )
progname = os.path.basename( arglist[0] )
usage = progname + " stack --params='parm1 parm2 parm3 ...' --zero --one --set=number --randomize --rand_alpha --import=file --export=file --print --backup --suffix --restore --delete"
parser = OptionParser(usage, version=SPARXVERSION)
parser.add_option("--params", type="string", default=None, help="parameter list")
parser.add_option("--zero", action="store_true", default=False, help="set parameter to zero")
parser.add_option("--one", action="store_true", default=False, help="set parameter to one")
parser.add_option("--set", type="float", default=0.0, help="set parameter to a value (different from 0.0)")
parser.add_option("--randomize", action="store_true", default=False, help="set parameter to randomized value")
parser.add_option("--rand_alpha", action="store_true", default=False, help="set all angles to randomized value")
parser.add_option("--import", type="string", dest="fimport", default=None, help="import parameters from file")
parser.add_option("--export", type="string", dest="fexport", default=None, help="export parameters to file")
parser.add_option("--print", action="store_true", dest="fprint", default=False, help="print parameters")
parser.add_option("--backup", action="store_true", default=False, help="backup parameters")
parser.add_option("--suffix", type="string", default="_backup", help="suffix for xform name in backup")
parser.add_option("--restore", action="store_true", default=False, help="restore parameters")
parser.add_option("--delete", action="store_true", default=False, help="delete parameters")
parser.add_option("--consecutive", action="store_true", default=False, help="set selected parameter to consecutive integers starting from 0")
parser.add_option("--list", type="string", default=None, help="Indices list containing the same amount of rows as the import file")
(options,args) = parser.parse_args( arglist[1:] )
if not options.fprint:
sp_global_def.print_timestamp( "Start" )
sp_global_def.write_command()
if len(args) != 1 :
sxprint( "Usage: " + usage )
ERROR( "Invalid number of parameters provided. Please see usage information above." )
return
if options.params == None:
sxprint( "Usage: " + usage )
ERROR( "No parameters provided. Please see usage information above." )
return
if sp_global_def.CACHE_DISABLE:
from sp_utilities import disable_bdb_cache
disable_bdb_cache()
from sp_applications import header
header(args[0], options.params, options.zero, options.one, options.set, options.randomize, options.rand_alpha, options.fimport, options.fexport, \
options.fprint, options.backup, options.suffix, options.restore, options.delete, options.consecutive, options.list)
if not options.fprint:
sp_global_def.print_timestamp( "Finish" )
def main():
import sys
arglist = []
for arg in sys.argv:
arglist.append( arg )
progname = os.path.basename(arglist[0])
usage = progname + " prjstack outdir bufprefix --delta --d --nvol --nbufvol --seedbase --snr --npad --CTF --MPI --verbose"
parser = OptionParser(usage,version=SPARXVERSION)
parser.add_option("--nvol", type="int", help="number of resample volumes to be generated")
parser.add_option("--nbufvol", type="int", default=1, help="number of fftvols in the memory")
parser.add_option("--delta", type="float", default=10.0, help="angular step for cones")
parser.add_option("--d", type="float", default=0.1, help="fraction of projections to leave out")
parser.add_option("--CTF", action="store_true", default=False, help="use CTF")
parser.add_option("--snr", type="float", default=1.0, help="Signal-to-Noise Ratio")
parser.add_option("--npad", type="int", default=2, help="times of padding")
parser.add_option("--seedbase", type="int", default=-1, help="random seed base")
parser.add_option("--MPI", action="store_true", default=False, help="use MPI")
parser.add_option("--verbose", type="int", default=0, help="verbose level: 0 no, 1 yes")
(options, args) = parser.parse_args( arglist[1:] )
if( len(args) !=1 and len(args) != 3):
sxprint("Usage: " + usage)
ERROR( "Invalid number of parameters used. Please see usage information above." )
return
prjfile = args[0]
if options.MPI:
myid = mpi.mpi_comm_rank( mpi.MPI_COMM_WORLD )
ncpu = mpi.mpi_comm_size( mpi.MPI_COMM_WORLD )
else:
myid = 0
ncpu = 1
if sp_global_def.CACHE_DISABLE:
from sp_utilities import disable_bdb_cache
disable_bdb_cache()
outdir = args[1]
bufprefix = args[2]
resample( prjfile, outdir, bufprefix, options.nbufvol, options.nvol, options.seedbase,\
options.delta, options.d, options.snr, options.CTF, options.npad,\
options.MPI, myid, ncpu, options.verbose )
def main():
progname = os.path.basename(sys.argv[0])
usage = progname + " stack "
parser = OptionParser(usage, version=sp_global_def.SPARXVERSION)
(options, args) = parser.parse_args(sys.argv[1:])
if len(args) != 1:
sxprint("Usage: " + usage)
sxprint("Please run \'" + progname + " -h\' for detailed options")
ERROR(
"Invalid number of parameters used. Please see usage information above."
)
return
else:
if sp_global_def.CACHE_DISABLE:
from sp_utilities import disable_bdb_cache
disable_bdb_cache()
from sp_applications import wrapper_params_3D_to_2D
sp_global_def.BATCH = True
wrapper_params_3D_to_2D(args[0])
sp_global_def.BATCH = False
def main():
arglist = []
for arg in sys.argv:
arglist.append(arg)
progname = os.path.basename(arglist[0])
usage = progname + " prjstack bufprefix --npad --CTF --verbose"
parser = OptionParser(usage, version=SPARXVERSION)
parser.add_option("--CTF",
action="store_true",
default=False,
help="use CTF")
parser.add_option("--npad", type="int", default=2, help="times of padding")
parser.add_option("--verbose",
type="int",
default=0,
help="verbose level: 0 no, 1 yes")
(options, args) = parser.parse_args(arglist[1:])
if (len(args) != 2):
sxprint("Usage: " + usage)
sxprint("Please run \'" + progname + " -h\' for detailed options")
ERROR(
"Invalid number of parameters used. Please see usage information above."
)
return
prjfile = args[0]
if sp_global_def.CACHE_DISABLE:
from sp_utilities import disable_bdb_cache
disable_bdb_cache()
bufprefix = args[1]
nprj = EMUtil.get_image_count(prjfile)
genbuf(prjfile, bufprefix, 0, nprj, options.CTF, options.npad,
options.verbose)
def main():
progname = os.path.basename(sys.argv[0])
usage = progname + " stack_in stack_out"
parser = OptionParser(usage, version=SPARXVERSION)
parser.add_option(
"--shift",
action="store_true",
default=False,
help=
"Apply only translation, disregard rotation, useful for centering of data (default False)"
)
parser.add_option(
"--ignore_mirror",
action="store_true",
default=False,
help=
"If centering data with CTF and astigmatism, use option ignore mirror (default False)"
)
parser.add_option("--method",
type="string",
default="quadratic",
help="Interpolation method (default quadratic)")
(options, args) = parser.parse_args()
if len(args) != 2:
sxprint("Usage: " + usage)
sxprint("Please run \'" + progname + " -h\' for detailed options")
ERROR(
"Invalid number of parameters used. Please see usage information above."
)
return
else:
if sp_global_def.CACHE_DISABLE:
from sp_utilities import disable_bdb_cache
disable_bdb_cache()
sp_global_def.BATCH = True
transform2d(args[0], args[1], options.shift, options.ignore_mirror,
options.method)
sp_global_def.BATCH = False
def main():
progname = os.path.basename(sys.argv[0])
usage = progname + " configure_file.cfg"
parser = OptionParser(usage, version=SPARXVERSION)
(options, args) = parser.parse_args()
if len(args) != 1:
sxprint("Usage: " + usage)
sxprint("Please run \'" + progname + " -h\' for detailed options")
sp_global_def.ERROR(
"Invalid number of parameters used. Please see usage information above."
)
return
if sp_global_def.CACHE_DISABLE:
from sp_utilities import disable_bdb_cache
disable_bdb_cache()
from sp_development import ali2d_mref
sp_global_def.BATCH = True
ali2d_mref(args[0])
sp_global_def.BATCH = False
def main():
progname = os.path.basename(sys.argv[0])
usage = progname + " out_averages outdir --ou=outer_radius --xr=x_range --ts=translation_step --maxit=max_iteration --CTF --snr=SNR --function=user_function_name --Fourvar --th_err=threshold_cutoff --ali=kind_of_alignment --center=center_type"
parser = OptionParser(usage,version=SPARXVERSION)
parser.add_option("--ou", type="int", default=-1, help="outer radius for rotational correlation < nx/2-1 (set to the radius of the particle)")
parser.add_option("--xr", type="string", default="4 2", help="range for translation search in x direction, search is +/xr ")
parser.add_option("--ts", type="string", default="2 1", help="step of translation search in both directions")
parser.add_option("--maxit", type="float", default=0, help="maximum number of iterations (0 means the maximum iterations is 10, but it will automatically stop should the criterion falls")
parser.add_option("--CTF", action="store_true", default=False, help="Consider CTF correction during the alignment ")
parser.add_option("--snr", type="float", default=1.0, help="signal-to-noise ratio of the data (set to 1.0)")
parser.add_option("--Fourvar", action="store_true", default=False, help="compute Fourier variance")
parser.add_option("--function", type="string", default="ref_ali2d", help="name of the reference preparation function")
parser.add_option('--Ng', type='int', default=-1, help='Ng')
parser.add_option('--K', type='int', default=-1, help='K')
parser.add_option("--dst", type="float", default=0.0, help="")
parser.add_option("--center", type="float", default=-1, help="-1.average center method; 0.not centered; 1.phase approximation; 2.cc with Gaussian function; 3.cc with donut-shaped image 4.cc with user-defined reference 5.cc with self-rotated average")
parser.add_option("--CUDA", action="store_true", default=False, help=" whether to use CUDA ")
parser.add_option("--GPUID", type="string", default="", help=" ID of GPUs to use")
parser.add_option('--MPI', action='store_true', default=False, help='MPI')
(options, args) = parser.parse_args()
if len(args) != 3:
sxprint( "Usage: " + usage )
sxprint( "Please run '" + progname + " -h' for detailed options" )
ERROR( "Invalid number of parameters used. Please see usage information above." )
return
else:
if sp_global_def.CACHE_DISABLE:
from sp_utilities import disable_bdb_cache
disable_bdb_cache()
sp_global_def.BATCH = True
from sp_development import mref_alignment
mref_alignment(args[0], args[1], args[2], options.ou, options.xr, options.ts, options.maxit, options.function, options.snr, options.CTF,
options.Fourvar, options.Ng, options.K, options.dst, options.center, options.CUDA, options.GPUID, options.MPI)
sp_global_def.BATCH = False
def main():
arglist = []
for arg in sys.argv:
arglist.append(arg)
progname = optparse.os.path.basename(arglist[0])
usage = progname + """ inputvolume locresvolume maskfile outputfile --radius --falloff --MPI
Locally filer a volume based on local resolution volume (sxlocres.py) within area outlined by the maskfile
"""
parser = optparse.OptionParser(usage, version=sp_global_def.SPARXVERSION)
parser.add_option(
"--radius",
type="int",
default=-1,
help=
"if there is no maskfile, sphere with r=radius will be used, by default the radius is nx/2-1"
)
parser.add_option("--falloff",
type="float",
default=0.1,
help="falloff of tanl filter (default 0.1)")
parser.add_option("--MPI",
action="store_true",
default=False,
help="use MPI version")
(options, args) = parser.parse_args(arglist[1:])
if len(args) < 3 or len(args) > 4:
sp_global_def.sxprint("See usage " + usage)
sp_global_def.ERROR(
"Wrong number of parameters. Please see usage information above.")
return
if sp_global_def.CACHE_DISABLE:
pass #IMPORTIMPORTIMPORT from sp_utilities import disable_bdb_cache
sp_utilities.disable_bdb_cache()
if options.MPI:
number_of_proc = mpi.mpi_comm_size(mpi.MPI_COMM_WORLD)
myid = mpi.mpi_comm_rank(mpi.MPI_COMM_WORLD)
main_node = 0
if (myid == main_node):
#print sys.argv
vi = sp_utilities.get_im(sys.argv[1])
ui = sp_utilities.get_im(sys.argv[2])
#print Util.infomask(ui, None, True)
radius = options.radius
nx = vi.get_xsize()
ny = vi.get_ysize()
nz = vi.get_zsize()
dis = [nx, ny, nz]
else:
falloff = 0.0
radius = 0
dis = [0, 0, 0]
vi = None
ui = None
dis = sp_utilities.bcast_list_to_all(dis, myid, source_node=main_node)
if (myid != main_node):
nx = int(dis[0])
ny = int(dis[1])
nz = int(dis[2])
radius = sp_utilities.bcast_number_to_all(radius, main_node)
if len(args) == 3:
if (radius == -1):
radius = min(nx, ny, nz) // 2 - 1
m = sp_utilities.model_circle(radius, nx, ny, nz)
outvol = args[2]
elif len(args) == 4:
if (myid == main_node):
m = sp_morphology.binarize(sp_utilities.get_im(args[2]), 0.5)
else:
m = sp_utilities.model_blank(nx, ny, nz)
outvol = args[3]
sp_utilities.bcast_EMData_to_all(m, myid, main_node)
pass #IMPORTIMPORTIMPORT from sp_filter import filterlocal
filteredvol = sp_filter.filterlocal(ui, vi, m, options.falloff, myid,
main_node, number_of_proc)
if (myid == 0):
filteredvol.write_image(outvol)
else:
vi = sp_utilities.get_im(args[0])
ui = sp_utilities.get_im(
args[1]
) # resolution volume, values are assumed to be from 0 to 0.5
nn = vi.get_xsize()
falloff = options.falloff
if len(args) == 3:
radius = options.radius
if (radius == -1):
radius = nn // 2 - 1
m = sp_utilities.model_circle(radius, nn, nn, nn)
outvol = args[2]
elif len(args) == 4:
m = sp_morphology.binarize(sp_utilities.get_im(args[2]), 0.5)
outvol = args[3]
sp_fundamentals.fftip(vi) # this is the volume to be filtered
# Round all resolution numbers to two digits
for x in range(nn):
for y in range(nn):
for z in range(nn):
ui.set_value_at_fast(x, y, z,
round(ui.get_value_at(x, y, z), 2))
st = EMAN2_cppwrap.Util.infomask(ui, m, True)
filteredvol = sp_utilities.model_blank(nn, nn, nn)
cutoff = max(st[2] - 0.01, 0.0)
while (cutoff < st[3]):
cutoff = round(cutoff + 0.01, 2)
pt = EMAN2_cppwrap.Util.infomask(
sp_morphology.threshold_outside(ui, cutoff - 0.00501,
cutoff + 0.005), m, True)
if (pt[0] != 0.0):
vovo = sp_fundamentals.fft(
sp_filter.filt_tanl(vi, cutoff, falloff))
for x in range(nn):
for y in range(nn):
for z in range(nn):
if (m.get_value_at(x, y, z) > 0.5):
if (round(ui.get_value_at(x, y, z),
2) == cutoff):
filteredvol.set_value_at_fast(
x, y, z, vovo.get_value_at(x, y, z))
sp_global_def.write_command(optparse.os.path.dirname(outvol))
filteredvol.write_image(outvol)
def main():
progname = os.path.basename(sys.argv[0])
usage = progname + " stack <maskfile> --search_rng=10 --maxit=max_iteration --CTF --snr=SNR --Fourvar=Fourier_variance --oneDx --MPI"
parser = OptionParser(usage, version=SPARXVERSION)
parser.add_option("--search_rng",
type="int",
default=-1,
help="Search range for x-shift")
parser.add_option("--search_ang",
type="int",
default=-1,
help="Search range for inplane rotation angle")
parser.add_option(
"--search_rng_y",
type="int",
default=-1,
help=
"Search range for x-shift. Not used for 1D search (oneDx flag set).")
parser.add_option("--maxit",
type="int",
default=100,
help="Maximum number of iterations program will perform")
parser.add_option("--CTF",
action="store_true",
default=False,
help="Use CTF correction")
parser.add_option(
"--snr",
type="float",
default=1.0,
help="signal-to-noise ratio of the data (default is 1.0)")
parser.add_option("--Fourvar",
action="store_true",
default=False,
help="compute Fourier variance")
parser.add_option("--oneDx",
action="store_true",
default=False,
help="1D search along x-axis")
parser.add_option("--MPI",
action="store_true",
default=False,
help="use MPI")
parser.add_option("--curvature",
action="store_true",
default=False,
help="for curved filament alignment")
(options, args) = parser.parse_args()
if not (options.MPI):
sxprint("Only MPI version is currently implemented.")
sxprint("Please run '" + progname + " -h' for detailed options")
return
if len(args) < 1 or len(args) > 2:
sxprint("usage: " + usage)
sxprint("Please run '" + progname + " -h' for detailed options")
else:
if len(args) == 1: mask = None
else: mask = args[1]
if sp_global_def.CACHE_DISABLE:
from sp_utilities import disable_bdb_cache
disable_bdb_cache()
sp_global_def.BATCH = True
if options.oneDx:
helicalshiftali_MPI(args[0], mask, options.maxit, options.CTF,
options.snr, options.Fourvar,
options.search_rng)
else:
shiftali_MPI(args[0], mask, options.maxit, options.CTF,
options.snr, options.Fourvar, options.search_rng,
options.oneDx, options.search_rng_y)
sp_global_def.BATCH = False
return
def main():
progname = os.path.basename(sys.argv[0])
usage = progname + " averages1 averages2 --th_grp"
parser = OptionParser(usage, version=SPARXVERSION)
parser.add_option("--T",
type="int",
default=0,
help=" Threshold for matching")
parser.add_option("--J", type="int", default=50, help=" J")
parser.add_option("--max_branching",
type="int",
default=40,
help=" maximum branching")
parser.add_option("--verbose",
action="store_true",
default=False,
help=" Threshold for matching")
parser.add_option("--timing",
action="store_true",
default=False,
help=" Get the timing")
(options, args) = parser.parse_args()
if sp_global_def.CACHE_DISABLE:
from sp_utilities import disable_bdb_cache
disable_bdb_cache()
sp_global_def.BATCH = True
from numpy import array
from sp_statistics import k_means_stab_bbenum
R = len(args)
Parts = []
mem = [0] * R
avg = [0] * R
for r in range(R):
data = EMData.read_images(args[r])
avg[r] = len(data)
part = []
for k in range(len(data)):
lid = data[k].get_attr('members')
mem[r] += len(lid)
lid = array(lid, 'int32')
lid.sort()
part.append(lid.copy())
Parts.append(part)
if options.timing:
from time import time
time1 = time()
MATCH, STB_PART, CT_s, CT_t, ST, st = k_means_stab_bbenum(
Parts,
T=options.T,
J=options.J,
max_branching=options.max_branching,
stmult=0.1,
branchfunc=2)
if options.verbose:
sxprint(MATCH)
sxprint(STB_PART)
sxprint(CT_s)
sxprint(CT_t)
sxprint(ST)
sxprint(st)
sxprint(" ")
for i in range(len(MATCH)):
u = MATCH[i][0] # u is the group in question in partition 1
assert len(STB_PART[u]) == CT_s[u]
sxprint("Group ", end=' ')
for r in range(R):
sxprint("%3d " % (MATCH[i][r]), end=' ')
sxprint(" matches: group size = ", end=' ')
for r in range(R):
sxprint(" %3d" % len(Parts[r][MATCH[i][r]]), end=' ')
sxprint(" matched size = %3d" % (CT_s[u]), end=' ')
if options.verbose:
sxprint(" matched group = %s" % (STB_PART[u]))
else:
sxprint("")
sxprint("\nNumber of averages = ", end=' ')
for r in range(R):
sxprint("%3d" % (avg[r]), end=' ')
sxprint("\nTotal number of particles = ", end=' ')
for r in range(R):
sxprint("%3d" % (mem[r]), end=' ')
sxprint(" number of matched particles = %5d" % (sum(CT_s)))
if options.timing:
sxprint("Elapsed time = ", time() - time1)
sp_global_def.BATCH = False
def main():
arglist = []
for arg in sys.argv:
arglist.append(arg)
progname = os.path.basename(arglist[0])
usage = progname + " stack ref_vol outdir --dp=rise --dphi=rotation --apix=pixel_size --phistep=phi_step --zstep=z_step --fract=helicising_fraction --rmax=maximum_radius --rmin=min_radius --CTF --sym=c1 --function=user_function --maxit=max_iter --MPI"
parser = OptionParser(usage, version=SPARXVERSION)
parser.add_option("--dp",
type="float",
default=1.0,
help="delta z - translation in Angstroms")
parser.add_option("--dphi",
type="float",
default=1.0,
help="delta phi - rotation in degrees")
parser.add_option("--apix",
type="float",
default=1.84,
help="pixel size in Angstroms")
parser.add_option("--rmin",
type="int",
default=0,
help="minimal radial extent of structure")
parser.add_option("--rmax",
type="int",
default=70,
help="maximal radial extent of structure")
parser.add_option("--fract",
type="float",
default=0.66,
help="fraction of the volume used for helical search")
parser.add_option("--sym",
type="string",
default="c1",
help="symmetry of the structure")
parser.add_option("--function",
type="string",
default="helical",
help="name of the reference preparation function")
parser.add_option("--zstep",
type="int",
default=1,
help="Step size for translational search along z")
parser.add_option("--CTF",
action="store_true",
default=False,
help="CTF correction")
parser.add_option("--maxit",
type="int",
default=5,
help="maximum number of iterations performed")
parser.add_option("--MPI",
action="store_true",
default=False,
help="use MPI version")
(options, args) = parser.parse_args(arglist[1:])
if len(args) != 3:
sxprint("Usage: " + usage)
sxprint("Please run \'" + progname + " -h\' for detailed options")
ERROR(
"Invalid number of parameters used. Please see usage information above."
)
return
else:
if not options.MPI:
ERROR(
"There is only MPI version of sxfilrecons3d.py. See SPARX wiki page for downloading MyMPI details."
)
return
if sp_global_def.CACHE_DISABLE:
from sp_utilities import disable_bdb_cache
disable_bdb_cache()
from sp_development import filrecons3D_MPI
sp_global_def.BATCH = True
filrecons3D_MPI(args[0], args[1], args[2], options.dp, options.dphi,
options.apix, options.function, options.zstep,
options.fract, options.rmax, options.rmin, options.CTF,
options.maxit, options.sym)
sp_global_def.BATCH = False
def main():
progname = os.path.basename(sys.argv[0])
usage = progname + " proj_stack output_averages --MPI"
parser = OptionParser(usage, version=SPARXVERSION)
parser.add_option("--img_per_group",
type="int",
default=100,
help="number of images per group")
parser.add_option("--radius",
type="int",
default=-1,
help="radius for alignment")
parser.add_option(
"--xr",
type="string",
default="2 1",
help="range for translation search in x direction, search is +/xr")
parser.add_option(
"--yr",
type="string",
default="-1",
help=
"range for translation search in y direction, search is +/yr (default = same as xr)"
)
parser.add_option(
"--ts",
type="string",
default="1 0.5",
help=
"step size of the translation search in both directions, search is -xr, -xr+ts, 0, xr-ts, xr, can be fractional"
)
parser.add_option(
"--iter",
type="int",
default=30,
help="number of iterations within alignment (default = 30)")
parser.add_option(
"--num_ali",
type="int",
default=5,
help="number of alignments performed for stability (default = 5)")
parser.add_option("--thld_err",
type="float",
default=1.0,
help="threshold of pixel error (default = 1.732)")
parser.add_option(
"--grouping",
type="string",
default="GRP",
help=
"do grouping of projections: PPR - per projection, GRP - different size groups, exclusive (default), GEV - grouping equal size"
)
parser.add_option(
"--delta",
type="float",
default=-1.0,
help="angular step for reference projections (required for GEV method)"
)
parser.add_option(
"--fl",
type="float",
default=0.3,
help="cut-off frequency of hyperbolic tangent low-pass Fourier filter")
parser.add_option(
"--aa",
type="float",
default=0.2,
help="fall-off of hyperbolic tangent low-pass Fourier filter")
parser.add_option("--CTF",
action="store_true",
default=False,
help="Consider CTF correction during the alignment ")
parser.add_option("--MPI",
action="store_true",
default=False,
help="use MPI version")
(options, args) = parser.parse_args()
myid = mpi.mpi_comm_rank(MPI_COMM_WORLD)
number_of_proc = mpi.mpi_comm_size(MPI_COMM_WORLD)
main_node = 0
if len(args) == 2:
stack = args[0]
outdir = args[1]
else:
sp_global_def.ERROR("Incomplete list of arguments",
"sxproj_stability.main",
1,
myid=myid)
return
if not options.MPI:
sp_global_def.ERROR("Non-MPI not supported!",
"sxproj_stability.main",
1,
myid=myid)
return
if sp_global_def.CACHE_DISABLE:
from sp_utilities import disable_bdb_cache
disable_bdb_cache()
sp_global_def.BATCH = True
img_per_grp = options.img_per_group
radius = options.radius
ite = options.iter
num_ali = options.num_ali
thld_err = options.thld_err
xrng = get_input_from_string(options.xr)
if options.yr == "-1":
yrng = xrng
else:
yrng = get_input_from_string(options.yr)
step = get_input_from_string(options.ts)
if myid == main_node:
nima = EMUtil.get_image_count(stack)
img = get_image(stack)
nx = img.get_xsize()
ny = img.get_ysize()
else:
nima = 0
nx = 0
ny = 0
nima = bcast_number_to_all(nima)
nx = bcast_number_to_all(nx)
ny = bcast_number_to_all(ny)
if radius == -1: radius = nx / 2 - 2
mask = model_circle(radius, nx, nx)
st = time()
if options.grouping == "GRP":
if myid == main_node:
sxprint(" A ", myid, " ", time() - st)
proj_attr = EMUtil.get_all_attributes(stack, "xform.projection")
proj_params = []
for i in range(nima):
dp = proj_attr[i].get_params("spider")
phi, theta, psi, s2x, s2y = dp["phi"], dp["theta"], dp[
"psi"], -dp["tx"], -dp["ty"]
proj_params.append([phi, theta, psi, s2x, s2y])
# Here is where the grouping is done, I didn't put enough annotation in the group_proj_by_phitheta,
# So I will briefly explain it here
# proj_list : Returns a list of list of particle numbers, each list contains img_per_grp particle numbers
# except for the last one. Depending on the number of particles left, they will either form a
# group or append themselves to the last group
# angle_list : Also returns a list of list, each list contains three numbers (phi, theta, delta), (phi,
# theta) is the projection angle of the center of the group, delta is the range of this group
# mirror_list: Also returns a list of list, each list contains img_per_grp True or False, which indicates
# whether it should take mirror position.
# In this program angle_list and mirror list are not of interest.
proj_list_all, angle_list, mirror_list = group_proj_by_phitheta(
proj_params, img_per_grp=img_per_grp)
del proj_params
sxprint(" B number of groups ", myid, " ", len(proj_list_all),
time() - st)
mpi_barrier(MPI_COMM_WORLD)
# Number of groups, actually there could be one or two more groups, since the size of the remaining group varies
# we will simply assign them to main node.
n_grp = nima / img_per_grp - 1
# Divide proj_list_all equally to all nodes, and becomes proj_list
proj_list = []
for i in range(n_grp):
proc_to_stay = i % number_of_proc
if proc_to_stay == main_node:
if myid == main_node: proj_list.append(proj_list_all[i])
elif myid == main_node:
mpi_send(len(proj_list_all[i]), 1, MPI_INT, proc_to_stay,
SPARX_MPI_TAG_UNIVERSAL, MPI_COMM_WORLD)
mpi_send(proj_list_all[i], len(proj_list_all[i]), MPI_INT,
proc_to_stay, SPARX_MPI_TAG_UNIVERSAL, MPI_COMM_WORLD)
elif myid == proc_to_stay:
img_per_grp = mpi_recv(1, MPI_INT, main_node,
SPARX_MPI_TAG_UNIVERSAL, MPI_COMM_WORLD)
img_per_grp = int(img_per_grp[0])
temp = mpi_recv(img_per_grp, MPI_INT, main_node,
SPARX_MPI_TAG_UNIVERSAL, MPI_COMM_WORLD)
proj_list.append(list(map(int, temp)))
del temp
mpi_barrier(MPI_COMM_WORLD)
sxprint(" C ", myid, " ", time() - st)
if myid == main_node:
# Assign the remaining groups to main_node
for i in range(n_grp, len(proj_list_all)):
proj_list.append(proj_list_all[i])
del proj_list_all, angle_list, mirror_list
# Compute stability per projection projection direction, equal number assigned, thus overlaps
elif options.grouping == "GEV":
if options.delta == -1.0:
ERROR(
"Angular step for reference projections is required for GEV method"
)
return
from sp_utilities import even_angles, nearestk_to_refdir, getvec
refproj = even_angles(options.delta)
img_begin, img_end = MPI_start_end(len(refproj), number_of_proc, myid)
# Now each processor keeps its own share of reference projections
refprojdir = refproj[img_begin:img_end]
del refproj
ref_ang = [0.0] * (len(refprojdir) * 2)
for i in range(len(refprojdir)):
ref_ang[i * 2] = refprojdir[0][0]
ref_ang[i * 2 + 1] = refprojdir[0][1] + i * 0.1
sxprint(" A ", myid, " ", time() - st)
proj_attr = EMUtil.get_all_attributes(stack, "xform.projection")
# the solution below is very slow, do not use it unless there is a problem with the i/O
"""
for i in xrange(number_of_proc):
if myid == i:
proj_attr = EMUtil.get_all_attributes(stack, "xform.projection")
mpi_barrier(MPI_COMM_WORLD)
"""
sxprint(" B ", myid, " ", time() - st)
proj_ang = [0.0] * (nima * 2)
for i in range(nima):
dp = proj_attr[i].get_params("spider")
proj_ang[i * 2] = dp["phi"]
proj_ang[i * 2 + 1] = dp["theta"]
sxprint(" C ", myid, " ", time() - st)
asi = Util.nearestk_to_refdir(proj_ang, ref_ang, img_per_grp)
del proj_ang, ref_ang
proj_list = []
for i in range(len(refprojdir)):
proj_list.append(asi[i * img_per_grp:(i + 1) * img_per_grp])
del asi
sxprint(" D ", myid, " ", time() - st)
#from sys import exit
#exit()
# Compute stability per projection
elif options.grouping == "PPR":
sxprint(" A ", myid, " ", time() - st)
proj_attr = EMUtil.get_all_attributes(stack, "xform.projection")
sxprint(" B ", myid, " ", time() - st)
proj_params = []
for i in range(nima):
dp = proj_attr[i].get_params("spider")
phi, theta, psi, s2x, s2y = dp["phi"], dp["theta"], dp[
"psi"], -dp["tx"], -dp["ty"]
proj_params.append([phi, theta, psi, s2x, s2y])
img_begin, img_end = MPI_start_end(nima, number_of_proc, myid)
sxprint(" C ", myid, " ", time() - st)
from sp_utilities import nearest_proj
proj_list, mirror_list = nearest_proj(
proj_params, img_per_grp,
list(range(img_begin, img_begin + 1))) #range(img_begin, img_end))
refprojdir = proj_params[img_begin:img_end]
del proj_params, mirror_list
sxprint(" D ", myid, " ", time() - st)
else:
ERROR("Incorrect projection grouping option")
return
###########################################################################################################
# Begin stability test
from sp_utilities import get_params_proj, read_text_file
#if myid == 0:
# from utilities import read_text_file
# proj_list[0] = map(int, read_text_file("lggrpp0.txt"))
from sp_utilities import model_blank
aveList = [model_blank(nx, ny)] * len(proj_list)
if options.grouping == "GRP":
refprojdir = [[0.0, 0.0, -1.0]] * len(proj_list)
for i in range(len(proj_list)):
sxprint(" E ", myid, " ", time() - st)
class_data = EMData.read_images(stack, proj_list[i])
#print " R ",myid," ",time()-st
if options.CTF:
from sp_filter import filt_ctf
for im in range(len(class_data)): # MEM LEAK!!
atemp = class_data[im].copy()
btemp = filt_ctf(atemp, atemp.get_attr("ctf"), binary=1)
class_data[im] = btemp
#class_data[im] = filt_ctf(class_data[im], class_data[im].get_attr("ctf"), binary=1)
for im in class_data:
try:
t = im.get_attr(
"xform.align2d") # if they are there, no need to set them!
except:
try:
t = im.get_attr("xform.projection")
d = t.get_params("spider")
set_params2D(im, [0.0, -d["tx"], -d["ty"], 0, 1.0])
except:
set_params2D(im, [0.0, 0.0, 0.0, 0, 1.0])
#print " F ",myid," ",time()-st
# Here, we perform realignment num_ali times
all_ali_params = []
for j in range(num_ali):
if (xrng[0] == 0.0 and yrng[0] == 0.0):
avet = ali2d_ras(class_data,
randomize=True,
ir=1,
ou=radius,
rs=1,
step=1.0,
dst=90.0,
maxit=ite,
check_mirror=True,
FH=options.fl,
FF=options.aa)
else:
avet = within_group_refinement(class_data, mask, True, 1,
radius, 1, xrng, yrng, step,
90.0, ite, options.fl,
options.aa)
ali_params = []
for im in range(len(class_data)):
alpha, sx, sy, mirror, scale = get_params2D(class_data[im])
ali_params.extend([alpha, sx, sy, mirror])
all_ali_params.append(ali_params)
#aveList[i] = avet
#print " G ",myid," ",time()-st
del ali_params
# We determine the stability of this group here.
# stable_set contains all particles deemed stable, it is a list of list
# each list has two elements, the first is the pixel error, the second is the image number
# stable_set is sorted based on pixel error
#from utilities import write_text_file
#write_text_file(all_ali_params, "all_ali_params%03d.txt"%myid)
stable_set, mir_stab_rate, average_pix_err = multi_align_stability(
all_ali_params, 0.0, 10000.0, thld_err, False, 2 * radius + 1)
#print " H ",myid," ",time()-st
if (len(stable_set) > 5):
stable_set_id = []
members = []
pix_err = []
# First put the stable members into attr 'members' and 'pix_err'
for s in stable_set:
# s[1] - number in this subset
stable_set_id.append(s[1])
# the original image number
members.append(proj_list[i][s[1]])
pix_err.append(s[0])
# Then put the unstable members into attr 'members' and 'pix_err'
from sp_fundamentals import rot_shift2D
avet.to_zero()
if options.grouping == "GRP":
aphi = 0.0
atht = 0.0
vphi = 0.0
vtht = 0.0
l = -1
for j in range(len(proj_list[i])):
# Here it will only work if stable_set_id is sorted in the increasing number, see how l progresses
if j in stable_set_id:
l += 1
avet += rot_shift2D(class_data[j], stable_set[l][2][0],
stable_set[l][2][1],
stable_set[l][2][2],
stable_set[l][2][3])
if options.grouping == "GRP":
phi, theta, psi, sxs, sy_s = get_params_proj(
class_data[j])
if (theta > 90.0):
phi = (phi + 540.0) % 360.0
theta = 180.0 - theta
aphi += phi
atht += theta
vphi += phi * phi
vtht += theta * theta
else:
members.append(proj_list[i][j])
pix_err.append(99999.99)
aveList[i] = avet.copy()
if l > 1:
l += 1
aveList[i] /= l
if options.grouping == "GRP":
aphi /= l
atht /= l
vphi = (vphi - l * aphi * aphi) / l
vtht = (vtht - l * atht * atht) / l
from math import sqrt
refprojdir[i] = [
aphi, atht,
(sqrt(max(vphi, 0.0)) + sqrt(max(vtht, 0.0))) / 2.0
]
# Here more information has to be stored, PARTICULARLY WHAT IS THE REFERENCE DIRECTION
aveList[i].set_attr('members', members)
aveList[i].set_attr('refprojdir', refprojdir[i])
aveList[i].set_attr('pixerr', pix_err)
else:
sxprint(" empty group ", i, refprojdir[i])
aveList[i].set_attr('members', [-1])
aveList[i].set_attr('refprojdir', refprojdir[i])
aveList[i].set_attr('pixerr', [99999.])
del class_data
if myid == main_node:
km = 0
for i in range(number_of_proc):
if i == main_node:
for im in range(len(aveList)):
aveList[im].write_image(args[1], km)
km += 1
else:
nl = mpi_recv(1, MPI_INT, i, SPARX_MPI_TAG_UNIVERSAL,
MPI_COMM_WORLD)
nl = int(nl[0])
for im in range(nl):
ave = recv_EMData(i, im + i + 70000)
nm = mpi_recv(1, MPI_INT, i, SPARX_MPI_TAG_UNIVERSAL,
MPI_COMM_WORLD)
nm = int(nm[0])
members = mpi_recv(nm, MPI_INT, i, SPARX_MPI_TAG_UNIVERSAL,
MPI_COMM_WORLD)
ave.set_attr('members', list(map(int, members)))
members = mpi_recv(nm, MPI_FLOAT, i,
SPARX_MPI_TAG_UNIVERSAL, MPI_COMM_WORLD)
ave.set_attr('pixerr', list(map(float, members)))
members = mpi_recv(3, MPI_FLOAT, i,
SPARX_MPI_TAG_UNIVERSAL, MPI_COMM_WORLD)
ave.set_attr('refprojdir', list(map(float, members)))
ave.write_image(args[1], km)
km += 1
else:
mpi_send(len(aveList), 1, MPI_INT, main_node, SPARX_MPI_TAG_UNIVERSAL,
MPI_COMM_WORLD)
for im in range(len(aveList)):
send_EMData(aveList[im], main_node, im + myid + 70000)
members = aveList[im].get_attr('members')
mpi_send(len(members), 1, MPI_INT, main_node,
SPARX_MPI_TAG_UNIVERSAL, MPI_COMM_WORLD)
mpi_send(members, len(members), MPI_INT, main_node,
SPARX_MPI_TAG_UNIVERSAL, MPI_COMM_WORLD)
members = aveList[im].get_attr('pixerr')
mpi_send(members, len(members), MPI_FLOAT, main_node,
SPARX_MPI_TAG_UNIVERSAL, MPI_COMM_WORLD)
try:
members = aveList[im].get_attr('refprojdir')
mpi_send(members, 3, MPI_FLOAT, main_node,
SPARX_MPI_TAG_UNIVERSAL, MPI_COMM_WORLD)
except:
mpi_send([-999.0, -999.0, -999.0], 3, MPI_FLOAT, main_node,
SPARX_MPI_TAG_UNIVERSAL, MPI_COMM_WORLD)
sp_global_def.BATCH = False
mpi_barrier(MPI_COMM_WORLD)
def main():
progname = os.path.basename(sys.argv[0])
usage = """%prog [options] input.pdb output.hdf
Converts a pdb file into an electron density map. 0,0,0 in PDB space will
map to the center of the volume."""
parser = OptionParser(usage=usage, version=EMANVERSION)
parser.add_option("--apix",
"-A",
type="float",
help="Angstrom/voxel",
default=1.0)
parser.add_option("--box",
"-B",
type="string",
help="Box size in pixels, <xyz> or <x,y,z>")
parser.add_option("--het",
action="store_true",
help="Include HET atoms in the map",
default=False)
parser.add_option(
"--chains",
type="string",
help=
"String list of chain identifiers to include, e.g. 'ABEFG'; default: include all chains",
default='')
parser.add_option(
"--center",
type="string",
default="a",
help=
"center: c - coordinates; a (default) - center of gravity; <x,y,z> - vector (in Angstrom) to subtract from all coordinates; n - none"
)
parser.add_option("--O",
action="store_true",
default=False,
help="use O system of coordinates")
parser.add_option("--quiet",
action="store_true",
default=False,
help="Verbose is the default")
parser.add_option("--tr0",
type="string",
default="none",
help="Filename of initial 3x4 transformation matrix")
parser.add_option("--set_apix_value",
action="store_true",
help="Set apix value in header of the ouput map",
default=False)
(options, args) = parser.parse_args() #
if len(args) < 2:
ERROR("Input and output files required")
return
if sp_global_def.CACHE_DISABLE:
from sp_utilities import disable_bdb_cache
disable_bdb_cache()
chains = options.chains
if chains == '':
chains = None
try:
infile = open(args[0], "r")
except:
ERROR("Cannot open input file")
return
aavg = [0, 0, 0] # calculate atomic center
asig = [0, 0, 0] # to compute radius of gyration
natm = 0
atoms = [] # we store a list of atoms to process to avoid multiple passes
nelec = 0
mass = 0
# read in initial-transformation file:
if (options.tr0 != "none"):
cols = read_text_file(options.tr0, -1)
txlist = []
for i in range(3):
txlist.append(cols[0][i])
txlist.append(cols[1][i])
txlist.append(cols[2][i])
txlist.append(cols[3][i])
tr0 = Transform(txlist)
# parse the pdb file and pull out relevant atoms
for line in infile:
if (line[:4] == 'ATOM' or (line[:6] == 'HETATM' and options.het)):
if chains and (line[21] not in chains): continue
try:
a = line[12:14].strip()
aseq = int(line[6:11].strip())
res = int(line[22:26].strip())
if (options.O):
x = float(line[38:46])
y = float(line[30:38])
z = -float(line[46:54])
else:
x = float(line[30:38])
y = float(line[38:46])
z = float(line[46:54])
except:
sxprint(
"PDB Parse error:\n%s\n'%s','%s','%s' '%s','%s','%s'\n" %
(line, line[12:14], line[6:11], line[22:26], line[30:38],
line[38:46], line[46:54]))
sxprint(a, aseq, res, x, y, z)
try:
nelec += atomdefs[a.upper()][0]
mass += atomdefs[a.upper()][1]
except:
sxprint(("Unknown atom %s ignored at %d" % (a, aseq)))
atoms.append([a, x, y, z])
natm += 1
if (options.center == "a"):
aavg[0] += x * atomdefs[a.upper()][1]
aavg[1] += y * atomdefs[a.upper()][1]
aavg[2] += z * atomdefs[a.upper()][1]
asig[0] += x**2 * atomdefs[a.upper()][1]
asig[1] += y**2 * atomdefs[a.upper()][1]
asig[2] += z**2 * atomdefs[a.upper()][1]
else:
aavg[0] += x
aavg[1] += y
aavg[2] += z
asig[0] += x**2
asig[1] += y**2
asig[2] += z**2
infile.close()
if (options.center == "a"):
rad_gyr = sqrt((asig[0] + asig[1] + asig[2]) / mass -
(aavg[0] / mass)**2 - (aavg[1] / mass)**2 -
(aavg[2] / mass)**2)
else:
rad_gyr = sqrt((asig[0] + asig[1] + asig[2]) / natm -
(aavg[0] / natm)**2 - (aavg[1] / natm)**2 -
(aavg[2] / natm)**2)
if not options.quiet:
sxprint(
"%d atoms; total charge = %d e-; mol mass = %.2f kDa; radius of gyration = %.2f A"
% (natm, nelec, mass / 1000.0, rad_gyr))
# center PDB according to option:
if (options.center == "a"):
if not options.quiet:
sxprint(
"center of gravity at %1.1f,%1.1f,%1.1f (center of volume at 0,0,0)"
% (aavg[0] / mass, aavg[1] / mass, aavg[2] / mass))
for i in range(len(atoms)):
atoms[i][1] -= aavg[0] / mass
atoms[i][2] -= aavg[1] / mass
atoms[i][3] -= aavg[2] / mass
if (options.center == "c"):
if not options.quiet:
sxprint(
"atomic center at %1.1f,%1.1f,%1.1f (center of volume at 0,0,0)"
% (aavg[0] / natm, aavg[1] / natm, aavg[2] / natm))
for i in range(len(atoms)):
atoms[i][1] -= aavg[0] / natm
atoms[i][2] -= aavg[1] / natm
atoms[i][3] -= aavg[2] / natm
spl = options.center.split(',')
if len(spl) == 3: # substract the given vector from all coordinates
if not options.quiet:
sxprint(
"vector to substract: %1.1f,%1.1f,%1.1f (center of volume at 0,0,0)"
% (float(spl[0]), float(spl[1]), float(spl[2])))
for i in range(len(atoms)):
atoms[i][1] -= float(spl[0])
atoms[i][2] -= float(spl[1])
atoms[i][3] -= float(spl[2])
# apply given initial transformation (this used to be done before centering,
# thereby loosing the translation. This is the right place to apply tr0):
if (options.tr0 != "none"):
if not options.quiet:
sxprint("Applying initial transformation to PDB coordinates... ")
for i in range(len(atoms)):
atom_coords = Vec3f(atoms[i][1], atoms[i][2], atoms[i][3])
new_atom_coords = tr0 * atom_coords
atoms[i][1] = new_atom_coords[0]
atoms[i][2] = new_atom_coords[1]
atoms[i][3] = new_atom_coords[2]
if not options.quiet:
sxprint("done.\n")
# bounding box:
amin = [atoms[0][1], atoms[0][2], atoms[0][3]]
amax = [atoms[0][1], atoms[0][2], atoms[0][3]]
for i in range(1, len(atoms)):
for k in range(3):
amin[k] = min(atoms[i][k + 1], amin[k])
amax[k] = max(atoms[i][k + 1], amax[k])
if not options.quiet:
sxprint("Range of coordinates [A]: x: %7.2f - %7.2f" %
(amin[0], amax[0]))
sxprint(" y: %7.2f - %7.2f" %
(amin[1], amax[1]))
sxprint(" z: %7.2f - %7.2f" %
(amin[2], amax[2]))
# find the output box size, either user specified or from bounding box
box = [0, 0, 0]
try:
spl = options.box.split(',')
if len(spl) == 1: box[0] = box[1] = box[2] = int(spl[0])
else:
box[0] = int(spl[0])
box[1] = int(spl[1])
box[2] = int(spl[2])
except:
for i in range(3):
box[i] = int(2 * max(fabs(amax[i]), fabs(amin[i])) / options.apix)
# Increase the box size by 1/4.
box[i] += box[i] // 4
if not options.quiet:
sxprint("Bounding box [pixels]: x: %5d " % box[0])
sxprint(" y: %5d " % box[1])
sxprint(" z: %5d " % box[2])
# figure oversampled box size
#bigb = max(box[0],box[1],box[2])
fcbig = 1
"""Multiline Comment0"""
#MULTILINEMULTILINEMULTILINE 0
#MULTILINEMULTILINEMULTILINE 0
#MULTILINEMULTILINEMULTILINE 0
#MULTILINEMULTILINEMULTILINE 0
#MULTILINEMULTILINEMULTILINE 0
#MULTILINEMULTILINEMULTILINE 0
#MULTILINEMULTILINEMULTILINE 0
if not options.quiet:
sxprint("Box size: %d x %d x %d" % (box[0], box[1], box[2]),
", oversampling ", fcbig)
# Calculate working dimensions
pixelbig = options.apix / fcbig
bigbox = []
for i in range(3):
bigbox.append(box[i] * fcbig)
# initialize the final output volume
outmap = EMData(bigbox[0], bigbox[1], bigbox[2], True)
nc = []
for i in range(3):
nc.append(bigbox[i] // 2)
# fill in the atoms
for i in range(len(atoms)):
#print "Adding %d '%s'"%(i,atoms[i][0])
if not options.quiet and i % 1000 == 0:
sxprint('\r %d' % i, end=' ')
sys.stdout.flush()
try:
elec = atomdefs[atoms[i][0].upper()][0]
#outmap[int(atoms[i][1]/pixelbig+bigbox[0]//2),int(atoms[i][2]/pixelbig+bigbox[1]//2),int(atoms[i][3]/pixelbig+bigbox[2]//2)] += elec
for k in range(2):
pz = atoms[i][3] / pixelbig + nc[2]
dz = pz - int(pz)
uz = ((1 - k) + (2 * k - 1) * dz) * elec
for l in range(2):
py = atoms[i][2] / pixelbig + nc[1]
dy = py - int(py)
uy = ((1 - l) + (2 * l - 1) * dy) * uz
for m in range(2):
px = atoms[i][1] / pixelbig + nc[0]
dx = px - int(px)
outmap[int(px) + m,
int(py) + l,
int(pz) + k] += ((1 - m) +
(2 * m - 1) * dx) * uy
except:
sxprint("Skipping %d '%s'" % (i, atoms[i][0]))
if not options.quiet:
sxprint('\r %d\nConversion complete.' %
len(atoms)) #," Now shape atoms."
"""Multiline Comment1"""
#MULTILINEMULTILINEMULTILINE 1
#MULTILINEMULTILINEMULTILINE 1
#MULTILINEMULTILINEMULTILINE 1
#MULTILINEMULTILINEMULTILINE 1
#MULTILINEMULTILINEMULTILINE 1
#MULTILINEMULTILINEMULTILINE 1
#MULTILINEMULTILINEMULTILINE 1
#MULTILINEMULTILINEMULTILINE 1
#MULTILINEMULTILINEMULTILINE 1
(filename_path, filextension) = os.path.splitext(args[1])
if filextension == ".hdf":
if options.set_apix_value:
outmap.set_attr("apix_x", options.apix)
outmap.set_attr("apix_y", options.apix)
outmap.set_attr("apix_z", options.apix)
outmap.set_attr("pixel_size", options.apix)
else:
sxprint("Pixel_size is not set in the header!")
outmap.write_image(args[1], 0, EMUtil.ImageType.IMAGE_HDF)
elif filextension == ".spi":
outmap.write_image(args[1], 0, EMUtil.ImageType.IMAGE_SINGLE_SPIDER)
else:
ERROR("Unknown image type")
return
def main():
progname = os.path.basename(sys.argv[0])
usage = progname + " stack outdir <maskfile> --K=10 --trials=2 --debug --maxit=100 --rand_seed=10 --crit='all' --F=0.9 --T0=2.0 --init_method='rnd' --normalize --CTF --MPI --CUDA"
parser = OptionParser(usage, version=SPARXVERSION)
parser.add_option("--K",
type="int",
default=2,
help="Number of classes (default 2)")
parser.add_option("--trials",
type="int",
default=1,
help="Number of trials of K-means (default 1)")
parser.add_option("--maxit",
type="int",
default=100,
help="Maximum number of iterations within K-means")
parser.add_option("--CTF",
action="store_true",
default=False,
help="Perform classification using CTF information")
parser.add_option("--rand_seed",
type="int",
default=-1,
help="Random seed of initial (default random)")
parser.add_option(
"--crit",
type="string",
default="D",
help=
"Criterions: Coleman [C], Harabasz[H], Davies-Bouldin[D], All [all]")
#parser.add_option("--F", type="float", default=0.0, help="Cooling in simulated annealing, ex.: 0.9")
#parser.add_option("--T0", type="float", default=0.0, help="Initial temperature in simulated annealing, ex: 100")
parser.add_option("--MPI",
action="store_true",
default=False,
help="Use MPI version")
parser.add_option("--debug", action="store_true", default=False, help="")
parser.add_option("--normalize",
action="store_true",
default=False,
help="Normalize images under the mask")
parser.add_option(
'--init_method',
type='string',
default='rnd',
help=
'Method used to initialize partition: "rnd" randomize or "d2w" for d2 weighting initialization (default is rnd)'
)
(options, args) = parser.parse_args()
if len(args) < 2 or len(args) > 3:
sxprint("usage: " + usage)
sxprint("Please run '" + progname + " -h' for detailed options")
ERROR(
"Invalid number of parameters used. Please see usage information above."
)
return
elif options.trials < 1:
ERROR("Number of trials should be at least 1")
return
else:
if len(args) == 2: mask = None
else: mask = args[2]
if options.K < 2:
ERROR("K must be > 1 group")
return
if options.CTF:
ERROR("CTF option not implemented")
return
if sp_global_def.CACHE_DISABLE:
from sp_utilities import disable_bdb_cache
disable_bdb_cache()
from sp_applications import k_means_main
sp_global_def.BATCH = True
k_means_main(args[0], args[1], mask, "SSE", options.K,
options.rand_seed, options.maxit, options.trials,
options.crit, options.CTF, 0.0, 0.0, options.MPI, False,
options.debug, options.normalize, options.init_method)
sp_global_def.BATCH = False
def main():
progname = os.path.basename(sys.argv[0])
usage = progname + " stack outdir <maskfile> --ir=inner_radius --ou=outer_radius --rs=ring_step --xr=x_range --yr=y_range --ts=translation_step --dst=delta --center=center --maxit=max_iteration --CTF --snr=SNR --Fourvar=Fourier_variance --Ng=group_number --Function=user_function_name --CUDA --GPUID --MPI"
parser = OptionParser(usage, version=SPARXVERSION)
parser.add_option(
"--ir",
type="float",
default=1,
help="inner radius for rotational correlation > 0 (set to 1)")
parser.add_option(
"--ou",
type="float",
default=-1,
help=
"outer radius for rotational correlation < nx/2-1 (set to the radius of the particle)"
)
parser.add_option(
"--rs",
type="float",
default=1,
help="step between rings in rotational correlation > 0 (set to 1)")
parser.add_option(
"--xr",
type="string",
default="4 2 1 1",
help="range for translation search in x direction, search is +/xr ")
parser.add_option(
"--yr",
type="string",
default="-1",
help="range for translation search in y direction, search is +/yr ")
parser.add_option("--ts",
type="string",
default="2 1 0.5 0.25",
help="step of translation search in both directions")
parser.add_option("--dst", type="float", default=0.0, help="delta")
parser.add_option(
"--center",
type="float",
default=-1,
help=
"-1.average center method; 0.not centered; 1.phase approximation; 2.cc with Gaussian function; 3.cc with donut-shaped image 4.cc with user-defined reference 5.cc with self-rotated average"
)
parser.add_option(
"--maxit",
type="float",
default=0,
help=
"maximum number of iterations (0 means the maximum iterations is 10, but it will automatically stop should the criterion falls"
)
parser.add_option("--CTF",
action="store_true",
default=False,
help="use CTF correction during alignment ")
parser.add_option("--snr",
type="float",
default=1.0,
help="signal-to-noise ratio of the data (set to 1.0)")
parser.add_option("--Fourvar",
action="store_true",
default=False,
help="compute Fourier variance")
parser.add_option("--Ng",
type="int",
default=-1,
help="number of groups in the new CTF filtration")
parser.add_option("--num_ali",
type="int",
default=3,
help="number of independent alignments to do")
parser.add_option(
"--function",
type="string",
default="ref_ali2d",
help="name of the reference preparation function (default ref_ali2d)")
parser.add_option("--CUDA",
action="store_true",
default=False,
help="use CUDA program")
parser.add_option("--GPUID",
type="string",
default="",
help="ID of GPUs available")
parser.add_option("--MPI",
action="store_true",
default=False,
help="use MPI version ")
(options, args) = parser.parse_args()
if len(args) < 2 or len(args) > 3:
sxprint("Usage: " + usage)
sxprint("Please run '" + progname + " -h' for detailed options")
ERROR(
"Invalid number of parameters used. Please see usage information above."
)
return
else:
if args[1] == 'None':
outdir = None
else:
outdir = args[1]
if len(args) == 2:
mask = None
else:
mask = args[2]
from sp_development import multi_ali2d
if sp_global_def.CACHE_DISABLE:
from sp_utilities import disable_bdb_cache
disable_bdb_cache()
sp_global_def.BATCH = True
multi_ali2d(args[0], outdir, mask, options.ir, options.ou, options.rs, options.xr, options.yr, options.ts, options.dst, options.center, \
options.maxit, options.CTF, options.snr, options.Fourvar, options.Ng, options.num_ali, options.function, options.CUDA, options.GPUID, options.MPI)
sp_global_def.BATCH = False
def main():
arglist = []
for arg in sys.argv:
arglist.append(arg)
progname = optparse.os.path.basename(arglist[0])
usage = (
progname
+ " prj_stack volume [begin end step] --CTF --npad=ntimes_padding --list=file --group=ID --snr=SNR --sym=symmetry --verbose=(0|1) --xysize --MPI"
)
parser = optparse.OptionParser(usage, version=sp_global_def.SPARXVERSION)
parser.add_option(
"--CTF", action="store_true", default=False, help="apply CTF correction"
)
parser.add_option("--snr", type="float", default=1.0, help="Signal-to-Noise Ratio")
parser.add_option("--sym", type="string", default="c1", help="symmetry")
parser.add_option(
"--list",
type="string",
help="file with list of images to be used in the first column",
)
parser.add_option(
"--group",
type="int",
default=-1,
help="perform reconstruction using images for a given group number (group is attribute in the header)",
)
parser.add_option(
"--MPI", action="store_true", default=False, help="use MPI version "
)
parser.add_option(
"--npad", type="int", default=2, help="number of times padding (default 2)"
)
parser.add_option(
"--verbose",
type="int",
default=0,
help="verbose level: 0 no verbose, 1 verbose",
)
parser.add_option(
"--xysize", type="int", default=-1, help="user expected size at xy direction"
)
parser.add_option(
"--zsize", type="int", default=-1, help="user expected size at z direction"
)
parser.add_option(
"--smearstep",
type="float",
default=0.0,
help="Rotational smear step (default 0.0, no smear)",
)
parser.add_option(
"--interpolation_method",
type="string",
default="4nn",
help="4nn, or tril: nearest neighbor, or trilinear interpolation",
)
parser.add_option(
"--niter",
type="int",
default=10,
help="number of iterations for iterative reconstruction",
)
parser.add_option(
"--upweighted",
action="store_true",
default=False,
help="apply background noise",
)
parser.add_option(
"--compensate",
action="store_true",
default=False,
help="compensate in reconstruction",
)
parser.add_option(
"--chunk_id",
type="int",
default=-1,
help="reconstruct both odd and even groups of particles",
)
parser.add_option(
"--target_window_size",
type="int",
default=-1,
help=" size of the targeted reconstruction ",
)
(options, args) = parser.parse_args(arglist[1:])
if sp_global_def.CACHE_DISABLE:
sp_utilities.disable_bdb_cache()
if len(args) == 2:
prj_stack = args[0]
vol_stack = args[1]
nimage = EMAN2_cppwrap.EMUtil.get_image_count(prj_stack)
pid_list = list(range(0, nimage))
elif len(args) == 5:
prj_stack = args[0]
vol_stack = args[1]
begin = string.atoi(args[2])
end = string.atoi(args[3])
step = string.atoi(args[4])
pid_list = list(range(begin, end, step))
else:
sp_global_def.ERROR("Incomplete list of arguments")
return
if options.list and options.group > -1:
sp_global_def.ERROR("options group and list cannot be used together")
return
sp_global_def.BATCH = True
if options.interpolation_method == "4nn":
sp_applications.recons3d_n(
prj_stack,
pid_list,
vol_stack,
options.CTF,
options.snr,
1,
options.npad,
options.sym,
options.list,
options.group,
options.verbose,
options.MPI,
options.xysize,
options.zsize,
options.smearstep,
options.upweighted,
options.compensate,
options.chunk_id,
)
elif options.interpolation_method == "tril":
if options.MPI is False:
sp_global_def.ERROR(
"Trilinear interpolation reconstruction has MPI version only!"
)
return
sp_applications.recons3d_trl_MPI(
prj_stack,
pid_list,
vol_stack,
options.CTF,
options.snr,
1,
options.npad,
options.sym,
options.verbose,
options.niter,
options.compensate,
options.target_window_size,
)
else:
sp_global_def.ERROR(
"Wrong interpolation method. The current options are 4nn, and tril. 4nn is the default one."
)
return
sp_global_def.write_command(optparse.os.path.dirname(vol_stack))
sp_global_def.BATCH = False
def main():
arglist = []
for arg in sys.argv:
arglist.append(arg)
progname = os.path.basename(arglist[0])
usage = progname + " stack ref_vol outdir <maskfile> --ir=inner_radius --ou=outer_radius --rs=ring_step --xr=x_range --ynumber=y_numbers --txs=translational_search_stepx --delta=angular_step --an=angular_neighborhood --center=1 --maxit=max_iter --CTF --snr=1.0 --ref_a=S --sym=c1 --datasym=symdoc --new"
parser = OptionParser(usage, version=SPARXVERSION)
#parser.add_option("--ir", type="float", default= -1, help="inner radius for rotational correlation > 0 (set to 1) (Angstroms)")
parser.add_option(
"--ou",
type="float",
default=-1,
help=
"outer radius for rotational 2D correlation < int(nx/2)-1 (set to the radius of the particle) (Angstroms)"
)
parser.add_option(
"--rs",
type="int",
default=1,
help="step between rings in rotational correlation >0 (set to 1)")
parser.add_option(
"--xr",
type="string",
default=" 4 2 1 1 1",
help=
"range for translation search in x direction, search is +/-xr (Angstroms) "
)
parser.add_option(
"--txs",
type="string",
default="1 1 1 0.5 0.25",
help=
"step size of the translation search in x directions, search is -xr, -xr+ts, 0, xr-ts, xr (Angstroms)"
)
parser.add_option(
"--y_restrict",
type="string",
default="-1 -1 -1 -1 -1",
help=
"range for translational search in y-direction, search is +/-y_restrict in Angstroms. This only applies to local search, i.e., when an is not -1. If y_restrict < 0, then for ihrsrlocalcons (option --localcons local search with consistency), the y search range is set such that it is the same ratio to dp as angular search range is to dphi. For regular ihrsr, y search range is the full range when y_restrict< 0. Default is -1."
)
parser.add_option(
"--ynumber",
type="string",
default="4 8 16 32 32",
help=
"even number of the translation search in y direction, search is (-dpp/2,-dpp/2+dpp/ny,,..,0,..,dpp/2-dpp/ny dpp/2]"
)
parser.add_option("--delta",
type="string",
default=" 10 6 4 3 2",
help="angular step of reference projections")
parser.add_option(
"--an",
type="string",
default="-1",
help=
"angular neighborhood for local searches (default -1, meaning do exhaustive search)"
)
parser.add_option(
"--maxit",
type="int",
default=30,
help=
"maximum number of iterations performed for each angular step (default 30) "
)
parser.add_option("--CTF",
action="store_true",
default=False,
help="CTF correction")
parser.add_option("--snr",
type="float",
default=1.0,
help="Signal-to-Noise Ratio of the data (default 1)")
parser.add_option("--MPI",
action="store_true",
default=True,
help="use MPI version")
#parser.add_option("--fourvar", action="store_true", default=False, help="compute Fourier variance")
parser.add_option("--apix",
type="float",
default=-1.0,
help="pixel size in Angstroms")
parser.add_option("--dp",
type="float",
default=-1.0,
help="delta z - translation in Angstroms")
parser.add_option("--dphi",
type="float",
default=-1.0,
help="delta phi - rotation in degrees")
parser.add_option(
"--ndp",
type="int",
default=12,
help=
"In symmetrization search, number of delta z steps equals to 2*ndp+1")
parser.add_option(
"--ndphi",
type="int",
default=12,
help="In symmetrization search,number of dphi steps equas to 2*ndphi+1"
)
parser.add_option("--dp_step",
type="float",
default=0.1,
help="delta z (Angstroms) step for symmetrization")
parser.add_option("--dphi_step",
type="float",
default=0.1,
help="dphi step for symmetrization")
parser.add_option(
"--psi_max",
type="float",
default=10.0,
help=
"maximum psi - how far rotation in plane can can deviate from 90 or 270 degrees (default 10)"
)
parser.add_option("--rmin",
type="float",
default=0.0,
help="minimal radius for hsearch (Angstroms)")
parser.add_option("--rmax",
type="float",
default=80.0,
help="maximal radius for hsearch (Angstroms)")
parser.add_option("--fract",
type="float",
default=0.7,
help="fraction of the volume used for helical search")
parser.add_option("--sym",
type="string",
default="c1",
help="symmetry of the structure")
parser.add_option("--function",
type="string",
default="helical",
help="name of the reference preparation function")
parser.add_option("--datasym",
type="string",
default="datasym.txt",
help="symdoc")
parser.add_option(
"--nise",
type="int",
default=200,
help="start symmetrization after nise steps (default 200)")
parser.add_option("--npad",
type="int",
default=2,
help="padding size for 3D reconstruction, (default 2)")
parser.add_option("--debug",
action="store_true",
default=False,
help="debug")
parser.add_option("--new",
action="store_true",
default=False,
help="use rectangular recon and projection version")
parser.add_option(
"--initial_theta",
type="float",
default=90.0,
help="intial theta for reference projection (default 90)")
parser.add_option(
"--delta_theta",
type="float",
default=1.0,
help="delta theta for reference projection (default 1.0)")
parser.add_option("--WRAP",
type="int",
default=1,
help="do helical wrapping (default 1, meaning yes)")
(options, args) = parser.parse_args(arglist[1:])
if len(args) < 1 or len(args) > 5:
sxprint("usage: " + usage + "\n")
sxprint("Please run '" + progname + " -h' for detailed options")
ERROR(
"Invalid number of parameters used. please see usage information above."
)
return
else:
# Convert input arguments in the units/format as expected by ihrsr_MPI in applications.
if options.apix < 0:
ERROR("Please enter pixel size")
return
rminp = int((float(options.rmin) / options.apix) + 0.5)
rmaxp = int((float(options.rmax) / options.apix) + 0.5)
from sp_utilities import get_input_from_string, get_im
xr = get_input_from_string(options.xr)
txs = get_input_from_string(options.txs)
y_restrict = get_input_from_string(options.y_restrict)
irp = 1
if options.ou < 0: oup = -1
else: oup = int((options.ou / options.apix) + 0.5)
xrp = ''
txsp = ''
y_restrict2 = ''
for i in range(len(xr)):
xrp += " " + str(float(xr[i]) / options.apix)
for i in range(len(txs)):
txsp += " " + str(float(txs[i]) / options.apix)
# now y_restrict has the same format as x search range .... has to change ihrsr accordingly
for i in range(len(y_restrict)):
y_restrict2 += " " + str(float(y_restrict[i]) / options.apix)
if sp_global_def.CACHE_DISABLE:
from sp_utilities import disable_bdb_cache
disable_bdb_cache()
from sp_applications import ihrsr
sp_global_def.BATCH = True
if len(args) < 4: mask = None
else: mask = args[3]
ihrsr(args[0], args[1], args[2], mask, irp, oup, options.rs, xrp,
options.ynumber, txsp, options.delta, options.initial_theta,
options.delta_theta, options.an, options.maxit, options.CTF,
options.snr, options.dp, options.ndp, options.dp_step,
options.dphi, options.ndphi, options.dphi_step, options.psi_max,
rminp, rmaxp, options.fract, options.nise, options.npad,
options.sym, options.function, options.datasym, options.apix,
options.debug, options.MPI, options.WRAP, y_restrict2)
sp_global_def.BATCH = False
def main():
global debug, logid
progname = os.path.basename(sys.argv[0])
usage = """%prog [options] <input stack/image> ...
Various CTF-related operations on images, including automatic fitting. Note that automatic fitting is limited to 5 microns
underfocus at most. Input particles should be unmasked and unfiltered. A minimum of ~20% padding around the
particles is required for background extraction, even if this brings the edge of another particle into the box in some cases.
Particles should be reasonably well centered. Can also optionally phase flip and Wiener filter particles. Wiener filtration comes
after phase-flipping, so if phase flipping is performed Wiener filtered particles will also be phase-flipped. Note that both
operations are performed on oversampled images if specified (though final real-space images are clipped back to their original
size. Increasing padding during the particle picking process will improve the accuracy of phase-flipping, particularly for
images far from focus."""
parser = OptionParser(usage=usage, version=EMANVERSION)
parser.add_option("--gui",
action="store_true",
help="Start the GUI for interactive fitting",
default=False)
parser.add_option("--auto_fit",
action="store_true",
help="Runs automated CTF fitting on the input images",
default=False)
parser.add_option(
"--bgmask",
type="int",
help=
"Compute the background power spectrum from the edge of the image, specify a mask radius in pixels which would largely mask out the particles. Default is boxsize/2.",
default=0)
parser.add_option("--apix",
type="float",
help="Angstroms per pixel for all images",
default=0)
parser.add_option("--voltage",
type="float",
help="Microscope voltage in KV",
default=0)
parser.add_option("--cs",
type="float",
help="Microscope Cs (spherical aberation)",
default=0)
parser.add_option("--ac",
type="float",
help="Amplitude contrast (percentage, default=10)",
default=10)
parser.add_option(
"--autohp",
action="store_true",
help=
"Automatic high pass filter of the SNR only to remove initial sharp peak, phase-flipped data is not directly affected (default false)",
default=False)
#parser.add_option("--invert",action="store_true",help="Invert the contrast of the particles in output files (default false)",default=False)
parser.add_option("--nonorm",
action="store_true",
help="Suppress per image real-space normalization",
default=False)
parser.add_option(
"--nosmooth",
action="store_true",
help=
"Disable smoothing of the background (running-average of the log with adjustment at the zeroes of the CTF)",
default=False)
#parser.add_option("--phaseflip",action="store_true",help="Perform phase flipping after CTF determination and writes to specified file.",default=False)
#parser.add_option("--wiener",action="store_true",help="Wiener filter (optionally phaseflipped) particles.",default=False)
parser.add_option("--oversamp",
type="int",
help="Oversampling factor",
default=1)
parser.add_option(
"--sf",
type="string",
help=
"The name of a file containing a structure factor curve. Can improve B-factor determination.",
default=None)
parser.add_option("--debug", action="store_true", default=False)
(options, args) = parser.parse_args()
if len(args) < 1: parser.error("Input image required")
if sp_global_def.CACHE_DISABLE:
from sp_utilities import disable_bdb_cache
disable_bdb_cache()
if options.auto_fit:
if options.voltage == 0: parser.error("Please specify voltage")
if options.cs == 0: parser.error("Please specify Cs")
if options.apix == 0: sxprint("Using A/pix from header")
debug = options.debug
global sfcurve
if options.sf:
sfcurve = XYData()
sfcurve.read_file(options.sf)
logid = E2init(sys.argv)
# if options.oversamp>1 : options.apix/=float(options.oversamp)
db_project = db_open_dict("bdb:project")
db_parms = db_open_dict("bdb:e2ctf.parms")
db_misc = db_open_dict("bdb:e2ctf.misc")
options.filenames = args
### Power spectrum and CTF fitting
if options.auto_fit:
img_sets = pspec_and_ctf_fit(
options,
debug) # converted to a function so to work with the workflow
### This computes the intensity of the background subtracted power spectrum at each CTF maximum for all sets
global envelopes # needs to be a global for the Simplex minimizer
# envelopes is essentially a cache of information that could be useful at later stages of refinement
# as according to Steven Ludtke
for i in img_sets:
envelopes.append(ctf_env_points(i[2], i[3], i[1]))
# we use a simplex minimizer to try to rescale the individual sets to match as best they can
scales = [1.0] * len(img_sets)
if (len(img_sets) > 3):
incr = [0.2] * len(img_sets)
simp = Simplex(env_cmp, scales, incr)
scales = simp.minimize(maxiters=1000)[0]
# sxprint scales
sxprint(" ")
# apply the final rescaling
envelope = []
for i in range(len(scales)):
cur = envelopes[i]
for j in range(len(cur)):
envelope.append((cur[j][0], cur[j][1] * scales[i]))
envelope.sort()
envelope = [i for i in envelope
if i[1] > 0] # filter out all negative peak values
db_misc = db_open_dict("bdb:e2ctf.misc")
db_misc["envelope"] = envelope
#db_close_dict("bdb:e2ctf.misc")
#out=file("envelope.txt","w")
#for i in envelope: out.write("%f\t%f\n"%(i[0],i[1]))
#out.close()
### GUI - user can update CTF parameters interactively
if options.gui:
img_sets = get_gui_arg_img_sets(options.filenames)
if len(img_sets) == 0:
E2end(logid)
ERROR("img_sets == 0")
return
app = EMApp()
gui = GUIctf(app, img_sets)
gui.show_guis()
app.exec_()
sxprint("done execution")
### Process input files
#if debug : print "Phase flipping / Wiener filtration"
# write wiener filtered and/or phase flipped particle data to the local database
#if options.phaseflip or options.wiener: # only put this if statement here to make the program flow obvious
# write_e2ctf_output(options) # converted to a function so to work with the workflow
E2end(logid)
