\section{Soft X-Ray Telescope (SXT)}

\subsection{Routines for Data Selection}
\index{data selection, SXT}

\subsubsection{SSWHERE}
\index{filter selection}

SSWHERE is a widget-driven program that creates an array of subscripts ({\it ss}) that fulfill a set of
criteria that you define to select SXT images.  For example to make an {\it ss}
array for YODAT where you want to select images from a data
set represented by roadmap, you merely type:
%
\idlinputa{ss=sswhere(roadmap)} \index{SSWHERE}
%
SSWHERE works on both the roadmap and index structures.  Available selection
criteria are:

\IItem
\item completeness of the image
\item SXT mode (normal/dark image/calibration)
\item pixel resolution
\item compression mode
\item filters
\item exposure DPE
\item DP mode
\item field of view location (see lower buttons)
\item time period (see lower buttons)
\end{itemize}

If you get a ``No matching Data'' response, check that you have selected all possible options.

\subsubsection{SHOW\_OBS3  }

SHOW\_OBS3 plots a time line summary of the SXT images that are in
the index or roadmap.  In addition to plotting a tick for each image
available, it shows the DP mode, DP rate, where the S/C days
are, and where SAA passages occur.  Some sample calls to SHOW\_OBS3 are:
%
\idlinputa{show\_obs3, roadmap}	\index{SHOW\_OBS3}
\idlinputb{show\_obs3, index}
%
It is possible to select images using SHOW\_OBS3 by clicking on
diagonally opposite corners of a box surrounding the images you wish
to select.  The calling sequence for that is:
%
\idlinputa{show\_obs3, roadmap, sel, ss}
%
where {\it sel} is a returned logical array the same length as roadmap, and is set 
true for all dsets selected, and {\it ss} is the returned subscripts of the selected
datasets.  A few examples on how to use the {\it sel} variable are:
%
\idlinputa{ss = where(sel)}	
\idlinputc{ss = where(sel and (gt\_dp\_mode(roadmap) eq 9))} 
%
\subsubsection{SHOW\_OBS4  }

The calling sequence of SHOW\_OBS4 is the same as SHOW\_OBS3, except there
are a few additional options in SHOW\_OBS4.  Run SHOW\_OBS4 with one of
the following commands:
%
\idlinputa{show\_obs4, roadmap}	\index{SHOW\_OBS4}
\idlinputb{show\_obs4, index}
%
It is possible to click on a time range for a closer look by:
\EEnumerate
\item Clicking with the left button at the start time
\item Clicking with the right button at the end time
\item Clicking with the left button on the box in the lower right
\item If you wish to exit, click with the middle button somewhere on the plot
\end{enumerate}

It is possible to select several regions using the following steps.
\EEnumerate
\item Click with the right button on the box in the lower left (Select Option).
      A square box should appear on the screen.
\item Click and hold the left button on the lower left corner of the box and
     drag the box to the lower left corner of the region you want to select, 
     then release.
\item Click and hold the middle button on the upper right corner of the box
    and stretch the box to encompass the images you want to select.
\item Repeat steps 2 and 3 until you have positioned the box where you
      want it.
\item Click on the right button to exit the selection option when you have 
     successfully positioned the box.
\item Now you can exit SHOW\_OBS4 by clicking on the middle button, or you can
     select another set of images by running steps 1 through 5 again.
\end{enumerate}

\subsubsection{PLOT\_FOV}

It is possible to make a simple display of the sun and to overlay the
box showing the field of view size and location by using PLOT\_FOV.
The index, roadmap or observing log entry can be used with this
routine.  A sample call is:
%
\idlinputd{plot\_fov, index, /box}\index{PLOT\_FOV}
%
\subsection{Routines for Making Time Plots}

\subsubsection{LCUR\_IMAGE}

See the description in the ``General Yohkoh Software'' chapter on
page~\pageref{lcur_image} or the description in the User's Guide.

\subsection{Routines for Image Display and Enhancement}

\subsubsection{STEPPER}

See the description in the ``General Yohkoh Software'' chapter on
page~\pageref{stepper} or the description in the User's Guide.


\subsubsection{XY\_RASTER}

XY\_RASTER makes a mosaic of several images and prints the times in the corner 
of each image.  Sample calls are:
%
\idlinputa{xy\_raster, index, data}\index{XY\_RASTER}
\idlinputb{xy\_raster, index, data, factor}
%
where {\it factor} is the rebin factor (a value of 1 will perform no
rebinning).  If there are too many images, the program will display 
the number of images which will fit on a page, and will prompt the
user for when to move to the next page.  The keyword {\it /notimes} will
inhibit the time labels, {\it /noscale} will inhibit image scaling (it will
use TV instead of TV\_SCL), {\it /individual\_scale} will scale each image
individually.

\subsubsection{DISP\_MONTH}

The routine DISP\_MONTH will display a month of SXT images in a 
calendar form (assuming you have the SFM database on-line).  A sample
call is:
%
\idlinputd{disp\_month, 'oct-93'}\index{DISP\_MONTH}

\subsubsection{UNSHARP\_MASK}
\index{image enhancement}

UNSHARP\_MASK is a basic image enhancement routine which uses the unsharp mask method.  The calling sequence is:
%
\idlinputa{dataout=unsharp\_mask(index, data)} \index{UNSHARP\_MASK}
%
where {\it data} and {\it dataout} are 2D arrays, and {\it index} is the index
entry that corresponds to {\it data}.  If no keywords are given the
defaults are used.  \index{ENHANCER}

Optional Keyword Parameters:

\vspace{0.2in}\begin{tabular}{lp{15.0cm}}
{\tt smooth  } & {\raggedright Size of smoothing box, integer.}\\
{\tt lowdelt}  & {\raggedright Lower $\delta$ cutoff, a percentage of minimum, decimal 0.xx.}\\
{\tt updelt  } & {\raggedright Upper $\delta$ cutoff, a percentage of maximum, decimal 0.xx.}\\
{\tt lowint }  & {\raggedright Saturation cutoff, don't add back when signal is BELOW\\
a given percentage of the saturation value, decimal 0.xx.}\\
{\tt upint }   & {\raggedright Saturation cutoff, don't add back when signal is ABOVE\\
a given percentage of the saturation value, decimal 0.xx.}\\
{\tt deltcoef} & {\raggedright Multiplier for $\delta$ field,  float x.x.}
\end{tabular}\vspace{0.2in}

