im500hdu = hdulist['image'].header
im500 = hdulist['image'].data * 1.0E3 #convert to mJy
nim500 = hdulist['error'].data * 1.0E3 #convert to mJy
w_500 = wcs.WCS(hdulist[1].header)
pixsize500 = 3600.0 * w_500.wcs.cd[1, 1] #pixel size (in arcseconds)
hdulist.close()
from astropy.coordinates import SkyCoord
from astropy import units as u
c = SkyCoord(ra=ras * u.degree, dec=decs * u.degree)
import pymoc
moc = pymoc.util.catalog.catalog_to_moc(c, 60, 15)
#---prior250--------
prior250 = xidplus.prior(
im250, nim250, im250phdu, im250hdu, moc=moc
) #Initialise with map, uncertianty map, wcs info and primary header
prior250.prior_cat(prior_cat['ra'],
prior_cat['dec'],
'prior_cat',
ID=prior_cat['help_id']) #Set input catalogue
prior250.prior_bkg(
-5.0, 5) #Set prior on background (assumes Gaussian pdf with mu and sigma)
#---prior350--------
prior350 = xidplus.prior(im350, nim350, im350phdu, im350hdu, moc=moc)
prior350.prior_cat(prior_cat['ra'],
prior_cat['dec'],
'prior_cat',
ID=prior_cat['help_id'])
prior350.prior_bkg(-5.0, 5)
decs = lofar_orig['DEC'][n:n + 1]
ID = lofar_orig['Source_Name'][n:n + 1]
from astropy.coordinates import SkyCoord
from astropy import units as u
c = SkyCoord(ra=ras * u.degree, dec=decs * u.degree)
import pymoc
moc_near = pymoc.util.catalog.catalog_to_moc(c, 60, 15)
moc_mask = inMoc(lofar_orig['RA'], lofar_orig['DEC'], moc_near)
moc = pymoc.util.catalog.catalog_to_moc(c, 120, 15)
prior = xidplus.prior(
radim_data, radim_err, radim_header, radim_header, moc=moc
) #Initialise with map, uncertianty map, wcs info and primary header
prior.prior_cat(lofar_orig['RA'][moc_mask],
lofar_orig['DEC'][moc_mask],
'prior_cat',
ID=lofar_orig['Source_Name'][moc_mask],
moc=moc) #Set input catalogue
prior.prior_bkg(
-5.0, 5) #Set prior on background (assumes Gaussian pdf with mu and sigma)
pind = np.arange(0, n_size) #*(1.0/radim_pixsize)
prior.set_prf(prf.array, pind, pind)
prior.get_pointing_matrix()
prior.upper_lim_map()
#import pylab as plt
#plt.figure(figsize=(20,10))
#plt.subplot(1,2,1)
#plt.imshow(pacs100_psf[0].data[centre100-radius100:centre100+radius100+1,centre100-radius100:centre100+radius100+1])
#plt.colorbar()
#plt.subplot(1,2,2)
#plt.imshow(pacs160_psf[0].data[centre160-radius160:centre160+radius160+1,centre160-radius160:centre160+radius160+1])
#plt.colorbar()
# ## Set XID+ prior class
# In[ ]:
#---prior100--------
prior100 = xidplus.prior(
im100, nim100, im100phdu, im100hdu, moc=Final
) #Initialise with map, uncertianty map, wcs info and primary header
prior100.prior_cat(prior['RA'],
prior['Dec'],
'GAMA09_Ldust_prediction_results.fits',
ID=prior['help_id']) #Set input catalogue
prior100.prior_bkg(
0.0, 5) #Set prior on background (assumes Gaussian pdf with mu and sigma)
#---prior160--------
prior160 = xidplus.prior(im160, nim160, im160phdu, im160hdu, moc=Final)
prior160.prior_cat(prior['RA'],
prior['Dec'],
'GAMA09_Ldust_prediction_results.fits',
ID=prior['help_id'])
prior160.prior_bkg(0.0, 5)
MIPS_Map = fits.open(filename[index])
w_im = wcs.WCS(MIPS_Map[1].header)
w_nim = wcs.WCS(MIPS_Map[2].header)
#print('w_im: ', w_im, '\n w_nim: ', w_nim)
MIPS_Map[1].header['CRVAL1'] = MIPS_Map[2].header['CRVAL1']
MIPS_Map[1].header['CRVAL2'] = MIPS_Map[2].header['CRVAL2']
data = MIPS_Map[1].data
# ## Set XID+ prior class
print('setting XID+ priors')
prior_MIPS = xidplus.prior(MIPS_Map[1].data,
MIPS_Map[2].data,
MIPS_Map[0].header,
MIPS_Map[1].header,
moc=Final)
prior_MIPS.prior_cat(masterlist[1].data['ra'][good],
masterlist[1].data['dec'][good],
masterfile,
flux_lower=MIPS_lower,
flux_upper=MIPS_upper,
ID=masterlist[1].data['help_id'][good])
#prior_MIPS.sra
#xidplus.plot_map([prior_MIPS])
prior_MIPS.set_prf(
MIPS_psf[1].data[centre - radius:centre + radius + 1,
def clus_get_xid(maps,
cats,
savemap=0,
simmap=0,
verbose=1,
confusionerrors=1):
err = False
thresh = 3.0
mf = 1.0
mJy2Jy = 1000.0 / mf
catfile = config.CLUSDATA + 'placeholder' #this doesn't actually seem to do anything in the xid code,
# but you need something for this for some reason.
#Old code not used anymore
# print('Retrieving data from cats')
# inra = []
# indec = []
# for i in range(len(cats)):
# for j in range(len(cats[i]['ra'])):
# if cats[i]['ra'][j] not in inra and cats[i]['dec'][j] not in indec:
# inra.append(cats[i]['ra'][j])
# indec.append(cats[i]['dec'][j])
# print('Done retrieving data from cats')
inra = np.array(cats['ra'])
indec = np.array(cats['dec'])
ra = inra * u.deg
dec = indec * u.deg
c = SkyCoord(ra, dec, unit='deg')
plt.scatter(ra, dec, c=cats['flux'], alpha=0.5)
plt.show()
print(inra)
#initializing data containers.
pinds = []
files = []
primary_hdus = []
noise_maps = []
data_maps = []
headers = []
pixsizes = []
prf_sizes = []
priors = []
prfs = []
for i in range(len(maps)):
bands = [18, 25, 36] #units of arcseconds
fwhm = bands[i] / maps[i]['pixsize'] #converts to arcseconds/pixel
pixs = maps[i]['pixsize']
size = pixs * 5
moc = pymoc.util.catalog.catalog_to_moc(c, size, 15)
#getting data from the fits files
files.append(maps[i]['file'])
hdul = fits.open(files[i])
headers.append(hdul[1].header)
primary_hdus.append(hdul[0].header)
img = hdul[1].data
data_maps.append(img)
noise_maps.append(hdul[2].data)
pixsizes.append(maps[i]['pixsize'])
prf_sizes.append(get_spire_beam_fwhm(maps[i]['band']))
pinds.append(np.arange(0, 101, 1) * 1.0 / pixsizes[i])
# print(maps[i]['file'])
# print(pixsizes[i])
#setting up priors
prior = xidplus.prior(data_maps[i],
noise_maps[i],
primary_hdus[i],
headers[i],
moc=moc)
prior.prior_cat(inra, indec, catfile, moc=moc)
prior.prior_bkg(-5.0, 5)
#setting up prfs.
# This prf doesnt quite look correct
# In previous set up we needed to rebin to accuratly describe our beam sizes
prf = Gaussian2DKernel(
bands[i] / 2.355, x_size=101,
y_size=101) #maybe x_size and y_size need to change.
prf.normalize(mode='peak')
prfs.append(prf.array)
# print(prfs)
exit()
#appending prf to prior and setting point matrix
prior.set_prf(prfs[i], pinds[i], pinds[i]) #prfs, xpinds, ypinds
prior.get_pointing_matrix()
prior.upper_lim_map()
#appending prior to priors list.
priors.append(prior)
print('fitting %s sources' % (priors[0].nsrc))
print('using %s %s %s pixels' %
(priors[0].snpix, priors[1].snpix, priors[2].snpix))
fit = SPIRE.all_bands(
priors[0], priors[1], priors[2], iter=1000
) #number of iterations should be at least 100 just set lower for testing.
posterior = xidplus.posterior_stan(fit, [priors[0], priors[1], priors[2]])
# figs, fig = xidplus.plots.plot_Bayes_pval_map(priors, posterior)
# print(type(figs)) #figs is list.
# print(figs) #fig is matplotlib.figure.figure object.
# print(type(fig))
# cols = ['PSW', 'PMW', 'PLW']
# counter = 0
# for figure in figs:
# figure.save('xid_%s.png' %(cols[counter]))
# counter += 1
# plt.imshow(figs)
spire_cat = cat.create_SPIRE_cat(posterior, priors[0], priors[1],
priors[2])
# spire_cat.writeto('xid_model_2_%s.fits' % (maps[0]['name']))
xid_data = spire_cat[1].data
xid = []
#in units of mJy for fluxes and degrees for RA/DEC
xid1 = {
'band': 'PSW',
'sra': xid_data.field('RA'),
'sdec': xid_data.field('DEC'),
'sflux': xid_data.field('F_SPIRE_250'),
'serr': xid_data.field(
'FErr_SPIRE_250_u'
), #there was also FErr_SPIRE_250_l don't know which to use.
'pflux': xid_data.field('F_SPIRE_250'),
'perr': xid_data.field('FErr_SPIRE_250_u'),
'model': None,
'mf': mf
} #idk if perr and pflux is right there may be a conversion needed for pflux.
#in mikes code it has pflux = output from xid / mJy2Jy.
xid2 = {
'band': 'PMW',
'sra': xid_data.field('RA'),
'sdec': xid_data.field('DEC'),
'sflux': xid_data.field('F_SPIRE_350'),
'serr': xid_data.field('FErr_SPIRE_350_u'),
'pflux': xid_data.field('F_SPIRE_350'),
'perr': xid_data.field('FErr_SPIRE_350_u'),
'model': None,
'mf': mf
}
xid3 = {
'band': 'PLW',
'sra': xid_data.field('RA'),
'sdec': xid_data.field('DEC'),
'sflux': xid_data.field('F_SPIRE_500'),
'serr': xid_data.field('FErr_SPIRE_500_u'),
'pflux': xid_data.field('F_SPIRE_500'),
'perr': xid_data.field('FErr_SPIRE_500_u'),
'model': None,
'mf': mf
}
#there was another term in the dictionary sflux, pflux and sflux looked like maybe the same thing, but I'm not sure.
#I left it out so if there are issues with that then it is because that is gone.
xid.append(xid1)
xid.append(xid2)
xid.append(xid3)
# models = create_model(maps, xid)
# for i in range(len(xid)):
# xid[i]['model'] = models[i]
# # only look at data with a flux lower than 0.0
# for i in range(len(xid)):
# whpl = []
# for j in range(xid[i]['model'].shape[0]):
# for k in range(xid[i]['model'].shape[1]):
# if xid[i]['pflux'][j] >= 0.0:
# whpl.append(j)
# whpl = np.array(whpl)
#
# xid[i]['sra'] = xid[i]['sra'][whpl]
# xid[i]['sdec'] = xid[i]['sdec'][whpl]
# xid[i]['x'] = xid[i]['x'][whpl]
# xid[i]['y'] = xid[i]['y'][whpl]
# xid[i]['sflux'] = xid[i]['sflux'][whpl]
# xid[i]['serr'] = xid[i]['serr'][whpl]
for i in range(len(xid)):
ra = xid[i]['sra'] * u.deg
dec = xid[i]['sdec'] * u.deg
c = SkyCoord(ra, dec)
#initializing w class.
hdul = fits.open(maps[i]['file'])
w = wcs(hdul[1].header)
#converting ra/dec to pixel coords.
px, py = skycoord_to_pixel(c, w)
xid[i]['x'] = px
xid[i]['y'] = py
xid[i]['sra'] = xid[i]['sra'].tolist()
xid[i]['sdec'] = xid[i]['sdec'].tolist()
xid[i]['sflux'] = xid[i]['sflux'].tolist()
xid[i]['serr'] = xid[i]['serr'].tolist()
xid[i]['pflux'] = xid[i]['pflux'].tolist()
xid[i]['perr'] = xid[i]['perr'].tolist()
xid[i]['x'] = xid[i]['x'].tolist()
xid[i]['y'] = xid[i]['y'].tolist()
#saving to json file for further analysis.
with open('xid_a0370_take_9_%s.json' % (xid[i]['band']),
'w') as f: #code for saving output to a file.
json.dump(xid[i], f)
#model = image_model(x,y, sflux, maps[i]['astr']['NAXIS'][0], maps[i]['astr']['NAXIS'][1],
#maps[i]['psf'])
#need to finish converting model over to python.
#
# if savemap:
# outfile = config.CLUSSBOX + 'clus_get_xid_model_' + maps[i]['band'] + '.fit'
# writefits(outfile, data=model, header_dict=maps[i]['shead'])
return xid, err
def setUp(self):
xidplus.__path__[0]
# Folder containing maps
imfolder = xidplus.__path__[0] + '/../test_files/'
pswfits = imfolder + 'cosmos_itermap_lacey_07012015_simulated_observation_w_noise_PSW_hipe.fits.gz' # SPIRE 250 map
pmwfits = imfolder + 'cosmos_itermap_lacey_07012015_simulated_observation_w_noise_PMW_hipe.fits.gz' # SPIRE 350 map
plwfits = imfolder + 'cosmos_itermap_lacey_07012015_simulated_observation_w_noise_PLW_hipe.fits.gz' # SPIRE 500 map
# Folder containing prior input catalogue
catfolder = xidplus.__path__[0] + '/../test_files/'
# prior catalogue
prior_cat = 'lacey_07012015_MillGas.ALLVOLS_cat_PSW_COSMOS_test.fits'
# output folder
output_folder = './'
# -----250-------------
hdulist = fits.open(pswfits)
im250phdu = hdulist[0].header
im250hdu = hdulist[1].header
im250 = hdulist[1].data * 1.0E3 # convert to mJy
nim250 = hdulist[2].data * 1.0E3 # convert to mJy
w_250 = wcs.WCS(hdulist[1].header)
pixsize250 = 3600.0 * w_250.wcs.cd[1, 1] # pixel size (in arcseconds)
hdulist.close()
# -----350-------------
hdulist = fits.open(pmwfits)
im350phdu = hdulist[0].header
im350hdu = hdulist[1].header
im350 = hdulist[1].data * 1.0E3 # convert to mJy
nim350 = hdulist[2].data * 1.0E3 # convert to mJy
w_350 = wcs.WCS(hdulist[1].header)
pixsize350 = 3600.0 * w_350.wcs.cd[1, 1] # pixel size (in arcseconds)
hdulist.close()
# -----500-------------
hdulist = fits.open(plwfits)
im500phdu = hdulist[0].header
im500hdu = hdulist[1].header
im500 = hdulist[1].data * 1.0E3 # convert to mJy
nim500 = hdulist[2].data * 1.0E3 # convert to mJy
w_500 = wcs.WCS(hdulist[1].header)
pixsize500 = 3600.0 * w_500.wcs.cd[1, 1] # pixel size (in arcseconds)
hdulist.close()
hdulist = fits.open(catfolder + prior_cat)
fcat = hdulist[1].data
hdulist.close()
inra = fcat['RA']
indec = fcat['DEC']
# select only sources with 100micron flux greater than 50 microJy
sgood = fcat['S100'] > 0.050
inra = inra[sgood]
indec = indec[sgood]
from astropy.coordinates import SkyCoord
from astropy import units as u
c = SkyCoord(ra=[150.74] * u.degree, dec=[2.03] * u.degree)
import pymoc
moc = pymoc.util.catalog.catalog_to_moc(c, 100, 15)
# ---prior250--------
prior250 = xidplus.prior(
im250, nim250, im250phdu, im250hdu, moc=moc
) # Initialise with map, uncertianty map, wcs info and primary header
prior250.prior_cat(inra, indec, prior_cat) # Set input catalogue
prior250.prior_bkg(
-5.0, 5
) # Set prior on background (assumes Gaussian pdf with mu and sigma)
# ---prior350--------
prior350 = xidplus.prior(im350, nim350, im350phdu, im350hdu, moc=moc)
prior350.prior_cat(inra, indec, prior_cat)
prior350.prior_bkg(-5.0, 5)
# ---prior500--------
prior500 = xidplus.prior(im500, nim500, im500phdu, im500hdu, moc=moc)
prior500.prior_cat(inra, indec, prior_cat)
prior500.prior_bkg(-5.0, 5)
self.priors = [prior250, prior350, prior500]
def process_prior(
c,
new_Table=None,
path_to_data=['../../../data/'],
field=['Lockman-SWIRE'],
path_to_SPIRE=[
'/Volumes/pdh_storage/dmu_products/dmu19/dmu19_HELP-SPIRE-maps/data/'
],
redshift_file=[
"/Volumes/pdh_storage/dmu_products/dmu24/dmu24_Lockman-SWIRE/data/master_catalogue_Lockman-SWIRE_20170710_photoz_20170802_r_and_irac1_optimised_UPDATED_IDs_20180219.fits"
],
redshift_prior=[0.1, 2.0],
radius=6.0,
alt_model=False):
# Import required modules
# In[3]:
# In[4]:
# Set image and catalogue filenames
# In[5]:
#Folder containing maps
pswfits = path_to_SPIRE[0] + '{}_SPIRE250_v1.0.fits'.format(
field[0]) #SPIRE 250 map
pmwfits = path_to_SPIRE[0] + '{}_SPIRE350_v1.0.fits'.format(
field[0]) #SPIRE 350 map
plwfits = path_to_SPIRE[0] + '{}_SPIRE500_v1.0.fits'.format(
field[0]) #SPIRE 500 map
#output folder
output_folder = './'
# Load in images, noise maps, header info and WCS information
# In[6]:
#-----250-------------
hdulist = fits.open(pswfits)
im250phdu = hdulist[0].header
im250hdu = hdulist[1].header
im250 = hdulist[1].data * 1.0E3 #convert to mJy
nim250 = hdulist[3].data * 1.0E3 #convert to mJy
w_250 = wcs.WCS(hdulist[1].header)
pixsize250 = np.abs(3600.0 *
w_250.wcs.cdelt[0]) #pixel size (in arcseconds)
hdulist.close()
#-----350-------------
hdulist = fits.open(pmwfits)
im350phdu = hdulist[0].header
im350hdu = hdulist[1].header
im350 = hdulist[1].data * 1.0E3 #convert to mJy
nim350 = hdulist[3].data * 1.0E3 #convert to mJy
w_350 = wcs.WCS(hdulist[1].header)
pixsize350 = np.abs(3600.0 *
w_350.wcs.cdelt[0]) #pixel size (in arcseconds)
hdulist.close()
#-----500-------------
hdulist = fits.open(plwfits)
im500phdu = hdulist[0].header
im500hdu = hdulist[1].header
im500 = hdulist[1].data * 1.0E3 #convert to mJy
nim500 = hdulist[3].data * 1.0E3 #convert to mJy
w_500 = wcs.WCS(hdulist[1].header)
pixsize500 = np.abs(3600.0 *
w_500.wcs.cdelt[0]) #pixel size (in arcseconds)
hdulist.close()
# XID+ uses Multi Order Coverage (MOC) maps for cutting down maps and catalogues so they cover the same area. It can also take in MOCs as selection functions to carry out additional cuts. Lets use the python module [pymoc](http://pymoc.readthedocs.io/en/latest/) to create a MOC, centered on a specific position we are interested in. We will use a HEALPix order of 15 (the resolution: higher order means higher resolution)
moc = pymoc.util.catalog.catalog_to_moc(c, 100, 15)
# Load in catalogue you want to fit (and make any cuts). Here we use HELP's VO database and directly call it using PyVO
# In[10]:
import pyvo as vo
service = vo.dal.TAPService(
"https://herschel-vos.phys.sussex.ac.uk/__system__/tap/run/tap")
# In[11]:
resultset = service.search(
"SELECT TOP 10000 * FROM herschelhelp.main WHERE 1=CONTAINS(POINT('ICRS', ra, dec),CIRCLE('ICRS',"
+ str(c.ra.deg[0]) + ", " + str(c.dec.deg[0]) + ", 0.028 ))")
# In[12]:
masterlist = resultset.table
def construct_prior(Table=None):
from astropy.coordinates import SkyCoord
#first use standard cut (i.e. not star and is detected in at least 3 opt/nir bands)
prior_list = masterlist[(masterlist['flag_gaia'] != 3)
& (masterlist['flag_optnir_det'] >= 3)]
#make skycoord from masterlist
catalog = SkyCoord(ra=masterlist['ra'], dec=masterlist['dec'])
#make skycoord from input table
c = SkyCoord(ra=Table['ra'], dec=Table['dec'])
#search around all of the new sources
idxc, idxcatalog, d2d, d3d = catalog.search_around_sky(
c, radius * u.arcsec)
#for every new sources
for src in range(0, len(Table)):
#limit to matches around interested sources
ind = idxc == src
#if there are matches
if ind.sum() > 0:
#choose the closest and check if its in the prior list all ready
in_prior = prior_list['help_id'] == masterlist[idxcatalog][
ind][np.argmin(d2d[ind])]['help_id']
#if its not in prior list
if in_prior.sum() < 1:
print(in_prior.sum())
#add to appended sources
prior_list = vstack([
prior_list,
masterlist[idxcatalog][ind][np.argmin(d2d[ind])]
])
return prior_list
# In[64]:
import astropy.units as u
#create table of candidate source
t = QTable([c.ra, c.dec], names=('ra', 'dec'))
#add candidate source to new sources table, create prior list
if new_Table is not None:
prior_list = construct_prior(vstack([t, new_Table]))
else:
prior_list = construct_prior(t)
if alt_model == True:
sep = 18
separation = c.separation(SkyCoord(prior_list['ra'],
prior_list['dec'])).arcsec
remove_ind = (separation > np.min(separation)) & (separation < sep)
prior_list.remove_rows(remove_ind)
# ## Get Redshift and Uncertianty
#
# Ken Duncan defines a median and a hierarchical bayes combination redshift. We need uncertianty so lets match via `help_id`
# In[26]:
photoz = Table.read(redshift_file[0])
# In[27]:
#help_id=np.empty((len(photoz)),dtype=np.dtype('U27'))
for i in range(0, len(photoz)):
photoz['help_id'][i] = str(
photoz['help_id'][i].strip()).encode('utf-8')
#photoz['help_id']=help_id
# In[28]:
from astropy.table import Column, MaskedColumn
prior_list['redshift'] = MaskedColumn(np.full(
(len(prior_list)), fill_value=redshift_prior[0]),
mask=[False] * len(prior_list))
prior_list.add_column(
MaskedColumn(np.full((len(prior_list)), fill_value=redshift_prior[1]),
mask=[False] * len(prior_list),
name='redshift_unc'))
# In[29]:
photoz
# In[30]:
ii = 0
for i in range(0, len(prior_list)):
ind = photoz['help_id'] == prior_list['help_id'][i]
try:
if photoz['z1_median'][ind] > 0.0:
prior_list['redshift'][i] = photoz['z1_median'][ind]
prior_list['redshift_unc'][i] = np.max(
np.array([
np.abs(photoz['z1_median'][ind] -
photoz['z1_min'][ind]),
np.abs(photoz['z1_max'][ind] -
photoz['z1_median'][ind])
]))
#prior_list['redshift_unc'].mask[i]=False
#prior_list['redshift'].mask[i]=False
except ValueError:
None
# In[33]:
dist_matrix = np.zeros((len(prior_list), len(prior_list)))
from astropy.coordinates import SkyCoord
from astropy import units as u
for i in range(0, len(prior_list)):
for j in range(0, len(prior_list)):
if i > j:
coord1 = SkyCoord(ra=prior_list['ra'][i] * u.deg,
dec=prior_list['dec'][i] * u.deg,
frame='icrs')
coord2 = SkyCoord(ra=prior_list['ra'][j] * u.deg,
dec=prior_list['dec'][j] * u.deg)
dist_matrix[i, j] = coord1.separation(coord2).value
# In[35]:
ind = (np.tril(dist_matrix) < 1.0 / 3600.0) & (np.tril(dist_matrix) > 0)
xx, yy = np.meshgrid(np.arange(0, len(prior_list)),
np.arange(0, len(prior_list)))
yy[ind]
# In[36]:
prior_list[yy[ind]]
# In[37]:
prior_list['redshift'].mask[yy[ind]] = True
# In[38]:
prior_list = prior_list[prior_list['redshift'].mask == False]
# In[39]:
prior_list
# XID+ is built around two python classes. A prior and posterior class. There should be a prior class for each map being fitted. It is initiated with a map, noise map, primary header and map header and can be set with a MOC. It also requires an input prior catalogue and point spread function.
#
# In[40]:
#---prior250--------
prior250 = xidplus.prior(
im250, nim250, im250phdu, im250hdu, moc=moc
) #Initialise with map, uncertianty map, wcs info and primary header
prior250.prior_cat(prior_list['ra'],
prior_list['dec'],
'photoz',
ID=prior_list['help_id'])
prior250.prior_bkg(
-5.0,
5) #Set prior on background (assumes Gaussian pdf with mu and sigma)
#---prior350--------
prior350 = xidplus.prior(im350, nim350, im350phdu, im350hdu, moc=moc)
prior350.prior_cat(prior_list['ra'],
prior_list['dec'],
'photoz',
ID=prior_list['help_id'])
prior350.prior_bkg(-5.0, 5)
#---prior500--------
prior500 = xidplus.prior(im500, nim500, im500phdu, im500hdu, moc=moc)
prior500.prior_cat(prior_list['ra'],
prior_list['dec'],
'photoz',
ID=prior_list['help_id'])
prior500.prior_bkg(-5.0, 5)
# Set PSF. For SPIRE, the PSF can be assumed to be Gaussian with a FWHM of 18.15, 25.15, 36.3 '' for 250, 350 and 500 $\mathrm{\mu m}$ respectively. Lets use the astropy module to construct a Gaussian PSF and assign it to the three XID+ prior classes.
# In[41]:
#pixsize array (size of pixels in arcseconds)
pixsize = np.array([pixsize250, pixsize350, pixsize500])
#point response function for the three bands
prfsize = np.array([18.15, 25.15, 36.3])
#use Gaussian2DKernel to create prf (requires stddev rather than fwhm hence pfwhm/2.355)
from astropy.convolution import Gaussian2DKernel
##---------fit using Gaussian beam-----------------------
prf250 = Gaussian2DKernel(prfsize[0] / 2.355, x_size=101, y_size=101)
prf250.normalize(mode='peak')
prf350 = Gaussian2DKernel(prfsize[1] / 2.355, x_size=101, y_size=101)
prf350.normalize(mode='peak')
prf500 = Gaussian2DKernel(prfsize[2] / 2.355, x_size=101, y_size=101)
prf500.normalize(mode='peak')
pind250 = np.arange(
0, 101,
1) * 1.0 / pixsize[0] #get 250 scale in terms of pixel scale of map
pind350 = np.arange(
0, 101,
1) * 1.0 / pixsize[1] #get 350 scale in terms of pixel scale of map
pind500 = np.arange(
0, 101,
1) * 1.0 / pixsize[2] #get 500 scale in terms of pixel scale of map
prior250.set_prf(
prf250.array, pind250, pind250
) #requires psf as 2d grid, and x and y bins for grid (in pixel scale)
prior350.set_prf(prf350.array, pind350, pind350)
prior500.set_prf(prf500.array, pind500, pind500)
print('fitting ' + str(prior250.nsrc) + ' sources \n')
print('using ' + str(prior250.snpix) + ', ' + str(prior350.snpix) +
' and ' + str(prior500.snpix) + ' pixels')
print('source density = {}'.format(prior250.nsrc / moc.area_sq_deg))
# Before fitting, the prior classes need to take the PSF and calculate how muich each source contributes to each pixel. This process provides what we call a pointing matrix. Lets calculate the pointing matrix for each prior class
# In[43]:
prior250.get_pointing_matrix()
prior350.get_pointing_matrix()
prior500.get_pointing_matrix()
# In[44]:
return [prior250, prior350, prior500], prior_list
