Beispiel #1
0
	def __init__(self,xs,ys,vs,cellsize,dv,UVFITSfile,cube_template_file):
		"""
		This function initializes the modeling object.
		Parameters
		----------
		xs: float
			X-axis size of the model image (in arcsec)
		ys: float
			Y-axis size of the model image (in arcsec)
		vs: float
			Velocity-axis size of the model image (in km/s)
		cellsize: float
			Arcseconds in a pixel
		dv: float
			Km/s in a channel
		UVFITSfile: string
			Filename of the UVFITS visibility file
		cube_template_file: string
			Filename of the image cube to be used as a model template (the dimensions and coordinates are the only thing that's used).
			It's best obtained by imaging the visibilities themselves, using mode='channel'. This ensures that the cell size is sufficient to suitable for the UV coverage.
		Returns
		-------
			    
		"""
		self.xs=xs   
		self.ys=ys   #y-axis size of the model image (in arcsec)
		self.vs=vs
		self.cellsize=cellsize
		self.dv=dv
		self.UVFITSfile=UVFITSfile #'.uvfits'
		self.cube_template_file=cube_template_file #'.fits'
		self.sbrad=np.arange(0,2,.01)   #radius vector defining the light profile, sbprof is the light intensity evaluated at these radial values
		self.velrad=self.sbrad          #use the same radius vector for the velocity definition, used by velprof to define the velocity profile
		self.nsamps=1e5                 #number of clouds, should be sufficient
		self.vis_complex_data, self.wgt_data = uvutil.visload(self.UVFITSfile) #load visibility and weights
		self.vis_complex_model_template=np.copy(self.vis_complex_data)
		self.wgt_data=self.wgt_data.flatten()
		self.good_vis=self.wgt_data>0
		self.wgt_data=self.wgt_data[self.good_vis]  #get rid of flagged data
		self.vis_complex_data=self.vis_complex_data.flatten()[self.good_vis]
		self.modelheader = fits.getheader(self.cube_template_file)   
		self.uu_cube, self.vv_cube, self.ww_cube = uvutil.uvload(self.UVFITSfile)
		self.pcd = uvutil.pcdload(self.UVFITSfile)
		self.Nxpix=self.modelheader['NAXIS1']
		self.Nypix=self.modelheader['NAXIS2']
		self.Nchan=self.modelheader['NAXIS3']
		self.Nxpix_small=int(self.xs/self.cellsize)
		self.Nypix_small=int(self.ys/self.cellsize)
		self.Nchan_small=int(self.vs/self.dv)
		#In this code we assume the continuum emission can be modelled as a 2D Gaussian, with known parameters. This is often the case and the continuum parameters are often precisely known. If they are not, include the continuum parameters as fitting parameters and make sure the visibilities cover a good range of continuum-only channels. 
		self.y,self.x,self.zz=np.mgrid[:self.Nypix_small,:self.Nxpix_small,:self.Nchan_small]   #define a coordinate cube of the same size as the KinMS model, to make the continuum model, to be added in.
		self.offset_lnlike=0
		self.xpos_center_padded,self.ypos_center_padded= int(self.Nxpix/2),int(self.Nypix/2)
Beispiel #2
0
def replace_visibilities_galario(visdataloc,sbmodelloc,modelvisloc):
	#this needs to be open, channel by channel
	modelimage_cube = fits.getdata(sbmodelloc)
	#this can be the same throughout
	modelheader = fits.getheader(sbmodelloc)
	#these need to be peeled, channel by channel for the following
	uu_cube, vv_cube, ww_cube = uvutil.uvload(visdataloc)
	vis_complex_cube, wgt_cube = uvutil.visload(visdataloc)
	#this can be the same throughout
	pcd = uvutil.pcdload(visdataloc)
	#all the following is done channel by channel
	for chan in range(modelimage_cube.shape[0]):
		uu=np.ones((uu_cube.shape[0],uu_cube.shape[1],1,uu_cube.shape[3]))
		vv=np.ones((vv_cube.shape[0],vv_cube.shape[1],1,vv_cube.shape[3]))
		uu[:,:,0,:]=uu_cube[:,:,chan,:]
		vv[:,:,0,:]=vv_cube[:,:,chan,:]
		modelimage=modelimage_cube[chan]
		uushape = uu.shape
		if len(uushape) == 2:
        		npol = uushape[0]
        		nrow = uushape[1]
        		uushape = (npol, 1, nrow)
		uu = uu.flatten()
		vv = vv.flatten()
		uu=uu.copy(order='C')
		vv=vv.copy(order='C')
		modelimage=np.roll(np.flip(modelimage,axis=0),1,axis=0).copy(order='C').byteswap().newbyteorder()
		model_complex = sampleImage(modelimage, np.absolute(modelheader['CDELT1'])/180*np.pi, uu, vv)   # sample_vis.uvmodel(modelimage, modelheader, uu, vv, pcd)
		vis_complex = model_complex.reshape(uushape)
		vis_complex_cube[:,:,chan,:]=vis_complex[:,:,0,:]
		if chan%10==0:	
			print chan
	#modelvisloc='../replaced_visib.uvfits'
	os.system('rm -rf ' + modelvisloc[:-7]+'*')
	cmd = 'cp ' + visdataloc + ' ' + modelvisloc	
	os.system(cmd)
	real = np.real(vis_complex_cube)
	imag = np.imag(vis_complex_cube)
	visfile = fits.open(modelvisloc, mode='update')
	visibilities = visfile[0].data
	visheader = visfile[0].header
	if visheader['NAXIS'] == 7:
	            visibilities['DATA'][:, 0, 0, :, :, :, 0] = real
	            visibilities['DATA'][:, 0, 0, :, :, :, 1] = imag
	elif visheader['NAXIS'] == 6:
	            visibilities['DATA'][:, 0, 0, :, :, 0] = real
	            visibilities['DATA'][:, 0, 0, :, :, 1] = imag
	else:
	            print("Visibility dataset has >7 or <6 axes.  I can't read this.")
	#visibilities['DATA'][:, 0, 0, :, :, 2] = wgt
	visfile[0].data = visibilities
	visfile.flush()
	visfile.close()
