GB . Data . DishUsersGuideForGBT

DISH User's Guide for GBT Observations

J. Braatz, G. Langston, J. Lockman, J. McMullin, and R.Garwood

Introduction to dish

dish is a fully capable tool for reducing Single Dish Radio Astronomy Data efficiently. dish builds on the AIPS++ capacities with tools specifically designed to meet the needs of astronomers when interpreting spectra and images from observations with single dish radio telescopes. dish provides all the capabilities of the UniPOPS? package used to reduce 140ft data. In addition, it has capabilities to optimally reduce different types of observations, having special functions for Beam Switched and Frequency Switched observing modes. Important new capabilities to flag selected ranges of spectra and produce spectral images are illustrated.

Additional documentation is available at the AIPS++ site: http://aips2.nrao.edu/docs/user/documentation.html

The best way to learn is by doing. The aips++ recipies page: http://aips2.nrao.edu/docs/recipes/Recipes/index.html has simple, step by step, guides for standard data reduction scenarios.

Starting up dish

The AIPS++ dish package is started under Unix by first setting up the unix shell environment. This is accomplished by running a shell script. It is recommended that the user work in an empty subdirectory, since many files will be created. Also, if you run from a disk mounted on the local machine, dish will run more responsively. See the OptimizingAIPSppInGB note for more details on this and other ways to help aips++ run faster in Green Bank.

In the first example, OH megamaser data will be reduced in the directory named "OH". It isn't required that a new empty directory be created, but doing so will isolated related aips++ files and directories in one location.

% mdkir OH                                    # Create an empty work directory
% cd OH                                       # Go to it
% gbdish                                      # Start up AIPS++ and dish

The gbdish command is specific to Green Bank. For installations away from Green Bank, you will need to follow these steps to start up dish:

% . /home/aips++/stable/aipsinint.sh             # Setup in the BASH shell
OR
% source /home/aips++/stable/aipsinit.csh       # Setup in the T/CSH shell
% dish                                          # Start up AIPS++ and dish

Note: The path to your aips++ installation may be different from /home/aips++/stable (the recommended installation in Green Bank).

Note: Chose one of the aipsinit lines shown above, appropriate for your shell.

After starting dish a number of messages are printed in the window. Three new Graphical User Interfaces appear;

message log
PGplotter
dish results manager.

The AIPS++ prompt is "-". Most commands return T (the glish True) if the command is successful. The prompts and Ts are dropped in the examples in this note.

A few comments on dish philosophy

In general, dish assumes that observations are organized into scans. A scan may contain a number of integrations. The concept of a globalscan is used in dish. The globalscan is essentially a single spectrum which many dish functions operate on, by default. The globalscan can be a single scan's spectrum, the spectrum from a single integration from within that scan, or the spectrum from an averaged group of scans. Its use will become evident as we proceed with the example. You can always see the contents of the globalscan spectrum by typing d.show().

An example dish session

This example session shows how GBT data are loaded into dish followed by a first examination of the observing parameters, calibration of some of the data, displaying the calibrated data, and averaging the data. In later examples more data will be averaged and fit.

The data used in this section are from a GBT OH megamaser survey by Jim Braatz of NRAO. The survey uses the GBT L-band receiver as the frontend and the Spectral Processor as the backend. (See http://www.gb.nrao.edu/GBT for a complete description of the GBT electronics). Two polarizations were observed over a 50 MHz bandwidth, using 1024 channels. The goal of the exercise is to determine whether redshifted OH maser emission is present in the 1665.4018 and 1667.359 MHz lines.

The following steps are taken:

Import the data into a MeasurementSet (MS)
Calibrate individual scans
Average selected scans
Display the result

The dish commands to complete these steps are shown below.

# Load survey scans 17, 18, 19, 20
d.import('/home/archive/early-data/tape-1/OHsurvey',,,17,20)  
d.lscans()                                      # List the scans
# AIPS++ output == [17,18,19,20]         
d.gms()                                         # Show scan relationships
d.plotr(17,1)                                   # Plot raw reference scan 17
                                                # Cal-On Spectra for 2 pol. (figure 2)
d.calib(18)                                     # Sig-Ref/Ref calibrate the Signal Scan
d.plotc(18)                                     # Plot the calibrated data,
                                                # also prepares data for averaging
d.accum()                                       # Transfer for averaging with other scan
d.calib(20)                                     # Sig-Ref/Ref calibrate the Signal Scan
d.plotc(20)                                     # Show the spectra and 
                                                # Transfer data for averaging
d.accum()                                       # Add the scan to the accumulation
d.ave()                                         # Average all accumulated scans
d.show()                                        # Look at the Average

fig1.1718rawcal.gif

Figure 1: Left: Raw reference spectra (scan 17) of an OFF-ON pair of scans (17 and 18) towards IRAS09539+0857. The dual polarization plots of the data in counts are presented. The spectral shape is due to the variation in IF gain across the band. Right: Calibrated spectra from the same OFF-ON pair of scans.

Next a baseline can be fit to the two polarization spectra and subtracted to show the detected OH emission.

                                                # Fit, remove a spectral baseline

d.nfit(3)                                       # Set third order polynomial
d.nregion(80,270,650,960)                       # Select channels 80-270 and 650-960 
d.bshape()                                      # Fit and show the baseline shape 
d.baseline()                                    # Subtract the baseline 
d.show()                                        # Show the baseline subtracted 
                                                # There is the 1667 OH line!
d.fileout('averageSpectra')                     # Name the output file 
d.keep()                                        # Save visible spectra; given number 18
exit                                            # We're done!

fig2.1718avesub.gif

Figure 2: Left: Dual polarization spectra of IRAS09539+0857 with the results of the third order baseline fit shown. Right: Dual polarization observation of IRAS09539+0857, with baseline fit subtracted.

Reload Saved Spectra; Fit components

Now we reopen the previously imported measurement set and restore the saved average spectra. In this step the spectra are fit with two Gaussian components, and displayed.

d.open('averageSpectra')                        # Re-open the previously averaged data
firstScan := d.lscans()[1]                      # Get the number of the ave scan
aveSD := d.getscan(firstScan)                   # Fetch the previously averaged scan
d.plotscan( aveSD)                              # plot the average scan
d.hanning()                                     # Hanning smooth the spectra
d.show()                                        # View the smoothed data
d.gauss(2)                                      # Fit 2 gaussians; X axis in GHz 
#Gauss:  1                                      AIPS++ output (see figure 4) 
#Center:  1.47757e+00   Height: 2.01256e-02    Width: 8.06329e-04
#Cerr:    3.12915e-05   Herr:   1.59137e-03    Werr:  7.41239e-05
#Gauss:  2                                      AIPS++ output
#Center:  1.47605e+00   Height: 8.07131e-03    Width: 6.44905e-04
#Cerr:    6.65425e-05   Herr:   1.82314e-03    Werr:  1.57421e-04
C := 2.99792E5                                  # Velocity of light in km/sec  
ohFreqB := 1665.400; ohFreqC := 1667.358        # Set OH constants 
C * (ohFreqB - 1476.05) / ohFreqB               # Calculate velocities 
34085.2739                                      # AIPS++ output in km/sec
C * (ohFreqC - 1477.57) / ohFreqC               # Calculate velocities 
34123.9998                                      # AIPS++ output in km/sec

The OH survey observations towards IRAS09539+0857 were made to confirm the observing setup for weak sources. These GBT observations show a peak of emission at 1.47757 GHz. The Arecibo survey of Darling and Giovanelli (2001, AJ, 121: 1278) had previously detected IRAS09539+0857 and measured a velocity of 38,673 km/sec (optical heliocentric), consistent with the observations presented here. (Note that $v_{opt}$ = 38673 km/sec [optical definition] corresponds to $v_{rad}$ = 34270 km/sec [radio definition]).

fig3.1718fitvel.gif

Figure 3: Left: Gaussian fits to the baseline subtracted and calibrated spectra from the average spectra towards IRAS09539+0857, X axis units are GHz. Right: Same as Left, except that X axis units are km/sec.

                                                                 # Use PG Plotter GUI; Set X
                                                                 # to Barycentric Radio km/sec
d.gauss(2,bchan=100, echan=400)                                  # Fit 2 gaussians; X axis in km/sec
Gauss:  1                                                        # AIPS++ output (see figure 4)
Center:     34397.004568   Height:         0.008296    Width:       111.158507
C-err :        12.172717   H-err :         0.001747    W-err:        28.826383
Gauss:  2
Center:     34124.739777   Height:         0.020254    Width:       144.852889
C-err :         5.465173   H-err :         0.001561    W-err:        12.959182

# the above Center values are in barycentric radio km/s

Data Path

The following lists the most often used utilities. There are many more available functions in dish. Type "help('Refman:dish')" at the command line prompt to redirect your browser to the dish command line documentation; 'd.info()' will also provide an alphabetical, table of all available dish functions); typing d.help('function_name') will provide information on the function (d.help('function_name',T) will also automatically drive your web browser to the AIPS++ User Reference Manual entry on this function).

