# Aperture photometry¶

There are four aperture functions available:

Function | Sums data within… |
---|---|

`sep.sum_circle` |
circle(s) |

`sep.sum_circann` |
circular annulus/annuli |

`sep.sum_ellipse` |
ellipse(s) |

`sep.sum_ellipann` |
elliptical annulus/annuli |

The follow examples demonstrate options for circular aperture photometry. The other functions behave similarly.

```
# sum flux in circles of radius=3.0
flux, fluxerr, flag = sep.sum_circle(data, objs['x'], objs['y'], 3.0)
# x, y and r can be arrays and obey numpy broadcasting rules.
# Here, r is an array instead of a single number:
flux, fluxerr, flag = sep.sum_circle(data, objs['x'], objs['y'],
3.0 * np.ones(len(objs)))
# use a different subpixel sampling (default is 5; 0 means "exact")
flux, fluxerr, flag = sep.sum_circle(data, objs['x'], objs['y'], 3.0,
subpix=0)
```

**Error calculation**

In the default modes illustrated above, the uncertainty `fluxerr`

is
not calculated and values of 0 are simply returned. The uncertainty can be
flexibly and efficiently calculated, depending on the characteristics
of your data. The presence of an `err`

or `var`

keyword indicates
a per-pixel noise, while the presense of a `gain`

keyword indicates
that the Poisson uncertainty on the total sum should be included. Some
illustrative examples:

```
# Specify a per-pixel "background" error and a gain. This is suitable
# when the data have been background subtracted.
flux, fluxerr, flag = sep.sum_circle(data, objs['x'], objs['y'], 3.0,
err=bkg.globalrms, gain=1.0)
# Variance can be passed instead of error, with identical results.
flux, fluxerr, flag = sep.sum_circle(data, objs['x'], objs['y'], 3.0,
var=bkg.globalrms**2, gain=1.0)
# Error or variance can be arrays, indicating that the background error
# is variable.
bkgrms = bkg.rms() # array, same shape as data
flux, fluxerr, flag = sep.sum_circle(data, objs['x'], objs['y'], 3.0,
err=bkgrms, gain=1.0)
# If your uncertainty array already includes Poisson noise from the object,
# leave gain as None (default):
flux, fluxerr, flag = sep.sum_circle(data, objs['x'], objs['y'], 3.0,
err=error_array)
# If your data represent raw counts (it is not background-subtracted),
# set only gain to get the poisson error:
flux, fluxerr, flag = sep.sum_circle(data, objs['x'], objs['y'], 3.0,
gain=1.0)
```

The error is calculated as

where the sum is over pixels in the aperture, \(\sigma_i\) is the
noise in each pixel, \(F\) is the sum in the aperture and
\(g\) is the gain. The last term is not added if `gain`

is
`None`

.

**Masking**

Apply a mask (same shape as data). Pixels where the mask is True are “corrected” to the average value within the aperture.

```
flux, fluxerr, flag = sep.sum_circle(data, objs['x'], objs['y'], 3.0,
mask=mask)
```

**Local background subtraction**

The `sum_circle`

and `sum_ellipse`

functions have options
for performing local background subtraction. For example, to subtract the background calculated in an annulus between 6 and 8 pixel radius:

```
flux, fluxerr, flag = sep.sum_circle(data, objs['x'], objs['y'], 3.0,
mask=mask, bkgann=(6., 8.))
```

Pixels in the background annulus are not subsampled and any masked pixels in the annulus are completely igored rather than corrected. The inner and outer radii can also be arrays. The error in the background is included in the reported error.

## Equivalent of FLUX_AUTO (e.g., MAG_AUTO) in Source Extractor¶

This is a two-step process. First we calculate the Kron radius for each object, then we perform elliptical aperture photometry within that radius:

```
kronrad, krflag = sep.kron_radius(data, x, y, a, b, theta, 6.0)
flux, fluxerr, flag = sep.sum_ellipse(data, x, y, a, b, theta, 2.5*kronrad,
subpix=1)
flag |= krflag # combine flags into 'flag'
```

This specific example is the equilvalent of setting ```
PHOT_AUTOPARAMS
2.5, 0.0
```

