daophot.tex

basic median filter simulation

to help determine whether the supplied parameters are appropiate. 
Note that the FIND algorithm is not a good one for identifying galaxies
or HII regions, since non-stellar objects are discriminated against in the
search.
           
FIND requires the user to supply an
approximate FWHM (in pixel units, not necessarily integral) for the image,
and an intensity threshold,
HMIN, above background.  Appendix II of the DAOPHOT manual describes
how to choose the intensity threshold to obtain a desired significance
level (e.g.\ 3.5 sigma) for the sources detected by FIND.
One is required to know the readout noise, RONOIS, and photons per
analog digital unit PHPADU for the CCD (needed for computing Poisson
statistics).  For a single (not coadded) image 
the threshold is determined as follows.
\begin{enumerate}
\item The random noise per pixel is computed from the sky level (found by
SKY) and the readout noise.
\begin{center}
random noise = {\tt SQRT(PHPADU$\ast$SKYMODE + RONOIS)}
\end{center}
\item After a FWHM (in pixels) 
has been supplied, FIND will print a value called the
``Relative Error''.  This is simply a scaling factor to convert the standard
error of one pixel, to that for detecting a point source.  For example,
the relative error = 1.06 and 0.79, respectively, for FWHM of 2.0 and 6.0
pixels
\item The 1 sigma random noise should be multiplied by the ``Relative error''.
This value should then be mulitiplied by the desired detection significance
(i.e. multiply by 3 for 3-sigma detection significance.)    
\end{enumerate}

The Gaussian convolution in FIND cancels out any large-scale variations
in the sky brightness.  However, FIND does not identify any variation 
in the {\em errors} (or fluctuations) in the sky brightness across an image.   
In this latter case, the detection significance of a supplied threshold 
may vary across the image.

FIND requires a large amount of virtual memory to perform the convolution.
This is because the Gaussian convolution requires REAL*4 data for both
input and output (even if your image array is INTEGER*2).  
\subsection{APER}
{\tt APER,IMAGE,X,Y,MAG,ERRAP,SKY,SKYERR,[PHPADU,APR,SKYRAD,BADPIX, /FLUX]} \\
{\tt T\_APER,IMAGE,FITSFILE,[APR,SKYRAD,BADPIX]} \\

APER performs circular aperture photometry, linearly weighting pixels
that are partially wihin the aperture radius.
The user must supply a set of aperture radii, an inner and
outer sky radius, and low and high bad pixel values.   
For each position (X,Y) found by FIND, APER will determine a sky value
and uncertainty, and the sky-corrected magnitude and uncertainty 
within each aperture.   Relative magnitudes are computed from the aperture flux,
FLUX in data units 
\begin{center}
{\tt MAG = 25 - 2.5$\ast$ALOG10(FLUX)} 
\end{center}
so that an aperture flux of 1 data unit is assigned a magnitude of 25.
If the /FLUX keyword is set, then APER will not convert to magnitudes.

APER will not compute a flux if one of the 
following conditions holds:
\begin{itemize}
\item The aperture exceeds the edge of the image
\item A sky value could not be determined (e.g. if MMM requires too many
      iterations), or the sky exceeds the gross intensity within the 
      aperture
\item At least one pixel within, or partially within, the aperture radius
      is ``bad''.                              
\end{itemize}

If a flux could not be computed, the star is assigned either a flux
of -100. or a magnitude of 99.9.
Although APER will output results in either flux units or magnitudes,
the subsequent procedures GETPSF and NSTAR will require their input in
magnitudes.
\subsection{GETPSF}                         
\begin{tabbing}
GETPSF,IMAGE, \=   \kill
{\tt GETPSF,IMAGE,X,Y,MAG,SKY,} \\
\>  {\tt  [RONOIS,PHPADU,GAUSS,PSF,IDPSF,PSFRAD,FITRAD,PSFNAME]} \\
{\tt T\_GETPSF,IMAGE, FITSFILE,[IDPSF,PSFRAD,FITRAD,PSFNAME]} \\
\end{tabbing}
                                                      