The keyword parameters allow you to customize the enhancer, though they
are all assigned default values if omitted in the call.  These
defaults depend on the images resolution, and may be changed as we gain 
experience.

\subsubsection{DE\_SPIKER}

The DE\_SPIKER function returns a cleaned image by removing spikes at a
specified input level.  The technique used is to difference a smoothed image
and the input image and find all pixels that deviate 
by more than a given threshold.
%
\idlinputa{clean\_img = de\_spiker(image, thresh)}\index{DE\_SPIKER}\index{spikes, SXT}\index{image spikes, SXT}
\idlinputb{clean\_img = de\_spiker(image, thresh, /neg)}
\idlinputb{clean\_img = de\_spiker(image, thresh, indices=indices)}
%
where, {\it image} is the input data array, {\it thresh} is the specified spike amplitude to
remove.  Optional input/output parameter {\it indices} contains the indices of
spikes at the level specified, and optional input switch {\it /neg} requests that
``dark holes'' be removed.

\subsubsection{SXT\_GRID  }

Draws heliocentric grid over an image.  It reads the ATT file to get
information on the spacecraft pointing, and also calls GET\_RB0P to get
the solar radius.  A sample call could be:
%
\idlinputa{tvscl, data(*,*,0)}	\index{SXT\_GRID}
\idlinputb{sxt\_grid, index(0)} 
%
The keyword option {\it /read} will allow the user to move the
cursor around the image and to display the heliocentric coordinates.
If {\it /angle} is used with {\it /read}, then the value displayed
is the angle relative to the sun center, which is useful to be used
with SXT\_PREP.

\subsection{Routines for Data and Information Extraction}
%
\subsubsection{GET\_INFO}

See the description in the ``General Yohkoh Software'' chapter on
page~\pageref{get_info}


\subsubsection{EXT\_SUBSET [*] }
EXT\_SUBSET extracts a subset (in x and y) of a data cube
and creates a new data and index array ({\it data\_out} and
{\it index\_out}) by typing:
%
\idlinputa{ext\_subset,index\_in,data\_in,index\_out,data\_out} \index{EXT\_SUBSET}
%
It is a mouse driven program.

\subsubsection{GT\_FILTA}
GT\_FILTA uses an index or roadmap structure  to determine the setting of the A filter:
%
\idlinputa{a = gt\_filta(index)} \index{GT\_FILTA}
%
The filter setting will be returned as an integer (1-6) where

\vspace{0.2in}\begin{tabular}{|l|l|l|l|} \hline
        1 &  Open 			& Op  	& Op \\
        2 &  Optical - narrow band 	& NaBan	& NB \\
        3 &  Quartz defocusing lens 	& Quart	& Qz \\
        4 &  Diffuser 			& Diffu	& Df \\
        5 &  Optical - Wide band 	& WdBan	& WB \\
        6 &  8\% neutral density X-ray filter & NuDen & ND \\ \hline
\end{tabular}\vspace{0.2in}

\noindent The last two columns show what GT\_FILTA returns when using the {\it /string} and {\it /short}
options.  The routine GET\_INFO uses the {\it /string} option.
It is possible to get a string type description of the filters used by
typing:
%
\idlinputa{b = gt\_filta(roadmap, /string)} \index{GT\_FILTB}
%
You can get a listing of these at any time by typing the following:
%
\idlinputd{print,gt\_filta()} 
%
\subsubsection{GT\_FILTB}

GT\_FILTB works exactly like GT\_FILTA but works for the X-ray filters

\vspace{0.2in}\begin{tabular}{|l|l|l|l|} \hline
        1 & Open 			 & Open		& Op \\
        2 & Thin Aluminum (1265 \AA) 	 & Al.1		& A1 \\
        3 & Dagwood Sandwich 		 & AlMg		& AM \\
        4 & Beryllium (119 $\mu$m)	 & Be119	& Be \\
        5 & Thick Aluminum (11.5 $\mu$m) & Al12		& A2 \\
        6 & Magnesium (2.5 $\mu$m)	 & Mg3		& Mg \\ \hline
\end{tabular}\vspace{0.2in}

\noindent The last two columns show what GT\_FILTB returns when using the {\it /string} and {\it /short}
options.  The routine GET\_INFO uses the {\it /string} option.

\subsubsection{GT\_PFI\_FFI}
\index{GT\_PFI\_FFI}
GT\_PFR\_FFI extracts the information on whether the image is a partial frame image (PFI)
or a full frame image (FFI).  Even values are PFI, odd values are FFI 
in general.

\vspace{0.2in}\begin{tabular}{|l|l|} \hline
	0 & {PFI} \\
        1 & {FFI} \\
        2 & {PFI Observing Region} \\
	3 & {FFI Patrol Image} \\ \hline
\end{tabular}\vspace{0.2in}

\noindent The {\it /ffi} keyword option can be used, and it will 
return a 1 if the image is an FFI and return
a 0 if it is a PFI (PFI strip or observing region).
The {\it /true\_ffi} keyword option will
return a 1 if the image is an FFI and return
a 0 if it is a PFI (PFI strip or observing region).
The {\it /true\_ffi} option will also check if it is an FFI strip
or if it is a PFI which was extracted from an FFI.

\subsubsection{GT\_RES}
GT\_RES extracts what resolution each SXT image was taken at by typing:
%
\idlinputa{res = gt\_res(roadmap)} \index{GT\_RES}
%
It outputs the resolution as a integer where:

\vspace{0.2in}\begin{tabular}{|l|l|} \hline
        0 & { full resolution } \\
        1 & { half resolution } \\
        2 & { quarter resolution } \\ \hline
\end{tabular}\vspace{0.2in}

\noindent It is possible to get a string type description of the resolution by
typing:
%
\idlinputd{res = gt\_res(roadmap, /string)} 
%
\subsubsection{GT\_COMP}
GT\_COMP extracts what compression was used for each SXT image was taken at by typing:
%
\idlinputa{comp = gt\_comp(roadmap)} \index{GT\_COMP}
%
It outputs the compression as a integer where:

\vspace{0.2in}\begin{tabular}{|l|l|} \hline
        0 & { Compressed (see routine SXT\_DECOMP) } \\
        1 & { Low 8 bits (of 12 bits) } \\
        2 & { High 8 bits (of 12 bits) } \\ \hline
\end{tabular}

\subsubsection{GT\_DPE}
\index{exposure levels, SXT}
\index{SXT exposure levels}
\index{DP exposure (DPE) level}

