ADMIT Products and Usage
- 1 Intro/What is ADMIT?
- 2 Obtaining ADMIT and data for this guide
- 3 Creating an ADMIT product
- 4 The ADMIT weblog, viewing the ADMIT product
- 5 Customizing ADMIT for your dataset
Intro/What is ADMIT?
The ALMA Data-Mining Toolkit (ADMIT) is an execution environment and set of tools for analyzing image data cubes. ADMIT is based on python and designed to be fully compliant with CASA and to utilize CASA routines where possible. ADMIT has a flow-oriented approach, executing a series of ADMIT Tasks (AT) in a sequence to produce a sequence of outputs. For the beginner, ADMIT can be driven by simple scripts that can be run at the Unix level or from inside of CASA. ADMIT provides a simple browser interface for looking at the data products, and all major data products are on disk as CASA images and graphics files. For the advanced user, ADMIT is a python environment for data analysis and for creating new tools for analyzing data.
For a detailed quick-look at ALMA images, standardized ADMIT “recipes” can be run which produce various products depending on the image type. For continuum images, ADMIT simply finds some of the basic image properties (RMS, peak flux, etc) and produces a moment map. For cube images, ADMIT will analyze the cube, attempt to identify spectral features, and create moment maps of each identified spectral line.
ADMIT does not interact with u,v data or create images from u,v data; CASA should be used to create images. ADMIT provides a number of ways to inspect your image cubes. The astronomer can then decide whether the ALMA image cubes need to be improved, which requires running standard CASA routines to re-image the u,v data. If new images are made, the ADMIT flow can be run on these new image cubes to produce new set of ADMIT products.
Obtaining ADMIT and data for this guide
For this CASA Guide, we will go through creating an ADMIT product of some science verification data and then inspect the output. You’ll of course need CASA installed (http://casa.nrao.edu/casa_obtaining.shtml) as well as ADMIT. To install ADMIT from scratch, you’ll need to clone the source code using git:
# In bash git clone https://github.com/astroumd/admit
If this method doesn't work for whatever reason, you can also use wget and then untar the file:
# In bash wget http://admit.astro.umd.edu/admit.tar.gz tar zxf admit.tar.gz
Then execute the configure step to create the necessary environment replacing "X" with the necessary software versions.
# In bash ls cd admit_1.X.X ./configure --with-casa-root=/path/to/casa-release-X.X.X
Once you have run the configure script, simply source the admit_start.sh script before executing any ADMIT commands.
# In bash source admit_start.sh
If you want to check that ADMIT is set up, you can type
# In bash admit
In your terminal after sourcing the start script and you should see the directory paths and versions of ADMIT. For more details, please see:
For this guide, we’ll be using the data from the Antennae Band 7 CASA Guide. We’ll just need the reference images, Antennae_Band7_ReferenceImages.tgz, which are available here:
Untar the package in your working area.
Creating an ADMIT product
Now that we have some ALMA images and ADMIT installed, let’s run one of the standard ADMIT recipes on our image. There are two standard recipes that handle most ALMA images, admit1.py (or runa1, http://admit.astro.umd.edu/admit/tricks.html#runa1-and-admit1-py) which works on data cubes and admit2.py (or runa2, http://admit.astro.umd.edu/admit/tricks.html#runa2-and-admit2-py) which works on continuum images. These images are data cubes so we’ll use the first recipe. There are two ways to do this, if you just want the results of the ADMIT recipe just type
# In bash runa1 Antennae_North.CO3_2Line.Clean.pcal1.image.fits
within the directory where the image is located. runa1 is the default implementation and gives a streamlined result. Another option is to specify the admit1.py recipe which allows you to use flags for customization. To do this, type:
# In bash /path/to/your/admit/installation/admit/admit/test/admit1.py Antennae_North.CO3_2Line.Clean.pcal1.image.fits
This will produce identical output as runa1; however, there are over 30 tunable parameters that allow you to set the VLSR, rest frequency, regions of interest, etc. as well as many line identification parameters to tune such as using the online version of Splatalogue rather than the internal one for line identification. These can be tuned via creating a file with your parameter choices and specifying it via the --apar flag. Later in this guide we will go through a little bit more on how to customize ADMIT to better suit your data but for now, more information can be found here:
In the end, either method (runa1 or admit1.py) will result in the creation of a file named Antennae_North.CO3_2Line.Clean.pcal1.image.admit which contains the output from the ADMIT recipe.
The ADMIT weblog, viewing the ADMIT product
To view the ADMIT output, start by descending into the Antennae_North.CO3_2Line.Clean.pcal1.image.admit directory and open up the index.html file in your favorite browser (currently Firefox is the best option). This will open up the ADMIT browser interface (weblog) which is the most convenient way to view the ADMIT results on the image. It should look something like Figure 1.
The text within each bar gives the ADMIT Task name, the task ID number, the parameters that were used within that task, and any output image names (Figure 1). Clicking on one of the green horizontal bars will reveal all the output for that ADMIT task. Just under the expanded bar will be the task name (which hyperlinks to the ADMIT wiki page for that task) and a one-line explanation of what that task does.
Now, we will go through all of the output in the ADMIT weblog and describe what each task does and what output to expect.
The ADMIT data Flow
Clicking on the top-most bar of the weblog, “Flow Diagram for Antennae_North.CO3_2Line.Clean.pcal1.image.admit” (see Figure 1), reveals the “ADMIT Flow Diagram” (Figure 3). This is an illustration of how the products created in each task flow through the entire process. For a detailed discussion of how ADMIT flows work (and how to create your own) please see
For continuum images, these diagrams are extremely simple but for line-dense image cubes these can be incredibly complicated. Figure 3 shows what the ADMIT Flow looks like for our dataset. This diagram is a directed acyclic graph representing the ADMIT Task connections. Each arrow represents the connection from an ADMIT task output to the input of another ADMIT Task. The integer next to each arrow is the zero-based index of the ADMIT Task's output basic data product. Note that any output basic data product may be used as the input for more than one ADMIT Task.
This is the most basic task that is performed at the beginning of any ADMIT workflow. This task reads in a FITS image, creates a CASA image and extracts basic information such as rest frequency, beam size, image size, minimum/maximum values, etc.
This task computes statistics on the image cube in the image-plane (meaning that the uv data is not examined). Here the RMS, mean intensity, and dynamic range are found which help with identifying lines in the spectrum. Additionally, two plots are created:
- Emission Characteristics Plot: The spectrum of various elements (SNR, peak signal, RMS, and minimum signal) are plotted.
- The Peak Point Plot: the image is searched and the peak emission locations are found for every channel in the cube and plotted. The size of the point in the image indicates the magnitude of the emission in that channel.
This task creates a moment 0 map of all the emission in the image cube, regardless of whether or not it comes from different spectral lines (Figure 4). The RMS, and therefore cutoff emission level, is determined by the previous step, CubeStats_AT.
This task creates a list of sources found in the 2D image created by CubeSum_AT. The output is a table which lists peak source positions and fluxes. An image is also displayed which shows where the sources are located.
Given the input from SFind2D_AT of source positions, the statistics of the image from CubeStats_AT, the moment map created by CubeSum_AT, and the initial input image, this task computes the spectra of the cube at a specific point (or points). The output are averaged spectra at up to the three maximum flux value pixel locations in the cube.
From input spectra provided from the previous CubeSpectrum_AT task, this task detects segments of emission (i.e. spectral lines) based off RMS cutoffs. The output is then a list of potential spectral lines and spectra showing where the potential lines have been identified. Six plots in all are created; a peak intensity spectrum, a minimum intensity, the three spectrum provided as inputs from CubeSpectrum_AT, and a Signal/Noise plot. For each plot, the potentially identified lines are overlaid on the spectrum and the amplitude is given as a multiple of the noise (either Peak/Noise or Minimum/Noise; Figure 5)
This task creates a position-velocity (PV) diagram through the input image cube. Given the original image cube and the output moment map from CubeSum_AT, the moment of inertia is computed and used to derive "the best slice" through the image cube. The output is then two figures, one showing the PV slice drawn through the moment map and the other is the PV diagram.
Using an input PV slice from PVSlice_AT and the cube statistics from CubeStats_AT (from which the RMS is taken), this task computes a cross-correlation of the PV slice. It does this by attempting to correlate sections of the spectrum with the whole PVSlice. If the section is not random noise, then the output will show a high correlation for that section. This can be most useful for detecting weak spectral lines.
In this task, ADMIT identifies spectral lines in the input datacube using the output from CubeSpectrum_AT and CubeStats_AT. The output here is very similar to the above LineSegment_AT task except that the line segments have now been identified. For our example here of the Antenna North we see that the large spectral line has been correctly identified as CO (3-2).
Given the output list of lines from LineID_AT, this task generates smaller line cubes from the input image cube each centered around an identified line. A table is presented showing the identified line molecule and rest frequency, the starting and ending channel for the smaller cube, and the name given to the output cube.
For each line cube that is made during the above task, LineCube_AT, a moment map is produced via Moment_AT. This task using the input line cube as well as information from CubeStats_AT to create a Moment 0, Moment 1, and Moment 2 map.
Likewise, for each line cube that is made during LineCube_AT, this task computes the spectrum for the max flux value pixel from the moment 0 map created in the Moment_AT task.
Finally, ADMIT creates another moment 0 map using the full, original input cube and information from CubeStats_AT.
Customizing ADMIT for your dataset
As outlined near the beginning of this guide, you can customize an ADMIT run by supplying additional parameters to admit1.py via a parameter file and pointing to it by using the --apar flag in your admit1.py call.
Each time ADMIT runs, it creates an admit0.py script (found in the same directory as the index.html file) which is an auto-generated script of the ADMIT flow that was performed. Therefore, another option for customizing your ADMIT output is to edit this script to include extra parameters for your data. For example, adding the VLSR to Ingest_AT or LineID_AT for more accurate line identification or changing the “online” boolean flag in LineID_AT to “True” so that ADMIT searches the online version of Splatalogue to identify lesser known chemical species.
To find out what parameters are available for customization, please see the online documentation for each task by clicking on the task name under its header in the weblog. After editing the script, run the new admit0.py script where the image is located to create the new ADMIT products by simply typing:
# In bash admit0.py
Once you are comfortable with editing the admit0.py script, this can help you start to create your own ADMIT flows which you can use to help you quickly sift through large datasets.