def scipion_split_particle_stacks(inputStar, inputStack, output, filename_prefix, deleteStack):
""" Read a STAR file with particles and write as individual images.
If a stack of images is given, use these instead of the images from the STAR file.
Also write a new STAR file pointing to these images.
This function requires that the script is run within Scipion Python environment. """
import pyworkflow.utils as pwutils
from pyworkflow.em import ImageHandler
ih = ImageHandler()
md = MetaData(inputStar)
md.addLabels('rlnOriginalName')
# Initialize progress bar
progressbar = ProgressBar(width=60, total=len(md))
for i, particle in enumerate(md, start=1):
outputImageName = '%s/%s_%06d.mrc' % (output, filename_prefix, i)
if inputStack:
ih.convert((i, inputStack), outputImageName )
particle.rlnOriginalName = '%s/%06d@%s' %(output, i, inputStack)
else:
ih.convert(particle.rlnImageName, outputImageName)
particle.rlnOriginalName = particle.rlnImageName
particle.rlnImageName = outputImageName
progressbar.notify()
print("\n")
md.write("%s/%s.star" % (output, filename_prefix))
if inputStack and deleteStack:
pwutils.cleanPath(inputStack)
def reconstruct_subparticles(threads, output, maxres, sym, angpix, do_halves, library_path):
""" Reconstruct subparticles. Also create two half maps using random subsets. """
def run_reconstruct(input, suffix='', extraArgs=''):
if threads>1 :
cmd = ('mpirun -np %s relion_reconstruct_mpi ') % (threads)
else:
cmd = ('relion_reconstruct ')
args = ('--sym %s %s --o %s%s.mrc --i %s.star --angpix %s') % (sym, extraArgs, input, suffix, input, angpix)
run_command(cmd + args,"", library_path)
for input in [output, output+'_subtracted']:
args = ""
inputStarName = input + '.star'
if os.path.exists(inputStarName):
md = MetaData(inputStarName)
if "rlnDefocusU" in md.getLabels():
args = args + "--ctf "
else:
print ("\nWarning: no CTF info found in %s!\n"
"The reconstruction will be performed without CTF correction.\n" % inputStarName)
# reconstruct random halves to Nyquist frequency
if "rlnRandomSubset" in md.getLabels() and do_halves:
half1Star, half2Star = split_star_to_random_subsets(input)
run_reconstruct(half1Star, "_class001_unfil", args)
run_reconstruct(half2Star, "_class001_unfil", args)
# reconstruct the map to maximum resolution given
if maxres:
args = args + "--maxres %s " % maxres
run_reconstruct(input, '_class001', args)
def create_initial_stacks(input_star, angpix, masked_map, output, extract_from_micrographs, library_path):
""" Create initial particle stacks (and STAR files) to be used
for extraction of subparticles. If the masked_map is passed,
another stack with subtracted particles will be created. """
print(" Creating particle images from which nothing is subtracted...")
split_particle_stacks(extract_from_micrographs, input_star, None, output, 'particles', deleteStack=False)
if masked_map:
print(" Creating particle images from which the projections of the masked "
"particle reconstruction have been subtracted...")
subtractedStackRoot = "%s/particles_subtracted" % output
md = MetaData(input_star)
args = " --i %s --o %s --ang %s --subtract_exp --angpix %s "
if "rlnDefocusU" in md.getLabels():
args = args + "--ctf "
else:
print ("\nWarning: no CTF info found in %s!\n"
"The subtraction will be performed without CTF correction.\n" % input_star)
run_command("relion_project" + args %
(masked_map, subtractedStackRoot, input_star, angpix),"",library_path)
run_command("mv %s.star %s_orig.star" % (subtractedStackRoot, subtractedStackRoot),"",library_path)
subtractedStack = subtractedStackRoot + '.mrcs'
split_particle_stacks(extract_from_micrographs, input_star, subtractedStack, output, 'particles_subtracted', deleteStack=True)
def create_initial_stacks(input_star, angpix, masked_map, output):
""" Create initial particle stacks (and STAR files) to be used
for extraction of subparticles. If the masked_map is passed,
another stack with subtracted particles will be created. """
print " Creating particle images from which nothing is subtracted..."
scipion_split_particle_stacks(input_star, None, output, 'particles', deleteStack=False)
if masked_map:
print(" Creating particle images from which the projections of the masked "
"particle reconstruction have been subtracted...")
subtractedStackRoot = "%s/particles_subtracted" % output
md = MetaData(input_star)
args = " --i %s --o %s --ang %s --subtract_exp --angpix %s "
if "rlnDefocusU" in md.getLabels():
args = args + "--ctf "
else:
print ("\nWarning: no CTF info found in %s!\n"
"The subtraction will be performed without CTF correction.\n" % input_star)
run_command("relion_project" + args %
(masked_map, subtractedStackRoot, input_star, angpix))
run_command("mv %s.star %s_orig.star" % (subtractedStackRoot, subtractedStackRoot))
subtractedStack = subtractedStackRoot + '.mrcs'
scipion_split_particle_stacks(input_star, subtractedStack, output, 'particles_subtracted', deleteStack=True)
def reconstruct_subparticles(threads, output, maxres, sym, angpix):
""" Reconstruct subparticles. Also create two half maps using random subsets. """
def run_reconstruct(input, suffix='', extraArgs=''):
cmd = ('relion_reconstruct ')
args = ('--sym %s --j %s %s --o %s%s.mrc --i %s.star --angpix %s') % (sym, threads, extraArgs, output, suffix, input, angpix)
run_command(cmd + args)
for input in [output, output+'_subtracted']:
args = ""
inputStarName = input + '.star'
if os.path.exists(inputStarName):
md = MetaData(inputStarName)
if "rlnDefocusU" in md.getLabels():
args = args + "--ctf "
else:
print ("\nWarning: no CTF info found in %s!\n"
"The reconstruction will be performed without CTF correction.\n" % inputStarName)
# reconstruct random halves to Nyquist frequency
if "rlnRandomSubset" in md.getLabels():
half1Star, half2Star = split_star_to_random_subsets(input)
run_reconstruct(half1Star, "_half1_class001_unfil", args)
run_reconstruct(half2Star, "_half2_class001_unfil", args)
# reconstruct the map to maximum resolution given
if maxres:
args = args + "--maxres %s " % maxres
run_reconstruct(input, '_class001', args)
def main(self):
self.define_parser()
args = self.parser.parse_args()
self.validate(args)
print "Remove overlapping particles..."
md = MetaData(args.input_star)
mdOut = MetaData()
mdOut.addLabels(md.getLabels())
new_particles = []
# get list of tags 'micrographs' but can be anything that defines
# a set of particles to compare
if args.originalParticles:
micrographs = self.get_originalParticleNames(md)
else:
micrographs = self.get_micrographs(md)
for micrograph in micrographs:
print "Processing micrograph %s..." % micrograph,
particles = self.get_particles(md, micrograph)
particles_unique = self.remove_overlapping_particles(particles, args.mindist)
new_particles.extend(particles_unique)
print "%s particle(s) kept." % len(particles_unique)
mdOut.addData(new_particles)
mdOut.write(args.output)
print "All done!"
def create_star(subparticles, star_filename):
""" Create a Relion style STAR file for extracting (using relion_preprocess)
all the subparticles for a given particle. """
md = MetaData()
md.addLabels("rlnCoordinateX", "rlnCoordinateY")
md.addData(subparticles)
md.write(star_filename)
def write_sorted_mic_star(folder, input_files, use_tilt_order_files,
custom_tilt_order, tilt_scheme, min_angle,
angle_step, starting_tilt_angle, tomo_name,
write_tilt_order_files, mic_id,
dose_symmetric_group_size,
dose_symmetric_groups_not_centered):
file_list = glob.glob(folder + '/' + input_files)
if sort_by_name:
file_list = sorted(file_list)
else:
file_list.sort(key=os.path.getmtime)
total_tilts = len(file_list)
if total_tilts == 0:
print('####')
print('No images found for %s' % tomo_name)
print('####')
return MetaData(), mic_id
order_list, doses_list, tilt_order_path, used_custom_or_file_tilt_order = parse_tilt_order_and_dose(
folder, False, False, use_tilt_order_files, custom_tilt_order,
total_tilts, tilt_scheme, min_angle, angle_step, starting_tilt_angle,
tomo_name, None, None, write_tilt_order_files,
dose_symmetric_group_size, dose_symmetric_groups_not_centered)
if not used_custom_or_file_tilt_order:
tilt_list = [
min_angle + (angle_step * i) for i in range(0, total_tilts)
]
else:
print(
'No tilt angle information available for the tilt angle star from %s.'
% tomo_name)
tilt_list = [None] * total_tilts
md = MetaData()
for i, (order, tilt) in enumerate(zip(order_list, tilt_list)):
file = file_list[order - 1]
p = Item()
p.rlnMicrographName = file
p.rlnMicrographId = mic_id
## extra labels
p.rlnTiltAngle = tilt
p.rlnTiltNumber = i + 1
p.rlnTomoName = tomo_name
mic_id += 1
md.addItem(p)
return md, mic_id
def create_star(subparticles, star_filename):
""" Create a Relion style STAR file for extracting (using relion_preprocess)
all the subparticles for a given particle. """
md = MetaData()
md.addLabels("rlnCoordinateX", "rlnCoordinateY")
md.addData(subparticles)
md.write(star_filename)
def main(self):
self.define_parser()
args = self.parser.parse_args()
if len(sys.argv) == 1:
self.error("No input particles STAR file given.")
print "Creating coordinate files..."
md = MetaData(args.input_star)
for particle in md:
coordinates_file = os.path.splitext(
particle.rlnMicrographName)[0] + "_" + args.suffix + ".star"
if "rlnOriginX" in md.getLabels():
particle.rlnCoordinateX = int(particle.rlnCoordinateX -
particle.rlnOriginX)
if "rlnOriginY" in md.getLabels():
particle.rlnCoordinateY = int(particle.rlnCoordinateY -
particle.rlnOriginY)
if not os.path.isfile(coordinates_file):
star = open(coordinates_file, "a")
star.write("\n")
star.write("data_images\n")
star.write("\n")
star.write("loop_\n")
star.write("_rlnMicrographName #1\n")
star.write("_rlnCoordinateX #2\n")
star.write("_rlnCoordinateY #3\n")
if "rlnAnglePsi" in md.getLabels():
star.write("_rlnAnglePsi #4\n")
if "rlnAnglePsiPrior" in md.getLabels():
star.write("_rlnAnglePsiPrior #5\n")
star.close()
if os.path.isfile(coordinates_file):
star = open(coordinates_file, "a")
star.write("%s\t%f\t%f\t" %
(os.path.basename(particle.rlnMicrographName),
particle.rlnCoordinateX, particle.rlnCoordinateY))
if "rlnAnglePsi" in md.getLabels():
star.write("%f\t" % (particle.rlnAnglePsi))
if "rlnAnglePsiPrior" in md.getLabels():
star.write("%f\t" % (particle.rlnAnglePsiPrior))
star.write("\n")
star.close()
def test_particles():
# We can also read particles star files
md = MetaData("particles.star")
# For example, we could remove particles meeting some criteria
good = [particle for particle in md
if float(particle.rlnParticleSelectZScore) > 0.5]
# There are some Relion star labels that are read as string
# so we need to care to convert them to the proper Python data type
md.setData(good)
print md.size() # should be 36 for the provided star file
md.write('particles_good.star')
def test_ctf():
# Copy all the values from the micrograph star file to particles
input_filename = "particles.star"
ctf_filename = "micrographs.star"
inputMd = MetaData(input_filename)
ctfMd = MetaData(ctf_filename)
# Add labels from CTF star
ctfLabels = ctfMd.getLabels()
inputMd.addLabels(ctfLabels)
# Index micrographs by name in a dictionary to retrieve from particles
micDict = {}
for mic in ctfMd:
micDict[mic.rlnMicrographName] = mic
for particle in inputMd:
mic = micDict[particle.rlnMicrographName]
particle.copyValues(mic, *ctfLabels)
inputMd.write('particles_ctf.star')
def main(self):
self.define_parser()
args = self.parser.parse_args()
self.validate(args)
print "Creating symmetry related particles..."
md = MetaData(args.input_star)
mdOut = MetaData()
mdOut.addLabels(md.getLabels())
new_particles = []
symmetry_matrices = matrix_from_symmetry(args.sym)
for particle in md:
angles_to_radians(particle)
new_particles.extend(create_symmetry_related_particles(particle, symmetry_matrices, args.random))
mdOut.addData(new_particles)
mdOut.write(args.output)
print "All done!"
print " "
def main(imod_edf_files, ctf_star, version, average_by_angle):
edf_list = sorted(glob.glob(imod_edf_files))
edf_folders = [os.path.dirname(i) for i in edf_list]
edf_folders = ['.'] if edf_folders == [''] else edf_folders
edf_names = [os.path.splitext(os.path.basename(i))[0] for i in edf_list]
ctf_md = MetaData(ctf_star)
md_dict = split_by_folder(ctf_md)
if average_by_angle != None:
md_dict = average_defocus_outside_angle(md_dict, edf_folders, edf_names, average_by_angle, do_average_phase_shift)
for edf_folder, edf_name in zip(edf_folders,edf_names):
try:
md = md_dict[edf_folder]
except:
print('imod folder "%s" not found in the star file.' % edf_folder)
continue
if version == '2' or version == '3':
write_imod_defocus_file(md, edf_folder, edf_name, int(version))
elif version == 'novactf':
write_nova_ctf_defocus(md, edf_folder, edf_name, novactf_append)
elif version == 'star':
write_separate_stars(md, edf_folder, edf_name, star_append)
def split_particle_stacks(extract_from_micrographs, inputStar, inputStack, output, filename_prefix, deleteStack):
""" Read a STAR file with particles and write as individual images.
If a stack of images is given, use these instead of the images from the STAR file.
Also write a new STAR file pointing to these images.
This function requires that the script is run within Scipion Python environment. """
md = MetaData(inputStar)
md.addLabels('rlnOriginalName')
# Initialize progress bar
progressbar = ProgressBar(width=60, total=len(md))
for i, particle in enumerate(md, start=1):
outputImageName = '%s/%s_%06d.mrc' % (output, filename_prefix, i)
# split stacks only if not extracting directly from micrographs
if not extract_from_micrographs:
if inputStack:
splitMrcStack('%06d@%s' %(i, inputStack), outputImageName)
particle.rlnOriginalName = '%s/%06d@%s' %(output, i, inputStack)
else:
splitMrcStack(particle.rlnImageName, outputImageName)
particle.rlnOriginalName = particle.rlnImageName
particle.rlnImageName = outputImageName
particle.rlnMicrographName = outputImageName
else:
particle.rlnOriginalName = particle.rlnImageName
particle.rlnImageName = '%s/%s' % (output, particle.rlnMicrographName.split('/').pop())
progressbar.notify()
print("\n")
md.write("%s/%s.star" % (output, filename_prefix))
if inputStack and deleteStack:
cleanPath(inputStack)
def test_micrographs():
# Create a new metadata and read micrograph star file
md = MetaData("micrographs.star")
# Just print its content
md.printStar()
# We can query the number of rows (micrographs in this case) in the metadata
print md.size() # should be 15 for the provided micrographs.star file
# We can checkout the columns (or labels) of the star file
print md.getLabels()
# We can remove the CTF related columns and write a new star file
md.removeLabels('rlnDefocusU', 'rlnDefocusV', 'rlnDefocusAngle')
# We can fill a column value with a constant
# (if the column does not exists, it will be added)
md.setLabels(rlnCtfFigureOfMerit=0, rlnDetectorPixelSize=7,
rlnRandomSubset=999)
# Finally let's write our new micrographs star file
md.write('micrograhs_noctf.star')
def main(self):
self.define_parser()
args = self.parser.parse_args()
#self.validate(args)
md = MetaData(args.input_star)
mdOut = MetaData()
mdOut.addLabels(md.getLabels())
cl = MetaData(args.classes)
particle_halfsize = args.size / 2
particles_out = []
for reference in cl:
self.angles_to_radians(reference, cl.getLabels())
for i, particle in enumerate(md):
self.angles_to_radians(particle, md.getLabels())
print "doing particle %s" % i
referenceOriginX = 0
referenceOriginY = 0
# search for the right reference for this particle
for reference in cl:
if reference.rlnClassNumber == particle.rlnClassNumber:
referenceOriginX = reference.rlnCoordinateX - particle_halfsize
referenceOriginY = reference.rlnCoordinateY - particle_halfsize
psi = particle.rlnAnglePsi
particle.rlnOriginX = particle.rlnOriginX - (
referenceOriginX * math.cos(-psi) -
referenceOriginY * math.sin(-psi))
particle.rlnOriginY = particle.rlnOriginY - (
referenceOriginY * math.cos(-psi) +
referenceOriginX * math.sin(-psi))
if "rlnAngleRot" in cl.getLabels():
particle.rlnAngleRot = particle.rlnAngleRot + reference.rlnAngleRot
if "rlnAngleTilt" in cl.getLabels():
particle.rlnAngleTilt = particle.rlnAngleTilt + reference.rlnAngleTilt
if "rlnAnglePsi" in cl.getLabels():
particle.rlnAnglePsi = particle.rlnAnglePsi + reference.rlnAnglePsi
particles_out.append(particle)
break
self.angles_to_degrees(particle, md)
mdOut.addData(particles_out)
mdOut.write(args.output)
def split_star_to_random_subsets(inputStarRoot):
inputStarName = inputStarRoot+'.star'
md = MetaData(inputStarName)
mdHalf1 = MetaData()
mdHalf2 = MetaData()
half1StarRoot = inputStarRoot+'_half1'
half2StarRoot = inputStarRoot+'_half2'
half1StarName = half1StarRoot+'.star'
half2StarName = half2StarRoot+'.star'
particlesHalf1 = []
particlesHalf2 = []
for particle in md:
if particle.rlnRandomSubset % 2 == 1:
particlesHalf1.append(particle.clone())
if particle.rlnRandomSubset % 2 == 0:
particlesHalf2.append(particle.clone())
mdHalf1.addData(particlesHalf1)
mdHalf2.addData(particlesHalf2)
labels = md.getLabels()
mdHalf1.addLabels(labels)
mdHalf2.addLabels(labels)
mdHalf1.write(half1StarName)
mdHalf2.write(half2StarName)
return half1StarRoot, half2StarRoot
def main(self):
self.define_parser()
args = self.parser.parse_args()
# Validate input arguments and required software
self.validate(args)
run_command("mkdir -p " + args.output, "/dev/null")
if args.prepare_particles:
print "Preparing particles for extracting subparticles."
create_initial_stacks(args.input_star, args.angpix, args.masked_map, args.output)
print "\nFinished preparing the particles!\n"
if args.create_subparticles:
# Load subparticle vectors either from Chimera CMM file or from
# command line (command and semi-colon separated)
# Distances can also be specified to modify vector lengths
subparticle_vector_list = load_vectors(args.cmm, args.vector,
args.length, args.angpix)
particles_star = args.output + "/particles.star"
if not os.path.exists(args.output + "/particles.star"):
self.error("Input file '%s not found. "
"Run the script first with --prepare_particles option."
% particles_star)
md = MetaData(particles_star)
print "Creating subparticles..."
# Initialize progress bar
progressbar = ProgressBar(width=60, total=len(md))
# Generate symmetry matrices with Relion convention
symmetry_matrices = matrix_from_symmetry(args.sym)
# Define some conditions to filter subparticles
filters = load_filters(radians(args.side), radians(args.top), args.mindist)
# Compute all subparticles (included subtracted if masked_map given)
mdOut = MetaData()
mdOutSub = MetaData()
for particle in md:
subparticles, subtracted = create_subparticles(particle,
symmetry_matrices,
subparticle_vector_list,
args.particle_size,
args.randomize,
args.output,
args.unique,
len(mdOut),
args.align_subparticles,
args.masked_map,
True,
filters,
args.angpix)
mdOut.addData(subparticles)
mdOutSub.addData(subtracted)
progressbar.notify()
md.removeLabels('rlnOriginZ', 'rlnOriginalName')
write_output_starfiles(md.getLabels(), mdOut, mdOutSub, args.output)
print "\nFinished creating the subparticles!\n"
if args.extract_subparticles:
print "Extracting subparticles..."
extract_subparticles(args.subparticle_size, args.np, args.masked_map, args.output, deleteParticles=True)
print "\nFinished extracting the subparticles!\n"
if args.reconstruct_subparticles:
print "Reconstructing subparticles..."
reconstruct_subparticles(args.j, args.output, args.maxres, args.subsym, args.angpix)
print "\nFinished reconstructing the subparticles!\n"
print "\nAll done!\n"
def main(self):
self.define_parser()
args = self.parser.parse_args()
self.validate(args)
print "Creating rotated particles..."
md = MetaData(args.input_star)
if args.vector and len(args.angles) != 0:
print "Please only provide a vector or a triplet of Euler angles for the particle rotation."
sys.exit(0)
elif args.vector:
vectors = load_vectors(None, args.vector, None, 1)
rot_matrix = vectors[0].matrix()
elif len(args.angles) != 0:
angles = args.angles.split(',')
if len(angles) != 3:
print "Please provide exactly 3 Euler angles for the particle rotation."
sys.exit(0)
else:
rot_rot = math.radians(float(angles[0]))
rot_tilt = math.radians(float(angles[1]))
rot_psi = math.radians(float(angles[2]))
rot_matrix = matrix_from_euler(rot_rot, rot_tilt, rot_psi)
else:
print "Please provide a vector or a triplet of Euler angles for the particle rotation."
sys.exit(0)
new_particles = []
mdOut = MetaData()
mdOut.addLabels(md.getLabels())
for particle in md:
new_particle = particle.clone()
angles_to_radians(particle)
rot = particle.rlnAngleRot
tilt = particle.rlnAngleTilt
psi = particle.rlnAnglePsi
matrix_particle = matrix_from_euler(rot, tilt, psi)
m = matrix_multiply(matrix_particle, matrix_transpose(rot_matrix))
rotNew, tiltNew, psiNew = euler_from_matrix(m)
new_particle.rlnAngleRot = rotNew
new_particle.rlnAngleTilt = tiltNew
new_particle.rlnAnglePsi = psiNew
angles_to_degrees(new_particle)
new_particles.append(new_particle)
mdOut.addData(new_particles)
mdOut.write(args.output)
print "All done!"
print " "
def main(self):
self.define_parser()
args = self.parser.parse_args()
self.validate(args)
print "Calculating symmetry related orientations..."
md = MetaData(args.input_star)
mdOut = MetaData()
mdOut.addLabels(md.getLabels())
mdOut.addLabels('rlnAngleRotPrior', 'rlnAngleTiltPrior',
'rlnAnglePsiPrior')
mdOut.removeLabels('rlnOriginalParticleName', 'rlnParticleName')
new_particles = []
symmetry_matrices = matrix_from_symmetry(args.sym)
for particle in md:
angles_to_radians(particle)
new_particles.extend(
create_symmetry_related_particles(particle, symmetry_matrices,
True))
mdOut.addData(new_particles)
for particle in mdOut:
particle.rlnAngleRotPrior = particle.rlnAngleRot
particle.rlnAngleTiltPrior = particle.rlnAngleTilt
particle.rlnAnglePsiPrior = particle.rlnAnglePsi
mdOut.write(args.output)
print "Calculating an asymmetric reconstruction..."
runProgram(
'relion_reconstruct',
'--i %s --o %s --ctf --sym C1 --angpix %s --maxres %s --j %s' %
(args.output, args.map, args.angpix, args.maxres, args.j))
print " "
print "All done!"
print " "
def split_by_folder(md):
current_dir = os.path.dirname(md._data[0].rlnMicrographName) if os.path.dirname(md._data[0].rlnMicrographName) != "" else '.'
temp_md = MetaData()
md_dict = {}
for p in md:
folder = os.path.dirname(p.rlnMicrographName) if os.path.dirname(p.rlnMicrographName) != "" else '.'
if folder == current_dir:
temp_md.addItem(p)
else:
temp_md.addLabels(md.getLabels())
md_dict[current_dir] = temp_md
current_dir = folder
temp_md = MetaData()
temp_md.addItem(p)
temp_md.addLabels(md.getLabels())
md_dict[current_dir] = temp_md
return md_dict
def average_defocus_outside_angle(md_dict, edf_folders, edf_names, angle, do_average_phase_shift):
corrected_md_dict = {}
corrected_md = MetaData()
labels = md_dict[edf_folders[0]].getLabels()
do_average_phase_shift = False if 'rlnPhaseShift' not in labels else do_average_phase_shift
corrected_md.addLabels(labels)
for edf_folder, edf_name in zip(edf_folders,edf_names):
try:
md = md_dict[edf_folder]
except:
print('imod folder "%s" not found in the star file.' % edf_folder)
continue
imod_file_root = get_imod_file_root(edf_name, edf_folder)
if use_estimated_tilt_angles:
tlt_file_name = '%s.tlt' % (imod_file_root)
else:
tlt_file_name = '%s.rawtlt' % (imod_file_root)
if not os.path.isfile(tlt_file_name):
print('Cannot find "%s". Make sure the tilt series has been aligned before executing this script!' % tlt_file_name)
return
tilt_list = read_tilt_angles(tlt_file_name)
average_list = []
average_md = MetaData()
apply_list = []
for i,(tilt,p) in enumerate(zip(tilt_list, md)):
if abs(tilt) <= abs(angle):
average_list.append(i)
average_md.addItem(p)
else:
apply_list.append(i)
if len(average_list) == 0: #check that averaging is possible
print('No tilt angles found with the range specified for %s' % edf_name)
corrected_md_dict[edf_folder] = md
corrected_md.addData(md)
continue
if len(apply_list) == 0:
print('No tilt angles found outside the range specified to apply defocus to for %s' % edf_name)
corrected_md_dict[edf_folder] = md
corrected_md.addData(md)
continue
#caluclate the average
average = sum([(p.rlnDefocusU+p.rlnDefocusV)/2 for p in average_md])/len(average_list)
if do_average_phase_shift:
phase_average = sum([float(p.rlnPhaseShift) for p in average_md])/len(average_list)
print('Taking the average defocus of tilts %d to %d (%f angstrom) and applying it to the following tilts for %s; %s' % (min(average_list)+1, max(average_list)+1, average, edf_name, ', '.join([str(apply+1) for apply in apply_list])))
if do_average_phase_shift:
print('Also applying the average phase shift (%f degrees) to those tilts' % (phase_average))
for i,p in enumerate(md):
if i in apply_list:
p.rlnDefocusU = average
p.rlnDefocusV = average
p.rlnDefocusAngle = 0
if do_average_phase_shift:
p.rlnPhaseShift = phase_average
corrected_md_dict[edf_folder] = md
corrected_md.addData(md)
if write_averaged_defocus_star:
print('Writing out star file with averaged defocus values to %s' % averaged_defocus_star_file)
corrected_md.write(averaged_defocus_star_file)
return corrected_md_dict
def main(self):
self.define_parser()
args = self.parser.parse_args()
# Validate input arguments and required software
self.validate(args)
try:
os.makedirs(args.output)
except OSError:
if not os.path.isdir(args.output):
raise
if args.prepare_particles:
print("Preparing particles for extracting subparticles.")
create_initial_stacks(args.input_star, args.angpix,
args.masked_map, args.output,
args.extract_from_micrographs,
args.library_path)
print("\nFinished preparing the particles!\n")
if args.create_subparticles:
# Load subparticle vectors either from Chimera CMM file or from
# command line (command and semi-colon separated)
# Distances can also be specified to modify vector lengths
subparticle_vector_list = load_vectors(args.cmm, args.vector,
args.length, args.angpix)
particles_star = args.output + "/particles.star"
if not os.path.exists(args.output + "/particles.star"):
self.error(
"Input file '%s not found. "
"Run the script first with --prepare_particles option." %
particles_star)
md = MetaData(particles_star)
# Get particle / micrograph size
if args.extract_from_micrographs:
mrcFilename = md._data[0].rlnMicrographName
print("Micrograph image size:")
else:
mrcFilename = md._data[0].rlnImageName
print("Particle image size:")
mrcFile = open(mrcFilename, "rb")
particleImageSizeX = int(struct.unpack('i', mrcFile.read(4))[0])
particleImageSizeY = int(struct.unpack('i', mrcFile.read(4))[0])
mrcFile.close()
print("%s, %s pixels\n" % (particleImageSizeX, particleImageSizeY))
print("Creating subparticles...")
# Generate symmetry matrices with Relion convention
symmetry_matrices = matrix_from_symmetry(args.sym,
args.library_path)
# Initialize progress bar
progressbar = ProgressBar(width=60, total=len(md))
# Define some conditions to filter subparticles
filters = load_filters(radians(args.side), radians(args.top),
args.mindist)
# Compute all subparticles (included subtracted if masked_map given)
mdOut = MetaData()
mdOutSub = MetaData()
for particle in md:
subparticles, subtracted = create_subparticles(
particle, symmetry_matrices, subparticle_vector_list,
particleImageSizeX, particleImageSizeY, args.randomize,
args.output, args.unique, len(mdOut),
args.align_subparticles, args.masked_map,
args.extract_from_micrographs, True, filters, args.angpix)
mdOut.addData(subparticles)
mdOutSub.addData(subtracted)
progressbar.notify()
md.removeLabels('rlnOriginZ', 'rlnOriginalName')
write_output_starfiles(md.getLabels(), mdOut, mdOutSub,
args.output)
if args.extract_from_micrographs:
md.setData(unique_micrographs(md))
md.write("%s/%s.star" % (args.output, 'micrographs'))
if len(mdOutSub):
mdOutSub.setData(unique_micrographs(mdOutSub))
mdOutSub.write("%s/%s.star" %
(args.output, 'micrographs_subtracted'))
print("\nFinished creating the subparticles!\n")
if args.extract_subparticles:
print("Extracting subparticles...")
if args.extract_from_micrographs:
if not args.create_subparticles:
md = MetaData(args.output + "/particles.star")
extract_subparticles(
args.subparticle_size, args.np, args.masked_map,
args.output, args.library_path,
args.only_extract_unfinished, args.invert_contrast,
args.normalize, False,
md._data[0].rlnMicrographName.split('/').pop(0))
else:
extract_subparticles(args.subparticle_size, args.np,
args.masked_map, args.output,
args.library_path,
args.only_extract_unfinished,
args.invert_contrast, args.normalize,
True, args.output)
print("\nFinished extracting the subparticles!\n")
if args.reconstruct_subparticles:
print("Reconstructing subparticles...")
reconstruct_subparticles(args.j, args.output, args.maxres,
args.subsym, args.angpix, args.do_halves,
args.library_path)
print("\nFinished reconstructing the subparticles!\n")
print("\nAll done!\n")
def main(input_files, input_folders, mic_star, tomo_name, tilt_scheme,
min_angle, angle_step, pixel_size, only_make_sorted_mic_star,
only_do_unfinished, use_tilt_order_files, custom_tilt_order,
write_tilt_order_files, starting_tilt_angle, only_print_command,
rln_version, ctf_software, CS, HT, AmpCnst, Box, ResMin, ResMax,
dFMin, dFMax, FStep, dAst, ctfWin, cores, gpu, ctf_exe, ctf_star,
write_tilt_angle_star, do_phaseshift, phase_min, phase_max,
phase_step, dose_symmetric_group_size,
dose_symmetric_groups_not_centered):
if mic_star == None:
if input_folders != None:
folder_list = sorted(glob.glob(input_folders))
folder_list = [dir for dir in folder_list if os.path.isdir(dir)]
else:
folder = '/'.join(input_files.split('/')[0:-1])
folder_list = ['.'] if folder == '' else [folder]
input_files = input_files.split('/')[-1]
mic_md = MetaData()
mic_id = 1
for folder in folder_list:
if input_folders != None:
tomo_name = folder.split('/')[-1]
#Main script for individual tilt series
tomo_mic_md, mic_id = write_sorted_mic_star(
folder, input_files, use_tilt_order_files, custom_tilt_order,
tilt_scheme, min_angle, angle_step, starting_tilt_angle,
tomo_name, write_tilt_order_files, mic_id,
dose_symmetric_group_size, dose_symmetric_groups_not_centered)
mic_md.addData(tomo_mic_md)
mic_md.addLabels(['rlnMicrographName'])
mic_md.write(default_micrograph_star_file)
if write_tilt_angle_star:
mic_md.addLabels('rlnMicrographId', 'rlnTiltNumber',
'rlnTiltAngle', 'rlnTomoName')
mic_md.write(default_tilt_angle_star_file)
mic_star = default_micrograph_star_file
if only_make_sorted_mic_star == True:
print('Only making sorted micrograph star... quitting.')
return
run_ctffind(mic_star, ctf_star, pixel_size, ctfWin, CS, HT, AmpCnst, Box,
ResMin, ResMax, dFMin, dFMax, FStep, dAst, ctf_exe, cores,
only_print_command, rln_version, ctf_software, gpu,
only_do_unfinished, do_phaseshift, phase_min, phase_max,
phase_step)
print("")
print(
"You can inspect the ctf estimation quality by running 'relion_display' on the resulting star file with the '--display rlnCtfImage option'"
)
print(
"Once you have aligned the tilt series in imod, use the 'tomo_write_imod_defocus' script to write the estimated ctf parameters into imod compatible .defocus files."
)
def main(self):
self.define_parser()
args = self.parser.parse_args()
self.validate(args)
print "Creating symmetry related particles..."
md = MetaData(args.input_star)
mdOut = MetaData()
mdOut.addLabels(md.getLabels())
new_particles = []
symmetry_matrices = matrix_from_symmetry(args.sym)
for particle in md:
angles_to_radians(particle)
new_particles.extend(
create_symmetry_related_particles(particle, symmetry_matrices,
args.random))
mdOut.addData(new_particles)
mdOut.write(args.output)
print "All done!"
print " "
def main(self):
self.define_parser()
args = self.parser.parse_args()
self.validate(args)
print "Remove overlapping particles..."
md = MetaData(args.input_star)
mdOut = MetaData()
mdOut.addLabels(md.getLabels())
new_particles = []
# get list of tags 'micrographs' but can be anything that defines
# a set of particles to compare
if args.originalParticles:
micrographs = self.get_originalParticleNames(md)
else:
micrographs = self.get_micrographs(md)
for micrograph in micrographs:
print "Processing micrograph %s..." % micrograph,
particles = self.get_particles(md, micrograph)
particles_unique = self.remove_overlapping_particles(particles, args.mindist)
new_particles.extend(particles_unique)
print "%s particle(s) kept." % len(particles_unique)
mdOut.addData(new_particles)
mdOut.write(args.output)
print "All done!"
def split_star_to_random_subsets(inputStarRoot):
inputStarName = inputStarRoot+'.star'
md = MetaData(inputStarName)
mdHalf1 = MetaData()
mdHalf2 = MetaData()
half1StarRoot = inputStarRoot+'_half1'
half2StarRoot = inputStarRoot+'_half2'
half1StarName = half1StarRoot+'.star'
half2StarName = half2StarRoot+'.star'
particlesHalf1 = []
particlesHalf2 = []
for particle in md:
if particle.rlnRandomSubset % 2 == 1:
particlesHalf1.append(particle.clone())
if particle.rlnRandomSubset % 2 == 0:
particlesHalf2.append(particle.clone())
mdHalf1.addData(particlesHalf1)
mdHalf2.addData(particlesHalf2)
labels = md.getLabels()
mdHalf1.addLabels(labels)
mdHalf2.addLabels(labels)
mdHalf1.write(half1StarName)
mdHalf2.write(half2StarName)
return half1StarRoot, half2StarRoot