def getVis(sbmodelloc, visdataloc): #print(sbmodelloc, visdataloc) # read in the surface brightness map of the model modelimage = fits.getdata(sbmodelloc) modelheader = fits.getheader(sbmodelloc) # load the uv data, including the phase center of the data uu, vv, ww = uvutil.uvload(visdataloc) # load the uv data, including the phase center of the data pcd = uvutil.pcdload(visdataloc) # sample the uv visfile[0].data using the model uushape = uu.shape if len(uushape) == 2: npol = uushape[0] nrow = uushape[1] uushape = (npol, 1, nrow) uu = uu.flatten() vv = vv.flatten() model_complex = sample_vis.uvmodel(modelimage, modelheader, \ uu, vv, pcd) vis_complex = model_complex.reshape(uushape) return vis_complex
def getVis(sbmodelloc, visdataloc): #print(sbmodelloc, visdataloc) # read in the surface brightness map of the model modelimage = fits.getdata(sbmodelloc) modelheader = fits.getheader(sbmodelloc) # load the uv data, including the phase center of the data uu, vv, ww = uvutil.uvload(visdataloc) # load the uv data, including the phase center of the data pcd = uvutil.pcdload(visdataloc) # sample the uv visfile[0].data using the model uushape = uu.shape if len(uushape) == 2: npol = uushape[0] nrow = uushape[1] uushape = (npol, 1, nrow) uu = uu.flatten() vv = vv.flatten() model_complex = sample_vis.uvmodel(modelimage, modelheader, \ uu, vv, pcd) vis_complex = model_complex.reshape(uushape) return vis_complex
def add(sbmodelloc, visdataloc, WeightByRMS=True, ExcludeChannels='none'): # read in the surface brightness map of the model modelimage = fits.getdata(sbmodelloc) modelheader = fits.getheader(sbmodelloc) # read in the uvfits data visfile = fits.open(visdataloc) visibilities = visfile[0].data # load the uv data, including the phase center of the data uu, vv, pcd = uvutil.uvload(visfile) # get the number of visibilities, spws, frequencies, polarizations if uu.ndim == 4: nvis = uu[:, 0, 0, 0] nspw = uu[0, :, 0, 0] nfreq = uu[0, 0, :, 0] npol = uu[0, 0, 0, :] if uu.ndim == 3: nvis = uu[:, 0, 0] nspw = 0 nfreq = uu[0, :, 0] npol = uu[0, 0, :] # sample the uv visibilities using the model uu = uu.flatten() vv = vv.flatten() model_complex = sample_vis.uvmodel(modelimage, modelheader, \ uu, vv, pcd) if nspw > 0: # get the real and imaginary components real = numpy.real(model_complex).reshape(nvis, nspw, nfreq, npol) imag = numpy.imag(model_complex).reshape(nvis, nspw, nfreq, npol) uu = uu.reshape(nvis, nspw, nfreq, npol) vv = vv.reshape(nvis, nspw, nfreq, npol) # replace data visibilities with model visibilities visibilities['DATA'][:, 0, 0, :, :, :, 0] = real_raw + real visibilities['DATA'][:, 0, 0, :, :, :, 1] = imag_raw + imag visibilities['DATA'][:, 0, 0, :, :, :, 2] = wgt else: # get the real and imaginary components real = numpy.real(model_complex).reshape(nvis, nfreq, npol) imag = numpy.imag(model_complex).reshape(nvis, nfreq, npol) uu = uu.reshape(nvis, nfreq, npol) vv = vv.reshape(nvis, nfreq, npol) # replace data visibilities with model visibilities visibilities['DATA'][:, 0, 0, :, :, 0] = real_raw + real visibilities['DATA'][:, 0, 0, :, :, 1] = imag_raw + imag visibilities['DATA'][:, 0, 0, :, :, 2] = wgt # replace the data visibilities with the model visibilities visfile[0].data = visibilities #visfile[0].data = vismodel return visfile
def replace(sbmodelloc, visdataloc): # read in the surface brightness map of the model modelimage = fits.getdata(sbmodelloc) modelheader = fits.getheader(sbmodelloc) # read in the uvfits data visfile = fits.open(visdataloc) # load the uv data, including the phase center of the data uu, vv = uvutil.uvload(visfile) # load the uv data, including the phase center of the data pcd = uvutil.pcdload(visfile) # get the number of visfile[0].data, spws, frequencies, polarizations if uu.ndim == 4: nvis = uu[:, 0, 0, 0].size nspw = uu[0, :, 0, 0].size nfreq = uu[0, 0, :, 0].size npol = uu[0, 0, 0, :].size if uu.ndim == 3: nvis = uu[:, 0, 0].size nspw = 0 nfreq = uu[0, :, 0].size npol = uu[0, 0, :].size # sample the uv visfile[0].data using the model uu = uu.flatten() vv = vv.flatten() model_complex = sample_vis.uvmodel(modelimage, modelheader, \ uu, vv, pcd) if nspw > 0: # deflatten the real and imaginary components real = numpy.real(model_complex).reshape(nvis, nspw, nfreq, npol) imag = numpy.imag(model_complex).reshape(nvis, nspw, nfreq, npol) # replace data visfile[0].data with model visfile[0].data visfile[0].data['DATA'][:, 0, 0, :, :, :, 0] = real visfile[0].data['DATA'][:, 0, 0, :, :, :, 1] = imag else: # deflatten the real and imaginary components real = numpy.real(model_complex).reshape(nvis, nfreq, npol) imag = numpy.imag(model_complex).reshape(nvis, nfreq, npol) # replace data visfile[0].data with model visfile[0].data visfile[0].data['DATA'][:, 0, 0, :, :, 0] = real visfile[0].data['DATA'][:, 0, 0, :, :, 1] = imag print "Exiting replace" #visfile[0].data = vismodel return visfile
def lnprob(pzero_regions, p_u_regions, p_l_regions, fixindx, \ real, imag, wgt, uuu, vvv, pcd, lnlikemethod, \ x_regions, y_regions, headmod_regions, celldata, \ model_types_regions, nregions, nlens_regions, nsource_regions): # impose constraints on parameters by setting chi^2 to enormously high # value when a walker chooses a parameter outside the constraints if (pzero_regions < p_l_regions).any(): probln = -numpy.inf mu_flux = 0 #print probln, mu_flux, pzero #print probln, ["%0.2f" % i for i in pzero] return probln, mu_flux if (pzero_regions > p_u_regions).any(): probln = -numpy.inf mu_flux = 0 #print probln, ["%0.2f" % i for i in pzero] return probln, mu_flux if (pzero_regions * 0 != 0).any(): probln = -numpy.inf mu_flux = 0 #print probln, ["%0.2f" % i for i in pzero] return probln, mu_flux # search poff_models for parameters fixed relative to other parameters fixed = (numpy.where(fixindx >= 0))[0] nfixed = fixindx[fixed].size poff_regions = p_u_regions.copy() poff_regions[:] = 0. for ifix in range(nfixed): poff_regions[fixed[ifix]] = pzero_regions[fixindx[fixed[ifix]]] parameters_regions = pzero_regions + poff_regions model_real = 0. model_imag = 0. npar_previous = 0 prindx = 0 amp = [] for regioni in range(nregions): # get the model info for this model x = x_regions[regioni] y = y_regions[regioni] headmod = headmod_regions[regioni] nlens = nlens_regions[regioni] nsource = nsource_regions[regioni] model_types = model_types_regions[prindx:prindx + nsource] prindx += nsource #model_types_regioni = model_types[regioni] # get pzero, p_u, and p_l for this specific model nparlens = 5 * nlens nparsource = 6 * nsource npar = nparlens + nparsource + npar_previous parameters = parameters_regions[npar_previous:npar] npar_previous += npar #----------------------------------------------------------------- # Create a surface brightness map of lensed emission for the given set # of foreground lens(es) and background source parameters. #----------------------------------------------------------------- g_image, g_lensimage, e_image, e_lensimage, amp_tot, amp_mask = \ lensutil.sbmap(x, y, nlens, nsource, parameters, model_types) amp.extend(amp_tot) amp.extend(amp_mask) #---------------------------------------------------------------------- # Python version of UVMODEL: # "Observe" the lensed emission with the interferometer #---------------------------------------------------------------------- if nlens > 0: # Evaluate amplification for each region lensmask = e_lensimage != 0 mask = e_image != 0 numer = g_lensimage[lensmask].sum() denom = g_image[mask].sum() amp_mask = numer / denom numer = g_lensimage.sum() denom = g_image.sum() amp_tot = numer / denom if amp_tot > 1e2: amp_tot = 1e2 if amp_mask > 1e2: amp_mask = 1e2 amp.extend([amp_tot]) amp.extend([amp_mask]) model_complex = sample_vis.uvmodel(g_image, headmod, uuu, vvv, pcd) model_real += numpy.real(model_complex) model_imag += numpy.imag(model_complex) #fits.writeto('g_lensimage.fits', g_lensimage, headmod, clobber=True) #import matplotlib.pyplot as plt #print pzero_regions #plt.imshow(g_lensimage, origin='lower') #plt.colorbar() #plt.show() # use all visibilities goodvis = (real * 0 == 0) # calculate chi^2 assuming natural weighting #fnuisance = 0.0 modvariance_real = 1 / wgt #+ fnuisance ** 2 * model_real ** 2 modvariance_imag = 1 / wgt #+ fnuisance ** 2 * model_imag ** 2 #wgt = wgt / 4. chi2_real_all = (real - model_real) ** 2. / modvariance_real chi2_imag_all = (imag - model_imag) ** 2. / modvariance_imag chi2_all = numpy.append(chi2_real_all, chi2_imag_all) # compute the sigma term sigmaterm_real = numpy.log(2 * numpy.pi * modvariance_real) sigmaterm_imag = numpy.log(2 * numpy.pi * modvariance_imag) sigmaterm_all = numpy.append(sigmaterm_real, sigmaterm_imag) # compute the ln likelihood if lnlikemethod == 'chi2': lnlike = chi2_all else: lnlike = chi2_all + sigmaterm_all # compute number of degrees of freedom #nmeasure = lnlike.size #nparam = (pzero != 0).size #ndof = nmeasure - nparam # assert that lnprob is equal to -1 * maximum likelihood estimate probln = -0.5 * lnlike[goodvis].sum() if probln * 0 != 0: probln = -numpy.inf #print ndof, probln, sigmaterm_all.sum(), chi2_all.sum() return probln, amp
def lnlike(pzero_regions, vis_complex, wgt, uuu, vvv, pcd, fixindx, paramSetup, computeamp=True, miriad=False): """ Function that computes the Ln likelihood of the data""" # search poff_models for parameters fixed relative to other parameters fixed = (numpy.where(fixindx >= 0))[0] nfixed = fixindx[fixed].size p_u_regions = paramSetup['p_u'] poff_regions = p_u_regions.copy() poff_regions[:] = 0. #for ifix in range(nfixed): # poff_regions[fixed[ifix]] = pzero_regions[fixindx[fixed[ifix]]] for ifix in range(nfixed): ifixed = fixed[ifix] subindx = int(fixindx[ifixed]) par0 = 0 if fixindx[subindx] > 0: par0 = pzero_regions[fixindx[subindx]] poff_regions[ifixed] = pzero_regions[subindx] + par0 parameters_regions = pzero_regions + poff_regions npar_previous = 0 amp = [] # Will contain the 'blobs' we compute g_image_all = 0. g_lensimage_all = 0. e_image_all = 0. e_lensimage_all = 0. nregions = paramSetup['nregions'] for regioni in range(nregions): # get the model info for this model x = paramSetup['x'][regioni] y = paramSetup['y'][regioni] headmod = paramSetup['modelheader'][regioni] nlens = paramSetup['nlens_regions'][regioni] nsource = paramSetup['nsource_regions'][regioni] model_types = paramSetup['model_types'][regioni] # get pzero, p_u, and p_l for this specific model nparlens = 5 * nlens nparsource = 6 * nsource npar = nparlens + nparsource + npar_previous parameters = parameters_regions[npar_previous:npar] npar_previous = npar #----------------------------------------------------------------- # Create a surface brightness map of lensed emission for the given set # of foreground lens(es) and background source parameters. #----------------------------------------------------------------- g_image, g_lensimage, e_image, e_lensimage, amp_tot, amp_mask = \ lensutil.sbmap(x, y, nlens, nsource, parameters, model_types, computeamp=computeamp) e_image_all += e_image e_lensimage_all += e_lensimage g_image_all += g_image g_lensimage_all += g_lensimage amp.extend(amp_tot) amp.extend(amp_mask) # -------------------------------------------------------------------- # Python version of UVMODEL: # "Observe" the lensed emission with the interferometer # -------------------------------------------------------------------- if nlens > 0: if computeamp: # Evaluate amplification for each region lensmask = e_lensimage != 0 mask = e_image != 0 numer = g_lensimage[lensmask].sum() denom = g_image[mask].sum() amp_mask = numer / denom numer = g_lensimage.sum() denom = g_image.sum() amp_tot = numer / denom if amp_tot > 1e2: amp_tot = 1e2 if amp_mask > 1e2: amp_mask = 1e2 amp.extend([amp_tot]) amp.extend([amp_mask]) else: amp.extend([1.0]) amp.extend([1.0]) if miriad: # save the fits image of the lensed source ptag = str(os.getpid()) SBmapLoc = 'LensedSBmap' + ptag + '.fits' fits.writeto(SBmapLoc, g_lensimage_all, header=headmod, clobber=True) # convert fits format to miriad format SBmapMiriad = 'LensedSBmap' + ptag + '.miriad' os.system('rm -rf ' + SBmapMiriad) cmd = 'fits op=xyin in=' + SBmapLoc + ' out=' + SBmapMiriad call(cmd + ' > /dev/null 2>&1', shell=True) # compute simulated visibilities modelvisfile = 'SimulatedVisibilities' + ptag + '.miriad' call('rm -rf ' + modelvisfile, shell=True) cmd = 'uvmodel options=subtract vis=' + visfilemiriad + \ ' model=' + SBmapMiriad + ' out=' + modelvisfile call(cmd + ' > /dev/null 2>&1', shell=True) # convert simulated visibilities to uvfits format mvuvfits = 'SimulatedVisibilities' + ptag + '.uvfits' call('rm -rf ' + mvuvfits, shell=True) cmd = 'fits op=uvout in=' + modelvisfile + ' out=' + mvuvfits call(cmd + ' > /dev/null 2>&1', shell=True) # read simulated visibilities mvuv = fits.open(mvuvfits) diff_real = mvuv[0].data['DATA'][:, 0, 0, 0, 0, 0] diff_imag = mvuv[0].data['DATA'][:, 0, 0, 0, 0, 1] wgt = mvuv[0].data['DATA'][:, 0, 0, 0, 0, 2] #model_complex = model_real[goodvis] + 1.0j * model_imag[goodvis] diff_all = numpy.append(diff_real, diff_imag) wgt = numpy.append(wgt, wgt) goodvis = wgt > 0 diff_all = diff_all[goodvis] wgt = wgt[goodvis] chi2_all = wgt * diff_all * diff_all else: model_complex = sample_vis.uvmodel(g_lensimage_all, headmod, uuu, vvv, pcd) # print(vis_complex.shape, model_complex.shape) # remove diff_all = numpy.abs(vis_complex - model_complex) chi2_all = wgt * diff_all * diff_all #model_real += numpy.real(model_complex) #model_imag += numpy.imag(model_complex) #fits.writeto('g_lensimage.fits', g_lensimage_all, headmod, clobber=True) #import matplotlib.pyplot as plt #print(pzero_regions) #plt.imshow(g_lensimage, origin='lower') #plt.colorbar() #plt.show() #plt.imshow(g_image, origin='lower') #plt.colorbar() #plt.show() # calculate chi^2 assuming natural weighting #fnuisance = 0.0 #modvariance_real = 1 / wgt #+ fnuisance ** 2 * model_real ** 2 #modvariance_imag = 1 / wgt #+ fnuisance ** 2 * model_imag ** 2 #wgt = wgt / 4. #chi2_real_all = (real - model_real) ** 2. / modvariance_real #chi2_imag_all = (imag - model_imag) ** 2. / modvariance_imag #chi2_all = numpy.append(chi2_real_all, chi2_imag_all) # compute the sigma term #sigmaterm_real = numpy.log(2 * numpy.pi / wgt) #sigmaterm_imag = numpy.log(2 * numpy.pi * modvariance_imag) # compute the ln likelihood lnlikemethod = paramSetup['lnlikemethod'] if lnlikemethod == 'chi2': lnlike = chi2_all else: # by definition, loglike = -n/2*ln(2pi sigma^2) - 1/(2sigma^2) sum of (data-model)^2 over i=1 to n; but the constant term doesn't matter sigmaterm_all = len(wgt) * numpy.log(2 * numpy.pi / wgt) lnlike = chi2_all # + sigmaterm_all # * -1/2 factor in latter step # compute number of degrees of freedom #nmeasure = lnlike.size #nparam = (pzero != 0).size #ndof = nmeasure - nparam # assert that lnlike is equal to -1 * maximum likelihood estimate # use visibilities where weight is greater than 0 #goodvis = wgt > 0 #likeln = -0.5 * lnlike[goodvis].sum() likeln = -0.5 * lnlike.sum() #print(pcd, likeln) if likeln * 0 != 0: likeln = -numpy.inf return likeln, amp
def lnlike(pzero_regions, vis_complex, wgt, uuu, vvv, pcd, fixindx, paramSetup, computeamp=True, miriad=False): """ Function that computes the Ln likelihood of the data""" # search poff_models for parameters fixed relative to other parameters fixed = (numpy.where(fixindx >= 0))[0] nfixed = fixindx[fixed].size p_u_regions = paramSetup['p_u'] poff_regions = p_u_regions.copy() poff_regions[:] = 0. #for ifix in range(nfixed): # poff_regions[fixed[ifix]] = pzero_regions[fixindx[fixed[ifix]]] for ifix in range(nfixed): ifixed = fixed[ifix] subindx = fixindx[ifixed] par0 = 0 if fixindx[subindx] > 0: par0 = pzero_regions[fixindx[subindx]] poff_regions[ifixed] = pzero_regions[subindx] + par0 parameters_regions = pzero_regions + poff_regions npar_previous = 0 amp = [] # Will contain the 'blobs' we compute g_image_all = 0. g_lensimage_all = 0. e_image_all = 0. e_lensimage_all = 0. nregions = paramSetup['nregions'] for regioni in range(nregions): # get the model info for this model x = paramSetup['x'][regioni] y = paramSetup['y'][regioni] headmod = paramSetup['modelheader'][regioni] nlens = paramSetup['nlens_regions'][regioni] nsource = paramSetup['nsource_regions'][regioni] model_types = paramSetup['model_types'][regioni] # get pzero, p_u, and p_l for this specific model nparlens = 5 * nlens nparsource = 6 * nsource npar = nparlens + nparsource + npar_previous parameters = parameters_regions[npar_previous:npar] npar_previous = npar #----------------------------------------------------------------- # Create a surface brightness map of lensed emission for the given set # of foreground lens(es) and background source parameters. #----------------------------------------------------------------- g_image, g_lensimage, e_image, e_lensimage, amp_tot, amp_mask = \ lensutil.sbmap(x, y, nlens, nsource, parameters, model_types, computeamp=computeamp) e_image_all += e_image e_lensimage_all += e_lensimage g_image_all += g_image g_lensimage_all += g_lensimage amp.extend(amp_tot) amp.extend(amp_mask) # -------------------------------------------------------------------- # Python version of UVMODEL: # "Observe" the lensed emission with the interferometer # -------------------------------------------------------------------- if nlens > 0: if computeamp: # Evaluate amplification for each region lensmask = e_lensimage != 0 mask = e_image != 0 numer = g_lensimage[lensmask].sum() denom = g_image[mask].sum() amp_mask = numer / denom numer = g_lensimage.sum() denom = g_image.sum() amp_tot = numer / denom if amp_tot > 1e2: amp_tot = 1e2 if amp_mask > 1e2: amp_mask = 1e2 amp.extend([amp_tot]) amp.extend([amp_mask]) else: amp.extend([1.0]) amp.extend([1.0]) if miriad: configloc = 'sandbox.yaml' configfile = open(configloc, 'r') config = yaml.load(configfile) visfile = config['UVData'] index = visfile.index('uvfits') visfilemiriad = visfile[0:index] + 'miriad' # save the fits image of the lensed source ptag = str(os.getpid()) SBmapLoc = 'LensedSBmap' + ptag + '.fits' fits.writeto(SBmapLoc, g_lensimage_all, header=headmod, clobber=True) # convert fits format to miriad format SBmapMiriad = 'LensedSBmap' + ptag + '.miriad' os.system('rm -rf ' + SBmapMiriad) cmd = 'fits op=xyin in=' + SBmapLoc + ' out=' + SBmapMiriad call(cmd + ' > /dev/null 2>&1', shell=True) # compute simulated visibilities modelvisfile = 'SimulatedVisibilities' + ptag + '.miriad' call('rm -rf ' + modelvisfile, shell=True) cmd = 'uvmodel options=subtract vis=' + visfilemiriad + \ ' model=' + SBmapMiriad + ' out=' + modelvisfile call(cmd + ' > /dev/null 2>&1', shell=True) # convert simulated visibilities to uvfits format mvuvfits = 'SimulatedVisibilities' + ptag + '.uvfits' call('rm -rf ' + mvuvfits, shell=True) cmd = 'fits op=uvout in=' + modelvisfile + ' out=' + mvuvfits call(cmd + ' > /dev/null 2>&1', shell=True) # read simulated visibilities mvuv = fits.open(mvuvfits) diff_real = mvuv[0].data['DATA'][:, 0, 0, 0, 0, 0] diff_imag = mvuv[0].data['DATA'][:, 0, 0, 0, 0, 1] wgt = mvuv[0].data['DATA'][:, 0, 0, 0, 0, 2] #model_complex = model_real[goodvis] + 1.0j * model_imag[goodvis] diff_all = numpy.append(diff_real, diff_imag) wgt = numpy.append(wgt, wgt) goodvis = wgt > 0 diff_all = diff_all[goodvis] wgt = wgt[goodvis] chi2_all = wgt * diff_all * diff_all else: model_complex = sample_vis.uvmodel(g_lensimage_all, headmod, uuu, vvv, pcd) vis_complex -= model_complex diff_all = wgt * numpy.abs(vis_complex)**2 chi2_all = diff_all #wgt * diff_all * diff_all #import pdb; pdb.set_trace() #model_real += numpy.real(model_complex) #model_imag += numpy.imag(model_complex) #fits.writeto('g_lensimage.fits', g_lensimage_all, headmod, clobber=True) #import matplotlib.pyplot as plt #print(pzero_regions) #plt.imshow(g_lensimage, origin='lower') #plt.colorbar() #plt.show() #plt.imshow(g_image, origin='lower') #plt.colorbar() #plt.show() # calculate chi^2 assuming natural weighting #fnuisance = 0.0 #modvariance_real = 1 / wgt #+ fnuisance ** 2 * model_real ** 2 #modvariance_imag = 1 / wgt #+ fnuisance ** 2 * model_imag ** 2 #wgt = wgt / 4. #chi2_real_all = (real - model_real) ** 2. / modvariance_real #chi2_imag_all = (imag - model_imag) ** 2. / modvariance_imag #chi2_all = numpy.append(chi2_real_all, chi2_imag_all) # compute the sigma term #sigmaterm_real = numpy.log(2 * numpy.pi / wgt) #sigmaterm_imag = numpy.log(2 * numpy.pi * modvariance_imag) # compute the ln likelihood lnlikemethod = paramSetup['lnlikemethod'] if lnlikemethod == 'chi2': lnlike = chi2_all else: sigmaterm_all = 2 * numpy.log(2 * numpy.pi / wgt) lnlike = chi2_all + sigmaterm_all # compute number of degrees of freedom #nmeasure = lnlike.size #nparam = (pzero != 0).size #ndof = nmeasure - nparam # assert that lnlike is equal to -1 * maximum likelihood estimate # use visibilities where weight is greater than 0 #goodvis = wgt > 0 #likeln = -0.5 * lnlike[goodvis].sum() likeln = -0.5 * lnlike.sum() #print(pcd, likeln) if likeln * 0 != 0: likeln = -numpy.inf return likeln, amp
def log_likelihood_bussman(p, data, sources, xmap, ymap, dx, dy, u, v, lowres_header, phase_center): """ Same as ``log_likelihood_lens`` but borrowing the visibility generation routine from Shane Bussman's ``uvmcmcfit``. This one is slower since computes the grid every time and does not use rectangular bivariate interpolation. Allegedly implements "optimal gridding" algorithm by Schwab+84. NOTE: WE ASSUME ALL 2D ARRAYS TO BE SQUARE Parameters ---------- p : array Array of proposed MCMC steps. Its length is the numbers of free parameters to fit. data : list List of ~visilens.VisData objects. sources : list List of objects of any subclass of ~astropy.modeling.models.Fittable2DModel xmap : array Full resolution array of x-coordinates (+x is West). ymap : array Full resolution array of y-coordinates (+y is North). dx: list List of full-resolution x-deflection field arrays. Assumes each source has different redshift so it must have the same length and same indices as `sources`. If two or more source have the same redshift one could pass as many copies of the same deflection field as needed. dy: list List of full-resolution y-deflection field arrays. Assumes each source has different redshift so it must have the same length and same indices as `sources`. If two or more source have the same redshift one could pass as many copies of the same deflection field as needed. u: array Irregular array of observed *u* coordinates in meters, not kilolambda. v: array Irregular array of observed *v* coordinates in meters, not kilolambda. lowres_header: FITS header object Header specifying the size and pixel scale of the downsampled image. Not necessarily the WCS. phase_center: list Right ascension and declination of the visibilities phase center, i.e [ra, dec] in degrees. """ source_list = check_priors(p, sources) if source_list is None: return -np.inf logL = 0.0 for i, dset in enumerate(data): npix = lowres_header['NAXIS1'] immap = create_image(source_list, xmap, ymap, dx, dy) # Re-sample while keeping total flux pre_sum = np.sum(immap) immap = resize(immap, (npix, npix)) post_sum = np.sum(immap) immap *= pre_sum / post_sum interpdata = uvmodel(immap, lowres_header, u, v, phase_center) logL -= np.sum(np.hypot(dset.real - interpdata.real, dset.imag - interpdata.imag) /\ dset.sigma ** 2) return logL