File Access	Scan Access	Editing	Calibration	Analysis	Display
import	getr	msplot	calib	(all operations)	plotr
open	getc	viewer	TPcal	e.g., aver	plotc
filein	getscan	autoflag	FScal	base	plotscan
fileout		flag	SRcal
		clip

Data and File Access

File Access

GBT data must be converted from their raw GbtFits files to an AIPS++ MeasurementSet before being accessed with dish functions. The command to fill raw GBT data is import. Once data have been filled, they can be accessed with the open function. Two additional file access functions, filein and fileout, are used to specify where data is read from and written to.

1. import - Fills an AIPS++ MeasurementSet from raw GBT FITS files and makes the data accessible from dish via the open command. The MeasurementSet created on disk will default to the input project name with an appended '_' followed by a backend specifier. If an 'outms' argument is supplied, the name on disk will be this string with the appended underscore and backend specified. import always follows the fill step with a call to open that sets this newly filled MS as the current input data source (filein=T). If a MeasurementSet having that name already exists, it will be appended to. In that case, only scans which start after the last time already filled to the existing MS will be added to that MS.

Example:

d.import(projdir='/home/mirror/gbtdata/OHsurvey',outms='oh',startscan=100,stopscan=105)

This creates a file 'oh_SP' on disk for spectral processor data, or 'oh_ACS' for the spectrometer.

Parameters:

projdir - The project directory (required)
outms - The name of the MeasurementSet to be created (defaults to project name)
outmsdir - The directory where outms will be written (defaults to current directory)
startscan - First scan to fill (defaults to first scan found)
stopscan - Last scan to fill (defaults to all scans)
backend - Backend to fill ("SP", "ACS", "DCR", or "Holography") (defaults to all backends)
calflag - Calibrate the data after filling (beta).
vv - The vanVleck correction to use for ACS data ("Schwab" is used if not specified, can also choose "none")
window - The windowing function to use for ACS data prior to the FFT from the lag to frequency domain. (defaults to "Hanning"; other choices are "Hamming" and "none")
oneacs - Fill all ACS banks into a single MS? (Defaults to T; if F, each bank will be filled to a separate MS)

'SPECTROMETER' is synonymous with 'ACS'. 'ACS' is used to shorten the amount of typing at the command line.

2. open - This function will load an existing data set (MeasurementSet or the type of table used by save and keep) on disk into dish memory. That is, it can be used on datasets which have already been filled using import. This places a tool attached to the data on disk into the Results Manager, making the data globally accessible in the Glish session (it can be manipulated from the command line, etc.). This may also performs a filein on the MeasurementSet (when filein is T) that indicates that subsequent commands/functions will use this MeasurementSet. It can also be used to create a new data set which can be used to save processed data using save and keep. Such a newly created data set is not a MeasurementSet, but instead is a simple aips++ table that resembles an SDFITS table.

Example:

d.open('oh_SP');

Parameters:

fullPath - The full path to the MeasurementSet file on disk (required)
access - The access permission on the MeasurementSet("r"=read,"w"=write; defaults to "r")
new - Create a blank(new) data set on disk? This can then be used to save processed data using save and keep. (defaults to F)
corrdata - Look at the CORRECTED_DATA column? (this will be a copy of the FLOAT_DATA (raw data) initially; defaults to T)
filein - Point to this MeasurementSet for subsequent operations? (defaults to T)

3. filein - This function sets the data set that will be examined and displayed. The files function indicates the current settings for the selected filein and fileout. This allows the user to switch between several already open data sets without having to re-enter the open command each time.

Example:

d.filein('ohSP')

Parameters:

wsname - The name of the data set as known to dish and shown in the results manager (NOTE: if there are dish values with the same name, open will append a numeric designator to the name to ensure it has a unique name).

4. fileout - This function sets the data set that will be written to. The files function will indicate the current settings for the selected filein and fileout. This allows the user to select between several already open data sets without having to re-enter the open command each time. fileout assumes that the data set has write permission (e.g., you should have already created the file with open).