in Source Extractor (note the 2.5 in the argument to
`sep.sum_ellipse`

). The second Source Extractor parameter is a
minimum diameter. To replicate Source Extractor behavior for non-zero
values of the minimum diameter, one would put in logic to use circular
aperture photometry if the Kron radius is too small. For example:

```
r_min = 1.75 # minimum diameter = 3.5
use_circle = kronrad * np.sqrt(a * b) < r_min
cflux, cfluxerr, cflag = sep.sum_circle(data, x[use_circle], y[use_circle],
r_min, subpix=1)
flux[use_circle] = cflux
fluxerr[use_circle] = cfluxerr
flag[use_circle] = cflag
```

## Equivalent of FLUX_RADIUS in Source Extractor¶

In Source Extractor, the FLUX_RADIUS parameter gives the radius of a
circle enclosing a desired fraction of the total flux. For example,
with the setting `PHOT_FLUXFRAC 0.5`

, FLUX_RADIUS will give the
radius of a circle containing half the “total flux” of the object. For
the definition of “total flux”, Source Extractor uses its measurement
of FLUX_AUTO, which is taken through an elliptical aperture (see
above). Thus, with the setting `PHOT_FLUXFRAC 1.0`

, you would find
the circle containing the same flux as whatever ellipse Source
Extractor used for `FLUX_AUTO`

.

Given a previous calculation of `flux`

as above, calculate the
radius for a flux fraction of 0.5:

```
r, flag = sep.flux_radius(data, objs['x'], objs['y'], 6.*objs['a'], 0.5,
normflux=flux, subpix=5)
```

And for multiple flux fractions:

```
r, flag = sep.flux_radius(data, objs['x'], objs['y'], 6.*objs['a'],
[0.5, 0.6], normflux=flux, subpix=5)
```

## Equivalent of XWIN_IMAGE, YWIN_IMAGE in Source Extractor¶

Source Extractor’s XWIN_IMAGE, YWIN_IMAGE parameters can be used for
more accurate object centroids than the default X_IMAGE, Y_IMAGE.
Here, the `winpos`

function provides this behavior. To match Source
Extractor exactly, the right `sig`

parameter (giving a description
of the effective width) must be used for each object. Source
Extractor uses `2. / 2.35 * (half-light radius)`

where the
half-light radius is calculated using `flux_radius`

with a fraction
of 0.5 and a normalizing flux of `FLUX_AUTO`

. The equivalent here is:

```
sig = 2. / 2.35 * r # r from sep.flux_radius() above, with fluxfrac = 0.5
xwin, ywin, flag = sep.winpos(data, objs['x'], objs['y'], sig)
```

## Segmentation-masked image measurements¶

SourceExtractor provides a mechanism for measuring the “AUTO” and “FLUX_RADIUS” parameters for a given object including a mask for neighboring sources. In addition to the mask, setting the SourceExtractor parameter `MASK_TYPE=CORRECT`

further fills the masked pixels of a given source with “good” pixel values reflected opposite of the masked pixels. The `SEP`

photometry and measurement functions provide an option for simple masking without reflection or subtracting neighbor flux.

For example, using a segmentation array provided by `sep.extract`

, we can compute the masked `flux_radius`

that could otherwise be artificially large due to flux from nearby sources:

```
# list of object id numbers that correspond to the segments
seg_id = np.arange(1, len(objs)+1, dtype=np.int32)
r, flag = sep.flux_radius(data, objs['x'], objs['y'], 6.*objs['a'], 0.5,
seg_id=seg_id, seg=seg,
normflux=flux, subpix=5)
```

To enforce that a given measurement **only** includes pixels within a segment, provide negative values in the `seg_id`

list. Otherwise the mask for a given object will be pixels with `(seg == 0) | (seg_id == id_i)`

.

The following functions include the segmentation masking: `sum_circle`

, `sum_circann`

, `sum_ellipse`

, `sum_ellipann`

, `flux_radius`

, and `kron_radius`

(`winpos`

**currently does not**).

## Masking image regions¶

Create a boolean array with elliptical regions set to True:

```
mask = np.zeros(data.shape, dtype=np.bool)
sep.mask_ellipse(mask, objs['x'], objs['y'], obs['a'], objs['b'],
objs['theta'], r=3.)
```