def __readUVW(self):
"""Read the UVW data from the MS. Works fine for a simulation (simdata).
To Be Checked for a real obs. with different targets."""
ms.open(self.vis)
uvw=ms.getdata(['amplitude','u','v','w'])
ms.done()
tb.open(self.vis)
self.f=tb.getcol('FLAG_ROW')
self.ff=tb.getcol('FLAG')
tb.done()
self.u=uvw['u']
self.v=uvw['v']
self.w=uvw['w']
self.amp=uvw['amplitude']
def bandpass_normalize(bandpass_table, bandpass_table_inv):
shutil.copytree(bandpass_table, bandpass_table_inv)
tb.open(bandpass_table_inv, nomodify=False)
gain = tb.getcol('CPARAM')
gain_norm = gain
#for each antenna and for each channel of the bandpass I divide out by the modulo of the complex number
for i in range(0, gain.shape[2]):
for j in range(0, gain.shape[1]):
a = gain[0, j, i]
#if the real part of the antenna gain is set to 1 it means that that antenna a/o channel is flag, so don't bother looking at it
if a.real != 1:
gain_norm[0, j, i] = gain_norm[0, j, i] / abs(gain_norm[0, j, i])
gain_norm[1, j, i] = gain_norm[1, j, i] / abs(gain_norm[1, j, i])
# print abs(gain_norm[i,j,0]),abs(gain[i,j,0]),i,j
# put back the normalized bandpass
tb.putcol('CPARAM', gain_norm)
tb.close()
tb.done()
def fill_flagged_soln(caltable='', doplot=False):
"""
This is to replace the gaincal solution of flagged/failed solutions by the nearest valid
one.
If you do not do that and applycal blindly with the table your data gets
flagged between calibration runs that have a bad/flagged solution at one edge.
Can be pretty bad when you calibrate every hour or more
(when you are betting on self-cal) of observation (e.g L-band of the EVLA)..one can
lose the whole hour of good data without realizing !
"""
tb.open(caltable, nomodify=False)
flg=tb.getcol('FLAG')
sol=tb.getcol('SOLUTION_OK')
ant=tb.getcol('ANTENNA1')
gain=tb.getcol('GAIN')
t=tb.getcol('TIME')
dd=tb.getcol('CAL_DESC_ID')
maxant=np.max(ant)
maxdd=np.max(dd)
npol=len(gain[:,0,0])
nchan=len(gain[0,:,0])
k=1
if(doplot):
pl.ion()
pl.figure(1)
pl.plot(t[(ant==k)], sol[0,0,(ant==k)], 'b+')
pl.plot(t[(ant==k)], flg[0,0,(ant==k)], 'r+')
pl.twinx()
pl.plot(t[(ant==k)], abs(gain[0,0,(ant==k)]), 'go')
print 'maxant', maxant
numflag=0.0
for k in range(maxant+1):
for j in range (maxdd+1):
subflg=flg[:,:,(ant==k) & (dd==j)]
subt=t[(ant==k) & (dd==j)]
subsol=sol[:,:,(ant==k) & (dd==j)]
subgain=gain[:,:,(ant==k) & (dd==j)]
#print 'subgain', subgain.shape
for kk in range(1, len(subt)):
for chan in range(nchan):
for pol in range(npol):
if(subflg[pol,chan,kk] and not subflg[pol,chan,kk-1]):
numflag += 1.0
subflg[pol,chan,kk]=False
subsol[pol, chan, kk]=True
subgain[pol,chan,kk]=subgain[pol,chan,kk-1]
if(subflg[pol,chan,kk-1] and not subflg[pol,chan,kk]):
numflag += 1.0
subflg[pol,chan,kk-1]=False
subsol[pol, chan, kk-1]=True
subgain[pol,chan,kk-1]=subgain[pol,chan,kk]
flg[:,:,(ant==k) & (dd==j)]=subflg
sol[:,:,(ant==k) & (dd==j)]=subsol
gain[:,:,(ant==k) & (dd==j)]=subgain
print 'numflag', numflag
if(doplot):
pl.figure(2)
k=1
#pl.clf()
pl.plot(t[(ant==k)], sol[0,0,(ant==k)], 'b+')
pl.plot(t[(ant==k)], flg[0,0,(ant==k)], 'r+')
pl.twinx()
pl.plot(t[(ant==k)], abs(gain[0,0,(ant==k)]), 'go')
pl.title('antenna='+str(k))
###
tb.putcol('FLAG', flg)
tb.putcol('SOLUTION_OK', sol)
tb.putcol('GAIN', gain)
tb.done()
def fill_flagged_soln(caltable='', doplot=False):
"""
This is to replace the gaincal solution of flagged/failed solutions by the nearest valid
one.
If you do not do that and applycal blindly with the table your data gets
flagged between calibration runs that have a bad/flagged solution at one edge.
Can be pretty bad when you calibrate every hour or more
(when you are betting on self-cal) of observation (e.g L-band of the EVLA)..one can
lose the whole hour of good data without realizing !
"""
tb.open(caltable, nomodify=False)
flg = tb.getcol('FLAG')
sol = tb.getcol('SOLUTION_OK')
ant = tb.getcol('ANTENNA1')
gain = tb.getcol('GAIN')
t = tb.getcol('TIME')
dd = tb.getcol('CAL_DESC_ID')
maxant = np.max(ant)
maxdd = np.max(dd)
npol = len(gain[:, 0, 0])
nchan = len(gain[0, :, 0])
k = 1
if (doplot):
pl.ion()
pl.figure(1)
pl.plot(t[(ant == k)], sol[0, 0, (ant == k)], 'b+')
pl.plot(t[(ant == k)], flg[0, 0, (ant == k)], 'r+')
pl.twinx()
pl.plot(t[(ant == k)], abs(gain[0, 0, (ant == k)]), 'go')
print 'maxant', maxant
numflag = 0.0
for k in range(maxant + 1):
for j in range(maxdd + 1):
subflg = flg[:, :, (ant == k) & (dd == j)]
subt = t[(ant == k) & (dd == j)]
subsol = sol[:, :, (ant == k) & (dd == j)]
subgain = gain[:, :, (ant == k) & (dd == j)]
#print 'subgain', subgain.shape
for kk in range(1, len(subt)):
for chan in range(nchan):
for pol in range(npol):
if (subflg[pol, chan, kk]
and not subflg[pol, chan, kk - 1]):
numflag += 1.0
subflg[pol, chan, kk] = False
subsol[pol, chan, kk] = True
subgain[pol, chan, kk] = subgain[pol, chan, kk - 1]
if (subflg[pol, chan, kk - 1]
and not subflg[pol, chan, kk]):
numflag += 1.0
subflg[pol, chan, kk - 1] = False
subsol[pol, chan, kk - 1] = True
subgain[pol, chan, kk - 1] = subgain[pol, chan, kk]
flg[:, :, (ant == k) & (dd == j)] = subflg
sol[:, :, (ant == k) & (dd == j)] = subsol
gain[:, :, (ant == k) & (dd == j)] = subgain
print 'numflag', numflag
if (doplot):
pl.figure(2)
k = 1
#pl.clf()
pl.plot(t[(ant == k)], sol[0, 0, (ant == k)], 'b+')
pl.plot(t[(ant == k)], flg[0, 0, (ant == k)], 'r+')
pl.twinx()
pl.plot(t[(ant == k)], abs(gain[0, 0, (ant == k)]), 'go')
pl.title('antenna=' + str(k))
###
tb.putcol('FLAG', flg)
tb.putcol('SOLUTION_OK', sol)
tb.putcol('GAIN', gain)
tb.done()
def make_primary_beams(image_name,lst,stokes_choice,beam_filename):
#
# define the frequencies of the simulated beams
#
freq_beams = np.zeros(11)
freq_beams[0] = 100e6
for j in range(1,11):
freq_beams[j] = freq_beams[j - 1] + 10e6
#
# read the input cube
#
tb.open(image_name)
q_cube = tb.getcol('map')
tb.close()
# ra = np.ndarray(shape=(image.shape[0],image.shape[1]),dtype=float)
# dec = np.ndarray(shape=(image.shape[0],image.shape[1]),dtype=float)
ia.open(image_name)
summary = ia.summary() # read the image summary
cube_shape = summary['shape'] # read the image shape: RA, DEC, Stokes, Freq
ra = np.ndarray(shape=(cube_shape[0],cube_shape[1]),dtype=float)
dec = np.ndarray(shape=(cube_shape[0],cube_shape[1]),dtype=float)
nchan = cube_shape[3] # number of channels in the cube
start_freq = summary['refval'][3] # start frequencies in Hz
df = summary['incr'][3] # frequency increment in Hz
#
# ra and dec will contain the RA and DEC corresponding to the pixel values in the image
#
#
for j in range(0,cube_shape[0]):
for k in range(0,cube_shape[1]):
a=ia.toworld([j,k,0,0]) # a dictionary is returned with the world coordinates of that pixel
b=a['numeric'] # the array is extracted from the dictionary a
ra[j,k] = b[0] # save the RA for pixel j,k
dec[j,k] = b[1] # save the DEC for pixel j,k
# print ra[j,k] * 12/np.pi,dec[j,k] * 180/np.pi,j,k
#
print 'RA and DEC calculated'
ia.close()
#
#
#
# read the beams
#
fekoX=fmt.FEKO('/home/gianni/PAPER/beams/fitBeam/data/PAPER_FF_X.ffe')
fekoY=fmt.FEKO('/home/gianni/PAPER/beams/fitBeam/data/PAPER_FF_Y.ffe')
feko_xpol=fekoX.fields[0]
feko_ypol=fekoY.fields[0]
phi=feko_xpol.phi*np.pi/180. # phi is the azimuth
theta=feko_xpol.theta*np.pi/180. # theta is the zenith angle
theta = np.pi/2 - theta # pyephem wants the elevation rather than the zenith angle
ra_beams = np.ndarray(shape=(phi.shape[0]),dtype=float) # array of RA corresponding to (phi,theta)
dec_beams = np.ndarray(shape=(phi.shape[0]),dtype=float) # array of DEC corresponding to (phi,theta)
#
# compute complex beams
#
gxx=feko_xpol.etheta*np.conj(feko_xpol.etheta)+feko_xpol.ephi*np.conj(feko_xpol.ephi)
#
# define an array that will contain all the simulated beams
#
beams = np.ndarray(shape=(gxx.shape[0],4,freq_beams.shape[0]),dtype=float)
#
# read all the beam models and save them in the beams array
#
for j in range(0,freq_beams.shape[0]):
feko_xpol = fekoX.fields[j] # these two lines give an error, I need to check with Griffin how to fix it
feko_ypol = fekoY.fields[j]
#
gxx = feko_xpol.etheta*np.conj(feko_xpol.etheta)+feko_xpol.ephi*np.conj(feko_xpol.ephi)
gyy = feko_ypol.etheta*np.conj(feko_ypol.etheta)+feko_ypol.ephi*np.conj(feko_ypol.ephi)
gxy = feko_xpol.etheta*np.conj(feko_ypol.etheta)+feko_xpol.ephi*np.conj(feko_ypol.ephi)
gyx = feko_ypol.etheta*np.conj(feko_xpol.etheta)+feko_ypol.ephi*np.conj(feko_xpol.ephi)
#
# make the stokes beams
#
beams[:,0,j] = (gxx+gyy).real
# beams[:,0,j] = beams[:,0,j] / np.max(beams[:,0,j]) # normalize the beams to be 1 at zenith
beams[:,1,j] = (gxx-gyy).real
beams[:,2,j] = (gxy+gyx).real
beams[:,3,j] = (gxy-gyx).imag
#
norm_beam = np.max(beams[:,0,5]) # beam peak at 150 MHz
beams[:,0,:] = beams[:,0,:] / norm_beam # normalize the beams to be 1 at zenith at 150 MHz
#
print norm_beam,np.max(beams[:,0,:])
print 'Beams read'
#
# bring the beam to RA,DEC coordinates
#
# Create an observer
#
paper = Observer()
#
# Set the observer at the Karoo
#
paper.lat, paper.long, paper.elevation = '-30:43:17', '21:25:40.08', 0.0
# j0 = ephem.julian_date(0) # invoked this way if import ephem
j0 = julian_date(0) # invoked this way if from ephem import *
# paper.date = float(lst)
paper.date = float(lst) - j0 + 5./60/24 # I think I need this. At http://stackoverflow.com/questions/8962426/convert-topocentric-coordinates-azimuth-elevation-to-equatorial-coordinates
# they seem to suggest that this is needed in order to get the right date and I seem to get the right
# RA if I include this. The factor 5./60/24 needs to be added as the lst reported in the filename refers to
# the beginning of the integration which is ~10 min long
for j in range(0,ra_beams.shape[0]):
a = paper.radec_of(phi[j],theta[j])
ra_beams[j] = a[0] # RA is in radians
dec_beams[j] = a[1] # DEC is in radians
#
#
# now interpolate the beams in frequency
#
interp_beam = np.ndarray(shape=(beams.shape[0],beams.shape[1],nchan),dtype=float)
cube_freq = start_freq
for chan in range(0,nchan):
a = np.max(q_cube[:,:,0,chan,0])
b = np.min(q_cube[:,:,0,chan,0])
if (a != 0 and b != 0): # if the image is not empty, then proceed
freq_dist = np.abs(cube_freq - freq_beams)
freq_dist_s = np.sort(freq_dist)
w = np.where(freq_dist == freq_dist_s[0])
if freq_dist_s[0] == 0:
#
# if the beam is simulated at the exact frequency channel, then do not interpolate
#
for j in range(0,4):
interp_beam[:,j,chan] = beams[:,j,w[0][0]]
#
# if they are not, perform a weighted average of the two closest beams in frequency. The weights are the inverse of the frequency distance squared
#
else:
w1 = np.where(freq_dist == freq_dist_s[1])
for j in range(0,4):
interp_beam[:,j,chan] = (beams[:,j,w[0][0]] * freq_dist_s[0]**(-2) + beams[:,j,w1[0][0]] * freq_dist_s[1]**(-2)) / (freq_dist_s[0]**(-2) + freq_dist_s[1]**(-2))
#
cube_freq = cube_freq + df
#
print 'Beams interpolated in frequency'
#
# now interpolate the beam at the observed RA,DEC
#
interp_beam_maps_q = np.ndarray(shape=(ra.shape[0],ra.shape[1],1,nchan,1),dtype=float)
#
for j in range(0,ra.shape[0]):
for k in range(0,ra.shape[1]):
#
# interpolating amongst the three closest points
#
# x = np.cos(ra[j,k])*np.cos(ra_beams)*np.cos(dec[j,k])*np.cos(dec_beams)
# y = np.sin(ra[j,k])*np.sin(ra_beams)*np.cos(dec[j,k])*np.cos(dec_beams)
# z = np.sin(dec[j,k])*np.sin(dec_beams)
# dist = np.sqrt(x**2 + y**2 + z**2)
#
dist = np.sqrt((ra[j,k] - ra_beams)**2 + (dec[j,k] - dec_beams)**2)
dist_s = np.sort(dist)
w0 = np.where(dist == dist_s[0])
w1 = np.where(dist == dist_s[1])
w2 = np.where(dist == dist_s[2])
#
interp_beam_maps_q[j,k,0,:,0] = interp_beam[w0[0][0],stokes_choice,:] / dist_s[0] + interp_beam[w1[0][0],stokes_choice,:] / dist_s[1] + interp_beam[w2[0][0],stokes_choice,:] / dist_s[2]
interp_beam_maps_q[j,k,0,:,0] = interp_beam_maps_q[j,k,0,:,0] / (dist_s[0]**(-1) + dist_s[1]**(-1) + dist_s[2]**(-1))
#
# nearest neighbour interpolation
#
# dist = np.sqrt((ra[j,k] - ra_beams)**2 + (dec[j,k] - dec_beams)**2)
# dist_s = np.sort(dist)
# w0 = np.where(dist == dist_s[0])
# interp_beam_maps_q[j,k,0,:,0] = interp_beam[w0[0][0],stokes_choice,:]
#
print 'Beams interpolated in angle'
#
# store the beams into an image
#
# beam_filename = image_name.strip('.image')
cmd = 'rm -rf ' + beam_filename + '.beams'
os.system(cmd)
cmd = 'cp -r ' + image_name + ' ' + beam_filename + '.beams'
os.system(cmd)
#
tb.open(beam_filename + '.beams',nomodify=False)
tb.putcol('map',interp_beam_maps_q)
tb.close()
tb.done()
ia.open(beam_filename + '.beams')
ia.tofits(beam_filename + '_beams.fits',overwrite=true)
ia.close()
#
#cmd = 'rm -rf '+filename
#os.system(cmd)
#cmd = 'python /home/gianni/Python_code/swap_column.py /home/gianni/PAPER/psa32/data/Original/'+filename+' '+filename
#os.system(cmd)
#ft(vis=filename,model='First_model/2455819.50285.model',usescratch=True)
#
cmd = 'rm -rf ' + filename
os.system(cmd)
cmd = 'cp -r /home/gianni/PAPER/psa32/data/Original/'+ filename + ' ' + filename
os.system(cmd)
tb.open(filename,nomodify=False)
data = tb.getcol('DATA')
tb.putcol('CORRECTED_DATA',data) # the CORRECTED_DATA column is initialized to DATA
tb.close()
tb.done()
#
tflagdata(vis=filename,mode='manual',spw='0:167~202',action='apply',datacolumn='DATA')
flagdata(vis=filename,mode='clip',clipminmax=[0,300],correlation='ABS_XY,YX',action='apply',datacolumn='DATA')
flagdata(vis=filename,mode='clip',clipminmax=[0,1000],correlation='ABS_XX,YY',action='apply',datacolumn='DATA')
#
out_fits = lst+'.fits'
out_fits_res = lst+'_residual.fits'
out_fits_model = lst+'_model.fits'
#
cmd = 'rm -rf '+ lst + '.image ' + lst + '.model ' + lst + '.residual ' + lst + '.flux' + lst + '.psf'
os.system(cmd)
#
# make an image
#
myphasecenter='J2000 20h00m00s -30d43m17.5s'
def ms2ripples(vis,
savepath,
timebinsec,
Nsam=None,
timebin=False,
overwrite=True,
verbose=True,
debug=False):
import astropy.constants as c
if timebin:
print("Performing time binning, by {:}s:".format(timebinsec))
prefix = vis.replace('.ms', '_timebin' + '{:}s.ms'.format(timebinsec))
prefix = os.path.basename(prefix)
timebinVis = os.path.join(savepath, prefix)
if overwrite:
rmtables(timebinVis)
default(split2)
split2(vis=vis,
timebin=str(timebinsec) + 's',
outputvis=timebinVis,
datacolumn='data',
keepflags=False)
if overwrite:
plotms(vis=timebinVis,
xaxis='uvdist',
yaxis='amp',
coloraxis='spw')
if debug and not os.path.exists(
timebinVis[:timebinVis.find('.ms')] + '.image'):
clean(vis=timebinVis,
imagename=timebinVis[:timebinVis.find('.ms')],
spw='',
mode='mfs',
nchan=-1,
imsize=800,
cell='0.0300arcsec',
niter=0,
interactive=False,
stokes='I')
oldvis = vis
vis = timebinVis
else:
raw_input(
"No time binning...proceed with caution. Press Enter to continue.")
# check that the MS has only 1 science target
tb.open(timebinVis + '/FIELD')
src = tb.getcell('NAME')
print("Source in {}: {}\n").format(timebinVis, src)
tb.close()
ms.open(timebinVis)
spwInfo = ms.getspectralwindowinfo()
nchan = spwInfo["0"]["NumChan"]
npol = spwInfo["0"]["NumCorr"]
ms.close()
tb.open(oldvis)
_dataShape = tb.getcol('DATA').shape
tb.close()
tb.open(timebinVis)
# tb.colnames
data = tb.getcol('DATA')
uvw = tb.getcol('UVW')
uvwShape = uvw.shape
nvis = len(uvw[1, :]) # before dropping flagged data
flagRow = tb.getcol('FLAG_ROW')
assert (flagRow == True).any() == False
data_desc_id = tb.getcol("DATA_DESC_ID")
sigma = tb.getcol('SIGMA')
# weight = tb.getcol('WEIGHT')
weight = 1. / sigma**2
# del sigma
if Nsam is not None:
from ripples_utils import pick_highSNR
idx = pick_highSNR(weight, Nsam, plothist=verbose)
uvw = uvw[:, idx]
with open(os.path.join(savepath, 'u.bin'), 'wb') as f:
f.write(uvw[0, :])
with open(os.path.join(savepath, 'v.bin'), 'wb') as f:
f.write(uvw[1, :])
if debug:
print uvw[0, :].max()
print uvw[0, :].min()
print uvw[1, :].max()
print uvw[1, :].min()
print uvw.dtype # float64
# del uvw
ant1 = tb.getcol('ANTENNA1')
ant2 = tb.getcol('ANTENNA2')
assert len(ant1) == nvis
assert len(ant2) == nvis
tb.done()
if Nsam is not None:
ant1 = ant1[idx]
ant2 = ant2[idx]
assert len(ant1) == len(uvw[0, :])
with open(os.path.join(savepath, 'ant1.bin'), 'wb') as f:
ant1 = np.asarray(ant1, dtype=np.float_)
# print ant1.dtype
f.write(ant1)
with open(os.path.join(savepath, 'ant2.bin'), 'wb') as f:
ant2 = np.asarray(ant2, dtype=np.float_)
f.write(ant2)
# ant1.tofile(os.path.join(savepath, 'ant1.bin'))
if debug:
print ant1.max()
print ant1.min()
print ant2.max()
print ant2.min()
xx = np.fromfile(os.path.join(savepath, 'ant1.bin'))
if Nsam is None:
assert len(xx) == nvis
else:
assert len(xx) == len(idx)
assert (xx == ant1).all()
xx = np.fromfile(os.path.join(savepath, 'ant2.bin'))
if Nsam is None:
assert len(xx) == nvis
else:
assert len(xx) == len(idx)
assert (xx == ant2).all()
# del ant1, ant2
if verbose:
print("Number of coorelation: ", npol)
print("data shape", data.shape)
print("data shape before time binning", _dataShape)
print("uvw shape", uvwShape)
print("weight shpae", weight.shape) # (npol, nvis)
tb.open(vis + '/SPECTRAL_WINDOW')
SPWFreqs = np.squeeze(tb.getcol("CHAN_FREQ"))
tb.done()
freq_per_vis = np.array([SPWFreqs[fff] for fff in data_desc_id])
# freqs = np.mean(SPWFreqs)
assert len(freq_per_vis) == nvis
if Nsam is not None:
freq_per_vis = freq_per_vis[idx]
with open(os.path.join(savepath, 'frequencies.bin'), 'wb') as f:
f.write(freq_per_vis)
del data_desc_id, SPWFreqs
if Nsam is not None:
data = data[:, :, idx]
weight = weight[:, idx]
if debug:
# randomly sample 1000 to image
from ripples_utils import calc_img_from_vis
_idx = np.random.choice(len(weight[0, :]), size=3000)
if npol == 2:
if data.shape[1] == 1:
# expand the channel axis for weight
__weight = weight[:, np.newaxis, :]
_data = np.average(data, weights=__weight, axis=0)
_weight = np.average(weight, axis=0) # npol, nvis
print _weight.shape
print _data.shape
_real = _data[0, _idx].real # nchan, nvis
_imag = _data[0, _idx].imag
visOut = np.array(zip(_real, _imag)).flatten()
_weight = _weight[_idx]
__weight_factor = len(_idx) / np.sum(_weight * _real**2 +
_weight * _imag**2)
print __weight_factor
_weight *= __weight_factor
test_img = calc_img_from_vis(uvw[0, _idx],
uvw[1, _idx],
_weight,
visOut,
freq_per_vis[_idx],
800,
pixsize=0.01)
import pdb
pdb.set_trace()
if npol == 1:
real = data.real
imag = data.imag
elif npol == 2:
print "Real and Imag shape before averaging two hands (npol, nchan, nvis): ", data.real.shape
if data.shape[1] == 1:
# expand the channel axis for weight
weight = weight[:, np.newaxis, :]
else:
print weight.shape
print("We shouldn't have to enter this condition.")
import pdb
pdb.set_trace()
# average the two hands
data = np.average(data, weights=weight, axis=0)
# print data.shape (nchan, nvis)
weight = np.average(weight, axis=0)
print weight.shape # should be (nchan, nvis)
real = data.real
imag = data.imag
del data
print "Shape after averaging two hands: ", real.shape
elif npol > 2:
raise NotImplementedError("more than 2 hands..")
# rescale weight
# uvmcmcfit way
if Nsam is None:
_factor = nvis / np.sum(weight * real**2 + weight * imag**2)
else:
_factor = len(idx) / np.sum(weight * real**2 + weight * imag**2)
_sigmas = (weight**-0.5) * _factor
if verbose:
print "simple rescale, factor of: ", _factor
print _sigmas.min(), _sigmas.max(), _sigmas.std()
print "New sigma in [mjy/beam]", (_sigmas**-2).sum()**-0.5 * 1.e3
del _sigmas
# Yashar way
# first grouping the visibilities into bins that probe the same signal
# take differences btw visibilities that null the sky
# then, we simply assume that the variance in the subtracted visibilities is equal to twice the noise variance
plotms(timebinVis, xaxis='V', yaxis='U', coloraxis='baseline')
scaling = []
for a1 in np.unique(ant1):
for a2 in np.unique(ant2):
if a1 < a2:
baselineX = (ant1 == a1) & (ant2 == a2)
if debug:
print a1, a2
print ant1, ant2
print ""
print a1 in ant1
print a2 in ant2
print ""
print np.where(a1 == ant1)
print np.where(a2 == ant2)
print np.where((ant1 == a1) & (ant2 == a2) == True)
if baselineX.any(
) == True: # important line! if we are picking a subset of points with nsam since we may miss some baselines.
if nchan == 1:
print real.shape
reals = real[0, baselineX]
imags = imag[0, baselineX]
sigs = weight[0, baselineX]**-0.5
else:
raise NotImplementedError(
"Not implemented for MS files with more than 1 channel per spw..."
)
# randomly split points into "two sets"
# subtract from "two set"
# subtract from neighboring
diffrs = reals - np.roll(reals, -1)
diffis = imags - np.roll(imags, -1)
std = np.mean([diffrs.std(), diffis.std()])
if debug:
print diffrs.min(), diffis.min()
print diffrs.max(), diffis.max()
print diffrs.std(), diffis.std()
print std / sigs.mean() / np.sqrt(2)
scaling.append(std / sigs.mean() / np.sqrt(2))
del ant1, ant2
sigma = weight**-0.5
scaling = np.asarray(scaling).mean()
sigma *= scaling
print 'Scaling factor: ', scaling
print 'Sigma after scaling [mJy/beam]: ', ((sigma**-2).sum())**-0.5 * 1E+3
# real_1, imag_1, real_2, imag_2, etc
visOut = np.array(zip(real, imag)).flatten()
if Nsam is None:
assert len(visOut) == int(nvis * 2)
weight = sigma**-2
weight = np.array(zip(
weight,
weight)).flatten() # TODO: want to make sure this works for nchan > 1
assert len(weight) == len(visOut)
if Nsam is not None:
assert len(visOut) == Nsam * 2
if Nsam is not None:
assert len(weight) == Nsam * 2
with open(os.path.join(savepath, 'vis_chan_0.bin'), 'wb') as f:
f.write(visOut)
with open(os.path.join(savepath, 'sigma_squared_inv.bin'), 'wb') as f:
f.write(weight)
if Nsam is None:
blah = np.zeros((nvis))
else:
blah = np.zeros((len(idx)))
with open(os.path.join(savepath, 'chan.bin'), 'wb') as f:
f.write(blah)
if debug:
# image the SAVED visibilities
uu = np.fromfile(os.path.join(savepath, 'u.bin'), 'wb')
vv = np.fromfile(os.path.join(savepath, 'v.bin'), 'wb')
weight = np.fromfile(os.path.join(savepath, 'sigma_squared_inv.bin'),
'wb')
visout = np.fromfile(os.path.join(savepath, 'vis_chan_0.bin'), 'wb')
calc_img_from_vis(uu, vv, weight, visOut, 1000, pixsize=0.05)
return None
