コード例 #1
0
ファイル: p3ctfrun.py プロジェクト: emkailu/pat3dem
def main():
	progname = os.path.basename(sys.argv[0])
	usage = progname + """ [options] <movie.mrcs>
	Run p3ctf.py on cluster.
	Needs:
	'ctffind' command (v4.0.16, Rohou & Grigorieff, 2015)
	"""
	
	args_def = {'apix':1.25, 'voltage':200, 'cs':2, 'ac':0.1, 'dpsize':5}	
	parser = argparse.ArgumentParser()
	parser.add_argument("image", nargs='*', help="specify images to be processed")
	parser.add_argument("-a", "--apix", type=float, help="specify apix, by default {}".format(args_def['apix']))
	parser.add_argument("-v", "--voltage", type=int, help="specify the voltage (kV), by default {}".format(args_def['voltage']))
	parser.add_argument("-c", "--cs", type=float, help="specify spherical abberration, by default {}".format(args_def['cs']))
	parser.add_argument("-ac", "--ac", type=float, help="specify amplitude contrast, by default {}".format(args_def['ac']))
	parser.add_argument("-d", "--dpsize", type=float, help="specify detector pixel size (um), by default {}".format(args_def['dpsize']))
	args = parser.parse_args()
	
	if len(sys.argv) == 1:
		print "usage: " + usage
		print "Please run '" + progname + " -h' for detailed options."
		sys.exit(1)
	# get default values
	for i in args_def:
		if args.__dict__[i] == None:
			args.__dict__[i] = args_def[i]
	# loop over all the input images
	walltime, cpu, ptile = 1, 1, 1
	option = '-a {} -v {} -c {} -ac {} -d {}'.format(args.apix, args.voltage, args.cs, args.ac, args.dpsize)
	for image in args.image:
		basename = os.path.basename(os.path.splitext(image)[0])
		cmd = "p3ctf.py {} {}".format(image, option)
		p3c.ada(cmd, basename, walltime, cpu, ptile)		
コード例 #2
0
ファイル: p3recrand.py プロジェクト: emkailu/pat3dem
def main():
	progname = os.path.basename(sys.argv[0])
	usage = progname + """ [options] <_data.star>
	Reconstruct from randomly selected particles from _data.star.
	Needs:
	relion (v1.4, Scheres, 2012)
	"""
	
	args_def = {'repeat':1000, 'apix':1.25, 'maxres':6, 'walltime':1}	
	parser = argparse.ArgumentParser()
	parser.add_argument("star", nargs='*', help="specify _data.star")
	parser.add_argument("-r", "--repeat", type=int, help="specify how many times you want to repeat the experiment (reconstruct from random particles), by default {}".format(args_def['repeat']))
	parser.add_argument("-a", "--apix", type=float, help="specify the apix, by default {}".format(args_def['apix']))
	parser.add_argument("-m", "--maxres", type=float, help="specify maximum resolution (in Angstrom) to consider in Fourier space, by default {}".format(args_def['maxres']))
	parser.add_argument("-w", "--walltime", type=int, help="specify the walltime (in hour), by default {}".format(args_def['walltime']))
	args = parser.parse_args()
	
	if len(sys.argv) == 1:
		print "usage: " + usage
		print "Please run '" + progname + " -h' for detailed options."
		sys.exit(1)
	# get default values
	for i in args_def:
		if args.__dict__[i] == None:
			args.__dict__[i] = args_def[i]
	# repeat
	star = args.star[0]
	star_dict = p3s.star_parse(star, 'data_images')
	header = star_dict['data_'] + star_dict['loop_']
	for i in xrange(args.repeat):
		# root name for output
		out = star[:-10] + '_repeat{:05}'.format(i)
		# check if output exists
		if os.path.isfile(out+'.mrc'):
			continue
		# write a new random data.star
		with open(star) as s_read:
			lines = s_read.readlines()[len(header):-1]
			l_len = len(lines)
			new_star = star[:-10] + '_repeat{:05}_data.star'.format(i)
			with open(new_star, 'w') as s_write:
				s_write.write(''.join(header))
				# randomly select for l_len times
				for j in xrange(l_len):
					k = random.randint(0,l_len-1)
					s_write.write(lines[k])
				s_write.write('\n')		
		# write and submit the job
		cmd = "`which relion_reconstruct` --i {} --o {} --angpix {} --maxres {} --ctf true".format(new_star, out+'.mrc', args.apix, args.maxres)
		walltime, cpu, ptile = args.walltime, 1, 1
		p3c.ada(cmd, out, walltime, cpu, ptile)
