def bs_multi_triangle(i, bs_arr, ft_frame, bs2bl_ix, mf, closing_tri_pix):
"""
Compute the bispectrum using the multiple triangle technique
Parameters:
-----------
`i` {int}:
Indice number of the bispectrum array (bs_arr),\n
`bs_arr` {array}:
Empty bispectrum array (bs_arr.shape[0] = n_bs),\n
`ft_frame` {array}:
fft of the frame where is extracted the bs value,\n
`bs2bl_ix` {list}:
Bispectrum to baselines indix,\n
`mf` {class}:
See make_mf function,\n
`closing_tri_pix` {array}:
Array of possible combination of indices in a splodge.\n
Returns:
--------
`bs_arr` {array}:
Filled bispectrum array.
"""
dim1 = ft_frame.shape[0]
dim2 = ft_frame.shape[1]
closing_tri_pix = closing_tri_pix.T
n_bispect = bs_arr.shape[1]
mfilter_spec = np.zeros([dim1, dim2])
mfc_pvct = array_coords(mf.cpvct, dim1)
coord_peak = array_coords(mf.cpvct, dim1)
for j in range(len(mfc_pvct[0])):
mfilter_spec[coord_peak[1][j], coord_peak[0][j]] = mf.cgvct[j]
mfilter_spec_op = np.roll(
np.roll(np.rot90(np.rot90(mfilter_spec)), 1, axis=0), 1, axis=1
)
mfilter_spec += mfilter_spec_op
mfilter_spec = mfilter_spec * np.fft.fftshift(ft_frame)
base_origin = closing_tri_pix[0, 0]
n_closing_tri = closing_tri_pix.shape[0]
All_multi_tri = []
for this_bs in range(n_bispect):
this_tri = bs2bl_ix[:, this_bs]
mfc_vect = np.array(mf.cpvct)
tri_splodge_origin = mfc_vect[mf.ix[0, this_tri]] # -80
splodge_shift = tri_splodge_origin - base_origin
splodge_shift = splodge_shift.reshape([1, len(splodge_shift)])
sh = np.ones([1, n_closing_tri])
this_trisampling = closing_tri_pix + np.dot(splodge_shift.T, sh).T
this_trisampling = this_trisampling.T
a = (splodge_shift + ((dim1 / 2) * (dim1 + 1))).astype(int)[0]
spl_offset = array_coords(a, dim1).T - dim1 // 2
spl_offset = spl_offset.T
this_trisampling[2, :] = (
this_trisampling[2, :]
- 2 * (spl_offset[0, 2] + 1 * spl_offset[1, 2] * dim1)
+ 0
)
this_trisampling[0, :] -= 0
this_trisampling[1, :] -= 0
this_trisampling = this_trisampling.astype(int)
mfilter_spec2 = mfilter_spec.ravel()
bs_arr[i, this_bs] = np.sum(
mfilter_spec2[this_trisampling[0, :]]
* mfilter_spec2[this_trisampling[1, :]]
* (mfilter_spec2[this_trisampling[2, :]])
)
All_multi_tri.append(this_trisampling)
return bs_arr
def tri_pix(array_size, sampledisk_r, verbose=True, display=True):
"""Compute all combination of triangle for a given splodge size"""
if array_size % 2 == 1:
cprint("\n! Warnings: image dimension must be even (%i)" % array_size, "red")
cprint("Possible triangle inside the splodge should be incorrect.\n", "red")
d = np.zeros([array_size, array_size])
d = plot_circle(d, array_size // 2, array_size // 2, sampledisk_r, display=False)
pvct_flat = np.where(d.ravel() > 0)
npx = len(pvct_flat[0])
for px1 in range(npx):
thispix1 = np.array(array_coords(pvct_flat[0][px1], array_size))
roll1 = np.roll(d, int(array_size // 2 - thispix1[0]), axis=0)
roll2 = np.roll(roll1, int(array_size // 2 - thispix1[1]), axis=1)
xcor_12 = d + roll2
valid_b12_vct = np.where(xcor_12.T.ravel() > 1)
thisntriv = len(valid_b12_vct[0])
thistrivct = np.zeros([3, thisntriv])
for px2 in range(thisntriv):
thispix2 = array_coords(valid_b12_vct[0][px2], array_size)
thispix3 = array_size * 1.5 - (thispix1 + thispix2)
bl3_px = thispix3[1] * array_size + (thispix3[0])
thistrivct[:, px2] = [pvct_flat[0][px1], valid_b12_vct[0][px2], bl3_px]
if px1 == 0:
l_pix1 = list(thistrivct[0, :])
l_pix2 = list(thistrivct[1, :])
l_pix3 = list(thistrivct[2, :])
else:
l_pix1.extend(list(thistrivct[0, :]))
l_pix2.extend(list(thistrivct[1, :]))
l_pix3.extend(list(thistrivct[2, :]))
closing_tri_pix = np.array([l_pix1, l_pix2, l_pix3]).astype(int)
n_trip = closing_tri_pix.shape[1]
if verbose:
print("Closing triangle in r = %2.1f: %i" % (sampledisk_r, n_trip))
cl_unique = clos_unique(closing_tri_pix)
c0 = array_size // 2
fw = 2 * sampledisk_r
if display:
import matplotlib.pyplot as plt
plt.figure(figsize=(5, 5))
plt.title(
"Splodge + unique triangle (tri = %i/%i, d = %i, r = %2.1f pix)"
% (cl_unique.shape[1], n_trip, array_size, sampledisk_r),
fontsize=10,
)
plt.imshow(d)
for i in range(cl_unique.shape[1]):
trip1 = cl_unique[:, i]
X, Y = array_coords(trip1, array_size)
X = list(X)
Y = list(Y)
X.append(X[0])
Y.append(Y[0])
plt.plot(X, Y, "-", lw=1)
plt.axis([c0 - fw, c0 + fw, c0 - fw, c0 + fw])
plt.tight_layout()
plt.show(block=False)
return closing_tri_pix