GT\_DPE extracts what DP exposure (DPE) level was used.  The DPE is a function
of the shutter exposure level (MBE) and the neutral density filter use.
It is possible to return the effective exposure duration in milliseconds by using the {\it /conv}
switch).
%
\idlinputa{dpe = gt\_dpe(index)}	\index{GT\_DPE}
\idlinputb{msec = gt\_dpe(roadmap, /conv)} 
%
The effective exposure for each of the DPE values are shown in the following
table.  For DPE values above 22, the effective exposure is

\begin{verbatim}
                exposure = (DPE-21) * 0.25 seconds
\end{verbatim}

% MK_DPE_LIST.TEX input starts here ---------------------------------------
\input mk_dpe_list.tex
% MK_DPE_LIST.TEX input ends here ---------------------------------------

\subsubsection{GT\_MBE}
\index{mail box exposure (MBE) level}
GT\_MBE extracts what mail box exposure (MBE) level was used.  This is the
actual shutter exposure level commanded.  It is possible to convert
to commanded shutter duration in milliseconds by using the {\it /conv}
switch).
%
\idlinputa{mbe = gt\_mbe(index)}	\index{GT\_MBE}
\idlinputc{shutdur = gt\_mbe(roadmap, /conv)} 
%
\subsubsection{GT\_EXPDUR}
GT\_EXPDUR will calculate the effective exposure duration
(not the commanded DPE)  of a series of images given an
index structure to work with.  You can get  an array of
exposures (exps) in msec by typing one of the following.  In
the second example, it returns the shutter duration (which is
also the CCD integration period).  For dark images the value
returned is the number of milliseconds the CCD integrated for
which is in multiples of 8 msec (8 msec is the minimum for
dark current images).
%
\idlinputa{expos = gt\_expdur(index)}	\index{GT\_EXPDUR}
\idlinputc{expos = gt\_expdur(index, /shut\_dur)} 
%
\subsubsection{GT\_EXPLAT}

GT\_EXPLAT will calculate the latency time between the 
time which is stored in the index and the actual time the
integration started.  The value returned is in milliseconds
and is typically between 50 and 100.
%
\idlinputd{explat = gt\_explat(index)}	\index{GT\_EXPLAT}
%
\subsubsection{GT\_EXPMODE}
GT\_EXPMODE routine returns the exposure mode.  The values it can return are:

\vspace{0.2in}\begin{tabular}{|l|l|} \hline
        0 & { Normal shuttered exposure } \\
        1 & { Dark image (shutter stays closed) } \\
        2 & { Calibration image (shutter open during readout) } \\ \hline
\end{tabular}\vspace{0.2in}
~\\
%
\idlinputd{expmode = gt\_expmode(index)}\index{GT\_EXPMODE} 
%
\subsubsection{GT\_CORNER}

GT\_CORNER will return the full resolution IDL (FRE) coordinates of
the center of the pixel in the lower left hand corner.
%
\idlinputa{corners = gt\_corner(roadmap)}\index{GT\_CORNER}
\idlinputc{x0 = gt\_corner(index, /x)}

\subsubsection{GT\_CENTER}

The output from GT\_CENTER can be the location of the center of
the field of view in (a) full resolution IDL (FRE) pixels, (b) heliocentric
coordinates, (c) the angle E/W and N/S from the center of the sun 
in arcseconds, or (d) the HXT equivalent pixel coordinates.  
The default is to read the ATT S/C pointing database for
the true de-jittered S/C pointing.  It is possible to use the commanded
S/C pointing information by using the /CMD option, which is much faster
and only of slightly reduced accuracy.
%
\idlinputa{pix = gt\_center(index)}	\index{GT\_CENTER}
\idlinputb{helio = gt\_center(index, /helio)}	
\idlinputb{helio = gt\_center(index, /helio, /cmd)}	
\idlinputb{ang = gt\_center(roadmap)}
%
where {\it ang(0,*)} is arcseconds east/west with east being 
negative and {\it ang(1,*)} is arcseconds north/south with
north being positive.  {\it helio} is in degrees, and {\it pix} is
in full resolution pixels.  It is possible to get the heliocentric
coordinates in a string of the form ``N12W23'' by using the /STRING
option.

\subsubsection{GT\_SXT\_AXIS}
\index{optical axis, SXT}
\index{X-ray axis, SXT}

The optical axis of the X-ray telescope has been determined from
pre-launch measurements of the effective area as a function of off-axis
angle.  The analysis is described more fully in SXT Calibration Note 36
(R.  Fuller, Jan-94).  The relative offset between the X-ray optical
axis and the optical axis in the Wide band or Narrow band filters was
determined by Tom Metcalf (22-Oct-92).  The combined results are
summarized below:

\begin{verbatim}
                      Optical Axis (CCD Full-Res Pixels)
                             x             y

      X-ray                 515           633
      Narrow Band (NaBan)   514.64        634.47
      Wide Band   (WdBan)   515.24        634.26
\end{verbatim}

The values can be quickly acquired on line using GT\_SXT\_AXIS{}.  The next
three lines will reproduce the values in the table above. Note that the
routine also accepts an index or roadmap data structure and that the filter
will be determined from the SXT structure.
%
\idlinputA{3}{print,gt\_sxt\_axis(0)	 	}{; 0=X-ray}\index{GT\_SXT\_AXIS}
\idlinputB{3}{print,gt\_sxt\_axis(1)	}{; 1=NaBan}
\idlinputB{3}{print,gt\_sxt\_axis(2)	}{; 2=WdBan}
\idlinputB{3}{print,gt\_sxt\_axis(1,/rel)  }{; NaBan relative to X-ray}
%
The sign convention can be understood if you remember that the NaBan image is
Northeast of the X-ray image.
\medskip

The X-ray optical axis has a somewhat large uncertainty, since the effective
area function is broad near the center of the field of view of the telescope.
The relative precision between the optical and X-ray axes has been determined
to better than 0.4 Full-Res pixels (see the Instrument Guide).

The {\it /rel\_xray} keyword option can be used to return the relative offset
to the X-ray axis.

\subsubsection{GT\_PIX\_SIZE}
\index{pixel size, SXT}

