SSWHERE is a widget-driven program that creates an array of subscripts (ss) that fulfill a set of
criteria that you define to select SXT images. For example to make an ss
array for YODAT where you want to select images from a data
set represented by roadmap, you merely type:
IDL > ss=sswhere(roadmap)
SSWHERE works on both the roadmap and index structures. Available selection criteria are:
If you get a ``No matching Data'' response, check that you have selected all possible options.
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:
IDL > show_obs3, roadmap
IDL > 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:
IDL > show_obs3, roadmap, sel, ss
where sel is a returned logical array the same length as roadmap, and is set true for all dsets selected, and ss is the returned subscripts of the selected datasets. A few examples on how to use the sel variable are:
IDL > ss = where(sel)
IDL > ss = where(sel and (gt_dp_mode(roadmap) eq 9))
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:
IDL > show_obs4, roadmap
IDL > show_obs4, index
It is possible to click on a time range for a closer look by:
It is possible to select several regions using the following steps.
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:
IDL > plot_fov, index, /box
See the description in the ``General Yohkoh Software'' chapter on page or the description in the User's Guide.
See the description in the ``General Yohkoh Software'' chapter on page or the description in the User's Guide.
XY_RASTER makes a mosaic of several images and prints the times in the corner
of each image. Sample calls are:
IDL > xy_raster, index, data
IDL > xy_raster, index, data, factor
where 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 /notimes will inhibit the time labels, /noscale will inhibit image scaling (it will use TV instead of TV_SCL), /individual_scale will scale each image individually.
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
IDL > disp_month, 'oct-93'
UNSHARP_MASK is a basic image enhancement routine which uses the unsharp mask method. The calling sequence is:
IDL > dataout=unsharp_mask(index, data)
where data and dataout are 2D arrays, and index is the index entry that corresponds to data. If no keywords are given the defaults are used.
Optional Keyword Parameters:
|smooth||Size of smoothing box, integer.|
|lowdelt||Lower d cutoff, a percentage of minimum, decimal 0.xx.|
|updelt||Upper d cutoff, a percentage of maximum, decimal 0.xx.|
|lowint||Saturation cutoff, don't add back when signal is BELOW|
|a given percentage of the saturation value, decimal 0.xx.|
|upint||Saturation cutoff, don't add back when signal is ABOVE|
|a given percentage of the saturation value, decimal 0.xx.|
|deltcoef||Multiplier for d field, float x.x.|
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.
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.
IDL > clean_img = de_spiker(image, thresh)
IDL > clean_img = de_spiker(image, thresh, /neg)
IDL > clean_img = de_spiker(image, thresh, indices=indices)
where, image is the input data array, thresh is the specified spike amplitude to remove. Optional input/output parameter indices contains the indices of spikes at the level specified, and optional input switch /neg requests that ``dark holes'' be removed.
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:
IDL > tvscl, data(*,*,0)
IDL > sxt_grid, index(0)
The keyword option /read will allow the user to move the cursor around the image and to display the heliocentric coordinates. If /angle is used with /read, then the value displayed is the angle relative to the sun center, which is useful to be used with SXT_PREP.
See the description in the ``General Yohkoh Software'' chapter on page 2.4.5
|2||Optical - narrow band||NaBan||NB|
|3||Quartz defocusing lens||Quart||Qz|
|5||Optical - Wide band||WdBan||WB|
|6||8% neutral density X-ray filter||NuDen||ND|
The last two columns show what GT_FILTA returns when using the /string and /short
options. The routine GET_INFO uses the /string option.
It is possible to get a string type description of the filters used by
IDL > b = gt_filta(roadmap, /string)
You can get a listing of these at any time by typing the following:
IDL > print,gt_filta()
GT_FILTB works exactly like GT_FILTA but works for the X-ray filters
|2||Thin Aluminum (1265 Å)||Al.1||A1|
|4||Beryllium (119 mm)||Be119||Be|
|5||Thick Aluminum (11.5 mm)||Al12||A2|
|6||Magnesium (2.5 mm)||Mg3||Mg|
The last two columns show what GT_FILTB returns when using the /string and /short options. The routine GET_INFO uses the /string option.
|2||PFI Observing Region|
|3||FFI Patrol Image|
The /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 /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 /true_ffi option will also check if it is an FFI strip or if it is a PFI which was extracted from an FFI.
It is possible to get a string type description of the resolution by
IDL > res = gt_res(roadmap, /string)
|0||Compressed (see routine SXT_DECOMP)|
|1||Low 8 bits (of 12 bits)|
|2||High 8 bits (of 12 bits)|
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 /conv
IDL > dpe = gt_dpe(index)
IDL > 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
exposure = (DPE-21) * 0.25 seconds
|0||0.08 msec||0||with ND||19||668.00 msec||12|
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.
IDL > explat = gt_explat(index)
|0||Normal shuttered exposure|
|1||Dark image (shutter stays closed)|
|2||Calibration image (shutter open during readout)|
IDL > expmode = gt_expmode(index)
GT_CORNER will return the full resolution IDL (FRE) coordinates of
the center of the pixel in the lower left hand corner.
IDL > corners = gt_corner(roadmap)
IDL > x0 = gt_corner(index, /x)
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.
IDL > pix = gt_center(index)
IDL > helio = gt_center(index, /helio)
IDL > helio = gt_center(index, /helio, /cmd)
IDL > ang = gt_center(roadmap)
where ang(0,*) is arcseconds east/west with east being negative and ang(1,*) is arcseconds north/south with north being positive. helio is in degrees, and 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.
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:
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.26The 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.
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 /rel_xray keyword option can be used to return the relative offset to the X-ray axis.
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:
IDL > print,gt_pix_size()
IDL > print,gt_pix_size(index)
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.
GT_TEMP_CCD returns the temperature of the CCD in degrees Celsius.
IDL > temp = gt_temp_ccd(index)
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.
IDL > temp = gt_temp_hk(index, 0, title=title)
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:
IDL > sxtpnt_sum, '5-oct-93 13:00', '6-oct-93 1:00'
it will produce a file in your home directory with the name ``sxtpnt_sum.txt'' (unless you specify the output file name with the outfil keyword option).
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 /long changes the formatting and information
IDL > pr_sxtobs,'15-nov-91 22:00','15-nov-91 22:05'
IDL > pr_sxtobs,'15-nov-91 22:00','15-nov-91 22:05',/long
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:
IDL > pfi_loc, '23-jun-93 1:00'
IDL > pfi_loc, timstr, hours=2
IDL > pfi_loc, index
IDL > pfi_loc, index, pfi_struct=sxtp
IDL > pfi_loc, index, '6-nov-93 3:30'
IDL > pfi_loc, index, '6-nov-93 3:30', /hour
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. The 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.
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 index and
data, or it can be the filenames infil and dataset numbers dset_arr.
Some sample calling sequences are:
IDL > sxt_prep, input1, input2, index_out, data_out
IDL > sxt_prep, index, data, index_out, data_out
IDL > sxt_prep, infil, dset_arr, index_out, data_out, $
IDL > helio=[-9.8,-20.3], date_helio='14-JUN-92 02:37:41'
IDL > sxt_prep, index, data, index_out, data_out, /helio, ref_image=10
IDL > sxt_prep, index, data, index_out, data_out, ref_image=spr_index(0)
IDL > sxt_prep, index, data, index_out, data_out, /roll
A description of some of the keywords follows:
|------- Calibration Parameters -------|
|nocorrections||If set, then LEAK_SUB, and therefore DARK_SUB, are not called.|
|dc_scalar||If set, then a simple scalar value is used for dark current subtraction. Default is to take the image closest in exposure.|
|dc_interpolate||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||If set, only flag +1 pixels above (in a column) the saturated area (not the -1 pixels) [see call to SXT_SATPIX].|
|sfd_corr||If set, then the input image is an SFD image. Use the SFD decompression, perform the registration, and recompress using the SFD compression.|
|------- Alignment Parameters -------|
|register||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||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 ïnfil")|
|helio||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.|
|date_helio||the reference date/time for the heliocentric input.|
|suncoord||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||The FRE (full resolution CCD pixel equivalent) of the center of the portion to extract.|
|outres||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||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.|
|fill_gap||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||If set, then perform the corrections for the roll offset.|
|normalize||If set, perform exposure normalization.|
|------- Miscellaneous Parameters ----|
|force_read||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||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.|
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.
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.
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 (data) and creates an integer array (ndat) of the
decompressed numbers by typing:
IDL > ndat = sxt_decomp(data)
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
IDL > bdat = sxt_comp(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
IDL > out = restore_low8(low8, comp)
where low8 is the SXT image taken with the low 8 bits, and comp is the comparable compressed image (ideally, acquired at nearly the same time).
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 106.
IDL > data_out = sfd_comp(data_in)
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.
IDL > data_out = sfd_decomp(data_in)
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:
IDL > ndat = exp_norm(data,index)
IDL > ndat = exp_norm(data,index,0)
To do this it follows the following steps:
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:
IDL > cimg = sxt_composite(index,data)
IDL > cimg = sxt_composite(index,data,satpix=satpix)
IDL > 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 data is byte-type. The user may optionally specify the dark-frame images in 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.
MK_SFD creates a desaturated set of images
from a series of long and short exposures by typing:
IDL > mk_sfd,infil,outfil,filpref
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:
0 = 1 dn/sec/5 arcsec pixel 255 = 1,000,000 dn/sec/5 arcsec pixelUse the routine SFD_DECOMP to restore the data from compressed bytes to real numbers.
It is possible to have the dark current removed from PFI and FFI images
by using the following command:
IDL > data_out = dark_sub(index,data)
The routine can interpolate between two reference images to simulate the input exposure duration by using the /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 /interpolate option can be turned on and run automatically
every time DARK_SUB is run by setting the environment variable
ys_dark_interp. An example of how to turn this on and off
# will enable automatic interplation
# 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.
These routines get an appropriate dark frame (dcdata) and its
index (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
IDL > get_dc_image, index(3), dcindex, dcdata
where index(3) is the index of the image you are working with, or you can pass a list array of indicies by typing:
IDL > get_dc_image, index, dcindex, dcdata, imap
For this case, imap is the same length as index and tells you which image to use in dcdata for the corresponding index. For example, if index is 10 elements long, and imap(8)=3, then you should use dcdata(*,*,3) for the image that goes with index(8).
It is possible to extract the dark frames manually using a command
similar to the following example:
IDL > 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).
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:
IDL > data_out = leak_sub(index,data)
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
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.
To linearly interpolate two images to a specified time type:
IDL > interp_img, index1, img1, index2, data2, time, index_out, img_out
IDL > 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 index and img. The input interpolation variable time can be in any Yohkoh standard time format. The returned parameters index_out and img_out refer to the interpolated index information and the interpolated image data respectively.
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.
IDL > SXT_FSP, index, data, fit_pars
SXTBOX_FSP fits spectra to a given box, chosen by LCUR_IMAGE, for a set of SXT images.
IDL > SXTBOX_FSP, index, data, fit_pars [, sc_par, ch_dta, sdel=sdel, $
IDL > outfile=outfile, pfile=pfile, same_bx=same_bx, boxq=boxq]
See the description under in the HXT chapter.
SXT_TEEM enables you to derive a
temperature map (Te) from two filters taken of the same region. Some sample
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
index1,data1 should contain data for a single SXT filter. index2,data2 should contain data for a single SXT filter which is different from that contained in index1 and 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 t1=t1 and 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 sum = sum calls SXT_SUMXY to rebin the data. The input image must be a 2-d or 3-d array 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 data1 is a cube, Te will be computed for each image by default. If subs=subs is present, subs should contain the indices of image pairs to analyze.
The keyword option 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 sum=2, then you must increase the value of thresh1 by a factor of 4 to have the same effect.
SXT_ERG_PER_DN returns the log of the radiative energy per DN
assuming a coronal spectral model with temperature, Te. The units
of the result are log10(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:
IDL > log10_erg_dn = sxt_erg_per_dn(log10_Te,filter)
IDL > 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(Te) between 5.5 and 8.0 use the following calling sequence:
; Generate a temperature vector
IDL > 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.
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:
; SXT Index should be a scalar
IDL > vignette = sxt_vignette(array)
IDL > vignette = sxt_vignette(index,energy)
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:
; Display SXT vignette function
The X-ray vignetting function can be approximately removed with the
routine SXT_OFF_AXIS. Example calling statements are:
IDL > data_out = sxt_off_axis(index, data, index_out)
IDL > data_out = sxt_off_axis(index, data, /update_index)
IDL > 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.
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.
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.
See the earlier section describing the details of SXT_PREP.
SXT_CENTER calculates the row (x) and column (y) of the
center of the solar disk and the radius (r) of the Sun
given a data cube (data) and the index structure (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.
IDL > sxt_center,data,index,x,y,r
There are many options that are possible to use, please check them with DOC_LIBRARY.
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)
determines the PFI corners from 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:
IDL > gbo_img = get_gbo_pfi(index, gbo_fullimg, gbo_time)
IDL > gbo_img = get_gbo_pfi(index, '/yd5/gbo91_46a/gkm911116.1958')
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 /noscale is set.
IDL > ocenter, image, x, y, radius
IDL > ocenter, image, x, y, radius, /noscale, cut=0.3
where image is the 2-D input image, and x and y are the E/W and N/S position of the sun. radius is the solar radius in pixels and cut is the fraction of image maximum to define the limb (default is 0.2)
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:
IDL > print, gtab_comm(index)
IDL > print, gtab_comm('15-nov-91')
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.
IDL > print, gtab_ffi(index)
IDL > 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.
PLOT_SOT will plot out the aspect sensor degradation as a
function of time by typing:
IDL > .run plot_sot
It will produce plots for both the narrow-band and wide-band filters.
PLOT_TEMPS2 plots the SXT instrument temperatures.
This program can only be run after the variable index exists which
came from an SXT file. A common practice is to run PLOT_SOT which gets
images over the whole mission.
IDL > .run plot_temps2
A mosaic of time histories of the various instrument temperatures will be plotted.
PLOT_SSL will plot the SXT summary log (SSL) information. A series of plots are made which include:
Sample calls are:
IDL > plot_ssl
IDL > plot_ssl, [0,1]
IDL > 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.