Beispiel #3
0
def subtract(sbmodelloc, visdataloc, modelvisloc, miriad=False):

    vis_model = getVis(sbmodelloc, visdataloc)

    # load the visibilities
    vis_data, vis_weight = uvutil.visload(visdataloc)

    vis_data -= vis_model

    #print(visdataloc, modelvisloc, miriad)
    writeVis(vis_data, visdataloc, modelvisloc, miriad=miriad)

    return
Beispiel #4
0
def subtract(sbmodelloc, visdataloc, modelvisloc, miriad=False):

    vis_model = getVis(sbmodelloc, visdataloc)
     
    # load the visibilities
    vis_data, vis_weight = uvutil.visload(visdataloc)

    vis_data -= vis_model

    #print(visdataloc, modelvisloc, miriad)
    writeVis(vis_data, visdataloc, modelvisloc, miriad=miriad)

    return
Beispiel #5
0
def plot(cleanup=True, configloc='sandbox.yaml', interactive=True, threshold=1.2, plot=True, tag='sandbox'):
    '''

    Parameters
    ----------
    threshold: float
        in mJy, cleaning threshold

    '''

    # read the input parameters
    configfile = open(configloc, 'r')
    config = yaml.load(configfile)

    paramSetup = setuputil.loadParams(config)
    fixindx = setuputil.fixParams(paramSetup)
    testfit = paramSetup['p_l']
    visfile = config['UVData']
    uuu, vvv, www = uvutil.uvload(visfile)
    pcd = uvutil.pcdload(visfile)
    vis_complex, wgt = uvutil.visload(visfile)

    # remove the data points with zero or negative weight
    positive_definite = wgt > 0
    vis_complex = vis_complex[positive_definite]
    wgt = wgt[positive_definite]
    uuu = uuu[positive_definite]
    vvv = vvv[positive_definite]

    testlnprob, testmu = lnprob(testfit, vis_complex, wgt, uuu, vvv, pcd,
           fixindx, paramSetup, computeamp=True)
    # prepend 1 dummy value to represent lnprob
    testfit = numpy.append(testlnprob, testfit)
    # append nmu dummy values that represent the magnification factors
    nlensedsource = paramSetup['nlensedsource']
    nlensedregions = paramSetup['nlensedregions']
    nmu = 2 * (numpy.array(nlensedsource).sum() + nlensedregions)

    for i in range(nmu):
        testfit = numpy.append(testfit, 0)

    print("lnprob: %f" %testlnprob)
    print("Using the following model parameters:")
    for k, v in zip(paramSetup['pname'], testfit[1:-4]):
        print("%s : %.4f" %(k,v))
    if plot:
        visualutil.plotFit(config, testfit, threshold,
                           tag=tag, cleanup=cleanup,
                           interactive=interactive)
    return testlnprob
Beispiel #6
0
def rollUp(visfile):
    u, v, w = uvutil.uvload(visfile)
    data, weight = uvutil.visload(visfile)
    real = np.real(data)
    imag = np.imag(data)
    nvis = u.size
    rolled = np.zeros((6, nvis))
    rolled[0, :] = u.flatten()
    rolled[1, :] = v.flatten()
    rolled[2, :] = w.flatten()
    rolled[3, :] = real.flatten()
    rolled[4, :] = imag.flatten()
    rolled[5, :] = weight.flatten()
    return rolled
Beispiel #7
0
def rollUp(visfile):
    u, v, w = uvutil.uvload(visfile)
    data, weight = uvutil.visload(visfile)
    real = np.real(data)
    imag = np.imag(data)
    nvis = u.size
    rolled = np.zeros((6, nvis))
    rolled[0, :] = u.flatten()
    rolled[1, :] = v.flatten()
    rolled[2, :] = w.flatten()
    rolled[3, :] = real.flatten()
    rolled[4, :] = imag.flatten()
    rolled[5, :] = weight.flatten()
    return rolled