The angular size of the SXT full-resolution pixel was determined from
pre-launch focal length measurements to be 2.45280 arc sec for the X-ray
telescope.  Half- and quarter-resolution images are twice and four times
this value, respectively.  A routine to provide this number is
GT\_PIX\_SIZE which is called as:
%
\idlinputa{print,gt\_pix\_size()}
\idlinputb{print,gt\_pix\_size(index)	}\index{GT\_PIX\_SIZE}
%
If the SXT index or roadmap is passed in, the routine will return the
appropriate pixel size in arc sec for the resolution of the data.  The
pixel size of the optical images is thought to be within 1\%\ of the
X-ray pixel size. 

\subsubsection{GT\_TEMP\_CCD}
\index{CCD temperature}
\index{temperature, CCD}

GT\_TEMP\_CCD returns the temperature of the CCD in degrees Celsius.
%
\idlinputd{temp = gt\_temp\_ccd(index)}\index{GT\_TEMP\_CCD} 
%
\subsubsection{GT\_TEMP\_HK  }
\index{temperature, housekeeping, SXT}

GT\_TEMP\_HK returns the temperature measured by the platinum resistance
thermometer (PRT) on the spacecraft and SXT instrument.  There are
16 temperatures saved in the SXT index.
%
\idlinputd{temp = gt\_temp\_hk(index, 0, title=title)}\index{GT\_TEMP\_HK} 
%
\subsubsection{SXTPNT\_SUM}

The routine SXTPNT\_SUM will read the observing log and give a summary of the
unique PFI pointing for a given time period.  It groups the summary listing based on
each unique pointing location over time.   See the User's Guide for a sample listing.
For the command:
%
\idlinputa{sxtpnt\_sum, '5-oct-93 13:00', '6-oct-93 1:00'}\index{SXTPNT\_SUM}
%
it will produce a file in your home directory with the name ``sxtpnt\_sum.txt''
(unless you specify the output file name with the {\it outfil} keyword option).

\subsubsection{PR\_SXTOBS}

The routine PR\_SXTOBS will read the observing log and list each and every FFI and PFI image
taken for the times requested.  The format of the output is simply the output
of GET\_INFO which is described in detail in the Reference Guide.  See the User's Guide
for a sample listing.  The keyword {\it /long} changes the formatting and information
displayed.
%
\idlinputa{pr\_sxtobs,'15-nov-91 22:00','15-nov-91 22:05'}\index{PR\_SXTOBS}
\idlinputc{pr\_sxtobs,'15-nov-91 22:00','15-nov-91 22:05',/long}
%

\subsubsection{PFI\_LOC}
\index{PFI pointing coordinates}
\index{pointing coordinates, SXT-PFI}

PFI\_LOC will display the SXT PFI location.  There are two modes which
can be used when calling PFI\_LOC.  If the first parameter is a 
date and time string, it will read the observing log and make a simple plot showing the
location relative to the sun's limbs.  If the first parameter is an
SXT index, then it assumes that you have displayed this full frame image,
and it reads the observing log and puts a box on the image where the
PFI is located.  Some sample calls are:
%
\idlinputa{pfi\_loc, '23-jun-93 1:00'}\index{PFI\_LOC}
\idlinputb{pfi\_loc, timstr, hours=2}\index{PFI\_LOC}
\idlinputb{pfi\_loc, index}
\idlinputb{pfi\_loc, index, pfi\_struct=sxtp}
\idlinputb{pfi\_loc, index, '6-nov-93 3:30'}
\idlinputb{pfi\_loc, index, '6-nov-93 3:30', /hour}
%
It is possible to use the {\it hours} keyword option to specify the
number of hours plus and minus the full frame time for which you wish to
have PFI locations displayed.  The {\it pfi\_struct} option exists so
that you can pass a PFI roadmap or index structure directly to the
PFI\_LOC to be displayed over the image.  If a second positional parameter
is passed, the routine will get the PFI locations for that time and
overlay them on the image.

When using STEPPER, the ``o'' option will call PFI\_LOC automatically
for you, taking into account any rebinning which has been performed on the
image. 

\subsection{Routines for Calibration and Analysis}

\subsubsection{SXT\_PREP}\label{sxt_prep}
\index{alignment, SXT images}

SXT\_PREP can perform a wide variety of the standard processing required to
use SXT data.  The User's Guide has a description of the capabilities and some
of the fundamentals, and it should be read before reading this section.

The input specifying which images to process can be either an {\it index} and
{\it data}, or it can be the filenames {\it infil} and dataset numbers {\it dset\_arr}.
Some sample calling sequences are:
%
\idlinputa{sxt\_prep, input1, input2, index\_out, data\_out}\index{SXT\_PREP}
\idlinputb{sxt\_prep, index, data, index\_out, data\_out}
\idlinputb{sxt\_prep, infil, dset\_arr, index\_out, data\_out, \$}
\idlinputbb{              helio=[-9.8,-20.3], date\_helio='14-JUN-92  02:37:41'}
\idlinputb{sxt\_prep, index, data, index\_out, data\_out, /helio, ref\_image=10}
\idlinputb{sxt\_prep, index, data, index\_out, data\_out, ref\_image=spr\_index(0)}
\idlinputb{sxt\_prep, index, data, index\_out, data\_out, /roll}

A description of some of the keywords follows:

\vspace{0.2in}\begin{tabular}{lp{12.0cm}}
{ }		& {\raggedright -------------------- Calibration Parameters --------------------} \\
nocorrections	& {\raggedright If set, then LEAK\_SUB, and therefore DARK\_SUB, are not called.} \\
dc\_scalar	& {\raggedright If set, then a simple scalar value is used for dark current 
		subtraction. Default is to take the image closest in exposure.}\\
dc\_interpolate	& {\raggedright If set, then perform interpolation on the dark frame
		images to get a better background subtraction.  Default is to
		take the image closest in exposure.}\\
upper\_only	& {\raggedright If set, only flag +1 pixels above (in a column) the
		saturated area (not the $-1$ pixels) [see call to SXT\_SATPIX].}\\
sfd\_corr	& {\raggedright If set, then the input image is an SFD image.  Use the
		SFD decompression, perform the registration, and recompress
		using the SFD compression.}\\
\end{tabular}

\vspace{0.2in}\begin{tabular}{lp{12.0cm}}
{ }		& {\raggedright -------------------- Alignment Parameters --------------------}\\
register	& {\raggedright If set, then perform the registration and correct only for
		the S/C jitter.  Using the HELIO or SUNCOORD options selects this option also.}\\
ref\_image	& {\raggedright A single roadmap or index structure which will be used 
		to define the sun or heliocentric coordinates for alignment.  
		It can be the image number (subscript) of the images being
		extracted which should be used (not the absolute dataset 
		number within the images listed in "infil") }\\
helio		& {\raggedright the reference latitude and longitude for the alignment.
		This should be the position of the active region at some 
		time, preferably near the time it crossed closest to the 
		center of the disk.  \\
			helio(0) = longitude E/W (E is negative) \\
			helio(1) = latitude N/S (S is negative) \\
		It can be a non-zero scalar value if REF\_IMAGE is passed in.
		In this case, the heliocentric coordinates are derived
		from REF\_IMAGE.}\\
\end{tabular}

\vspace{0.2in}\begin{tabular}{lp{12.0cm}}
date\_helio	& {\raggedright the reference date/time for the heliocentric input.} \\
suncoord	& {\raggedright The coordinates of the center of the portion to extract
		   in angular arcseconds relative to sun center. \\
			suncoord(0) = E--W coordinate (E is negative) \\
			suncoord(1) = N--S coordinate (S is negative) }\\
ccdcoord	& {\raggedright The FRE (full resolution CCD pixel equivalent) of the
		center of the portion to extract.}\\
outres		& {\raggedright The resolution of the output image (0=FR, 1=HR, 2=QR).
		If not set, then convert all to full res.  Only relevant if
		registering the images.}\\
outsize		& {\raggedright The dimension of the output image [\#col, \#lin].
		If it is a scalar value, it will make the \#lin = \#col.
		If not set, it will make it the largest size of the input
		field of views.  If PFI and FFI are mixed, it will take
		the largest PFI.}\\
\end{tabular}

\vspace{0.2in}\begin{tabular}{lp{12.0cm}}
fill\_gap	& {\raggedright A gap can exist between two PFI strips for a single
		   observing region because of a change in S/C pointing.
		   If this variable is set, then the gap between the PFI
		   strips is filled by interpolating the lines above and below.}\\
roll\_do		& {\raggedright If set, then perform the corrections for the roll offset.}\\
normalize	& {\raggedright If set, perform exposure normalization.}\\
\end{tabular}

\vspace{0.2in}\begin{tabular}{lp{12.0cm}}
{ }		& {\raggedright -------------------- Miscellaneous Parameters ----------} \\
force\_read	& {\raggedright If set, read all datasets at once even if input was 
		  specified with INFIL/DSET.  This is available because doing 
		  LEAK\_SUB on all images at once if the input is PFI is more 
		  efficient.}\\
outfil		& {\raggedright If specified, the data will not be passed back in INDEX\_OUT and
		  DATA\_OUT.  Instead, it will be saved in an SDA file with the
		  name specified by this parameter. 
		  If ``uncert" and ``satpix" are included in the procedure call,
		  they will be saved with the same file name with a ``\_unc"
		  and a ``\_sat" appended to the file name.}\\
\end{tabular}\vspace{0.2in}

SXT\_PREP always stores the actual pixel address of the portion extracted and used.
The .HIS.SUN\_CENTER value stored in the index is always the actual pixel address
where the sun center fell on the CCD for that time.  When a registration is performed,
the CORNER\_SAV value will not be set to the same value, even though it is a registered
cube.  This is because the registration is RELATIVE TO SUN CENTER, and that is changing.
Plotting the corner minus the sun center WILL result in a flat plot with all values
identical.

\subsubsection{XSXT\_PREP}

XSXT\_PREP was under development as this volume was being written.  See
the User's Guide for a overview of the capabilities of XSXT\_PREP. \index{XSXT\_PREP}

\subsubsection{SXT\_DECOMP}
\index{data decompression, SXT}

The SXT data are normally compressed from a 12-bit word to an 8-bit word
via a pseudo-square-root compression algorithm.  SXT\_DECOMP takes the
compressed data array ({\it data}) and creates an integer array ({\it ndat}) of the
decompressed numbers by typing:
%
\idlinputd{ndat = sxt\_decomp(data)} \index{SXT\_DECOMP}
%

\subsubsection{SXT\_COMP}
\index{data compression, SXT}

It is possible to re-compress the data. The
routine SXT\_COMP will compress integer data which is in the range
between 0 and 4095 into byte data using the SXT compression 
algorithm.
%
\idlinputd{bdat = sxt\_comp(data)} \index{SXT\_COMP}
%
\subsubsection{RESTORE\_LOW8}
\index{low-8 bit SXT data}

RESTORE\_LOW8 will combine a compressed image with a low 8-bit image to restore
the full 12 bits of resolution.  The images need to be taken relatively
close in time (less than hours apart), and it must be for the same
PFI location.  A sample call is
%
\idlinputa{out = restore\_low8(low8, comp)}\index{RESTORE\_LOW8}
%
where {\it low8} is the SXT image taken with the low 8 bits, and
{\it comp} is the comparable compressed image (ideally, acquired
at nearly the same time).

\subsubsection{SFD\_COMP}\index{SFD images}

The SFD (SXT Full-frame Desaturated) images use a logarithmic compression
in order to save the data as byte type.  SXT\_COMP compresses the
data into byte type.  The compression algorithm
assumes that the data input is in DN/sec/HR pixel and the values
range between 0 and $10^6$.
%
\idlinputd{data\_out = sfd\_comp(data\_in)} \index{SFD\_COMP} 
%
\subsubsection{SFD\_DECOMP}\index{SFD images}

The SFD (SXT Full-frame Desaturated) images use a logarithmic compression
in order to save the data as byte type.  The decompression algorithm
is data\_out = $10.^{(data\_in/255.*6)}$.  The routine SFD\_DECOMP will
do this decompression for you.  Beware: the output are floating type numbers 
and therefore, require four times as much memory.
%
\idlinputd{data\_out = sfd\_decomp(data\_in)} \index{SFD\_DECOMP} 
%
\subsubsection{EXP\_NORM} 

EXP\_NORM 
\footnote{If this code is used as a template, we recommend
that the calling sequence be {\it index,data} for all routines}
takes a data array and produces an exposure and summation mode
normalized floating point array.  Note the floating array takes four times
more room so don't use too big an array to start with.  You need to give
it an index array -- make sure that the two correspond exactly or else
the results will be meaningless.  To run it, type:
%
\idlinputa{ndat = exp\_norm(data,index)} \index{EXP\_NORM}
\idlinputb{ndat = exp\_norm(data,index,0)}
%
To do this it follows the following steps:
\IItem
\item decompresses the data array
\item subtracts background
\item divides by the exposure time
\item divides by the number of pixels binned
\end{itemize}

\subsubsection{SXT\_COMPOSITE}
\index{desaturated SXT images (SFD)}
\index{composite SXT images}

SXT\_COMPOSITE combines two or three SXT images with different exposures into
a ``composite'' image.  The longest exposure is used as the basis for the
final exposure.  SXT\_COMPOSITE uses the results of SXT\_SATPIX to
identify the locations of saturated pixels and replaces them with
equivalent pixels from the shorter exposure images, scaled for the long
exposure image.  This routine uses the algorithm that is used to produce
the ``sfd'' images in the standard SXT movie.  Example calls are:
%
\idlinputa{cimg = sxt\_composite(index,data)}\index{SXT\_COMPOSITE}
\idlinputb{cimg = sxt\_composite(index,data,satpix=satpix)}
\idlinputb{cimg = sxt\_composite(index,data,dc\_data,sx=[1,2,3],sd=[0,2,1])}
%
By default, SXT\_COMPOSITE will do dark and leak frame subtraction if
{\it data} is byte-type.  The user may optionally specify the dark-frame images
in {\it dc\_data} and will default to $data-dc\_data$ unless the explicit
X-ray and Dark-frame indices are given in $sx$ and $sd$, respectively.

Note that the replaced pixels are box-car smoothed with a smoothing
window of 5 pixels.
 
\subsubsection{MK\_SFD}\index{SFD images}

MK\_SFD creates a desaturated set of images
from a series of long and short exposures by typing:
%
\idlinputa{mk\_sfd,infil,outfil,filpref} \index{MK\_SFD}
%
where $infil$ is a string array of one or more SFR filenames (and
locations), $outfil$ is the string array containing the name of directory
where you want the file to be created, and $filpref$ is a string array
which contains the three letter file prefix name (usually SFD).  The
desaturated image is compressed such that:

\begin{verbatim}
                      0 =         1 dn/sec/5 arcsec pixel
                    255 = 1,000,000 dn/sec/5 arcsec pixel
\end{verbatim}
Use the routine SFD\_DECOMP to restore the data from compressed bytes
to real numbers.

\subsubsection{DARK\_SUB}
\index{dark frame subtraction, SXT}
\index{background, SXT}

It is possible to have the dark current removed from PFI and FFI images
by using the following command:
%
\idlinputa{data\_out = dark\_sub(index,data)} \index{DARK\_SUB} 
%
The routine can interpolate between two reference images to simulate the
input exposure duration by using the {\it /interpolate} option.  It will call
the routine GET\_DC\_IMAGE to get the proper image and take the
subsection for the PFI cases.  The SDC data files for the time period
being calibrated must be in the directory \$DIR\_SXT\_SDC. 

The {\it /interpolate} option can be turned on and run automatically
every time DARK\_SUB is run by setting the environment variable
{\tt ys\_dark\_interp}.  An example of how to turn this on and off
is:
%
\ultrixinputA{3}{setenv ys\_dark\_interp 1}{\# will enable automatic interplation}
\ultrixinputB{3}{unsetenv ys\_dark\_interp }{\# will disable automatic interplation}
%
LEAK\_SUB calls DARK\_SUB if the input data is BYTE type, so normally a user does not need to call DARK\_SUB
directly.

\subsubsection{GET\_DC\_IMAGE}

These routines get an appropriate dark frame ({\it dcdata}) and its
index ({\it dcindex}) to match the images you are working with. 
The routines find the full-frame dark image that is closest in
time and exposure level.  The routine can interpolate between two
reference images to simulate the input exposure duration by using the
/INTERPOLATE option.  It can be called with the index for a single image
by typing:
%
\idlinputa{get\_dc\_image, index(3), dcindex, dcdata} \index{GET\_DC\_IMAGE}
%
where {\it index(3)} is the index of the image you are working with, or you can
pass a list array of indicies by typing:
%
\idlinputa{get\_dc\_image, index, dcindex, dcdata, imap}
%
For this case, {\it imap} is the same length as {\it index} and tells you which
image to use in {\it dcdata} for the corresponding index.  For example,
if {\it index} is 10 elements long, and {\it imap(8)=3}, then you should use
{\it dcdata(*,*,3)} for the image that goes with {\it index(8)}.

It is possible to extract the dark frames manually using a command
similar to the following example:
%
\idlinputa{get\_dc\_image, xxx,dc\_index, dc\_data, times='1-sep-92 1:00', res=0, dpe=15}
%
The SDC data files for the time period being calibrated must be in the
directory \$DIR\_SXT\_SDC (and the SDW data files must be in
\$DIR\_SXT\_SDW when calibrating images which were taken when the TEC is
off). 

\subsubsection{LEAK\_SUB}
\index{leak frame subtraction, SXT}
\index{straylight, SXT}
\index{background, SXT}

On 13-Nov-92, there was an entrance filter failure which caused visible
light to contaminate the X-ray images.
It is possible to have the leak image removed from PFI and FFI images
by using the following command:
%
\idlinputa{data\_out = leak\_sub(index,data)} \index{LEAK\_SUB} 
%
The routine will call DARK\_SUB if it comes in as byte type.  The
technique at the time of writing this guide was to find the sunset
leak image which matched the following criteria
\IItem
\item The same X-ray analysis filter.
\item Using the ND filter if the input X-ray image used the ND filter.
\item The nominal S/C pointing must be the same (there is one set of
	images between 13-Nov-92 and 19-Aug-93, and another set for
	images taken after 19-Aug-93)
\end{itemize}

The small changes in S/C pointing were not being accounted for as of
Jan-94, even though there is a relatively strong dependence on
pointing drift.  Future modifications to LEAK\_SUB might take this 
factor into account.

The leak image files must be in the directory \$DIR\_SXT\_SFC.

\subsubsection{INTERP\_IMG}

To linearly interpolate two images to a specified time type:
%
\idlinputa{interp\_img, index1, img1, index2, data2, time, index\_out, img\_out}	\index{INTERP\_IMG}
\idlinputb{interp\_img, idx(10),img(*,*,10),idx(12),img(*,*,12), time, nidx, nimg}
%
where the two input images to be interpolated are specified by the paired
variables {\it index} and {\it img}.  The input
interpolation variable {\it time} can be in any Yohkoh standard time format.
The returned parameters {\it index\_out} and {\it img\_out}
refer to the interpolated {\it index} information and the interpolated image
{\it data} respectively.

\subsubsection{SXT\_FSP and SXTBOX\_FSP [*]} \index{spectral fitting}

SXT\_FSP is the same as HXS\_FSP, but for SXT spectra, you now have the option to fit 
temperatures and emission measures using more than two filters.
%
\idlinputa{SXT\_FSP, index, data, fit\_pars} \index{SXT\_FSP}
%
SXTBOX\_FSP fits spectra to a given box, chosen by LCUR\_IMAGE, for a set of 
SXT images. 
%
\idlinputa{SXTBOX\_FSP, index, data, fit\_pars [, sc\_par, ch\_dta, sdel=sdel, \$}
\idlinputcc{		outfile=outfile, pfile=pfile, same\_bx=same\_bx, boxq=boxq]}

\subsubsection{SXTHXT\_FSP and SXTHXTBOX\_FSP [*]} \index{spectral fitting}

See the description under in the HXT chapter.

\subsubsection{SXT\_TEEM}
\index{temperatures, SXT}
\index{determining temperatures, SXT}

SXT\_TEEM enables you to derive a
temperature map (Te) from two filters taken of the same region.  Some sample
calls are:
%
\idlinputa{sxt\_teem,index1,data1,index2,data2,Te}\index{SXT\_TEEM}
\idlinputb{sxt\_teem,index1,data1,index2,data2,Te,EM,dTe,dEM,subs=subs}
\idlinputb{sxt\_teem,index1,data1,index2,data2,Te,EM,dTe,dEM,\$}
\idlinputbb{     sat1=sat1,sat2=sat2,unc1=unc1,unc2=unc2}
\idlinputb{sxt\_teem,index1,data1,index2,data2,Te,EM,dTe,dEM,\$}
\idlinputbb{     sat1=sat1,sat2=sat2,unc1=unc1,unc2=unc2,/average}
%
{\it index1,data1} should contain data for a single SXT filter.  {\it index2,data2}
   should contain data for a single SXT filter which is different from that
   contained in {\it index1} and {\it data1}.

 The input data should be decompressed and background subtracted.  If index
   is a vector, then the data arrays should be 3-d arrays (cubes).

   Normally, SXT\_TEEM will get the proper exposure times from the index.
   However, if you have renormalized the data in a non-standard manner, then use 
   the {\it t1=t1} and {\it t2=t2} keyword to over-ride the value in index.
t1 = Integration time in msec.
If Image1 is a cube, then t1 must be a vector and whose 
length = n\_elements(Image1(0,0,*))

The keyword option {\it sum = sum}
calls SXT\_SUMXY to rebin the data.
The input image must be a 2-d or 3-d array
{\it sum} must be an integral fraction of the number of X and Y elements.
If either of the two preceding conditions is not met, summing is not done.

If {\it data1} is a cube, {\it Te} will be computed for each image by default.
If {\it subs=subs} is present, {\it subs} should contain the indices of image
pairs to analyze.

The keyword option {\it thresh1=thresh1, thresh2=thresh2}
sets the level above which data are considered for processing.
The level is set on the background subtracted, rebinned data values.
If {\it sum=2}, then you must increase the value of {\it thresh1} by a factor
of 4 to have the same effect.

\subsubsection{SXT\_ERG\_PER\_DN}

SXT\_ERG\_PER\_DN returns the log of the radiative energy per DN
assuming a coronal spectral model with temperature, $T_e$.  The units
of the result are $\log_{10}$(erg/DN), where DN is assumed to be the
decompressed and background subtracted value that is read out of the CCD
camera.  Example calling statements are:
%
\idlinputa{log10\_erg\_dn = sxt\_erg\_per\_dn(log10\_Te,filter)}\index{SXT\_ERG\_PER\_DN}
\idlinputb{log10\_erg\_dn = sxt\_erg\_per\_dn(log10\_Te,filter,date='1-dec-92')}
%
and $log10\_Te$ and $filter$ are input variables which may be vectors.  $log10\_Te$ is
the log of the electron temperature (K), of the solar plasma and $filter$
is the SXT filter number.  For example, to compute $\log10$(erg/DN) for all filters
over the range of temperatures between $\log10(T_e)$ between 5.5 and 8.0 use the
following calling sequence:
%
\idlinputA{3}{Te = 5.5 + findgen(26)*.1         }{ ; Generate a temperature vector}
\idlinputb{log10\_erg\_dn = sxt\_erg\_per\_dn(Te,indgen(6)+1)}
%
The purpose of the $date$ keyword option is to allow the post-November
1992 SXT response functions to be used.  This can be invoked by specifying
any date later than ``14-Nov-92'', the day after a hole in the entrance
filter appeared, and caused the SXT response function to change.

\subsubsection{SXT\_VIGNETTE}\index{vignette}

The SXT vignette function was determined from pre-launch calibration data obtained
at White Sands Missile Range (WSMR) and was further refined using flight data.
The vignette function is approximated by two non-concentric cones.  The
routine SXT\_VIGNETTE computes the SXT vignette function for a given SXT
image as described in the scalar SXT $index$ as follows:
%
\idlinputA{3}{vignette = sxt\_vignette(index)}{        ; SXT Index should be a scalar}
\idlinputb{vignette = sxt\_vignette(array)}
\idlinputb{vignette = sxt\_vignette(index,energy)}\index{SXT\_VIGNETTE}
%
If $array$ is given then $array = [x0,y0,Nx,Ny,Mode]$ and $Mode =$ 0, 1, or
2, for full, half and quarter resolution.  The second argument, $energy$
will specify whether to use the low-energy results (derived from C-K and
Al-K test data) or the high-energy results (derived from Ag-L test data).
SXT\_VIGNETTE is called by SXT\_OFF\_AXIS to correct SXT images.  A quick
summary is available by typing:
%
\idlinputD{3}{help\_vignette          }{; Display SXT vignette function}\index{HELP\_VIGNETTE}

\subsubsection{SXT\_OFF\_AXIS}

The X-ray vignetting function can be approximately removed with the
routine SXT\_OFF\_AXIS.  Example calling statements are:
%
\idlinputa{data\_out = sxt\_off\_axis(index, data, index\_out)}\index{SXT\_OFF\_AXIS}
\idlinputb{data\_out = sxt\_off\_axis(index, data, /update\_index)}
\idlinputb{vignette = sxt\_off\_axis(index, /vignette\_only)}
%
SXT\_OFF\_AXIS calls SXT\_VIGNETTE to calculate the SXT X-ray vignette 
function.  See SXT Calibration Note 37 and the Instrument Guide of this
manual for more information.  Two Vignette functions have been determined:
the high-energy function is applied to the Al12 and Be119 filters and
the low-energy function is applied to all other filters.  Note that this
approach is somewhat approximate and care should be used when applying this
correction to SXT data.

\subsubsection{WL\_PROCESS [*]}

Alan McAllister wrote the routine WL\_PROCESS to process the SXT aspect
sensor images and generate limb darkening profiles, flat field images,
white light images minus the dark current, flat field, and limb darkening
signals.   The routine is still under development and you should look
at the documentation header of that routine for more details.

\subsection{Routines for Image Alignment}

The routines described here are specific to SXT.  There are also some routines
listed in the General Yohkoh Software chapter which can be used for either
SXT or other ground-based images.

\subsubsection{SXT\_PREP}

See the earlier section describing the details of SXT\_PREP.

\subsubsection{SXT\_CENTER [*]}
\index{alignment, SXT images}

SXT\_CENTER calculates the row ({\it x}) and column ({\it y}) of the
center of the solar disk and the radius ({\it r}) of the Sun
given a data cube ({\it data}) and the index structure ({\it index}).
The routine performs a fit to the limbs of the image.  The fit can
be off by several pixels in the E/W direction for X-ray images.
See the SXC database if you are interested in the X-ray center
for all SFD images as calculated by SXT\_CENTER.
%
\idlinputa{sxt\_center,data,index,x,y,r} \index{SXT\_CENTER}
%
There are many options that are possible to use, please
check them with DOC\_LIBRARY.

\subsubsection{GET\_GBO\_PFI [*]}
\index{alignment with ground-based images}
\index{ground-based images, aligning to SXT}

Given a SXT PFI image and either the file name of a ground-based image,
or the ground-based image itself, GET\_GBO\_PFI will extract the portion of
the GBO image corresponding to the SXT PFI.  The routine (a modification
of the routine GBO\_PFI written by Alan McAllister)\index{GBO\_PFI}
determines the PFI corners from {\it index}, rotates these to the
time of the GBO image, and extracts the section of the GBO image.
You can either pass in the GBO image itself, in which
case you MUST also supply the time for it, or a string
with the path/filename using the Yohkoh file name convention.
Some sample calls are:
%
\idlinputa{gbo\_img = get\_gbo\_pfi(index, gbo\_fullimg, gbo\_time)}
\idlinputc{gbo\_img = get\_gbo\_pfi(index, '/yd5/gbo91\_46a/gkm911116.1958')}\index{GET\_GBO\_PFI}

\subsubsection{OCENTER}

OCENTER will obtain the center of the Sun from a optical full frame image.
It makes a ``silhouette image'' consisting of 1's and 0's, then
calculates the centroid to determine $x$ and $y$. The area is used to
determine the image radius. The input image can be compressed
or decompressed, and in any summation mode.  The output is in SXT full resolution
pixels unless {\it /noscale} is set.
%
\idlinputa{ocenter, image, x, y, radius}\index{OCENTER}
\idlinputb{ocenter, image, x, y, radius, /noscale, cut=0.3}
%
where {\it image} is the 2-D input image, and {\it x} and {\it y} are the
E/W and N/S position of the sun.  {\it radius} is the solar radius in
pixels and {\it cut} is the fraction of image maximum to define the limb (default is 0.2)

\subsection{Routines for Accessing Secondary Database Files}

\subsubsection{GTAB\_COMM, GTAB\_ENTRY, GTAB\_ROI}
\index{control tables, SXT}
\index{sequence tables, SXT}
\index{tables, SXT}

It is possible to get information on what was used in an SXT table by
using one of these routines.  GTAB\_COMM returns information on the
common table, GTAB\_ENTRY returns information on the entry tables,
and GTAB\_ROI returns information on the ROI location and image
shape tables.  Some sample calls:
%
\idlinputa{print, gtab\_comm(index)}	\index{GTAB\_COMM}\index{GTAB\_ENTRY}\index{GTAB\_ROI}
\idlinputc{print, gtab\_comm('15-nov-91')} 
%
\subsubsection{GTAB\_PFI and GTAB\_FFI}

These routines allow a user to print information on the partial-frame
and full-frame observing sequence being used.  There are four possible
sequences for PFI and four more for FFI.  Which sequence is used is
determined by the DP mode and telemetry rate.  If the SXT index for
an image is passed, then it will figure out which of the four sequences was
running at that time.  
%
\idlinputa{print, gtab\_ffi(index)}	\index{GTAB\_FFI}\index{GTAB\_PFI}
\idlinputb{print, gtab\_pfi('15-nov-91', 2)}
%
If a time is passed, it will default to show
sequence number 0.  It is possible to specify which sequence table by passing
it as a second parameter.

\subsection{Routines for Engineering Plots}

\subsubsection{PLOT\_SOT}

PLOT\_SOT will plot out the aspect sensor degradation as a
function of time by typing:
%
\idlinputa{.run plot\_sot} \index{PLOT\_SOT}
%
It will produce plots for both the narrow-band and wide-band filters.

\subsubsection{PLOT\_TEMPS2 [*]}

PLOT\_TEMPS2  plots the SXT instrument temperatures.
This program can only be run after the variable {\it index} exists which
came from an SXT file.  A common practice is to run PLOT\_SOT which gets 
images over the whole mission.
%
\idlinputa{.run plot\_temps2} \index{PLOT\_TEMPS2}
%
A mosaic of time histories of the various instrument temperatures will
be plotted. 

\subsubsection{PLOT\_SSL}

PLOT\_SSL will plot the SXT summary log (SSL) information.  A series of 
plots are made which include:
\IItem
\item Plots of measured exposure levels
\item Plots of SXT temperatures
\item Plots of number and duration of exposures through different filters
\item Plots of percentage of data received
\item Plots of average/max SXS1,SXS2,HXT-Low,RBM counting rates
\end{itemize}

Sample calls are:
%
\idlinputa{plot\_ssl}\index{PLOT\_SSL}
\idlinputb{plot\_ssl, [0,1]}
\idlinputb{plot\_ssl, 3}
%
where the second example only plots the first two series of plots (exposure levels
and SXT temperatures), and the last example only plots percentage of data received.
