def recons3d_trl_struct_MPI(
myid,
main_node,
prjlist,
paramstructure,
refang,
rshifts_shrank,
delta,
upweighted=True,
mpi_comm=None,
CTF=True,
target_size=-1,
avgnorm=1.0,
norm_per_particle=None,
):
"""
recons3d_4nn_ctf - calculate CTF-corrected 3-D reconstruction from a set of projections using three Eulerian angles, two shifts, and CTF settings for each projeciton image
Input
list_of_prjlist: list of lists of projections to be included in the reconstruction
"""
if mpi_comm == None:
mpi_comm = mpi.MPI_COMM_WORLD
refvol = sp_utilities.model_blank(target_size)
refvol.set_attr("fudge", 1.0)
if CTF:
do_ctf = 1
else:
do_ctf = 0
fftvol = EMAN2_cppwrap.EMData()
weight = EMAN2_cppwrap.EMData()
params = {
"size": target_size,
"npad": 2,
"snr": 1.0,
"sign": 1,
"symmetry": "c1",
"refvol": refvol,
"fftvol": fftvol,
"weight": weight,
"do_ctf": do_ctf,
}
r = EMAN2_cppwrap.Reconstructors.get("nn4_ctfw", params)
r.setup()
if prjlist:
if norm_per_particle == None:
norm_per_particle = len(prjlist) * [1.0]
nnx = prjlist[0].get_xsize()
nny = prjlist[0].get_ysize()
nshifts = len(rshifts_shrank)
for im in range(len(prjlist)):
# parse projection structure, generate three lists:
# [ipsi+iang], [ishift], [probability]
# Number of orientations for a given image
numbor = len(paramstructure[im][2])
ipsiandiang = [
old_div(paramstructure[im][2][i][0], 1000)
for i in range(numbor)
]
allshifts = [
paramstructure[im][2][i][0] % 1000 for i in range(numbor)
]
probs = [paramstructure[im][2][i][1] for i in range(numbor)]
# Find unique projection directions
tdir = list(set(ipsiandiang))
bckgn = prjlist[im].get_attr("bckgnoise")
ct = prjlist[im].get_attr("ctf")
# For each unique projection direction:
data = [None] * nshifts
for ii in range(len(tdir)):
# Find the number of times given projection direction appears on the list, it is the number of different shifts associated with it.
lshifts = sp_utilities.findall(tdir[ii], ipsiandiang)
toprab = 0.0
for ki in range(len(lshifts)):
toprab += probs[lshifts[ki]]
recdata = EMAN2_cppwrap.EMData(nny, nny, 1, False)
recdata.set_attr("is_complex", 0)
for ki in range(len(lshifts)):
lpt = allshifts[lshifts[ki]]
if data[lpt] == None:
data[lpt] = sp_fundamentals.fshift(
prjlist[im], rshifts_shrank[lpt][0],
rshifts_shrank[lpt][1])
data[lpt].set_attr("is_complex", 0)
EMAN2_cppwrap.Util.add_img(
recdata,
EMAN2_cppwrap.Util.mult_scalar(
data[lpt], old_div(probs[lshifts[ki]], toprab)),
)
recdata.set_attr_dict({
"padffted": 1,
"is_fftpad": 1,
"is_fftodd": 0,
"is_complex_ri": 1,
"is_complex": 1,
})
if not upweighted:
recdata = sp_filter.filt_table(recdata, bckgn)
recdata.set_attr_dict({"bckgnoise": bckgn, "ctf": ct})
ipsi = tdir[ii] % 100000
iang = old_div(tdir[ii], 100000)
r.insert_slice(
recdata,
EMAN2_cppwrap.Transform({
"type":
"spider",
"phi":
refang[iang][0],
"theta":
refang[iang][1],
"psi":
refang[iang][2] + ipsi * delta,
}),
old_div(toprab * avgnorm, norm_per_particle[im]),
)
# clean stuff
del bckgn, recdata, tdir, ipsiandiang, allshifts, probs
sp_utilities.reduce_EMData_to_root(fftvol, myid, main_node, comm=mpi_comm)
sp_utilities.reduce_EMData_to_root(weight, myid, main_node, comm=mpi_comm)
if myid == main_node:
dummy = r.finish(True)
mpi.mpi_barrier(mpi_comm)
if myid == main_node:
return fftvol, weight, refvol
else:
return None, None, None
def helicalshiftali_MPI(stack,
maskfile=None,
maxit=100,
CTF=False,
snr=1.0,
Fourvar=False,
search_rng=-1):
nproc = mpi.mpi_comm_size(mpi.MPI_COMM_WORLD)
myid = mpi.mpi_comm_rank(mpi.MPI_COMM_WORLD)
main_node = 0
ftp = file_type(stack)
if myid == main_node:
print_begin_msg("helical-shiftali_MPI")
max_iter = int(maxit)
if (myid == main_node):
infils = EMUtil.get_all_attributes(stack, "filament")
ptlcoords = EMUtil.get_all_attributes(stack, 'ptcl_source_coord')
filaments = ordersegments(infils, ptlcoords)
total_nfils = len(filaments)
inidl = [0] * total_nfils
for i in range(total_nfils):
inidl[i] = len(filaments[i])
linidl = sum(inidl)
nima = linidl
tfilaments = []
for i in range(total_nfils):
tfilaments += filaments[i]
del filaments
else:
total_nfils = 0
linidl = 0
total_nfils = bcast_number_to_all(total_nfils, source_node=main_node)
if myid != main_node:
inidl = [-1] * total_nfils
inidl = bcast_list_to_all(inidl, myid, source_node=main_node)
linidl = bcast_number_to_all(linidl, source_node=main_node)
if myid != main_node:
tfilaments = [-1] * linidl
tfilaments = bcast_list_to_all(tfilaments, myid, source_node=main_node)
filaments = []
iendi = 0
for i in range(total_nfils):
isti = iendi
iendi = isti + inidl[i]
filaments.append(tfilaments[isti:iendi])
del tfilaments, inidl
if myid == main_node:
print_msg("total number of filaments: %d" % total_nfils)
if total_nfils < nproc:
ERROR(
'number of CPUs (%i) is larger than the number of filaments (%i), please reduce the number of CPUs used'
% (nproc, total_nfils),
myid=myid)
# balanced load
temp = chunks_distribution([[len(filaments[i]), i]
for i in range(len(filaments))],
nproc)[myid:myid + 1][0]
filaments = [filaments[temp[i][1]] for i in range(len(temp))]
nfils = len(filaments)
#filaments = [[0,1]]
#print "filaments",filaments
list_of_particles = []
indcs = []
k = 0
for i in range(nfils):
list_of_particles += filaments[i]
k1 = k + len(filaments[i])
indcs.append([k, k1])
k = k1
data = EMData.read_images(stack, list_of_particles)
ldata = len(data)
sxprint("ldata=", ldata)
nx = data[0].get_xsize()
ny = data[0].get_ysize()
if maskfile == None:
mrad = min(nx, ny) // 2 - 2
mask = pad(model_blank(2 * mrad + 1, ny, 1, 1.0), nx, ny, 1, 0.0)
else:
mask = get_im(maskfile)
# apply initial xform.align2d parameters stored in header
init_params = []
for im in range(ldata):
t = data[im].get_attr('xform.align2d')
init_params.append(t)
p = t.get_params("2d")
data[im] = rot_shift2D(data[im], p['alpha'], p['tx'], p['ty'],
p['mirror'], p['scale'])
if CTF:
from sp_filter import filt_ctf
from sp_morphology import ctf_img
ctf_abs_sum = EMData(nx, ny, 1, False)
ctf_2_sum = EMData(nx, ny, 1, False)
else:
ctf_2_sum = None
ctf_abs_sum = None
from sp_utilities import info
for im in range(ldata):
data[im].set_attr('ID', list_of_particles[im])
st = Util.infomask(data[im], mask, False)
data[im] -= st[0]
if CTF:
ctf_params = data[im].get_attr("ctf")
qctf = data[im].get_attr("ctf_applied")
if qctf == 0:
data[im] = filt_ctf(fft(data[im]), ctf_params)
data[im].set_attr('ctf_applied', 1)
elif qctf != 1:
ERROR('Incorrectly set qctf flag', myid=myid)
ctfimg = ctf_img(nx, ctf_params, ny=ny)
Util.add_img2(ctf_2_sum, ctfimg)
Util.add_img_abs(ctf_abs_sum, ctfimg)
else:
data[im] = fft(data[im])
del list_of_particles
if CTF:
reduce_EMData_to_root(ctf_2_sum, myid, main_node)
reduce_EMData_to_root(ctf_abs_sum, myid, main_node)
if CTF:
if myid != main_node:
del ctf_2_sum
del ctf_abs_sum
else:
temp = EMData(nx, ny, 1, False)
tsnr = 1. / snr
for i in range(0, nx + 2, 2):
for j in range(ny):
temp.set_value_at(i, j, tsnr)
temp.set_value_at(i + 1, j, 0.0)
#info(ctf_2_sum)
Util.add_img(ctf_2_sum, temp)
#info(ctf_2_sum)
del temp
total_iter = 0
shift_x = [0.0] * ldata
for Iter in range(max_iter):
if myid == main_node:
start_time = time()
print_msg("Iteration #%4d\n" % (total_iter))
total_iter += 1
avg = EMData(nx, ny, 1, False)
for im in range(ldata):
Util.add_img(avg, fshift(data[im], shift_x[im]))
reduce_EMData_to_root(avg, myid, main_node)
if myid == main_node:
if CTF: tavg = Util.divn_filter(avg, ctf_2_sum)
else: tavg = Util.mult_scalar(avg, 1.0 / float(nima))
else:
tavg = model_blank(nx, ny)
if Fourvar:
bcast_EMData_to_all(tavg, myid, main_node)
vav, rvar = varf2d_MPI(myid, data, tavg, mask, "a", CTF)
if myid == main_node:
if Fourvar:
tavg = fft(Util.divn_img(fft(tavg), vav))
vav_r = Util.pack_complex_to_real(vav)
# normalize and mask tavg in real space
tavg = fft(tavg)
stat = Util.infomask(tavg, mask, False)
tavg -= stat[0]
Util.mul_img(tavg, mask)
tavg.write_image("tavg.hdf", Iter)
# For testing purposes: shift tavg to some random place and see if the centering is still correct
#tavg = rot_shift3D(tavg,sx=3,sy=-4)
if Fourvar: del vav
bcast_EMData_to_all(tavg, myid, main_node)
tavg = fft(tavg)
sx_sum = 0.0
nxc = nx // 2
for ifil in range(nfils):
"""
# Calculate filament average
avg = EMData(nx, ny, 1, False)
filnima = 0
for im in xrange(indcs[ifil][0], indcs[ifil][1]):
Util.add_img(avg, data[im])
filnima += 1
tavg = Util.mult_scalar(avg, 1.0/float(filnima))
"""
# Calculate 1D ccf between each segment and filament average
nsegms = indcs[ifil][1] - indcs[ifil][0]
ctx = [None] * nsegms
pcoords = [None] * nsegms
for im in range(indcs[ifil][0], indcs[ifil][1]):
ctx[im - indcs[ifil][0]] = Util.window(ccf(tavg, data[im]), nx,
1)
pcoords[im - indcs[ifil][0]] = data[im].get_attr(
'ptcl_source_coord')
#ctx[im-indcs[ifil][0]].write_image("ctx.hdf",im-indcs[ifil][0])
#print " CTX ",myid,im,Util.infomask(ctx[im-indcs[ifil][0]], None, True)
# search for best x-shift
cents = nsegms // 2
dst = sqrt(
max((pcoords[cents][0] - pcoords[0][0])**2 +
(pcoords[cents][1] - pcoords[0][1])**2,
(pcoords[cents][0] - pcoords[-1][0])**2 +
(pcoords[cents][1] - pcoords[-1][1])**2))
maxincline = atan2(ny // 2 - 2 - float(search_rng), dst)
kang = int(dst * tan(maxincline) + 0.5)
#print " settings ",nsegms,cents,dst,search_rng,maxincline,kang
# ## C code for alignment. @ming
results = [0.0] * 3
results = Util.helixshiftali(ctx, pcoords, nsegms, maxincline,
kang, search_rng, nxc)
sib = int(results[0])
bang = results[1]
qm = results[2]
#print qm, sib, bang
# qm = -1.e23
#
# for six in xrange(-search_rng, search_rng+1,1):
# q0 = ctx[cents].get_value_at(six+nxc)
# for incline in xrange(kang+1):
# qt = q0
# qu = q0
# if(kang>0): tang = tan(maxincline/kang*incline)
# else: tang = 0.0
# for kim in xrange(cents+1,nsegms):
# dst = sqrt((pcoords[cents][0] - pcoords[kim][0])**2 + (pcoords[cents][1] - pcoords[kim][1])**2)
# xl = dst*tang+six+nxc
# ixl = int(xl)
# dxl = xl - ixl
# #print " A ", ifil,six,incline,kim,xl,ixl,dxl
# qt += (1.0-dxl)*ctx[kim].get_value_at(ixl) + dxl*ctx[kim].get_value_at(ixl+1)
# xl = -dst*tang+six+nxc
# ixl = int(xl)
# dxl = xl - ixl
# qu += (1.0-dxl)*ctx[kim].get_value_at(ixl) + dxl*ctx[kim].get_value_at(ixl+1)
# for kim in xrange(cents):
# dst = sqrt((pcoords[cents][0] - pcoords[kim][0])**2 + (pcoords[cents][1] - pcoords[kim][1])**2)
# xl = -dst*tang+six+nxc
# ixl = int(xl)
# dxl = xl - ixl
# qt += (1.0-dxl)*ctx[kim].get_value_at(ixl) + dxl*ctx[kim].get_value_at(ixl+1)
# xl = dst*tang+six+nxc
# ixl = int(xl)
# dxl = xl - ixl
# qu += (1.0-dxl)*ctx[kim].get_value_at(ixl) + dxl*ctx[kim].get_value_at(ixl+1)
# if( qt > qm ):
# qm = qt
# sib = six
# bang = tang
# if( qu > qm ):
# qm = qu
# sib = six
# bang = -tang
#if incline == 0: print "incline = 0 ",six,tang,qt,qu
#print qm,six,sib,bang
#print " got results ",indcs[ifil][0], indcs[ifil][1], ifil,myid,qm,sib,tang,bang,len(ctx),Util.infomask(ctx[0], None, True)
for im in range(indcs[ifil][0], indcs[ifil][1]):
kim = im - indcs[ifil][0]
dst = sqrt((pcoords[cents][0] - pcoords[kim][0])**2 +
(pcoords[cents][1] - pcoords[kim][1])**2)
if (kim < cents): xl = -dst * bang + sib
else: xl = dst * bang + sib
shift_x[im] = xl
# Average shift
sx_sum += shift_x[indcs[ifil][0] + cents]
# #print myid,sx_sum,total_nfils
sx_sum = mpi.mpi_reduce(sx_sum, 1, mpi.MPI_FLOAT, mpi.MPI_SUM,
main_node, mpi.MPI_COMM_WORLD)
if myid == main_node:
sx_sum = float(sx_sum[0]) / total_nfils
print_msg("Average shift %6.2f\n" % (sx_sum))
else:
sx_sum = 0.0
sx_sum = 0.0
sx_sum = bcast_number_to_all(sx_sum, source_node=main_node)
for im in range(ldata):
shift_x[im] -= sx_sum
#print " %3d %6.3f"%(im,shift_x[im])
#exit()
# combine shifts found with the original parameters
for im in range(ldata):
t1 = Transform()
##import random
##shix=random.randint(-10, 10)
##t1.set_params({"type":"2D","tx":shix})
t1.set_params({"type": "2D", "tx": shift_x[im]})
# combine t0 and t1
tt = t1 * init_params[im]
data[im].set_attr("xform.align2d", tt)
# write out headers and STOP, under MPI writing has to be done sequentially
mpi.mpi_barrier(mpi.MPI_COMM_WORLD)
par_str = ["xform.align2d", "ID"]
if myid == main_node:
from sp_utilities import file_type
if (file_type(stack) == "bdb"):
from sp_utilities import recv_attr_dict_bdb
recv_attr_dict_bdb(main_node, stack, data, par_str, 0, ldata,
nproc)
else:
from sp_utilities import recv_attr_dict
recv_attr_dict(main_node, stack, data, par_str, 0, ldata, nproc)
else:
send_attr_dict(main_node, data, par_str, 0, ldata)
if myid == main_node: print_end_msg("helical-shiftali_MPI")
def mref_ali2d(stack,
refim,
outdir,
maskfile=None,
ir=1,
ou=-1,
rs=1,
xrng=0,
yrng=0,
step=1,
center=1,
maxit=0,
CTF=False,
snr=1.0,
user_func_name="ref_ali2d",
rand_seed=1000,
MPI=False):
"""
Name
mref_ali2d - Perform 2-D multi-reference alignment of an image series
Input
stack: set of 2-D images in a stack file, images have to be squares
refim: set of initial reference 2-D images in a stack file
maskfile: optional maskfile to be used in the alignment
inner_radius: inner radius for rotational correlation > 0
outer_radius: outer radius for rotational correlation < nx/2-1
ring_step: step between rings in rotational correlation >0
x_range: range for translation search in x direction, search is +/xr
y_range: range for translation search in y direction, search is +/yr
translation_step: step of translation search in both directions
center: center the average
max_iter: maximum number of iterations the program will perform
CTF: if this flag is set, the program will use CTF information provided in file headers
snr: signal-to-noise ratio of the data
rand_seed: the seed used for generating random numbers
MPI: whether to use MPI version
Output
output_directory: directory name into which the output files will be written.
header: the alignment parameters are stored in the headers of input files as 'xform.align2d'.
"""
# 2D multi-reference alignment using rotational ccf in polar coordinates and quadratic interpolation
if MPI:
mref_ali2d_MPI(stack, refim, outdir, maskfile, ir, ou, rs, xrng, yrng,
step, center, maxit, CTF, snr, user_func_name,
rand_seed)
return
from sp_utilities import model_circle, combine_params2, inverse_transform2, drop_image, get_image
from sp_utilities import center_2D, get_im, get_params2D, set_params2D
from sp_statistics import fsc
from sp_alignment import Numrinit, ringwe, fine_2D_refinement, search_range
from sp_fundamentals import rot_shift2D, fshift
from random import seed, randint
import os
import sys
from sp_utilities import print_begin_msg, print_end_msg, print_msg
import shutil
# create the output directory, if it does not exist
if os.path.exists(outdir):
shutil.rmtree(
outdir
) #ERROR('Output directory exists, please change the name and restart the program', "mref_ali2d", 1)
os.mkdir(outdir)
import sp_global_def
sp_global_def.LOGFILE = os.path.join(outdir, sp_global_def.LOGFILE)
first_ring = int(ir)
last_ring = int(ou)
rstep = int(rs)
max_iter = int(maxit)
print_begin_msg("mref_ali2d")
print_msg("Input stack : %s\n" % (stack))
print_msg("Reference stack : %s\n" % (refim))
print_msg("Output directory : %s\n" % (outdir))
print_msg("Maskfile : %s\n" % (maskfile))
print_msg("Inner radius : %i\n" % (first_ring))
ima = EMData()
ima.read_image(stack, 0)
nx = ima.get_xsize()
# default value for the last ring
if last_ring == -1: last_ring = nx / 2 - 2
print_msg("Outer radius : %i\n" % (last_ring))
print_msg("Ring step : %i\n" % (rstep))
print_msg("X search range : %i\n" % (xrng))
print_msg("Y search range : %i\n" % (yrng))
print_msg("Translational step : %i\n" % (step))
print_msg("Center type : %i\n" % (center))
print_msg("Maximum iteration : %i\n" % (max_iter))
print_msg("CTF correction : %s\n" % (CTF))
print_msg("Signal-to-Noise Ratio : %f\n" % (snr))
print_msg("Random seed : %i\n\n" % (rand_seed))
print_msg("User function : %s\n" % (user_func_name))
output = sys.stdout
import sp_user_functions
user_func = sp_user_functions.factory[user_func_name]
if maskfile:
import types
if type(maskfile) is bytes: mask = get_image(maskfile)
else: mask = maskfile
else: mask = model_circle(last_ring, nx, nx)
# references
refi = []
numref = EMUtil.get_image_count(refim)
# IMAGES ARE SQUARES! center is in SPIDER convention
cnx = nx / 2 + 1
cny = cnx
mode = "F"
#precalculate rings
numr = Numrinit(first_ring, last_ring, rstep, mode)
wr = ringwe(numr, mode)
# reference images
params = []
#read all data
data = EMData.read_images(stack)
nima = len(data)
# prepare the reference
ima.to_zero()
for j in range(numref):
temp = EMData()
temp.read_image(refim, j)
# eve, odd, numer of even, number of images. After frc, totav
refi.append([temp, ima.copy(), 0])
seed(rand_seed)
again = True
ref_data = [mask, center, None, None]
Iter = 0
while Iter < max_iter and again:
ringref = []
#print "numref",numref
### Reference ###
mashi = cnx - last_ring - 2
for j in range(numref):
refi[j][0].process_inplace("normalize.mask", {
"mask": mask,
"no_sigma": 1
})
cimage = Util.Polar2Dm(refi[j][0], cnx, cny, numr, mode)
Util.Frngs(cimage, numr)
Util.Applyws(cimage, numr, wr)
ringref.append(cimage)
assign = [[] for i in range(numref)]
sx_sum = [0.0] * numref
sy_sum = [0.0] * numref
for im in range(nima):
alpha, sx, sy, mirror, scale = get_params2D(data[im])
# Why inverse? 07/11/2015 PAP
alphai, sxi, syi, scalei = inverse_transform2(alpha, sx, sy)
# normalize
data[im].process_inplace("normalize.mask", {
"mask": mask,
"no_sigma": 0
})
# If shifts are outside of the permissible range, reset them
if (abs(sxi) > mashi or abs(syi) > mashi):
sxi = 0.0
syi = 0.0
set_params2D(data[im], [0.0, 0.0, 0.0, 0, 1.0])
ny = nx
txrng = search_range(nx, last_ring, sxi, xrng, "mref_ali2d")
txrng = [txrng[1], txrng[0]]
tyrng = search_range(ny, last_ring, syi, yrng, "mref_ali2d")
tyrng = [tyrng[1], tyrng[0]]
# align current image to the reference
#[angt, sxst, syst, mirrort, xiref, peakt] = Util.multiref_polar_ali_2d_p(data[im],
# ringref, txrng, tyrng, step, mode, numr, cnx+sxi, cny+syi)
#print(angt, sxst, syst, mirrort, xiref, peakt)
[angt, sxst, syst, mirrort, xiref,
peakt] = Util.multiref_polar_ali_2d(data[im], ringref, txrng,
tyrng, step, mode, numr,
cnx + sxi, cny + syi)
iref = int(xiref)
# combine parameters and set them to the header, ignore previous angle and mirror
[alphan, sxn, syn, mn] = combine_params2(0.0, -sxi, -syi, 0, angt,
sxst, syst, int(mirrort))
set_params2D(data[im], [alphan, sxn, syn, int(mn), scale])
if mn == 0: sx_sum[iref] += sxn
else: sx_sum[iref] -= sxn
sy_sum[iref] += syn
data[im].set_attr('assign', iref)
# apply current parameters and add to the average
temp = rot_shift2D(data[im], alphan, sxn, syn, mn)
it = im % 2
Util.add_img(refi[iref][it], temp)
assign[iref].append(im)
refi[iref][2] += 1
del ringref
if again:
a1 = 0.0
for j in range(numref):
msg = " group #%3d number of particles = %7d\n" % (
j, refi[j][2])
print_msg(msg)
if refi[j][2] < 4:
#ERROR("One of the references vanished","mref_ali2d",1)
# if vanished, put a random image there
assign[j] = []
assign[j].append(randint(0, nima - 1))
refi[j][0] = data[assign[j][0]].copy()
else:
max_inter = 0 # switch off fine refi.
br = 1.75
# the loop has to
for INter in range(max_inter + 1):
# Calculate averages at least ones, meaning even if no within group refinement was requested
frsc = fsc(
refi[j][0], refi[j][1], 1.0,
os.path.join(outdir,
"drm_%03d_%04d.txt" % (Iter, j)))
Util.add_img(refi[j][0], refi[j][1])
Util.mul_scalar(refi[j][0], 1.0 / float(refi[j][2]))
ref_data[2] = refi[j][0]
ref_data[3] = frsc
refi[j][0], cs = user_func(ref_data)
if center == -1:
cs[0] = sx_sum[j] / len(assign[j])
cs[1] = sy_sum[j] / len(assign[j])
refi[j][0] = fshift(refi[j][0], -cs[0], -cs[1])
for i in range(len(assign[j])):
im = assign[j][i]
alpha, sx, sy, mirror, scale = get_params2D(
data[im])
alphan, sxn, syn, mirrorn = combine_params2(
alpha, sx, sy, mirror, 0.0, -cs[0], -cs[1], 0)
set_params2D(
data[im],
[alphan, sxn, syn,
int(mirrorn), scale])
# refine images within the group
# Do the refinement only if max_inter>0, but skip it for the last iteration.
if INter < max_inter:
fine_2D_refinement(data, br, mask, refi[j][0], j)
# Calculate updated average
refi[j][0].to_zero()
refi[j][1].to_zero()
for i in range(len(assign[j])):
im = assign[j][i]
alpha, sx, sy, mirror, scale = get_params2D(
data[im])
# apply current parameters and add to the average
temp = rot_shift2D(data[im], alpha, sx, sy, mn)
it = im % 2
Util.add_img(refi[j][it], temp)
# write the current average
TMP = []
for i_tmp in range(len(assign[j])):
TMP.append(float(assign[j][i_tmp]))
TMP.sort()
refi[j][0].set_attr_dict({'ave_n': refi[j][2], 'members': TMP})
del TMP
# replace the name of the stack with reference with the current one
newrefim = os.path.join(outdir, "aqm%03d.hdf" % Iter)
refi[j][0].write_image(newrefim, j)
Iter += 1
msg = "ITERATION #%3d \n" % (Iter)
print_msg(msg)
newrefim = os.path.join(outdir, "multi_ref.hdf")
for j in range(numref):
refi[j][0].write_image(newrefim, j)
from sp_utilities import write_headers
write_headers(stack, data, list(range(nima)))
print_end_msg("mref_ali2d")