docs: def do_photometry(self, data, error=None, mask=None, method='exact',
                        subpixels=5, unit=None):
          """
          Perform aperture photometry on the input data.
  
          Parameters
          ----------
          data : array_like or `~astropy.units.Quantity` instance
              The 2D array on which to perform photometry.  ``data``
              should be background subtracted.
  
          error : array_like or `~astropy.units.Quantity`, optional
              The pixel-wise Gaussian 1-sigma errors of the input
              ``data``.  ``error`` is assumed to include *all* sources of
              error, including the Poisson error of the sources (see
              `~photutils.utils.calc_total_error`) .  ``error`` must have
              the same shape as the input ``data``.
  
          mask : array_like (bool), optional
              A boolean mask with the same shape as ``data`` where a
              `True` value indicates the corresponding element of ``data``
              is masked.  Masked data are excluded from all calculations.
  
          method : {'exact', 'center', 'subpixel'}, optional
              The method used to determine the overlap of the aperture on
              the pixel grid.  Not all options are available for all
              aperture types.  Note that the more precise methods are
              generally slower.  The following methods are available:
  
                  * ``'exact'`` (default):
                    The the exact fractional overlap of the aperture and
                    each pixel is calculated.  The returned mask will
                    contain values between 0 and 1.
  
                  * ``'center'``:
                    A pixel is considered to be entirely in or out of the
                    aperture depending on whether its center is in or out
                    of the aperture.  The returned mask will contain
                    values only of 0 (out) and 1 (in).
  
                  * ``'subpixel'``
                    A pixel is divided into subpixels (see the
                    ``subpixels`` keyword), each of which are considered
                    to be entirely in or out of the aperture depending on
                    whether its center is in or out of the aperture.  If
                    ``subpixels=1``, this method is equivalent to
                    ``'center'``.  The returned mask will contain values
                    between 0 and 1.
  
          subpixels : int, optional
              For the ``'subpixel'`` method, resample pixels by this factor
              in each dimension.  That is, each pixel is divided into
              ``subpixels ** 2`` subpixels.
  
          unit : `~astropy.units.UnitBase` object or str, optional
              An object that represents the unit associated with the input
              ``data`` and ``error`` arrays.  Must be a
              `~astropy.units.UnitBase` object or a string parseable by
              the :mod:`~astropy.units` package.  If ``data`` or ``error``
              already have a different unit, the input ``unit`` will not
              be used and a warning will be raised.
  
          Returns
          -------
          aperture_sums : `~numpy.ndarray` or `~astropy.units.Quantity`
              The sums within each aperture.
  
          aperture_sum_errs : `~numpy.ndarray` or `~astropy.units.Quantity`
              The errors on the sums within each aperture.
          """
  
          data = np.asanyarray(data)
  
          if mask is not None:
              mask = np.asanyarray(mask)
  
              data = copy.deepcopy(data)    # do not modify input data
              data[mask] = 0
  
              if error is not None:
                  # do not modify input data
                  error = copy.deepcopy(np.asanyarray(error))
                  error[mask] = 0.
  
          aperture_sums = []
          aperture_sum_errs = []
          for mask in self.to_mask(method=method, subpixels=subpixels):
              data_cutout = mask.cutout(data)
  
              if data_cutout is None:
                  aperture_sums.append(np.nan)
              else:
                  aperture_sums.append(np.sum(data_cutout * mask.data))
  
              if error is not None:
                  error_cutout = mask.cutout(error)
  
                  if error_cutout is None:
                      aperture_sum_errs.append(np.nan)
                  else:
                      aperture_var = np.sum(error_cutout ** 2 * mask.data)
                      aperture_sum_errs.append(np.sqrt(aperture_var))
  
          # handle Quantity objects and input units
          aperture_sums = self._prepare_photometry_output(aperture_sums,
                                                          unit=unit)
          aperture_sum_errs = self._prepare_photometry_output(aperture_sum_errs,
                                                              unit=unit)
  
          return aperture_sums, aperture_sum_errs