def makeSBmap(config, fitresult): """ Make a surface brightness map of the lensed image for a given set of model parameters. """ import lensutil from astropy.io import fits import os import setuputil import re import numpy # Loop over each region # read the input parameters paramData = setuputil.loadParams(config) nlensedsource = paramData['nlensedsource'] nlensedregions = paramData['nlensedregions'] npar_previous = 0 configkeys = config.keys() configkeystring = " ".join(configkeys) regionlist = re.findall('Region.', configkeystring) SBmap_all = 0 LensedSBmap_all = 0 nregion = len(regionlist) for regioni in range(nregion): regstring = 'Region' + str(regioni) #indx = paramData['regionlist'].index(regstring) cr = config[regstring] nmu = 2 * (numpy.array(nlensedsource).sum() + nlensedregions) if nmu > 0: allparameters0 = list(fitresult)[1:-nmu] else: allparameters0 = list(fitresult)[1:] # search poff_models for parameters fixed relative to other parameters fixindx = setuputil.fixParams(paramData) poff = paramData['poff'] ndim_total = len(poff) fixed = (numpy.where(fixindx >= 0))[0] nfixed = fixindx[fixed].size parameters_offset = numpy.zeros(ndim_total) for ifix in range(nfixed): ifixed = fixed[ifix] subindx = fixindx[ifixed] par0 = 0 if fixindx[subindx] > 0: par0 = fitresult[fixindx[subindx] + 1] parameters_offset[ifixed] = fitresult[subindx + 1] + par0 allparameters = allparameters0 + parameters_offset # count the number of lenses configkeys = cr.keys() configkeystring = " ".join(configkeys) lenslist = re.findall('Lens.', configkeystring) nlens = len(lenslist) # count the number of sources sourcelist = re.findall('Source.', configkeystring) nsource = len(sourcelist) nparperlens = 5 nparpersource = 6 nparlens = nparperlens * nlens nparsource = nparpersource * nsource npar = nparlens + nparsource + npar_previous parameters = allparameters[npar_previous:npar] npar_previous = npar #nlens = paramData['nlens_regions'][indx] #nsource = paramData['nsource_regions'][indx] x = paramData['x'][regioni] y = paramData['y'][regioni] modelheader = paramData['modelheader'][regioni] model_types = paramData['model_types'][regioni] SBmap, LensedSBmap, Aperture, LensedAperture, mu_tot, mu_mask = \ lensutil.sbmap(x, y, nlens, nsource, parameters, model_types, \ computeamp=True) caustics = False if caustics: deltapar = parameters[0:nparlens + nparpersource] refine = 2 nx = x[:, 0].size * refine ny = y[:, 0].size * refine x1 = x[0, :].min() x2 = x[0, :].max() linspacex = numpy.linspace(x1, x2, nx) y1 = y[:, 0].min() y2 = y[:, 0].max() linspacey = numpy.linspace(y1, y2, ny) onex = numpy.ones(nx) oney = numpy.ones(ny) finex = numpy.outer(oney, linspacex) finey = numpy.outer(linspacey, onex) mumap = numpy.zeros([ny, nx]) for ix in range(nx): for iy in range(ny): deltapar[-nparpersource + 0] = finex[ix, iy] deltapar[-nparpersource + 1] = finey[ix, iy] xcell = paramData['celldata'] deltapar[-nparpersource + 2] = xcell deltaunlensed, deltalensed, A1, A2, mu_xy, mu_xymask = \ lensutil.sbmap(finex, finey, nlens, 1, deltapar, ['Delta']) mumap[ix, iy] = mu_xy[0] import matplotlib.pyplot as plt plt.imshow(mumap, origin='lower') plt.contour(mumap, levels=[mumap.max() / 1.1]) import pdb pdb.set_trace() SBmap_all += SBmap LensedSBmap_all += LensedSBmap LensedSBmapLoc = 'LensedSBmap.fits' SBmapLoc = 'SBmap_Region.fits' cmd = 'rm -rf ' + LensedSBmapLoc + ' ' + SBmapLoc os.system(cmd) fits.writeto(LensedSBmapLoc, LensedSBmap_all, modelheader) fits.writeto(SBmapLoc, SBmap_all, modelheader) return
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
crpix2 = nymod / 2 + 1 cdelt1 = -1 * celldata / 3600 / oversample cdelt2 = celldata / 3600 / oversample modelheader.update('naxis1', nxmod) modelheader.update('cdelt1', cdelt1) modelheader.update('crpix1', crpix1) modelheader.update('crval1', ra_centroid) modelheader.update('ctype1', 'RA---SIN') modelheader.update('naxis2', nymod) modelheader.update('cdelt2', cdelt2) modelheader.update('crpix2', crpix2) modelheader.update('crval2', dec_centroid) modelheader.update('ctype2', 'DEC--SIN') g_image, g_lensimage, e_image, e_lensimage, amp_tot, amp_mask = \ lensutil.sbmap(x, y, nlens, nsource, parameters, model_types) #-------------------------------------------------------------------------- # Compute magnification numer = g_lensimage.sum() denom = g_image.sum() mu_fluxratio = numer / denom print 'F_out / F_in = ', mu_fluxratio #-------------------------------------------------------------------------- # write the lensed and unlensed surface brightness maps to disk outfits = 'sbmap_image_Region' + sri + '.fits' outfits_miriad = 'sbmap_image' + sri outfits_unlens = 'sbmap_source' + sri + '.fits' os.system('rm -rf ' + outfits) os.system('rm -rf ' + outfits_unlens)
def makeSBmap(config, fitresult): """ Make a surface brightness map of the lensed image for a given set of model parameters. """ import lensutil from astropy.io import fits import os import setuputil import re import numpy # Loop over each region # read the input parameters paramData = setuputil.loadParams(config) nlensedsource = paramData['nlensedsource'] nlensedregions = paramData['nlensedregions'] npar_previous = 0 configkeys = config.keys() configkeystring = " ".join(configkeys) regionlist = re.findall('Region.', configkeystring) SBmap_all = 0 LensedSBmap_all = 0 nregion = len(regionlist) for regioni in range(nregion): regstring = 'Region' + str(regioni) #indx = paramData['regionlist'].index(regstring) cr = config[regstring] nmu = 2 * (numpy.array(nlensedsource).sum() + nlensedregions) if nmu > 0: allparameters0 = list(fitresult)[1:-nmu] else: allparameters0 = list(fitresult)[1:] # search poff_models for parameters fixed relative to other parameters fixindx = setuputil.fixParams(paramData) poff = paramData['poff'] ndim_total = len(poff) fixed = (numpy.where(fixindx >= 0))[0] nfixed = fixindx[fixed].size parameters_offset = numpy.zeros(ndim_total) for ifix in range(nfixed): ifixed = fixed[ifix] subindx = fixindx[ifixed] par0 = 0 if fixindx[subindx] > 0: par0 = fitresult[fixindx[subindx] + 1] parameters_offset[ifixed] = fitresult[subindx + 1] + par0 allparameters = allparameters0 + parameters_offset # count the number of lenses configkeys = cr.keys() configkeystring = " ".join(configkeys) lenslist = re.findall('Lens.', configkeystring) nlens = len(lenslist) # count the number of sources sourcelist = re.findall('Source.', configkeystring) nsource = len(sourcelist) nparperlens = 5 nparpersource = 6 nparlens = nparperlens * nlens nparsource = nparpersource * nsource npar = nparlens + nparsource + npar_previous parameters = allparameters[npar_previous:npar] npar_previous = npar #nlens = paramData['nlens_regions'][indx] #nsource = paramData['nsource_regions'][indx] x = paramData['x'][regioni] y = paramData['y'][regioni] modelheader = paramData['modelheader'][regioni] model_types = paramData['model_types'][regioni] SBmap, LensedSBmap, Aperture, LensedAperture, mu_tot, mu_mask = \ lensutil.sbmap(x, y, nlens, nsource, parameters, model_types, \ computeamp=True) caustics = False if caustics: deltapar = parameters[0:nparlens + nparpersource] refine = 2 nx = x[:, 0].size * refine ny = y[:, 0].size * refine x1 = x[0, :].min() x2 = x[0, :].max() linspacex = numpy.linspace(x1, x2, nx) y1 = y[:, 0].min() y2 = y[:, 0].max() linspacey = numpy.linspace(y1, y2, ny) onex = numpy.ones(nx) oney = numpy.ones(ny) finex = numpy.outer(oney, linspacex) finey = numpy.outer(linspacey, onex) mumap = numpy.zeros([ny, nx]) for ix in range(nx): for iy in range(ny): deltapar[-nparpersource + 0] = finex[ix, iy] deltapar[-nparpersource + 1] = finey[ix, iy] xcell = paramData['celldata'] deltapar[-nparpersource + 2] = xcell deltaunlensed, deltalensed, A1, A2, mu_xy, mu_xymask = \ lensutil.sbmap(finex, finey, nlens, 1, deltapar, ['Delta']) mumap[ix, iy] = mu_xy[0] import matplotlib.pyplot as plt plt.imshow(mumap, origin='lower') plt.contour(mumap, levels=[mumap.max()/1.1]) import pdb; pdb.set_trace() SBmap_all += SBmap LensedSBmap_all += LensedSBmap LensedSBmapLoc = 'LensedSBmap.fits' SBmapLoc = 'SBmap_Region.fits' cmd = 'rm -rf ' + LensedSBmapLoc + ' ' + SBmapLoc os.system(cmd) fits.writeto(LensedSBmapLoc, LensedSBmap_all, modelheader) fits.writeto(SBmapLoc, SBmap_all, modelheader) return
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