コード例 #3
0
ファイル: p3rosettarun.py プロジェクト: emkailu/pat3dem
def main():
	progname = os.path.basename(sys.argv[0])
	usage = progname + """ [options] <*.pdb>
	Run rosetta.
	"""
	
	args_def = {'repeat':100, 'resolution':4, 'rosetta3':'/scratch/user/kailuyang/compile/rosetta_bin_linux_2015.39.58186_bundle/main'}	
	parser = argparse.ArgumentParser()
	parser.add_argument("pdb", nargs='*', help="specify pdb to be processed")
	parser.add_argument("-r", "--repeat", type=int, help="specify repeat, by default {}".format(args_def['repeat']))
	parser.add_argument("-re", "--resolution", type=float, help="specify reslution, by default {}".format(args_def['resolution']))
	parser.add_argument("-r3", "--rosetta3", type=str, help="specify rosetta3, by default {}".format(args_def['rosetta3']))
	args = parser.parse_args()
	
	if len(sys.argv) == 1:
		print "usage: " + usage
		print "Please run '" + progname + " -h' for detailed options."
		sys.exit(1)
	# get default values
	for i in args_def:
		if args.__dict__[i] == None:
			args.__dict__[i] = args_def[i]
	# loop over input pdbs
	for i in args.pdb:
		basename = os.path.basename(os.path.splitext(i)[0])
		for j in xrange(args.repeat):
			out = '{}_repeat{:04}'.format(basename, j)
			with open('{}.sh'.format(out), 'w') as write_sh:
				write_sh.write('ROSETTA3={}\n'.format(args.rosetta3))
				write_sh.write('$ROSETTA3/source/bin/rosetta_scripts.linuxgccrelease \\\n')
				write_sh.write('    		-database $ROSETTA3/database/ \\\n')
				write_sh.write('    		-in::file::s {} \\\n'.format(i))
				write_sh.write('    		-parser::protocol refine.xml \\\n')
				write_sh.write('    		-parser::script_vars denswt=25 rms=1.5 reso={} map={}.mrc testmap={}.mrc \\\n'.format(args.resolution, basename, basename))
				write_sh.write('    		-ignore_unrecognized_res \\\n')
				write_sh.write('    		-edensity::mapreso {} \\\n'.format(args.resolution))
				write_sh.write('    		-default_max_cycles 200 \\\n')
				write_sh.write('    		-edensity::cryoem_scatterers \\\n')
				write_sh.write('    		-out::suffix _{} \\\n'.format(out))
				write_sh.write('    		-crystal_refine\n')
			# submit to cluster
			cmd = 'sh {}.sh'.format(out)
			walltime, cpu, ptile = 1, 1, 1
			p3c.ada(cmd, out, walltime, cpu, ptile)			
コード例 #4
0
ファイル: p3movierun.py プロジェクト: emkailu/pat3dem
def main():
	progname = os.path.basename(sys.argv[0])
	usage = progname + """ [options] <f.txt>
	Run p3movie.py to process movies listed in f.txt, and the movies will be deleted to save space.
	"""
	
	args_def = {'apix':1.25, 'voltage':200, 'time':200, 'rate':8, 'save':'0 0 0', 'xsuper':7420, 'scale':1, 'delete':1}
	parser = argparse.ArgumentParser()
	parser.add_argument("f", nargs='*', help="specify the txt file used for p3download.py")
	parser.add_argument("-a", "--apix", type=float, help="specify counting apix before scaling, by default {}".format(args_def['apix']))
	parser.add_argument("-v", "--voltage", type=int, help="specify the voltage (kV), by default {}".format(args_def['voltage']))
	parser.add_argument("-t", "--time", type=float, help="specify exposure time per frame in ms, by default {}".format(args_def['time']))
	parser.add_argument("-r", "--rate", type=float, help="specify dose rate in e/pix/s (counting pixel, not superresolution), by default {}. if specified as 0, no filtered sum will be output".format(args_def['rate']))
	parser.add_argument("-s", "--save", type=str, help="save a specified number of aligned frames, by default '{}', which means do not save. e.g., '0 19 4' means the saved movie starts from frame #0, ends at #19, in total (19-0+1)/4 = 5 frames. if 19 >= the real number of frames of the movie, skip".format(args_def['save']))
	parser.add_argument("-x", "--xsuper", type=int, help="specify the x dimension of superresolution images, by default {}".format(args_def['xsuper']))
	parser.add_argument("-sc", "--scale", type=float, help="specify the down scaling factor, by default {}. e.g., 1.2 means counting images will be downscaled by 1.2 times, superresolution 2.4".format(args_def['scale']))
	parser.add_argument("-d", "--delete", type=int, help="delete (!!!) the raw movie (specify as 1), by default {}, which means do not delete".format(args_def['delete']))
	args = parser.parse_args()
	
	if len(sys.argv) == 1:
		print "usage: " + usage
		print "Please run '" + progname + " -h' for detailed options."
		sys.exit(1)
	# get default values
	for i in args_def:
		if args.__dict__[i] == None:
			args.__dict__[i] = args_def[i]
	# import
	import pat3dem.cluster as p3c
	# get the local file list based on f.txt
	f = args.f[0]
	f2 = f + '.p3movie'
	with open(f) as f_r:
		lines = f_r.readlines()
	with open(f2, 'w') as f2_w:
		for i in lines:
			j = './' + i.replace('\\','/').split('/')[-1]
			f2_w.write(j)
	with open(f2) as f2_r:
		lines = f2_r.readlines()
	# run line #i if line #(i+1) exists, the last line will be ignored
	walltime, cpu, ptile = 1, 1, 1
	option = "-a {} -v {} -t {} -r {} -s '{}' -x {} -sc {} -d {}".format(args.apix, args.voltage, args.time, args.rate, args.save, args.xsuper, args.scale, args.delete)
	for i, l in enumerate(lines[:-1]):
		l = l.strip()
		l2 = lines[i+1].strip()
		while not os.path.isfile(l2):
			time.sleep(60)
		# submit the job, the option '-d 1' means delete the raw movie!!!
		cmd = "p3movie.py {} {}".format(l, option)
		basename = os.path.basename(os.path.splitext(l)[0])
		p3c.ada(cmd, basename, walltime, cpu, ptile)
	# process the last one
	last = lines[-1].strip()
	size = os.path.getsize(last)
	time.sleep(30)
	size_new = os.path.getsize(last)
	while size_new > size:
		size = size_new
		time.sleep(30)
		size_new = os.path.getsize(last)
	cmd = "p3movie.py {} {}".format(last, option)
	basename = os.path.basename(os.path.splitext(last)[0])
	p3c.ada(cmd, basename, walltime, cpu, ptile)