Some of the catalogues are available here, if you're interested.

The biggest challenge was confusion (about which there is a great deal of confusion). For example, in this HerMES image, everything you can see is light from galaxies, and each galaxy produces a small round blob in the image. The number of galaxies is so high, that light from any one galaxy is confused with light from numerous neighbouring galaxies.

So when the computer looks at the image and spots a blob with brightness 30 mJy, what does that mean? Does it mean there is one galaxy there with brightness 30 mJy? Or perhaps there are 10 galaxies, with brightnesses of 15 mJy or lower?

It's difficult to tell. But what you can do (and what we did in the paper) is to stick fake galaxies (blobs) into the image, and see what difference that makes. So if we have a fake galaxy with brightness 30 mJy, and we put it in at a random position, what effect will that have, on average? What is the probability that it will be detected? (This is approaching what we mean by the completeness of the catalogue, although it is far from easy to know what is meant by those simple words "it" and "detected"!) What brightness will it be measured to have, on average? 20 mJy? 30 mJy? 40 mJy? 100 mJy?

For very bright galaxies, it's relatively straightforward. But for fainter things, it can do your head in...

Here's a Python function to accompany the previous post. It's not maximally efficient, but should make sense...

from scipy import stats
def gaussian_pixel(minxy, maxxy, sigma, meanxy=(0.,0.), norm=None):
    """Return the value of a pixel sampling a 2D Gaussian,
    normalized such that the area under the Gaussian is 1
    (default) or such that the peak is given by norm."""
    x1, y1 = minxy
    x2, y2 = maxxy
    x0, y0 = meanxy
    if norm is None:
        norm = 1. / 2 / math.pi / sigma ** 2
    return norm * 2 * math.pi * sigma ** 2 / (x2 - x1) / (y2 - y1) * (
        (1 - stats.erfc((x2 - x0) / math.sqrt(2) / sigma)) / 2.
        - (1 - stats.erfc((x1 - x0) / math.sqrt(2) / sigma)) / 2.) * (
        (1 - stats.erfc((y2 - y0) / math.sqrt(2) / sigma)) / 2.
        - (1 - stats.erfc((y1 - y0) / math.sqrt(2) / sigma)) / 2.)

If the pixels are larger than infinitesimal, as is generally the case, then the maximum value of the pixelated PRF will be the average value over the pixel, which will be less than 1.

For example, if the PRF is a two-dimensional Gaussian, centred on , with standard deviation , then the value in a pixel with and will be

Ugh. Let's make that simpler. For a PRF centred on , and a pixel , this is

As an example, the fairly-Gaussian beam for the Herschel Space Observatory SPIRE instrument has an FWHM of around 18", which corresponds to a standard deviation of around . If we make a Jy/beam map with pixel size 6", then the peak value for a 1 Jy point source in the centre of a pixel will be

Easy.

First, find , which is the point response function (PRF), telling you what a point source of flux 1 will look like in the map. This may be normalized so that the peak is 1 (if your map is in Jy/beam or similar), or so that (if your map is in Jy/pixel or similar). If your map is in MJy/sr ... well, figure it out and add a comment below. Basically, if you normalize your PRF correctly, you won't need to worry about the map units in what follows. Phew.

Now the measured value of each pixel around the point source, , will be

Now the badness of the fit is measured by the , which is given by

Now just do this for each pixel in the map (corresponding to a point source centred on each pixel) and you're done.

Worked example. is 0.5, 1.0 and 0.5, for three adjacent pixels (you'll have realised that the map is in Jy/beam or similar), and is 1, 2 and 1 Jy/beam, for three adjacent pixels, with the same (tiny!) value of for each pixel (in this case, we can ignore the value of in what follows). So the flux at the central pixel is estimated to be

This is an example of a matched filter (I haven't read the page, but hopefully including the link will make me look clever). And, given that point sources are under no particular obligation to align themselves with the centres of the pixels of your map, can easily be re-estimated for a source with a certain offset from the pixel centre.

1. StarFinder seems to do a great job at finding point sources in crowded fields. It includes a routine for generating the Airy pattern. For a 51 x 51 array, with the peak at [25, 25], and an FWHM of 8.0 pixels, this is the command:

psf = airy_pattern(51, 51, 25, 25, 2./8.0)
isurface, psf

The output looks something like this:

2. The IDL Astronomy User's Library contains a routine, psf_gaussian, that produces a Gaussian PSF. To produce the same as above, the command would be:

psf = psf_gaussian(npix=51, fwhm=8.0, /double)
isurface, psf

... which produces something like this: