Soft X-Ray Telescope (SXT)
    5.1  How to View SXT Images
    5.2  Preparing the SXT Data for Analysis (SXT_PREP)
    5.3  Making a Light Curve with SXT Images (LCUR_IMAGE)
    5.4  Making a Mission Long SXT Light Curve
    5.5  Jitter and Assembly of PFIs from Multiple Exposures
    5.6  Displaying SXT and Ground-Based Synoptic Maps
    5.7  Alignment of Optical and X-Ray Images
    5.8  Aligning Ground-Based Images with SXT
        5.8.1  Determining the Coordinates Using FIT_LIMB
        5.8.2  Determining the Coordinates Using DSK_LOCB
        5.8.3  Determining the Coordinates and/or Roll by Feature Correlation
        5.8.4  Registering One Image to Another Image
    5.9  How to Correct for Vignetting
    5.10  Determining the Pointing Coordinates for SXT PFI
        5.10.1  Simple Plots of Location Relative to the Solar Limb
        5.10.2  Overlaying the PFI Location on an Image (PFI_LOC)
        5.10.3  Listing of the Images and Heliocentric Locations
        5.10.4  Extracting the PFI Location (GT_CENTER)
    5.11  Filter Responses
    5.12  Determining Temperatures for SXT Images (SXT_TEEM)
        5.12.1  Read in the data
        5.12.2  Prepare the data: Part 1 (background subtraction, registration)
        5.12.3  Prepare the data: Part 2 (Filter selection)
        5.12.4  Prepare the data: Part 3 (Interpolation)
        5.12.5  Compute SXT temperatures
        5.12.6  Additional Hints and Notes
    5.13  Looking at Time-Profiles of Temperatures (GO_TEEM)
    5.14  How to Fit SXT Spectra (McTiernan) [*]
    5.15  Useful Routines for SXT

5  Soft X-Ray Telescope (SXT)

5.1  How to View SXT Images

Once the SXT data are read into index and data using YODAT or RD_SDA, it is very simple to display images. A general purpose routine called STEPPER is the most common method used.

STEPPER takes a data cube (data) and allows a user to step through the images and to display them as a movie. If the index is passed into STEPPER (as shown in 2 of the examples below) it is possible to chose an option to display light curves. Some sample calls are:
IDL >  stepper, data
IDL >  stepper, data, info_array
IDL >  stepper, index, data, xsiz=512
IDL >  stepper, index, data, info_array
where info_array and xsiz are optional parameters. xsiz indicates the size of the displayed image you want (must be an integer multiple of the original array). It is a window driven program.

Some other keyword options are start=start to specify the starting image to display; /noscale to not perform automatic scaling on each individual image (uses TV instead of TVSCL); subscript=ss to specify the image numbers to display (default is to display all images in the data cube); /filter_panels to display each unique filter in a different location on the window; /sequence_panels to display each unique image sequence in a different location on the window.

When STEPPER begins, the following menu is displayed.

-------- STEPPER Options --------
There are 259 images in the array
There are 259 images selected
Enter "b" to step backwards                 "h" to call HARDCOPY
      "s" to select new start index         "z" for ZOOM
      "c" to call LOADCT                    "x" for XLOADCT
      "p" to call the IDL PROFILES routine  "l" to call light curve routine
      "g" to overlay SXT solar grid         "o" for observing region location
      "q" to quit                           "m" for movie mode
      "?" to display this help menu         "anything else" to step forward

The user only needs to press the key to select the option (no < CR > required). It is possible to overlay a grid showing the solar limb and latitude/longitude lines for either full frame or partial frame images. The ``l'' option calls LCUR_IMAGE and the user should read section 5.3 for more details.

The routine XSTEPPER is a widget driven routine which operates in a manner similar to STEPPER, but has some other capabilities. A sample call is:
IDL >  xstepper, data, info_array

It is possible to load a data cube into a widget to be ``animated'' using the routine XMOVIE (which is simply an interface for IDL's XINTERANIMATE). The speed which the frames can be displayed is quite fast. There are some memory restrictions which do not allow large data cubes. Some sample calls are:
IDL >  xmovie, data
IDL >  xmovie, data, ss=ss       ; only displaying images listed in ss

A final popular routine for displaying images is the routine XY_RASTER. This routine will make a raster pattern of a time series of images to display time evolution. The images start at upper left and go to lower right, and the time is optionally written at the bottom of each image. Some sample calls are:
IDL >  xy_raster, index, data
IDL >  xy_raster, index, data, 3, ss=ss
The second example blows the image up to three times its input size and only displays the images listed in the array ss.

5.2   Preparing the SXT Data for Analysis (SXT_PREP)

It is the desire of the SXT team to have the routine SXT_PREP used for most of the preparation of the SXT data. The SXT_PREP routine performs a variety of tasks, some of which are described in the following list.

  1. Flag the saturated pixels
  2. Calculate the decompression error uncertainties for each pixel
  3. Perform standard corrections to the data

  4. Align the images and build the observing region (or mosaic of PFI images). The routine can handle PFI, FFI, or a mix of images. It can extract subportions out of FFI images. The alignment can be done

  5. Optionally fill in the horizontal gaps in the observing region (or)
  6. Optionally exposure normalize to a one second exposure

Some important elements of SXT_PREP are:

The steps to using SXT_PREP can be somewhat involved. The basic steps are described below, but the routine XSXT_PREP is an easy way for a user to specify what processing should be performed, and XSXT_PREP is described at the end of this section.

  1. Select the files which have the data of interest. You can use YODAT to do this, or some other method.

  2. Select the images that you wish to process. Again, YODAT can do this, or you can use SSWHERE or another method for selecting the images. If you are not using YODAT, then one option is to read the roadmaps of the files, and pass the roadmap to SSWHERE. The following example assumes the list of file names (as a string vector) is in the variable infil.
    IDL >  rd_roadmap, infil, rmap
    IDL >  ss = sswhere(rmap)

  3. To register images, it might be necessary to determine the coordinates for the center of the aligned images. Some methods for specifying the coordinates are:

    If you only selected PFI images, and the PFI images you selected are all for the same active region, then you do not need to specify the coordinates of an aligned image (it will automatically derive the optimal coordinates by averaging all PFI center locations). If they are not for the same region, then you should either modify your selection so that it only includes one location on the sun, or select a image which all of the data should be aligned to and use the ref_image=index(ialign) option, or you can specify the absolute coordinates (the procedure for establishing those coordinates is described below).

    If you have mixed PFI and FFI images, then you can specify one of the partial frame images, and then all images will be registered to that image, and the appropriate portion of the FFI image will be extracted and aligned.

    If you selected only FFI images, but you want to extract a portion to make a registered movie, then you will need to determine the coordinates for the registered image. A simple method to do this is to use SXT_GRID. If you want to simply remove the S/C jitter and the SXT pointing changes (register relative to sun center), then display a full frame image and call SXT_GRID. An example is:
    IDL >  tvscl, data(*,*,5)
    IDL >  sxt_grid, index(5), /read_out, last=loc, /angle
    As you move the cursor around, you will see that the values in the small window are changing. When the cursor is located at the location where you want the center of your image, press the right button. If you want to register images and track on a heliocentric coordinate, then you can use SXT_GRID again to get those coordinates. An example is:
    IDL >  tvscl, data(*,*,5)
    IDL >  sxt_grid, index(5), /read_out, last=loc
    It is necessary to specify the size of the output image when extracting a partial frame out of a full frame.

  4. Run SXT_PREP. If you are reading the data and passing the index and data to SXT_PREP, then the observing regions should not be assembled (answer ``No'' to this question in YODAT). This is important because jitter and drift can cause pointing changes between the different exposures that comprise of one PFI observing region.

    It is possible to pass index and data into SXT_PREP, or to pass the file name array (infil) and the data sets to extract (ss). The results can be returned in the third and fourth parameters (index2 and data2) or they can be written directly to an output file (outfil=outfil).

    Below are some examples of how to call SXT_PREP.

IDL >  sxt_prep, infil, ss, index2, data2, /reg
IDL >  sxt_prep, infil, ss, index2, data2, uncert, satpix, /reg
IDL >  sxt_prep, infil, ss, index2, data2, helio=loc, date_helio=date_helio
IDL >  sxt_prep, infil, ss, index2, data2, helio=[-9.8,-20.3], $
IDL >   date_helio='14-JUN-92 02:37:41')
IDL >  sxt_prep, index, data, index2, data2, /reg, ref_image=index(55), outsiz=100
IDL >  sxt_prep, index, data, index2, data2, /reg, ref_image=index(55), /helio
IDL >  sxt_prep, infil, ss, index2, data2, /reg, /sfd, outres=1, $
IDL >   outsiz=[100,200], suncoord=suncoord
IDL >  sxt_prep, infil, ss, /reg, outfil=outfil, /dc_interpolate, /normalize

XSXT_PREP provides a graphical user interface to SXT_PREP. The XSXT_PREP routine simplifies the access to the many SXT_PREP options and varied calling sequences. In addition, XSXT_PREP provides a front end to some additional data selection and filtering tools which may be used to fine tune the data set and allows graphical definition of all SXT_PREP input parameters. The following graphical tools are provided:

The combination of graphical interface and online help make this a good routine to learn through use. It is a main level routine. For starters, try the following calling sequence:
IDL >  .run yodat       ; select SXT data cube to process
IDL >  .run xsxt_prep       ; play around

5.3   Making a Light Curve with SXT Images (LCUR_IMAGE)

It is possible to display a light curve of the SXT image intensities using the routine LCUR_IMAGE. This routine is available from within STEPPER so the user can select the option by entering ``l''.

Some examples for calling LCUR_IMAGE directly are:
IDL >  lcur_image, index, data
IDL >  lcur_image, index, data, lcur
IDL >  lcur_image, index, data, lcur, uncert, satpix
IDL >  lcur_image, index, data, xsiz=512
IDL >  lcur_image, index, data, xsiz=512, /poly
IDL >  lcur_image, index, data, xsiz=512, /nonorm, subscript=subscript
index and data are input, and lcur is the output - an array with the image intensities. uncert and satpix are optional inputs which are the uncertainty and saturated pixel map which is returned from SXT_PREP. If these two variables are passed, the routine will mark points which are saturated or have high uncertainty. The xsiz option will blow up the image to be 512 pixel wide (an 512 pixels tall if it is square) so that the selection of a region is simple.

-------- LCUR_IMAGE Options --------
Enter "p" to mark and plot light curves (loops until exited)
      "m" to overplot all of the selected light curves
      "r" to display the regions selected ("R" to make a hardcopy)
      "s" to change the method to mark regions to plot.  Currently: RECT
      "d" to call "stepper" to refresh/display a new image
      "z" to reset (zero out) all of the regions saved so far
      "o" to enable/disable over plotting of new curves. Currently: DISABLED
      "6" to enable/disable making 6 window plots.  Currently:      DISABLED
      "h" to produce a hard copy of the most recent light curve
      "H" to produce a hard copy of all selected light curves
      "q" to exit LCUR_IMAGE ("x" will work too)
Enter your option (no return required).  It is case sensitive.

The user can select several different areas on the image and overplot the light curves for each region. The light curves and regions are labeled so that they can be differentiated. Hardcopy options exist, along with several other capabilities. See the documentation header for the program and the Reference Guide for more details.

5.4  Making a Mission Long SXT Light Curve

The following command will display a light curve which uses the integrated total of the full disk SFD images. There is one plot for thin Al and another one for AlMg.
IDL >  .run plot_sxl
The SXL database must be available on your system for this program to work.

5.5  Jitter and Assembly of PFIs from Multiple Exposures

See the section ``Preparing the SXT Data for Analysis (SXT_PREP)'' on page 5.2 for a description of how to align images.

5.6  Displaying SXT and Ground-Based Synoptic Maps

The SXT synoptic maps are constructed from strips extracted from full disk desaturated SXT images made using the thin aluminum filter. Each map depicts a single Carrington rotation. There are three sets of maps, corresponding to strips centered on the central meridian of the solar disk, 45 E longitude, and 45 W longitude. The widths of the strips are determined by the time differences between images. For a given map, as many full disk images are used as are available provided the time difference between contiguous images exceeds 1.5 hours. Due to occasional gaps in the coverage of full disk imagery, some of the synoptic maps show corresponding gaps. The maps constructed from strips centered at the degree longitudes are distorted at high latitudes because vertical strips are extracted which do not follow the longitude line. The images from which the strips are extracted have been registered to remove the effects of spacecraft pointing changes. Each strip is shifted along the vertical axis so that heliographic latitude 0 is always centered in the assembled map. However, projection effects in the vertical axis have not been removed. This means that the latitude scale is not linear but reflects the cosine projection effect of a spherical structure (the corona) projected on to a flat image.

The following are some examples of how to display the synoptic images which are in the Yohkoh database. The first example just displays a single synoptic map for the central meridian for carrington rotation number 1860. The second example displays three SXT synoptic maps, central, +45 and -45. The third example has a single synoptic image which is the Kitt Peak magnetogram for carrington rotation number carrington_rot_num. The fourth example shows SXT central meridian and the Kitt Peak magnetogram and He 10830 synoptic maps.
IDL >  disp_synop, 1860
IDL >  disp_synop, 1860, /allsxt
IDL >  disp_synop, carrington_rot_num, /kpmag
IDL >  disp_synop, carrington_rot_num, /gbo

An example of how to read one of the SXT central meridian synoptic map images is shown below, along with an example of how to read a Kitt Peak magnetogram synoptic map for carrington rotation number 1862.
IDL >  rd_xda, '$DIR_GEN_SYNOPTIC/ssc_cr1862a.01', -1, index, data
IDL >  img = rfits('$DIR_GEN_SYNOPTIC/gkm_cr1862a.01', header=header)

5.7  Alignment of Optical and X-Ray Images

When SXT_PREP is called with the /register switch, the optical images are automatically aligned to the X-ray images. See the Instrument Guide and the routine GT_SXT_AXIS in the Reference Guide for more details.

5.8  Aligning Ground-Based Images with SXT

The software tools for aligning SXT images and other images is in a very early stage of development. The routine COAL_IMAGE along with some other tools can be used in a fairly manual method to co-align a pair of images.

The alignment between SXT images and other images can be performed by the following steps. The SXT images do not require steps 1 or 2 since the absolute pointing and roll are known for SXT images.


Figure 5.6: Coordinate definition for COAL_IMAGE

  1. For the non-SXT image, determine the distance that the lower left pixel is from the center of the sun in pixel units (see Fig. 5.6). This can be accomplished in one of several methods.

  2. Determine the roll of the image relative to solar north. Again there are several techniques to determine this value

  3. Run COAL_IMAGE to register one image to another image. The program will correct for:

5.8.1  Determining the Coordinates Using FIT_LIMB

FIT_LIMB is a modified version of SXT_CENTER. It currently requires that you know the pixel size of the image which is being processed (although the pixel size can be derived by calling FIT_LIMB multiple times with different pixel sizes until the diameter of the solar limb outline matches the image). It allows fits to a partial solar limb. A sample call to FIT_LIMB is
IDL >  fit_limb,img,x0,y0,/int,pixel_size=3.97
where it assumes that you have the image to be fit in the variable img. The /int enables the interactive selection of the initial guess of the fit. It is very important that the first guess be very close. pixel_size=3.97 specifies the pixel size in arcseconds. The E/W and N/S sun center coordinates are returned in x0 and y0. These values must be inverted since we want the corner coordinate relative to sun center.
IDL >  corner2 = [-x0, -y0]

5.8.2  Determining the Coordinates Using DSK_LOCB

If you have a full disk image with well a defined limb, you can use the routine DSK_LOCB. A sample call is:
IDL >  dsk_locb,img,horzcnt=x0,vertcnt=y0,horzrad=rz,vertrad=ry
IDL >  corner2 = [-x0, -y0]

See the Reference Guide or the documentation header for more details on DSK_LOCB.

5.8.3  Determining the Coordinates and/or Roll by Feature Correlation

It is also possible to determine the coordinates of the corner by matching features to another image for which the sun center location is know. This would be necessary for images that do not include the solar limb. No standard piece of software was available when this guide was written so send a request for information to the e-mail address shown in the preface of this guide.

A crude routine called FLASH_COMP is available to take two images and flash them using XINTERANIMATE. The images are scaled independently and do not need to be put into an data cube. A sample call is
IDL >  flash_comp, img1, img2

5.8.4  Registering One Image to Another Image

Once the image coordinates are known for the non-SXT image(s), you can call the routine COAL_IMAGE which will co-align one image to another. The following assumptions are made for the sample calling sequences below.
IDL >  pix2 = 3.97       ; pixel size of non-SXT image
IDL >  pix1 = gt_pix_size(index)       ; SXT image pixel size
IDL >  corner1 = gt_corner(index, /from_sc)       ; the SXT corner

To convert the non-SXT image to the resolution and align it to the SXT image you would use the first command below, and you can optionally compare the newly aligned images with the second command.
IDL >  out1 = coal_image(img, corner2, corner1, [256,256], mag=pix2/pix1)
IDL >  flash_comp, out1, data

The following are the commands to convert the SXT image to the resolution of the non-SXT image, and align it to the non-SXT image:
IDL >  out2 = coal_image(data, index, corner2, [512,512], mag=pix1/pix2)
IDL >  flash_comp, out2, img

There is an optional keyword angle which will roll one image relative to the other if the angle is known. See the description of COAL_IMAGE in the reference guide and the program header for more information.

5.9  How to Correct for Vignetting

The SXT X-ray effective area varies across the 42×42 arcmin field-of-view. The shape of the vignette function can be examined with the IDL program HELP_VIGNETTE. At 21 arcmin from the optical axis, the low-energy response ( < 1.49 keV) falls to approximately 75% and the high-energy response (2.98 keV) falls to approximately 50% of the on-axis value (see the Instrument Guide for more details). Because of this, some care should be taken when, for example, making temperature analyses with thin and thick filters of flares that occur near the solar limb.

There are no fully approved routines to remove or correct for the SXT vignette function. There are, however, two preliminary routines. SXT_VIGNETTE will compute the vignette function as it is currently understood. The form and parameters of the shape may be changed as additional data and analysis results become available. The routine SXT_OFF_AXIS will correct for the vignette function by calling SXT_VIGNETTE. Users are warned that these routines are preliminary and may not be the most appropriate technique to use, depending on the scientific application.

5.10  Determining the Pointing Coordinates for SXT PFI

5.10.1  Simple Plots of Location Relative to the Solar Limb

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 if you have the index, roadmap or observing log structures. A sample call is:
IDL >  plot_fov, index, /box

If you don't have a PFI structure, then you can use the routine PFI_LOC. It can accept a date and time and will display a simple plot of the sun and the SXT PFI location (PFI_LOC simply reads the observing log and then calls PLOT_FOV). Some sample calls are
IDL >  pfi_loc, '23-jun-93 1:00'
IDL >  pfi_loc, timstr, hours=2
The second example will display all of the different PFI locations for the time stored in the string variable timstr 2 hours.

5.10.2  Overlaying the PFI Location on an Image (PFI_LOC)

If you have displayed a full frame image and you wish to see where the SXT PFI region was located, you can use the routine PFI_LOC. Assuming that the index of the image which is displayed is index, then a sample calling sequence is:
IDL >  pfi_loc, index
It is possible to use the 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. When using STEPPER, the ``o'' option will call PFI_LOC automatically for you, taking into account any rebinning which was performed on the image.

5.10.3  Listing of the Images and Heliocentric Locations

See section 2.1.4 for some details on routines for listing the SXT partial frame pointing information.

5.10.4  Extracting the PFI Location (GT_CENTER)

The routine GT_CENTER will allow a user to determine the coordinates of the center of a PFI image. The output from this routine can be the location of the center of the field of view in (a) full resolution IDL pixels coordinates 5, (b) heliocentric, (c) the angle E/W and N/S from the center of the sun in arcseconds, or (d) the HXT equivalent pixel coordinates. If the user has the index available in the variable index, then he can use the following commands (these commands will also work for the roadmap structure)
IDL >  pix = gt_center(index)
IDL >  helio = gt_center(index, /helio)
IDL >  helio = gt_center(index, /helio, /string)
IDL >  helio = gt_center(index, /helio, /cmd)
IDL >  ang = gt_center(index)
The default is to read the ATT S/C pointing database for the true sun center location. 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. The /STRING option will print the heliocentric coordinates in the format ``N23E45''.

5.11  Filter Responses

See the Instrument Guide for details on the SXT telescope and filter responses.

5.12  Determining Temperatures for SXT Images (SXT_TEEM)


Figure 5.7: The effective area of the SXT: The thick curve shows gives the effective area for the indicated filter. The thin curve is the open filter case (no analysis filter) effective area over-plotted for comparison.


Figure 5.8: The total SXT signal as a function of log10(Te) for the open filter and the analysis filters as indicated. NOTE: Be and Al12 are mistakenly reversed in Tsuneta et al., (1991).


Figure 5.9: Ratios of the SXT response functions. For the curve marked ``Be119/(2×Al12)'' the effective observing time with the Al12 filter has been doubled with respect to the Be119 filter. For the curve marked ``2×Al12/Al.1'' the effective observing time with the Al12 filter has again been doubled, this time with respect to the Al.1 filter.

The SXT X-ray filters were chosen to provide a different effective area for each filter as a function of wavelength (Fig. 5.7). The SXT response functions are computed by folding a thermal spectrum with the SXT effective area through each filter. The result is shown in Fig. 5.8, for the Mewe 1985 spectrum using coronal abundances. The ratios of the fluxes observed through the various filters is temperature sensitive. Three filter ratio combinations are shown in Fig. 5.9. These ratios are actually ``mean" temperatures and are only correct for the case of an isothermal plasma.

The SXT images may be used to compute temperatures after the data have been properly prepared. Normally, SXT_PREP should be called to prepare the data. The steps to follow are given in the next sections.

5.12.1  Read in the data

This can be done using YODAT or by directly reading the data file. If the data consist of observing regions (OR), then do not assemble the data when reading it with YODAT (the data will be assembled by SXT_PREP).

5.12.2  Prepare the data: Part 1 (background subtraction, registration)

Normally, you should use SXT_PREP to do the decompression, background subtraction, and stray light subtraction (pinhole leak). For example:
IDL >  SXT_PREP,index,data,new_index,new_data,unc,sat
IDL >  SXT_PREP,index,data,new_index,new_data,unc,sat,/register
The variables unc and sat are arrays that contain, respectively, the decompression error and information about the saturated pixels. It is not necessary to exposure normalize the data.

See the Reference Guide or Section 5.2 of the User's Guide for more information about running SXT_PREP.

5.12.3  Prepare the data: Part 2 (Filter selection)

It is necessary to select the filters which will be used for the analysis. The are many ways to do this. An example is given below for the Al.1 and Be119 filters:
IDL >  i1 = where(GT_FILTB(new_index) eq 4)       ; Get Be119 indices
IDL >  i2 = where(GT_FILTB(new_index) eq 2)       ; Get Al.1 indices

IDL >  data1 = new_data(*,*,i1)
IDL >  index1 = new_index(i1)
IDL >  sat1 = sat(*,*,i1)
IDL >  unc1 = unc(*,*,i1)

IDL >  data2 = new_data(*,*,i2)
IDL >  index2 = new_index(i2)
IDL >  sat2 = sat(*,*,i2)
IDL >  unc2 = unc(*,*,i2)

5.12.4  Prepare the data: Part 3 (Interpolation)

Because of the design of the SXT and the spacecraft telemetry system, images are never obtained in two different filters simultaneously. If the solar fluxes vary rapidly compared to the observing cadence, it is recommended that you interpolate the intensities of one filter to match the time at which the data in the other filter were acquired. This can be done using SXT_INTERP, which will do a linear interpolation on a pixel by pixel basis. An example calling sequence is:
IDL >  SXT_INTERP,index1,data1,ntimes,unc1,sat1
where ntimes is an array of times to which the interpolation should be made. For example, in the case given here, it would be appropriate to set
IDL >  ntimes = index2
in order to interpolate the filter ``1'' data to the times of filter ``2'' data.

Note that SXT_INTERP ``over-writes'' the input variables (to save memory).

5.12.5  Compute SXT temperatures

The routine SXT_TEEM should be used to compute temperatures from SXT filter data. This routine will compute the filter ratio and then determine the temperature and emission measure and uncertainties. Some example calling sequences are:
IDL >  sxt_teem, index1, data1, index2, data2, Te
IDL >  sxt_teem, index1, data1, index2, data2, Te, EM, dTe, dEM,subs=subs
IDL >  sxt_teem, index1, data1, index2, data2, Te, EM, dTe, dEM,$
IDL >   sat1=sat1,sat2=sat2,unc1=unc1,unc2=unc2
IDL >  sxt_teem, index1, data1, index2, data2, Te, EM, dTe, dEM,$
IDL >   sat1=sat1,sat2=sat2,unc1=unc1,unc2=unc2,/average
Note that Te (K) and EM (cm-3) are returned as log10 values as are their uncertainties. Some ratios may have invalid temperatures and these are flagged with Te=0. data1 and data2 do not need to be exposure normalized if index1 and index2 are SXT index structures (since the index1 and index2 parameters can optionally be scalar values which are the X-ray filter numbers).

The results may be displayed using different techniques. One way is to use a user contributed routine:
IDL >  tv_teem,Te,dTe,level=.3
where level= specifies the maximum value of dTe which is displayed. This is a convenient way to suppress the display of pixels that have low statistical significance.

5.12.6  Additional Hints and Notes

5.13  Looking at Time-Profiles of Temperatures (GO_TEEM)

The GO_TEEM procedure computes the time-profile of the spatially averaged electron temperature (Te) and emission measure (EM) for a processed data cube. The results are plotted to the screen and are also saved to the return variables te, em, dte, and dem so they can be saved for later reference. The program prompts the user to select a pair of thin and thick filters to be used in the computation, an interpolation method (none is an option) and a reference image from the data cube from which the user can view in detail. Once the user has reviewed the selected reference image and decided which parts of the image to study, the user then uses various tools to specify small or large arbitrarily shaped regions to study the time-profiles.

Processed data cubes can be made in the following way:

A sample call for SXT_PREP is:
IDL >  sxt_prep, in_index, in_data, out_index, out_data, unc_data, satpix, /reg
The out_index and out_data (in units of data number (DN)) can then be saved to a user created ``sda'' file with a simple call to SAV_SDA:
IDL >  sav_sda, 'my_processed_data', out_index, out_data
Example call to GO_TEEM:
IDL >  go_teem, out_index, out_data, te, em, dte, dem, f11, fl2, time=time, $
IDL >   comments=comments, unc=unc, satpix=satpix, /interp
out_index index record. from SXT_PREP
out_data data from SXT_PREP.
unc (optional) data for computing error bars
satpix (optional) data for flagging saturated pixels
/interp flag requesting that SPLINE interpolation of the database
values is used (default is linear interp.)
te list of log(Te K)
em list of log(EM cm-3)
dte 1s errors of Te
dem 1s errors of EM
fl1 dn/sec light curves for selected thick filter
fl2 dn/sec light curves for selected thin filter
time list of interpolated times
comments list of user entered comments for plot titles

5.14  How to Fit SXT Spectra (McTiernan) [*]

A general discussion of the McTiernan spectral fitting programs is given on page 6.3.1 in the description of fitting WBS spectra.

Also available are spectrometer-type fits for SXT data. In order to do this, the regular SXT filter response functions are rewritten as if they are spectrometer channel response curves. SXT_FSP calls SXT_PREP and SXT_INTERP to get the data in the appropriate form. Then the routine ANY_FSP is called, which does the spectral fit in the same manner as the HXS or HXT. Only two types of fits can be used for SXT_FSP, the thermal SXR lines fit (tyspec = 10) or the single power law fit (tyspec = 1). Thus it is possible to get single temperature fits using three or more filters. SXTBOX_FSP does the same thing, except for regions chosen by the user, as in HXTBOX_FSP.

5.15  Useful Routines for SXT

See the routines listed in the Appendix of this User's Guide on page A.4.

Converted at the YDAC on Oct 4, 2004
(from LaTEX using TTH, version 1.92, with postprocessing)