Example:

d.fileout('avg_spectra')

Parameters:

wsname - The name of the data set as known to dish and shown in the results manager (NOTE: if there are dish values with the same name, open will append a numeric designator to the name to ensure it has a unique name).

Scan (Data) Access

Data in the MeasurementSet contains both the uncalibrated (raw or observed data) and the calibrated data. Initially, the calibrated data is simply a copy of the uncalibrated data. As the data is manipulated through the calibration routines (calib, TPcal, FScal, SRcal), the calibrated data becomes distinct.

The SdRecord (single dish record) is the data structure returned by the data access commands. It is a Glish record containing astronomical information (data, header, history, etc). In dish, an SdRecord is essentially synonymous with "spectrum" plus associated descriptive (header) information.

Several dish functions operate on a globally accessible SdRecord to help simplify the interface. In general, these functions will operate on the currently displayed spectrum or the contents of this globally accessible record (called globalscan1). Functions which take no arguments will, in general, access this spectrum and perform the operation on it.

1. getr - Retrieve uncalibrated (raw) data. This function returns an SdRecord. Specifying only the scan and phase will yield an average over all available integrations. getr accesses the FLOAT_DATA column of the MeasurementSet (the raw data) which is never modified. This function only works on a MeasurementSet (not on data sets created using open containing data stored using keep or save).

Example:

- s35_1 := d.getr(35,1,1,1) #retrieve scan 35, phase 1, integration 1,
                            #polarization 1 from the opened MS and
                            #store in variable s35_1
- s35_1 := d.getr(35,1)     #retrieve scan 35, phase 1, average all 
                            #integrations, show all polarizations

Parameters:

scan - Scan number (required)
phase - Scan phase (required)
int - Scan integration (if more than 1). If this is not specified it will average all integrations together.
pol - Polarization. If not specified it will return all available polarizations.
nif - IF number. If not specified it will use the first.
nfeed - Feed number. If not specified it will use the first.

2. getc - Retrieve calibrated data. This function returns an SdRecord. Specifying only the scan will yield an average over all available integrations. The function accesses the CORRECTED_DATA column of the MeasurementSet (the calibrated/corrected data). This function only works on a MeasurementSet (not on data sets created using open containing data stored using keep or save).

Example:

- s35_c1 := d.getc(35,1,1)  #retrieve scan 35, integration 1,
                            #polarization 1 from the opened MS and
                            #store in variable s35_c1
- s35_c1 := d.getc(35)      #retrieve scan 35, average all integrations, 
                            #show all polarizations

Parameters:

scan - Scan number (required)
int - Scan integration (if more than 1). If this is not specified, it will average all integrations together.
pol - Polarization. If not specified, it will return all available polarizations.
nif - IF number. If not specified, it will use the first.
nfeed - Feed number. If not specified, it will use the first.

3. getscan - Retrieve an individual row (phase, integration) from a scan. This functions returns an SdRecord. This function works on all types of data sets but is most useful in retrieving data previously saved using keep or save.

Example:

- s35_c1 := d.getscan(35,3) #retrieve scan 35, subscan 1

Parameters:

scannum - Scan number (required)
subscan - Sub scan number (default=1). Sub scan is used if the same scan number appears in the data set multiple times (either because there were several integrations or because several versions of the same scan number were saved).

Data Inspection and Display

Flagging

Flagging data is done in two basic modes: 1) command line and 2) GUI. There are two basic command line flagging utilities, clip and flag.

clip is a simple function which will allow you to flag a currently viewed spectrum. It sets the flag sub-record in the SdRecord being viewed.

Example:

d.clip(0.4);    #clip all above 0.4
d.clip(0.4,[100:500]);  #clip above 0.4 in the channel range 100-500
d.clip(-0.3,clipdir='low'); #clip below -0.3

Parameters:

cliplevel - Threshold for clipping
channelrange - range to apply clip. Default is whole spectrum.
clipdir - clip direction: 'high' (default) is above and 'low' is below.

flag is a more complete flagging utility allowing versatile flagging of data. Automated flagging based on data statistics is under development for single dish data. flag sets the FLAG column in the main table of the MeasurementSet.

Example:

d.open('stjul13SP');
d.gms();
d.plotc(36)
d.flag(36,channel=100:120)      #flag all subscans, polarizations of scan
                                #36 in the channel range of 100:120
d.plotc(36)                     #you should see the range masked
d.flag(36,flag=F);              #unset all flagging
d.plotc(36)                     #it's back!
d.flag(36,channel=500:550,polarization=1)
d.plotc(36)                     #you should see a gap just in the first
                                #polarization

d.flag(36,flag=F);
d.flag(36,1)                    #flag just the first integration
d.plotc(36)                     #should look okay though it doesn't
                                #include the first integration
d.plotc(36,1)                   #masked
d.plotc(36,2)                   #okay

Parameters:

scan - scan number(s) to flag. If no scan is specified, it will flag all scans in the data according to the other parameters (e.g., all channels within a range for the MeasurementSet can be flagged in this manner).
ints - integration number; if none specified, all will be flagged.
polarization - polarization number(s); if none specified, it will flag all polarizations.
channel - channel (range) to flag; if none specified, it will flag all channels.
flag - flag (T) or unflag (F) the data; the default is T.

autoflag

autoflag is a tool within AIPS++ which allows automated (based on statistics, etc) flagging of data without direct examination of each flagged row/scan. A few specific examples are provided below.

Flag based on statistics

include 'autoflag.g'
af:=autoflag('stjul13SP')       #Specify the MeasurementSet to operate on
af.setfreqmed();                #Use a sliding median filter in frequency
                                # default threshold is 5
af.run(plotscr=F);
af.done();                      #important to release the MeasurementSet

Figure 4: Left: the unflagged data. Right: the flagged data. This is being viewed with the viewer as discussed below.

Clip data using autoflag

include 'autoflag.g'
af:=autoflag('stjul13SP')   # Specify the MeasurementSet to operate on

cliprec:=[=]                # set up a record to contain the clipping info
cliprec[1]:=[expr='ABS XX',min=0,max=200]
                            #clip the XX correlation above 200 and below 0
af.setselect(clip=cliprec)  #specify the clip record as the selection
af.run(plotscr=F)           #execute (disable intermediate displays)

Interactive (using a GUI) modes of flagging are also enabled through the viewer and msplot tools.

For the viewer:

include 'viewer.g'
dv.gui();

This will bring up two GUIs. The first is for selecting what to display. You select the MeasurementSet and choose the type of display (only 'Raster' is available for MeasurementSets). This will then be displayed in the other display panel.

fig2.5.gif

Figure 5: Display of the Adjust panel for the viewer with the flagging tab open alongside a viewer display. Some of the data on the right has been flagged as bad. The selection will mark all times for the selected channels and all polarizations and spectral windows (from the Adjust panel selection).

For msplot:

include 'msplot.g'
mp := msplot('your_measurementset_name');

This brings up a GUI which will allow you to select the type of display ("X vs. Y" or "Display data as image") and optionally select a subset of the data.

Display

1. plotr - Display uncalibrated (raw) data using the dish plotter. Specifying only the scan and phase will yield an average over all available integrations. plotr accesses the FLOAT_DATA column of the MeasurementSet (the raw data) which is never modified. This function only works on a MeasurementSet (not on data sets created using open containing data stored using keep or save).

Parameters:

scan - Scan number (required)
phase - Scan phase (required)
int - Scan integration (if more than 1). If this is not specified it will average all integrations together.
pol - Polarization. If not specified it will show all available polarizations.
nif - IF number. If not specified it will use the first.
nfeed - Feed number. If not specified it will use the first.

2. plotc - Display calibrated data using the dish plotter. Specifying only the scan will yield an average over all available integrations. plotc accesses the CORRECTED_DATA column of the MeasurementSet (the calibrated/corrected data). This function only works on a MeasurementSet (not on data sets created using open containing data stored using keep or save).

Parameters:

scan - Scan number (required)
int - Scan integration (if more than 1). If this is not specified, it will average all integrations together.
pol - Polarization. If not specified, it will display all available polarizations.
nif - IF number. If not specified, it will use the first.
nfeed - Feed number. If not specified it will use the first.

3. plotscan - Plots an SdRecord to the dish plotter (as returned from functions like getr, getc, and getscan).

Parameters:

scanrec - A scan record (SdRecord, required)
overlay - Overlay the plot? (T=true, F=false,default).

The dish plotter

The dish plotter is the standard dish display for spectral line data. It is built on the existing AIPS++ pgplotter tool and so has all of the basic PGPLOT functionality. In addition, the plotter features tools for:

changing the X-axis units
changing the reference frame for the X-axis
toggling header information display
toggling the overlay of subsequent plots
options for a) reversing the color scheme and b) providing a chalkboard draw facility
toggling the X-axis autoscale
unzoom (incrementally unzooms any zooms)
line identification (marks any molecular lines within the frequency ranges of the displayed plot

Calibration

Calibration is applied to the data based on information in the STATE table of the MS, in particular, these functions utilize the OBSMODE column to determine a procedure type, switching signal, and switching state. In addition, information on the procedure size and procedure sequence number are used. That information in turn comes from the GO FITS file associated with that scan. Indexing from within the MeasurementSet is done using the scan number. There have historically been times when the GO FITS information was either missing completely or had the wrong scan number. In such cases, the calibration function described here may not work correctly and you may need to work directly with the data using getr and other, more primative dish and Glish capabilities.

dish attempts to implement the SpecLineCalibration draft memo.

A scale factor may be applied (multiplied) to the data as part of the calibration depending on the requested units. That scale factor is given here:

$factor = \frac{e^{\tau (1/sin(elev))}}{\eta_x}$

where $\eta_x$ is the efficiency factor determined by the user selected units (1 for TA', $\eta_l$ for TA*, $\eta_M$ for TMB, or $\frac{\eta_A}{0.351582}$ for Jy). If the requested units are TA, no scale factor is applied.

The efficiencies are

$\eta_l$ is the rear spillover, ohmic loss, and blockage efficiency. dish currently assumes that this is 0.99 in all cases.
$\eta_A$ is the aperture efficiency.
$\eta_M$ is the main beam efficiency. dish assumes that $\eta_M = 1.4 \eta_A$

The default efficiencies as well as opacity at zenith ( $\tau$ ) used by dish in the default case are returned by the eff function.

eff - return a Glish record containing the default efficiencies and opacity

Parameters:

frequency - the frequency in Hz
elevation - the elevation in degrees.

eff stores these values in a public place in dish. They can be modified and the calibration routines can be told to use already set values. In this way, you can supply your own values for the efficiencies and opacity.

uniget returns a named variable known to dish. In this context the relevent named variables are "tau", "etal", "eta", and "etabeam".

Example:

- print d.uniget("etal")
0.99

uniput sets a named variable inside of dish. In this context the relevent named variables are "tau", "etal", "eta", and "etabeam".

Example:

- d.uniput("etal",0.90")
- print d.uniget("etal")
0.9

geteff returns a Glish record containing all these efficiencies and the opactity and the scale factor to be used for a given scan and units.

Parameters:

scan - the scan number (required)
units - the desired units. This is an integer having the following interpretation: 0=TA, 1=TA*, 2=TMB, 3=Jy, 4=TA'.
calceffs - calculate the efficiencies and tau ? If T (the default) use the default values and parameterizations known to dish. If F, use whatever has already been set (using uniput).

Based on the observation procedure, the calibration functions will attempt to calibrate data. Typically, this entails calibrating "cal on" and "cal off" switching phases of signal (on source) and reference (off source) observations, where the "cal" is a known noise diode. e.g.,

$V_{sig}(\nu) = \frac{(V_{sig,on}(\nu) w_{sig,on} + V_{sig,off}(\nu) w_{sig,off})}{w_{sig,on} + w_{sig,off}}$

Similarly for the reference observation, $V_{ref}$ is also calculated.

These then lead to the difference spectrum:

$T_{diff}(\nu) = <T_{sys,ref}> \frac{V_{sig}(\nu) - V_{ref}(\nu)}{V_{ref}(\nu)}$ where, $T_{sys,ref}$ is:

$< T_{sys,ref}(\nu) > = < \frac{T_{cal}(\nu) V_{ref}(\nu)}{V_{ref,on}(\nu) - V_{ref,off}(\nu)} >$ 1. calib - Function to attempt to calibrate data taking using any known procedure type. It determines the procedure sequence number and looks in the MeasurementSet for the other scans in the procedure. It then does the appropriate thing (e.g., if it is a map, it will calibrate all of the scans in the map, if it is a OnOff scan sequence (or OffOn) it will calibrate both scans and then perform the (sig-ref)/ref calcilation. See the calib function documentation in the User Reference Manual for dish for more details on this.

Parameters:

scan - The scan number or vector of scans to calibrate (required)
baseline fit and subtract a polynomial? (defaults to F)
range - The channel range over which to fit the baseline polynomial (only used if baseline=T, if not supplied, all channels will be used)
order - The order of the fit for the baseline polynomial (only used if baseline=T, defaults to 1).
units - The output units: 0=TA, 1=TA*, 2=TMB, 3=Jy and 4=TA' as described above.
flipsr - Flip the sense of sig and ref
fold - For frequency switched data, this will fold over the spectrum using the observed frequency switch.
flipfold - Flip the sense of the fold - useful if the result of fold produces a negative feature where a positive one was expected.
calceffs - calculate efficiences and tau for this scan? (defaults to T; same usage as in geteff described above).

2. TPcal - Function to calibrate any TPwCAL scans. Unlike calib, it will only calibrate the specified scan(s).

Parameters:

scan - The scan number or vector of scans to calibrate (required)
baseline - fit and subtract a polynomial? (defaults to F)
range - The channel range over which to fit the baseline polynomial (only used if baseline=T, if not supplied, all channels will be used)
order - The order of the fit for the baseline polynomial (only used if baseline=T, defaults to 1).
units - The output units: 0=TA, 1=TA*, 2=TMB, 3=Jy and 4=TA' as described above.
flipsr - Flip the sense of sig and ref
fold - For frequency switched data, this will fold over the spectrum using the observed frequency switch.
flipfold - Flip the sense of the fold - useful if the result of fold produces a negative feature where a positive one was expected.
calceffs - calculate efficiences and tau for this scan? (defaults to T; same usage as in geteff described above).

3. FScal - Function to calibrate any FSWITCH scans. Unlike calib, it will only calibrate the specified scan(s).

Parameters:

scan - The scan number or vector of scans to calibrate (required)
baseline - fit and subtract a polynomial? (defaults to F)
range - The channel range over which to fit the baseline polynomial (only used if baseline=T, if not supplied, all channels will be used)
order - The order of the fit for the baseline polynomial (only used if baseline=T, defaults to 1).
units - The output units: 0=TA, 1=TA*, 2=TMB, 3=Jy and 4=TA' as described above.
flipsr - Flip the sense of sig and ref
fold - For frequency switched data, this will fold over the spectrum using the observed frequency switch.
flipfold - Flip the sense of the fold - useful if the result of fold produces a negative feature where a positive one was expected.
calceffs - calculate efficiences and tau for this scan? (defaults to T; same usage as in geteff described above).

4. SRcal - Function to perform a (SIG-REF)/REF calibration. Unlike the other calibration routines, SRcal uses the CORRECTED_DATA column (remember this is identical to the observed data in FLOAT_DATA if no calibration has been performed); this allows a layered approach to TPwCAL scans which can be noise diode calibrated and then subsequently calibrated with SRcal. SRcal is ideally suited for situations with many SIGs per REF. Unlike calib, it will only calibrate the specified scan(s).

Parameters:

scans - The scan number or vector of scans that are on signal (required)
refscans - The scan number or vector of scans that are on reference (required). These are averaged and the resulting average is then applied to each signal scan in turn. Alternately, an sdrecord may be passed in this parameter and it will be used as the reference.
baseline - fit and subtract a polynomial? (defaults to F)
range - The channel range over which to fit the baseline polynomial (only used if baseline=T, if not supplied, all channels will be used)
order - The order of the fit for the baseline polynomial (only used if baseline=T, defaults to 1).
units - The output units: 0=TA, 1=TA*, 2=TMB, 3=Jy and 4=TA' as described above.
calceffs - calculate efficiences and tau for this scan? (defaults to T; same usage as in geteff described above).

Analysis

Each of the following operations has a GUI counterpart in dish. We describe only the command line interface.

Averaging

The functionality for averaging is provided in the aver function.

aver - Average a group of scans and subscans.

Example:

- myavg := d.aver([303,305:308])   #average scans 303,305,306,307,308
- myavg := d.aver([159:165],'1/4') #average every fourth subscan in 
-                                  #scans 159-165

Generally, you need to understand how the data was taken to effectively use aver.

Parameters:

scanlist - a vector of scan numbers
subscanlist - a vector of subscans. This can also be the string 'odd', 'even', or 'n/m'. 'odd' will average every odd subscan in the specified scans, 'even' will average every even subscan in the specified scans, and 'n/m' will select every nth subscan in a sequence of m (for example ('1/4' will select subscans [1,5,9,..]).
weighting - 'NONE', 'RMS', 'TSYS'
alignment - 'NONE', 'VELOCITY', 'XAXIS'

There is also a means of averaging individual scans using an accumulator. Three functions are relevant: sclear, accum, and ave.

Example:

  d.sclear()    # clear the accumulator
  d.getc(35)    # retrieve calibrated scan 35
  d.accum()     # add the scan to the accumulator
  d.getc(36)    # retrieve calibrated scan 36
  d.accum()     # add the scan to the accumulator
  d.ave()       # average scans in the accumulator
  d.show()      # display the result on the plotter

sclear takes no parameters, and clears the accumulator.

accum adds a scan into the accumulator

Parameter:

scans - the list of scans to accumulate. If none are supplied, it uses the current globalscan.

ave averages the contents of the accumulator, and the average is returned to the globalscan1 spectrum for further processing.

An equivalent alternative to the previous example:

  d.sclear()       # clear the accumulator
  d.accum([35,36]) # add the scans to the accumulator
  d.ave()          # average scans in the accumulator
  d.show()         # display the result on the plotter

A UniPOPS-like stack is also available. The stack is simply a vector of scan numbers which are intended to be averaged, or operated on in some other manner. It is possible to use Glish methods to accomplish the formation and manipulation of a vector of scan numbers; nevertheless, these stack techniques provide another path for those familiar with the UniPOPS syntax.

Four functions are used to manipulate the stack: empty, addstack, delete and tellstack.

Example:

  d.empty()                 # clear the stack
  d.addstack(10,50,2)       # add even scans from 10 through 50 to the stack
  d.delete(24)              # remove scan 24
  d.delete(28)              # remove scan 28
  d.tellstack()             # show the contents of the stack
  d.aver(d.tellstack())     # average the scans listed in the stack

Function empty takes no parameters, and simply clears the stack.

Function addstack is used to append new entries to the stack.

Parameters:

beg : the first scan numer to add (required)
end : the last scan number to add (defaults to beg)
inc : the increment (defaults to 1)

So, addstack(10) appends scan 10 to the stack; addstack(15,18) appends scans 15, 16, 17 and 18 to the stack, and addstack(21,28,3) appends scans 21, 24 and 27 to the stack. If these three commands were executed on an empty stack, the result would be [10, 15, 16, 17, 18, 21, 24, 27].

delete removes a given scan by scan number from the stack. It takes a single argument, the scan number to remove. So to remove scan 16 from the stack constructed above, type d.delete(16).

tellstack takes no parameters, and is used to list the entries in the stack, and also to pass the stack to other functions in AIPS++. For example, to average the entries in the stack, type d.aver(d.tellstack()).

Fitting Baselines

Baselines can be removed during the calibration step; this is the most efficient means if the baseline regions are constant and there are many scans to operate on. Additional functions for baselining are also provided using base.

base - Perform a polynomial or sinusoidal baseline fit to a scan, optionally subtracting it.

Example:

mybl := d.base(order=2,action='subtract',range='[50:400],[1500:2000]')
                                        # This will perform a 2nd order poly.
                                        # fit to the currently displayed scan.

Parameters:

scanrec - an SdRecord. It will use the current display if none is specified.
order - the order of the polynomial
range - channel range for computing baseline. NOTE: currently this is specified as a string (e.g., range='[50:100],[800:1000]')
action - 'subtract' (to subtract the baseline) 'show' (to display the fit)
cursor - T (to set the region with a cursor; F is default)
autoplot - T (to automatically plot the results; F is default)

One can also fit a baseline with these UniPOPS-like functions.

d.nregion(50,100,900,1000)# Provide pairs of numbers as the channel range for the
                          # baseline region.  Any number of pairs defining separate regions
                          # to include in the fit can be given here.
d.setregion()             # This will prompt the user to set the baseline regions
                          # with a cursor
d.nfit(1)                 # Fit a first order polynomial
d.bshape()                # Show the baseline fit superposed on the spectrum
d.baseline()              # Subtract the baseline; this also calls the 
                          # d.rms() function displaying the baseline region stats
d.show()                  # Show the result

Fitting Gaussians

The dish function used to fit gaussian profiles is gauss. This function can fit multiple gaussians simultanously. The range of data used in the fit can be restricted if necessary. It can also be used interactively so set the initial guesses.

A typical sequence of events is:

Plot a spectrum using, e.g., plotc
Subtract a baseline, if this has not already been done.
Fit the gaussian using, typically, d.gauss(1,prompt=T)

gauss - Fit one or more gaussian profiles to a spectrum

Example 1: This example fits a single gaussian to the displayed spectrum. The function makes a guess at the component to be fit. The function can be used this way when there is a single, unambiguous component to be fit.

- d.gauss(1)          
Gauss:  1
Center: 1.280574e+01   Height: 2.124378e-02    Width: 8.603278e-05
C-err : 1.807589e-05   H-err : 8.627218e-03    W-err: 3.990019e-05

Example 2: This example shows how the user can use the mouse cursor to specify initial guesses to the gaussian fit. This is useful when your spectrum has many components and you want to specify which ones to fit. After calling the d.gauss function, check the message window in the plotter and follow the instructions given there. The user will first click on the plot to specify the range of values used for the fit, and then will click on the approximate peak and half-width of the spectral components. The half-width click should be roughly on the edge of the spectral line, halfway down from the peak. The fitting routine is robust enough that, for lines with good signal, the initial guesses do not have to be perfectly placed.

- d.gauss(2,prompt=T) 
NORMAL: Follow instructions on the plotter's message line for entering
NORMAL: restrictions and initial guesses for the fits.
Gauss:  1
Center: 1.280523e+01   Height: 1.121331e-02    Width: 3.324110e-04
C-err : 4.848294e-05   H-err : 3.218354e-03    W-err: 1.141686e-04
Gauss:  2
Center: 1.281269e+01   Height: 1.322893e-02    Width: 1.396933e-04
C-err : 2.543723e-05   H-err : 5.079551e-03    W-err: 5.988269e-05

Parameters:

ngauss - Number of gaussians to fit (required)
guess - Estimates of the height, center and width. If not supplied the function will attempt to guess them
prompt - prompts for the user to use the dish plotter cursor to interactively supply the initial parameter estimates
pol - Polarization to fit. Defaults to 1. Only one polarization can be operated on at a time.
bchan - the beginning channel to use in the fit. Defaults to the first channel.
echan - the end channel to use in the fit. Defaults to the last channel.
plotfit - plot the fit on top of the displayed spectrum? (defaults to T)
plotres - plot the residuals on top of the displayed spectrum? (defaults to F)
ploteach - plot each component of the fit separately on the displayed spectrum (defaults to F)
ret - return the fitted parameters as a Glish record (defaults to F)

Moments and Statistics

There are several functions for obtaining statistical information on a given spectrum.

1. stat - Provide statistics on an SdRecord

Example:

- d.stat()            # stats of the last viewed spectrum (full range)
[peak=68.9537735, area=0.00448239934, min=-0.303991884, rms=5.74451895,
scan=35, centroid=1.42037562, vpeak=1.4203805, startint=1.41901819,
stopint=1.42400843] 
- d.stat(range='[700:800]');      # stats over a limited range of channels
[peak=68.9537735, area=914.18058, min=0.242817193, rms=16.1565856,
scan=35, centroid=745, vpeak=744, startint=700, stopint=800] 
- d.stat(range='[550:650]')      # stats over a different range of channels
[peak=0.180041969, area=-1.33219323, min=-0.202106252, rms=0.0901912276,
scan=35, centroid=0, vpeak=554, startint=550, stopint=650]

Parameters:

scanrec - SdRecord to use; default is the last viewed
range - Channel range to provide statistics over

2. rms - Display statistics on a region of the globalscan

This function will calculate statistics on the regions set via setregion or nregion.

Example:

- d.rms()
Using 1023 for calculating baseline stats.
== Feed  1  ===
RMS   =  3.24550665    Mean =  0.000737983237    Num points =  1023
max   =  48.9361229   min =  -12.9025164
nregion =  [1 1023] 
== Feed  2  ===
RMS   =  3.29074012    Mean =  0.351124813    Num points =  1023
max   =  50.4430733   min =  -14.0051394
nregion =  [1 1023]

3. stats - Display statistics over a region.

This function will calculate statistics of the globalscan. It will use the global echan and bchan parameters for the region if available; these can also be set within the function.

Example:

- d.stats()
Feed : 1       bchan: 1        rms  : 5.744519       min  : -0.303992   
Npts : 1023    echan: 1023     mean : 0.898234       max  : 68.953773   

Feed : 2       bchan: 1        rms  : 6.180395       min  : -0.329462   
Npts : 1023    echan: 1023     mean : 0.912738       max  : 73.913177

Parameters:

quiet - Suppress writing of information to the screen? (defaults to F)
feed - Limit information to a single polarization (defaults to all polarizations)
bchan - Beginning channel for region (defaults to first channel)
echan - End channel for region (defaults to last channel)

4. moment - Display statistics over a region.

This function will calculate statistics of the globalscan. It will use the global emoment and bmoment parameters for the region if available; these can be set with the bmoment and emoment.

Example:

- d.bmoment(700)
T
- d.emoment(800)
T
- d.moment()     
[peak=68.9537735, area=914.18058, min=0.242817193, rms=16.1565856,
scan=35, centroid=745, vpeak=744, startint=700, stopint=800]

Regridding

smooth - Smooth the resolution of the last viewed spectrum

Example:

- smooth_spc:=d.smooth(type='HANNING',decimate=T);
- d.plotscan(smooth_spc)

Parameters:

scanrec - SdRecord to smooth; default is last viewed
type - "HANNING", "BOXCAR", "GAUSSIAN" (default is "HANNING")
width - The boxcar smoothing width in channels.
decimate - decimate when smoothing (default=F)

boxcar, hanning, and chngres are streamlined cases of smooth using type BOXCAR, HANNING, or GAUSSIAN respectively, and with decimation=T.

boxcar - Perform a boxcar smooth on the last viewed spectrum

Example:

d.show()
d.boxcar(5)
d.show()

Parameters:

smooth_width - The boxcar smoothing width in channels.

hanning - Perform a hanning smooth on the last viewed spectrum

Example:

d.show()
d.hanning()
d.show()

chngres - Perform a gaussian smooth on a spectrum

Example:

d.show()
d.chngres(5)
d.show()

Parameters:

smooth_width - The gaussian smoothing width in channels.

Saving Spectra

Saving spectra to into a new or existing output file is done using fileout, lsoutfile, save, and keep. fileout was described in the section on file access.

save - Save a spectrum to the output data set.

Example:

d.files()
Current filein is  :  N1SP
Current fileout is :  exampleout
d.save()                           #save currently viewed spectrum to output file.

Parameters:

sdrec - An SdRecord. The default is the last viewed one.
outf - Specify a new output data set (this must exist and be writable). If not supplied, the current fileout is used.

keep does the same thing as save in the default case; it takes no arguments

lsoutfile - List the scan numbers in the specified output file.

Example:

- d.fileout('exampleout')
New file  exampleout  is created
- d.save()
- d.lsoutfile()
159

Writing Spectra

writetofile - Write ASCII columned data of x and y to a disk file.

Example:

- d.writetofile('final.spc'); #default is to write currently viewed spectrum.

The columns that are written out are: the x-axis in the currently displayed units and the data arrays for each polarization.

Parameters:

outfile - The output file on disk.
scanrec - Scan record to write (default is currently displayed)

Imaging

Imaging in dish is done with the imager tool in AIPS++. Currently, there are two functions (makeim and imagems) in dish to achieve this. makeim will operate on a mapping procedure within a MS. imagems will operate on all of the scans within a MS; this is particularly useful for imaging several pieces of maps over the same region. Once an image is made, it can be examined by constructing an image tool as in this example.

include 'image.g'          # need only be done once
myim := image('scanimage') # insert the name of your image here
myim.view()                # launch the viewer - many other functions are available

makeim - Make a spectral line data cube.

Example:

- d.makeim(345,600,900,imname='g29.im');

This function selects the appropriate data from the MeasurementSet, regrids the data and constructs the image. The data are converted into the coordinate system of the image and then added to the image using a gridding function (boxcar [BOX], prolate spheroidal [SF], or primary beam [PB]). The size of the convolving function can be controlled for BOX and SF gridding. The PB gridding is not recommended since the primary beam model currently known to the imager is a poor approximation to the GBT beam. The default size of the convolving function (convsupport) seems to produce the most satisfying images although there is no right answer. For BOX convolving, the default is 0. That is equivalent to nearest-pixel gridding. Data values are simply averaged in with whatever has previously contributed to the cell in the image nearest to the actual pointing direction for that data value. For SF gridding,the convsupport defaults to a value of 1. This means that the convolving function falls to a value of 0 at a radius of 1 image pixel from the pointing direction of each data point. There is no convolution along the frequency axis. Data values are simply averaged at the frequency value in the image nearest to their observed value.

Parameters:

scan - The starting scan in a mapping procedure (required)
start - The starting channel along the spectral axis (required)
stop - The end channel along the spectral axis (required)
step - The number of channels to average (default=1, no spectral averaging)
imname - The output image name (defaults to "scanimage")
spwid - Spectral Window ID (this is set automatically but can be over-ridden here)
nx - Number of grid points in x. This is automatically calculated by the program to be (map_extent_x/cellx) + buffer (several points, depends on convolution function). This may be over-ridden here.
ny - Same as nx but for the y axis.
cellx - The cell size is automatically set by the frequency (giving the wavelength) and the size of the telescope to be $(1/2)*\lambda/{Diameter}$ . It may be over-ridden here.
celly - The same for y direction of cell.
gridfn - The gridding function to use (defaults to "SF", can also be "BOX").
convsupport - The convolution support radius (defaults to F, which translates to 0 for BOX and 1 for SF).

imagems - Make a spectral line data cube from scans in a MeasurementSet.

Example:

- d.imagems('cloud_SP',520,1000,imname='cloud.im');

This function selects the appropriate data from the MeasurementSet, regrids the data and constructs the image. The data are converted into the coordinate system of the image and then added to the image using a gridding function (boxcar [BOX], prolate spheroidal [SF] or primary beam [PB]). The PB gridding is not recommended since the primary beam model currently known to the imager is a poor approximation to the GBT beam. The default size of the convolving function (convsupport) seems to produce the most satisfying images although there is no right answer. For BOX convolving, the default is 0. That is equivalent to nearest-pixel gridding. Data values are simply averaged in with whatever has previously contributed to the cell in the image nearest to the actual pointing direction for that data value. For SF gridding,the convsupport defaults to a value of 1. This means that the convolving function falls to a value of 0 at a radius of 1 image pixel from the pointing direction of each data point. There is no convolution along the frequency axis. Data values are simply averaged at the frequency value in the image nearest to their observed value.

Parameters:

msname - The name of the MS on disk (required)
start - The starting channel along the spectral axis (required)
stop - The end channel along the spectral axis (required)
step - The number of channels to average (default=1, no spectral averaging)
imname - The output image name (defaults to "scanimage")
spwid - Spectral Window ID (this is set automatically but can be over-ridden here)
nx - Number of grid points in x. This is automatically calculated by the program to be (map_extent_x/cellx) + buffer (several points, depends on convolution function). This may be over-ridden here.
ny - Same as nx but for the y axis.
cellx - The cell size is automatically set by the frequency (giving the wavelength) and the size of the telescope to be $(1/2)*\lambda/{Diameter}$ . It may be over-ridden here.
celly - The same for y direction of cell. displayed)
gridfn - The gridding function to use (defaults to "BOX", can also be "SF").
convsupport - The convolution support radius (defaults to F, which translates to 0 for BOX and 1 for SF).

Image Moments

The image tool function moments offers traditional moment analysis (weighted sums of profiles) of images. It offers a wide range of moments and a wide range of methods with which to calculate them. The word `moment' is used loosely here. It refers to collapsing an axis (the moment axis) to one pixel and setting the value of that pixel (for all of the other non-collapsed axes) to something computed from the data values along the moment axis. For example, take an RA-DEC-Velocity cube, collapse the velocity axis by computing the mean intensity at each RA-DEC pixel. This function offers many different moments and a variety of interactive and automatic methods to compute them. A quick summay of the available moments:

-1 - the mean value of the spectrum ${ {1\over n} {\sum {I_i}}}$
0 - the integrated value of the spectrum $M_0 = \sum I_i$
1 - the intensity weighted coordinate (this is traditionally used to get 'velocity fields') $M_1 = { {\sum {I_i v_i}} \over {M_0}}$
2 - the intensity weighted dispersion of the coordinate (this is traditionally used to get 'velocity dispersion fields') $\sqrt{ { {\sum {I_i \left(v_i - M_1\right)^2}} \over {M_0}}}$
3 - the median of the spectrum
4 - the median coordinate. Here the spectrum is treated as a probability distribution, generating the cumulative distribution, and finding the coordinate corresponding to the 50% value. This moment is not very robust, but it is useful for quickly generating a velocity field in a way that is not sensitive to noise. However, it will only give sensible results under certain conditions. The generation of the cumulative distribution and the finding of the 50% level really only makes sense if the cumulative distribution is monotonic. This essentially means only selecting pixels which are positive or negative. For this reason, this moment type is only supported with the basic method (see below - i.e. no smoothing, no windowing, no fitting) with a pixel selection range that is either all positive, or all negative
5 - the standard deviation about the mean of the spectrum $\sqrt{ {1\over {\left(n-1\right)}} \sum{\left(I_i - \bar{I}\right)^2 }}$
6 - the root mean square of the spectrum $\sqrt{ {1 \over n} \sum{I_i^2}}$
7 - the absolute mean deviation of the spectrum ${1 \over n} \sum {|(I_i - \bar{I})|}$
8 - the maximum value of the spectrum
9 - the coordinate of the maximum value of the spectrum
10 - the minimum value of the spectrum
11 - the coordinate of the minimum value of the spectrum

- im:=image('g29im')       #g29im is the data cube
- im.moments(moments=[-1,0])    #get the average and integrated moments
Moment axis type is Frequency

***********************************************************************
You have selected the following methods
The basic method
Created /home/despina2/scratch/jmcmulli/g29im.average
Created /home/despina2/scratch/jmcmulli/g29im.integrated
Begin computation of moments
Finished image::moments
       0.48 real        0.08 user        0.02 system
T 
- im2:=image('g29im_integrated')
- im2.view()
- im.summary();
- r:=drm.box(blc='1 1 1 5', trc='20 20 1 100') # create a region
- #using the channels 5 to 100; the first 2 coordinates are ra, dec,
- #the 3rd is stokes, and the 4th is the channel axis.
- im.moments(moments=0,region=r,outfile='g29im_lowvel') #create the
- #integrated intensity over channels 5-100

You can also use the GUI interface via:

- im:=image('g29im')            #g29im is the data cube
- im.momentsgui();      #use GUI to derive moments

See the User Reference Manual on the moments function of the image tool for the most details moments and moment methods.

Image Source Fitting

Source fitting is achieved through the imagefitter tool. From the example above:

- imfit:=imagefitter('g29im_integrated')
- #Use the GUI to select a region (double click to derive source characteristics,
- #statistics, residuals, etc. The 'show' button will display the fit value.

Image math

Manipulation of images is done with the imagecalc tool. With this you can construct an image from expressions involving other images. For example,

im1 := imagecalc(outfile='x3', pixels='sin(x1) + min(x2) ')

where the image disk files x1 and x2 must pre-exist and the result is the image disk file called x3.

You can also construct a read-only image from expressions involving other images. The output image is never created, it is just evaluated each time you use it.

im2 := imagecalc(pixels='pi() - min(x2) + sqrt(x1)')

where the image disk files x1 and x2 must pre-exist. Note that by simply excluding the output file name (argment outfile) you have created the read-only image.

With the image calc function, you can change the pixel values of an image by replacing them with the result of the expression:

im1 := image('x2')
im2 := im1.calc('abs(x2) / min(x2)')

where the image disk file x2 must pre-exist. Because the scalar expression is evaluated first, the images in the expression can be the same as the image which is being overwritten.

Note that for image file names with special characters in them (like for example), you should (double) escape those characters or put the file name in double quotes. E.g.

- im1 := imagecalc(pixels='test\\-im')            # Note double escape
- im2 := imagecalc(pixels='"test-im"')

When using imagecalc, you can use either image disk file names, or an associated image tool name in the expression. For example,

im1 := image('im1')
im2a := imagecalc('im2a', '2*im1')     # Use disk file names
im2b := imagecalc('im2b', '2*$im1')    # Use tool name

For information on image manipulation (concatenation, addition, etc), see the aips++ cookbook.

Exiting dish

To exit dish, type 'exit' at the Glish command line. If you have enabled the "Save state when done" option (in the GUI), the state of dish will be preserved for your next session (it will be loaded automatically). You can also manually save the state of dish using the File menu options of the main dish GUI.