Beispiel #8
0
def plot(cleanup=True, configloc='sandbox.yaml', interactive=True):

    # read the input parameters
    configfile = open(configloc, 'r')
    config = yaml.load(configfile)

    paramSetup = setuputil.loadParams(config)
    fixindx = setuputil.fixParams(paramSetup)
    testfit = paramSetup['p_l']
    visfile = config['UVData']
    uuu, vvv, www = uvutil.uvload(visfile)
    pcd = uvutil.pcdload(visfile)
    vis_complex, wgt = uvutil.visload(visfile)

    # remove the data points with zero or negative weight
    positive_definite = wgt > 0
    vis_complex = vis_complex[positive_definite]
    wgt = wgt[positive_definite]
    uuu = uuu[positive_definite]
    vvv = vvv[positive_definite]

    testlnprob, testmu = lnprob(testfit,
                                vis_complex,
                                wgt,
                                uuu,
                                vvv,
                                pcd,
                                fixindx,
                                paramSetup,
                                computeamp=True)
    # prepend 1 dummy value to represent lnprob
    testfit = numpy.append(testlnprob, testfit)
    # append nmu dummy values that represent the magnification factors
    nlensedsource = paramSetup['nlensedsource']
    nlensedregions = paramSetup['nlensedregions']
    nmu = 2 * (numpy.array(nlensedsource).sum() + nlensedregions)

    for i in range(nmu):
        testfit = numpy.append(testfit, 0)
    tag = 'sandbox'

    print("lnprob: %f" % testlnprob)
    print("Using the following model parameters:")
    for k, v in zip(paramSetup['pname'], testfit[1:-4]):
        print("%s : %.4f" % (k, v))
    visualutil.plotFit(config,
                       testfit,
                       tag=tag,
                       cleanup=cleanup,
                       interactive=interactive)
Beispiel #9
0
nfiles = len(fitsfiles)
nvis = []

# read in the observed visibilities
uuu = []
vvv = []
real = []
imag = []
wgt = []
for file in fitsfiles:
    print file
    vis_data = fits.open(file)

    uu, vv = uvutil.uvload(vis_data)
    pcd = uvutil.pcdload(vis_data)
    real_raw, imag_raw, wgt_raw = uvutil.visload(vis_data)
    uuu.extend(uu)
    vvv.extend(vv)
    real.extend(real_raw)
    imag.extend(imag_raw)
    wgt.extend(wgt_raw)

# convert the list to an array
real = numpy.array(real)
imag = numpy.array(imag)
wgt = numpy.array(wgt)
uuu = numpy.array(uuu)
vvv = numpy.array(vvv)
#www = numpy.array(www)

# remove the data points with zero or negative weight
Beispiel #10
0
    #--------------------------------------------------------------------------
    # read in Python visibilities
        
    fitsfiles = config.FitsFiles
    #print fitsfiles
    nfiles = len(fitsfiles)

    # read in the observed visibilities
    for file in fitsfiles:

        # read in the observed visibilities
        obsdata = fits.open(file)

        # get the real and imaginary components
        data_real, data_imag, data_wgt = uvutil.visload(obsdata)
        
        #----------------------------------------------------------------------
        # Python version of UVMODEL
        # "Observe" the lensed emission with the SMA and write to a new file
        #----------------------------------------------------------------------
        # Python replace:
        nameindx = file.find('uvfits')
        name = file[0:nameindx-1]

        py_replace = uvmodel.replace(outfits, file)
        #py_real, py_imag, py_wgt = uvmodel.components(py_replace)
        #dreal = py_real - data_real
        #dimag = py_imag - data_imag
        #py_chi2 = py_wgt * (dreal ** 2 + dimag ** 2)
        #print name, 'py-replace ', py_chi2.sum(), py_wgt.sum()
Beispiel #11
0
        visfile = newvisfile
    else:
        miriad = False
else:
    miriad = False

# attempt to process multiple visibility files.  This won't work if miriad=True
try:
    filetype = visfile[-6:]
    if filetype == 'uvfits':
        uvfits = True
    else:
        uvfits = False
    uuu, vvv, www = uvutil.uvload(visfile)
    pcd = uvutil.pcdload(visfile)
    vis_complex, wgt = uvutil.visload(visfile)
except:
    try:
        for i, ivisfile in enumerate(visfile):
            filetype = ivisfile[-6:]
            if filetype == 'uvfits':
                uvfits = True
            else:
                uvfits = False
            iuuu, ivvv, iwww = uvutil.uvload(ivisfile)
            ipcd = uvutil.pcdload(ivisfile)
            ivis_complex, iwgt = uvutil.visload(ivisfile)
            if i == 0:
                uuu = iuuu
                vvv = ivvv
                pcd = ipcd