GETPSF requires the positions (X,Y) found by FIND, and the magnitude,
MAG and sky values, SKY, found by APER.  The PSF determined by GETPSF
is represented by a 5 element vector GAUSS, containing the best-fit
bivariate gaussian parameters, and by a lookup array of residuals.
The user must supply the index numbers of the stars to be used to create
the PSF.   Ideally, the PSF stars should be isolated, free of bad pixels, 
and free of any saturated pixels.
GETPSF will also store the PSF as an STSDAS (modified FITS) disk image.
(In order to view the PSF, one must recombine the residuals with the Gaussian;
this can be done with the procedure RDPSF.)

\subsection{GROUP}
{\tt GROUP,XC,YC,RMAX,NGROUP} \\
{\tt T\_GROUP, FITSFILE,RMAX}     \\
                          
GROUP will assign a group number to each star with position (XC,YC).
The user must supply a value of RMAX, the radius at which two stars
are considered to be just overlapping.  Stetson suggests setting RMAX
equal to the radius of the brightest star {\em plus} the fitting radius
to be used in NSTAR.  The idea is that the pixels used to fit the PSF
to a star will only be contaminated by stars with the same group number.

The IDL code for GROUP is extremely elegant (only 7 lines long!)  However,
it is approximately half as fast as the equivalent FORTRAN.

\subsection{NSTAR}
\begin{tabbing}
NSTAR,IMAGE \= \kill
{\tt NSTAR,IMAGE,ID,X,Y,MAG,SKY,GROUP,} \\
\>    {\tt  [PHPADU,RONOIS,PSFNAME,MAGERR,ITER,CHISQ,PEAK, /VARSKY]} \\
{\tt T\_NSTAR,IMAGE, FITSFILE,[PSFNAME,GROUPSEL, /VARSKY]} \\
\end{tabbing}

NSTAR will simultaneously fit the PSF to all stars within a given group.
Three parameters are determined for each star - the (X,Y) position, and
the magnitude, MAG.  As initial conditions to the least-squares fit, NSTAR
requires the (X,Y) positions obtained from FIND, and the magnitudes, MAG
obtained from APER.   The sky values obtained from APER are taken as fixed
parameters.  Other required inputs are the GROUP vector created by GROUP,
and the name of the PSF file created by GETPSF.   

The DAOPHOT user's manual describes the moderately sophisticated star-rejection
algorithm used by NSTAR.   Basically, a star is rejected if (1) it merges
with a brighter star, (2)  it is more than 12.5 magnitudes fainter than
the PSF star, or (3) its brightness  is less than the 2-sigma noise level.
Upon output, the vector ID will contain the ID numbers of the stars that
were {\em not} rejected.

NSTAR has three output vectors that describe the quality of the fit.
CHISQ gives the chi-square of the fit for each star per degree of freedom,
and should be close to 1, {\em if  proper values of the readout noise
and photon per analog digital unit were supplied}.  
PEAK (called SHARP by Stetson) determines
whether the star is broader or narrow than the PSF.  Isolated stars should
have PEAK approximately equal to zero, while extended sources (galaxies,
unresolved binaries) will have PEAK greater than zero.  Finally, NITER
gives the number of iterations required for the fit.  If NITER = 50, then
the least-squares solution did not converge for at least one star in the
group.

NSTAR is the most CPU-intensive step in the DAOPHOT sequence and should
usually be done in batch.  The CPU time required depends exponentially
(I would guess) on the size of the group.   
The T\_NSTAR call allows one to select specific
groups to process through the vector GROUPSEL.  
\subsection{SUBSTAR}
{\tt SUBSTAR,IMAGE,X,Y,MAG,[ID,PSFNAME]}  \\
{\tt T\_SUBSTAR,IMAGE, FITSFILE,[ID, PSFNAME, /VERBOSE]} \\

SUBSTAR will subtract the PSF, scaled to each star's magnitude, MAG, 
from positions specified by the vectors (X,Y).  Note that IMAGE
will be modified to contain the star-subtracted image, so be sure to 
have a duplicate copy if the original is needed.
If desired, then only a subset of stars, specified by the ID vector,
will be subtracted.
                   
\end{document}