This documentation is focused on the pulsar science applications of VCS data. For a detailed description of the VCS and its science goals and capabilities, please see Tremblay et al. (2015).
While not necessary, it will be useful to have a basic understanding of radio interferometry when reading this documentation, so this might help (if you're unfamiliar). We also have a series of papers on the tied-array beamformer: Ord et al. (2019), Xue et al. (2019) and McSweeney et al. (2020).
The wrapper script
process_vcs.py is used for many of the steps needed to reduce the voltages to produce incoherently/coherently summed data in PSRFITS and/or VDIF format. It attempts to make things as streamlined and user-friendly as possible. To see detailed usage information,
process_vcs.py -h. There is also the recently developed
beamform.nf which can display its detailed usage with
For our current Pawsey installation, there are a few specifics:
/groupfile system so make sure all of your data is on
/astro. The Galaxy (and Magnus) Cluster(s) should be thought of a backup cluster or somewhere to do testing.
In order to access any of the tools, you will need to source in your personal profile:
/pawsey/mwa/software/psrBash.profile or on Galaxy:
/group/mwavcs/PULSAR/psrBash.profile. One way to do this is to add the following to your .bashrc
if [[ $HOSTNAME == garrawarla* ]]; then alias sp3='source /pawsey/mwa/software/profiles/mwavcs_pulsar.profile' elif [[ $HOSTNAME == galaxy* ]]; then alias sp3='source /group/mwavcs/PULSAR/psrBash.profile' fi
Then just run the command
sp3 to load all our software
There is a master branch and a development branch of the main codebase. By default,
psrBash.profile will load the master branch, which is meant to represent the most stable version. However, there may be bugs that were later discovered and fixed, but which have not yet been grafted back into the master branch. If you wish to try the more cutting edge development branch, then after sourcing
module unload vcstools/master module load vcstools/devel
The Nextflow scripts (.nf) are in the mwa_search module so to switch to the development version run
module unload mwa_search/master module load mwa_search/devel
(Using module unload & load is preferable to using module switch on account of certain undesirable quirks of the Galaxy system.)
We have endeavoured to make sure this is done without requiring the user's attention, however, please double-check working directories and defaults for scripts.
A note regarding code examples:
Code snippets or complete command-line calls will be enclosed in a code block, i.e.
This is a code block
Furthermore, scripts will require some input and other input will be optional. Optional arguments will be surrounded by
 characters. In both cases, where the user need to specify some input (rather than just toggling a mode of operation), a brief description of that input will be surrounded by
<> characters. For example:
test.py --user_input <required input> [--optional_user_input <optional user input>] [--optional_flag]
Table of Contents
Data are downloaded via the "copyq" on the Zeus machine at Pawsey. In the background on the NGAS servers, the raw voltages are (slowly) being "recombined" - they are labeled with the "Processed" flag on the MWA data archive.
Therefore, there are two different "kinds" of downloads available: raw data OR recombined data. In both cases, the time from a download request to having the data on disk is typically ~few days (depending on volume, load on queues/archives, etc).
All being well, the decision between "raw" and "recombined" downloads should be auto-magically made for you by the
vcs_download.nf script (see Nextflow Notes for tips on running Nextflow scripts). If the data on the NGAS server has been processed, the script will download the "tarballed" recombined files (and, rather nicely, sends them off to get "untarred" on the fly). If the data has not been completely processed, then the raw data will be downloaded and then recombined.
To download an entire observation (referred to by their observation IDs, GPS seconds, as labelled on the MWA data archive), use:
vcs_download.nf --obsid <obs ID> --all
otherwise, if you only want some interval [begin, end] of the full observation, then use:
vcs_download.nf --obsid <obs ID> --begin <starting GPS second> --end <end GPS second>
A note on beginning and end times: the observation ID does not correspond to the starting GPS second of the data. In order to determine the beginning/end times of the observation data, use:
mwa_metadb_utils.py <obs ID>
and this will help you determine the correct GPS times to pass to the
-e options. This applies for all jobs that have an optional beginning and end times.
If there are any issues with the above download method you can always try the perivious method using the
To download an entire observation (referred to by their observation IDs, GPS seconds, as labelled on the MWA data archive), use:
process_vcs.py -m download -o <obs ID> -a
otherwise, if you only want some interval [begin, end] of the full observation, then use:
process_vcs.py -m download -o <obs ID> -b <starting GPS second> -e <end GPS second>
Additionally, if the data have been processed on the NGAS server, then you have the option to ONLY download the incoherently summed data files (*_ics.dat) with the mode option:
To check progress, use:
squeue -p copyq -M zeus -u $USER
and you should see something like this:
Each user can have a maximum of 8 concurrent download jobs running.
By default, data are written to
/astro/mwavcs/vcs/[obs ID]. Once the observation appears to have downloaded correctly, it is good practice to check. The easiest way is to check to output from the
process_vcs.py download command. In
/group/mwavcs/vcs/[obs ID] there is a subdirectory labelled "
batch". Within the "batch" directory is stored all of the submitted SLURM scripts and their output. If there has been a problem in downloading data, this will appear as up to 10 files named "
check_volt_[GPS time]_0.out check_volt_[GPS time]_1.out check_volt_[GPS time]_2.out ...
After 10 attempts to correctly download the data, we stop trying. In this case, the user will need to investigate the SLURM output to see what was going wrong.
If the raw data was downloaded, and you manually want to check them, then use:
checks.py -m download -d raw -o <obs ID> -a (or -b/-e)
otherwise, if the recombined data (i.e. with the "Processed" flag on the MWA data archive) were downloaded, and you manually want to check them, then use:
checks.py -m recombine -o <obs ID> -a (or -b/-e)
The total data volume downloaded will vary, but for maximum duration VCS observations this can easily be ~40 TB of just raw data. It is therefore important to keep in mind the amount of data you are processing and the disk space your are consuming. If only the raw voltages have been downloaded then you will need to recombine the data yourself, which doubles the amount of data (see next section).
Note that this step should be performed automatically by the
Recombine takes data spread over 32 files per second (each file contains 4 fine channels from one quarter of the array) and recombines them to 24+1 files per second (24 files with 128 fine channels from the entire array and one incoherent sum file); this is done on the GPU cluster ("gpuq") on Galaxy. When downloading the data, if you retrieved the "Processed" (i.e. recombined) data, then ignore this step as it has already been done on the NGAS server.
To recombine all of the data, use
process_vcs.py -m recombine -o <obs ID> -a
or, for only a subset of data, use
process_vcs.py -m recombine -o <obs ID> -b <starting GPS second> -e <end GPS second>
If you want to see the progress, then use:
squeue -p gpuq -u $USER
Generally, this processing should not take too long, typically ~few hours.
As before, it is a good idea to check at this stage to make sure that all of the data were recombined properly. To do this, use:
checks.py -m recombine -o <obs ID>
This will check that there are all the recombined files are present and of the correct size. If there are missing raw files the recombining process will make zero-padded files and leave gaps in your data. If you would like to do a more robust check, beamform and splice the data (using the following steps) and then run:
prepdata -o recombine_test -nobary -dm 0 <fits files>
Then you can look through the produced .dat file for gaps using:
exploredat <.dat file>
Once you are happy that the data have been recombined correctly then you should delete the raw voltages (as they are no longer used in the pipeline and are a massive drain on storage resources).
After the download has completed, you already have all that is necessary to create the first kind of beamformed data: an incoherent sum. The data used to create this kind of beamformed output are labelled as
<obsID>_<GPS second>_ics.dat in the downloaded data directory (
/group/mwavcs/vcs/<obs ID>/combined by default), hence we refer to the incoherent sum files as ICS files. The incoherent sum is, basically, the sum of the tile powers, producing a full tile's field of view, with a √N improvement in sensitivity over a single tile, where N is the number of tiles combined. Unfortunately, this kind of data is also very susceptible to RFI corruption, thus you will need to be quite stringent with your RFI mitigation techniques (in time and frequency).
To create the incoherent sum, we run:
create_ics_psrfits.py <obs ID> [-b base directory]
where the optional argument
-b can be used to make the script look in the input path for the ICS data, but the default is
/group/mwavcs/vcs/<obs ID>. This script will create a folder called
ics in the base directory and populate it with the incoherently summed PSRFITS data products. There will be one file per 200-seconds of data, and the files are labelled as
<obs ID>_XXXX.fits, where
XXXX corresponds to which 200-second chunk is included (i.e.
0001 means the first 200 seconds of data).
In order to coherently beamform the data (i.e. form a tied-array or phased-array beam at a given pointing somewhere within the "incoherent" beam), we need to account for a number of factors. These corrections and how they are calculated is totally beyond the scope of this guide, but it amounts to: "What delay do we add to each tile to make sure they all phase-up and point at the same place on the sky?"
There are different ways that we can get this information. In our case, there are two types of observations that can be used:
dedicated calibrator: usually directly before or after the target observation on a bright calibrator source. These are stored on the MWA data archive as visibilities (they are run through the online correlator like normal MWA observations). You can find the observation ID for the calibrator by searching on the MWA data archive or by using the following command which will list compatible calibrator IDs sorted by how close they are in time to the observation:
mwa_metadb_utils.py -c <obs ID>
In order to download the calibration observation, set your MW ASVO API key as an environment variable. Below are some steps to do so:
.bashrcfile (i.e. export MWA_ASVO_API_KEY=<your API key>)
To download a dedicated calibrator observation, use:
process_vcs.py -m download_cal -o <obs ID> -O <cal obs ID>
which will automatically create the correct directory structure and symbolic links and download the calibrator data to
/astro/mwavcs/vcs/[cal obs ID]/[cal obs ID]. A symbolic link to this directory, called "
vis", that is created in
/group/mwavcs/vcs/[obs ID]/cal/[cal obs ID].
For both of these types of calibration data, there are (technically) multiple methods we can use to get calibration solutions, including:
We currently only use the RTS to produce solutions, though in principle the imaging software pipeline is just as valid.
There are a number of steps to go from the visibilities to a usable calibration solution. Most of which is setting up the RTS input files. In all cases, we need a metafits file which contains a lot of information about the array setup, observation parameters, etc. By downloading a dedicated calibrator observation, there will be a
[obs ID]*metafits*.fits included. When correlating for in-beam calibration,
process_vcs.py will also check to see if there is a metafits file available and download it.
In order to do the calibration, we need 1 or more bright sources in the field to actually get the phase and amplitude solutions. The RTS uses a list of known sources to calibrate the antennas.
First, change to the directory where the calibrator "
vis" symbolic link is located. This should be
/group/mwavcs/vcs/[obs ID]/cal/[cal obs ID]. We get a list of sources for the RTS to use by running:
srclist_by_beam.py -m <cal obs metafits file> -n <number of sources> -s <base RTS source list>
which will create a source list of one "super" source, which contains N components and is called "
srclist_puma-*_[obs ID]_patch[N].txt". In general, it's a good idea to have N~1000, regardless of whether you are using a dedicated calibrator observation of doing in-beam calibration, but this number is totally arbitrary (in some cases, 100 may do).The RTS selects the brightest source per channel and uses it to calibrate the tile amplitudes and gains. The remaining N-1 sources ("components") are then used to correct for ionospheric shifts.
An important note here is that we have two options for the base RTS source list, which are captured with the following environment variables:
$RTS_SRCLIST(newest source list, based on GLEAM catalogue, but does have gaps, particularly around some of the "A-team" sources and the Galactic plane)
$RTS_SRCLIST_V2(the old source list, still has gaps around the Galactic plane, but includes the "A-team" we normally use for calibration)
By default, this code searches for a source with a beam-weighted flux density >10 Jy and within 1 degree of the nominal pointing centre. If no source satisfies that criteria, the search radius is incrementally increased by 0.5 degrees until a source is found. The
srclist_by_beam.py code also has an experimental option "order" (
-o), which we can use to specify which sources to select based on flux density and distance from the pointing centre. For example, if we wanted to allow the primary calibrator to be 5 Jy (instead of the default minimum of 10 Jy), and search within a 20 degree radius of the pointing centre, then our command would become:
srclist_by_beam.py -m <cal obs metafits file> -n <number of sources> -s <base RTS source list> -o experimental=10,20
This is particularly handy if, by default, the code does not pick up on the desired calibrator source (i.e. if you know Pic A is in the field, but not within the central degree or so). You can specify a wider search radius to begin with, at which point Pic A should be selected as the "base" calibrator source. If all else fails, please use
$RTS_SRCLIST_V2 as the base source list and try again.
To create a RTS-specific configuration file (which the RTS reads to get all the information and file locations, etc, that it needs), use:
calibrate_vcs.py -o <obs ID> -O <cal obs ID> -m <cal obs metafits file> -s <output source list> [--gpubox_dir <path/to/visibilities>] [--rts_output_dir <output directory>] [--n_vis_grp <# groups>] [--offline] [--nosubmit]
--gpubox_dir option is by default pointing to
/group/mwavcs/vcs/[obs ID]/cal/[cal obs ID]/vis, and should only be changed if the visibilities are stored in a non-standard location.
--rts_output_dir is by default pointing to
/group/mwavcs/vcs/[obs ID]/cal/[cal obs ID], and only experienced users should change the output directory. The script will create a "
rts" subdirectory in the argument of
--n_vis_grp is an advanced option that sets how many bins the visibility data are chopped into. This affects how well the RTS can combat decorrelation over the band and will depend strongly on the baseline configuration (i.e. long baselines decorrelate faster, so more bins are required). In theory there is no downside to increasing this number other than computation time, but we are limited by GPU memory in this case. The default number of bins created is 6, but even this is not sufficient for the longest baselines. Given the current limitations of the Galaxy GPU queue hardware, we cannot use anything more than 6.
--offline flag allows for offline correlated data to be used with the RTS (experimental - we have had limited success in doing this).
--nosubmit flag tells the script to not submit the jobs to the GPU queue, but just to write the required scripts.
You should see an output like the following:
This script will create a "
rts" subdirectory in whatever directory was given
--rts_output_dir and populate it with:
flagged_tiles.txt, which contains the numbers of tiles that need to be flagged, based on what is in the metafits file provided,
flagged_channels.txt, which contains the channel numbers (depending on the fine channel resolution provided) to be flagged, and
rts_[cal obs ID].in, which is what the RTS will read during initialisation.
After the RTS has run, it will create a set of files in the "
rts" subdirectory (Bandpass calibration files and Direction Independent Jones matrix files) used to actually beamform the data.
Once the calibration is completed (it runs on the "gpuq"), move to the rts directory and run:
which will show you the bandpass amplitude and phase calibration solutions for each coarse channel in the "attempt_1" subdirectory. From these plots, we are able to identify troublesome tiles and/or channels and include these in the
flagged_channels.txt and then re-running the calibration step.
A good solution will have a relatively flat bandpass with a nominal "gain relative to band average" value of ~1 for Jones Matrix elements P←X (top left) and Q←Y (bottom right), and should have a gain value of ~0 for the P←Y (top right) and Q←X (bottom left) components. Below is an example of the amplitudes for an excellent calibration solution.
For the phase solutions, we expect that the P←X (top left) and Q←Y (bottom right) components are around 0 degrees, while the P←Y (top right) and Q←X(bottom left) should be random. Below are the phase solutions corresponding to the above amplitude solutions.
Remember to check the calibration solution for each coarse channel and if only a single coarse channel appears to have problems, that is okay, just remember that when processing your data (with Presto or DSPSR) as you may have to flag that coarse channel.
If your calibration solutions don't look as clean as the above images you can use the following steps to attempt to improve them. Remember that calibration is more art than science so try a few different methods and see what works, auto_plot.bash will make a new "attempt_N" subdirectory so if you make your calibration solution worse you can copy the files from the attempt subdirectory with a better solution to the rts directory to overwrite your latest attempt. If a calibration solution isn't converging it may be easy to try a different calibration observation (3C444 often gives the best calibration solutions).
Here is an example of an imperfect calibration solution
The key in these plots are suggestions of which tiles may need to be flagged. These suggestions mean different things for amplitude or phase solution plotting:
I (Nick) normally use the amplitude plots to work out what needs flagging so you can assume I'm talking about amplitude plots from here onward. Here are some basic tips:
In the "attempt_number_N" subdirectory are a chan_x_output.txt and phase_x_output.txt file that contains all of the recommended flags that the calibration plotting script creates. These can be useful when deciding which tile(s) to flag next. The following bash command will output the worst tile for each channel:
for i in $(ls chan*txt); do grep $(cat $i | cut -d '=' -f 3 | cut -d ' ' -f 1 | sort | tail -n 2 | head -n 1) $i; done
Here is an example output of the bash command
Possible PQ flag: ID= 82, max=2.921873 (flag 81?) Possible QQ flag: ID=123, max=1.634151 (flag 122?) Possible PP flag: ID= 69, max=1.744891 (flag 68?) Possible PP flag: ID= 82, max=1.776776 (flag 81?) Possible PP flag: ID=123, max=1.676935 (flag 122?) Possible QQ flag: ID=123, max=1.500668 (flag 122?) Possible PP flag: ID= 6, max=1.759412 (flag 5?) Possible PP flag: ID=123, max=1.584389 (flag 122?) Possible PP flag: ID=123, max=1.545457 (flag 122?) Possible PP flag: ID= 82, max=1.906439 (flag 81?) Possible QQ flag: ID= 15, max=1.805018 (flag 14?) Possible PP flag: ID= 82, max=1.837698 (flag 81?) Possible PP flag: ID=123, max=1.877094 (flag 122?) Possible QQ flag: ID=121, max=1.762988 (flag 120?) Possible PP flag: ID= 6, max=1.699051 (flag 5?) Possible QQ flag: ID= 14, max=1.678808 (flag 13?) Possible PP flag: ID=123, max=1.892947 (flag 122?) Possible QQ flag: ID=123, max=1.839456 (flag 122?) Possible QQ flag: ID=121, max=1.696999 (flag 120?) Possible QQ flag: ID= 69, max=1.818684 (flag 68?) Possible PP flag: ID= 6, max=1.750552 (flag 5?) Possible PP flag: ID=123, max=1.908161 (flag 122?) Possible PP flag: ID= 6, max=2.012411 (flag 5?) Possible PP flag: ID= 15, max=1.563874 (flag 14?)
So for this example, you should flag tile 122.
The MWA can optionally split its 30.72 MHz of bandwidth up into 24 x 1.28 MHz bands that can be spread anywhere within the nominal observing range (70-300 MHz). We call observations of this type "picket fence". Calibrating these observations and combining them can be a little more involved, but none-the-less doable.
The RTS takes quite a bit of work to get going with picket fence data. It assumes that when you pass it data that all the frequency bands are contiguous. So we have to do some "hacking" of the configuration files we send for each picket fence channel. We've incorporated all of the difficult stuff into
calibrate_vcs.py, so the user shouldn't need to worry whether they are calibrating using picket fence data or not.
ls" command to find all of the gpubox files, which on a parallel file system can sometimes hang. This will be obvious when watching the RTS job for a channel takes much longer than other channels. In this case, it is a good idea to look in the batch output file (named something like
RTS_[obs ID]*.out)and the log files (which are written to the output directory specified when calling
calibrate_vcs.py) to help determine which jobs are hanging. These jobs should be cancelled and resubmitted individually to the queue.
flagged_channels.txt) and re-run the calibration (often you will need to iterate a few times anyway). Hopefully, by eliminating really bad tiles/fine-channels, other coarse channels will converge.
In the case where trying to calibrate on a dedicated calibrator observation fails, we can try in-beam calibration. This requires visibilities made from the actual data you're ultimately trying to beamform on, thus we need to use the offline correlator. This is relatively easy, as it's a mode that
process_vcs.py has: it will send off the correlator jobs at the frequency and time resolution you request and will (by default) put them in the
While you technically can correlate the entire observation, that is not recommended - the data volume will be immense. Usually you can just correlate ~200 seconds and that will be sufficient for a calibration solution.
For a desired frequency and time resolution over the interval [begin : end] (in GPS seconds), use:
process_vcs.py -m correlate -o <obs ID> -b <starting GPS second> -e <end GPS second> --ft_res <freq. res. (kHz)> <time res. (ms)>
A typical ft_res is
--ft_res 40 1000 which is 40 (kHz) and 1 (second) integrations. Note that the offline implementation of the correlator is (currently) LIMITED to a maximum dump time of 1 second. Again, see the
process_vcs.py help for details.
The correlator jobs are run on Galaxy's "gpuq", thus you can check the jobs using:
squeue -u $USER -p gpuq
The huge field-of-view of the MWA's tile beam means that there can be 100s of pulsars in an observation. To list all pulsars in the beam run the following command
find_pulsar_in_obs.py -o <obs ID>
Which will create a file
<obs ID>_analytic_beam.txt with all the pulsars in the beam.
You can also run
find_pulsar_in_obs.py -o <obs ID> --sn_est
To estimate the signal-to-noise ratio of the pulsars in this observation. Note that this is a time-consuming calculation so you'll have to be patient and they often have large uncertainties. See section Estimating pulsar fluxes at MWA frequencies for more information on the method.
We do have a data processing pipeline that will beamform, fold and create stokes profiles on all pulsars in the beam. This pipeline is extremely processing heavy and still in development so it's best that you ask Keegan or Nick to run the pipeline for you.
The new Nextflow beamforming method is just a better wrapper for the beamformer (see Nextflow Notes for pros, cons and tips) and automatically splices the fits files. The old method is shown below if you prefer it.
To display the available options of the Nextflow beamformer run
Once we have finished calibrating we can beamform using
beamform.nf --obsid <obs ID> --calid <cal ID> --all (or --begin <begin GPS time> --end <end GPS time>) --pointings <"RA string">_<"DEC string"> [--ipfb] [--summed]
["RA string"] is formatted as "hh:mm:ss.ss" and
["DEC string"] is formatted as "dd:mm:ss.ss" (including the sign: "+" or "-") you can also include multiple pointings by separating them by a space. The beamformer will output full polarisation (Stokes I, Q, U & V) PSRFITS files unless you used the
--summed flag. The summed option only outputs Stokes I which means you can't create polarisation profiles but uses a quarter of the storage and for that reasons is useful for large scale searches.
In our experience, it typically takes ~0.3x real-time to beamform. The process will create a directory
/astro/mwavcs/vcs/[obs ID]/pointings/[RA string]_[DEC string] where the PSRFITS files will labelled as something like:
[obs ID]_[pointing]_ch[lowest channel]-[highest channel]_0001.fits
[channel] is the absolute frequency channel (0-256).
We are also able to create VDIF format output by including
--ipfb which instead produces two files per channel:
[obs ID]_[pointing]_ch[channel]_u.hdr [obs ID]_[pointing]_ch[channel]_u.vdif
[obs ID], [pointing] and
[channel] are defined as above.
There are a few different modes in which the beamformer can be operated and these different "modes" produce different outputs.
With the calibration solutions, we are able to form a tied-array beam at any pointing direction within the field-of-view. To start the beamforming process (it runs on the "gpuq"), use:
process_vcs.py -m beamform -o <obs ID> -a (or -b/-e) -p <"RA string"> <"DEC string"> --DI_dir </path/to/rts/output> --flagged_tiles </path/to/flagged_tiles.txt> [--incoh] [--bf_out_format <"psrfits" or "vdif" or "both">]
["RA string"] is formatted as "hh:mm:ss.ss" and
["DEC string"] is formatted as "dd:mm:ss.ss" (including the sign: "+" or "-"). If you also want the incoherent sum, you can pass the
We are able to splice together adjacent frequency channels for each 200 second chunk using the
splice_psrfits program. In it's current form it accepts all the files you want to splice into one (i.e. the 24 coarse channel data files for an individual 200 second chunk), plus an output suffix. It is invoked as follows:
splice_psrfits [file1] [file2] ... [suffix]
and the output file will be named
Note that frequency ordering matters here! The beamformed PSRFITS are already ordered by channel, so just add them in order. i.e.
splice_psrfits [lowest channel] [second lowest channel] [...] [suffix]
If you give it channels in the wrong frequency order, it will complain about channels not being "adjacent" and crash.
For VDIF output, each channel is written to its own file. As far as we can tell, the only way to add them together is to first create the archives using DSPSR and then add them together with PSRCHIVE tools.
To make this all easier, the
splice.sh script will handle the multiple frequency channels and multiple 200-second chunk aspect of this. To make use of this, change into the directory that contains the individual coarse channel PSRFITS, and then run:
at which point you will be asked to input the Project ID (usually G0024), the observation ID (this is required), how many 200-second chunks you want to combine, and the lowest and high coarse channel number. All of these, except the observation ID, have sensible defaults. If you do not enter an observation ID, the script will not proceed.
PRESTO and DSPSR are not currently natively installed on Garrawarla so the following singularity commands.
For PRESTO commands use:
singularity exec /pawsey/mwa/singularity/presto/presto.sif /bin/bash -c "<command_here>"
singularity exec /pawsey/mwa/singularity/presto/presto.sif /bin/bash -c "prepfold -o <output_name> -psr <pulsar_jname> *fits"
For DSPSR and PSRCHIVE commands use:
singularity exec /pawsey/mwa/singularity/dspsr/dspsr.sif /bin/bash -c "<command_here>"
The MWA Pulsar Database is where we store all of our detections and it is your responsibility to upload all detections you make to it.
To get an account email Nick Swainston (firstname.lastname@example.org) and then perform the following steps to set up your account on the Pawsey supercomputers.
Make a file with your username and password
cd ~ vi .mwa_pulsar_database_auth
Then write this to the file:
export MWA_PULSAR_DB_USER="<username>" export MWA_PULSAR_DB_PASS="<password>"
<password> with your username and password. Then we will change the permissions so no one else can open it
chmod 600 .mwa_pulsar_database_auth
Then open your .bashrc and add the line
This should now set your username and password every time you log in so log in again
There are a variety of files that you can upload to the database so it's a good idea to look through the available options with
The most common upload is a PRESTO prepfold detection which can be uploaded with
submit_to_database.py -o <obs ID> -O <cal ID> -p <pulsar_Jname> -b <bestprof_file> --ppps <presto_plot>
<bestprof_file> file should end in .pfd.bestprof and the
<presto_plot> file should end in .pfd.ps
Nick has developed an MWA pulsar search pipeline which is getting stable enough for most users to be able to start running. These pipelines are very processing heavy and can cause bugs if run in a non-standard way so it's best to discuss with Nick what sort of search you're planning to do.
The main difference between the
mwa_search_pipeline.nf is that
pulsar_search.nf doesn't beamform and
mwa_search_pipeline.nf does. For this reason, you can replace any of the following
pulsar_search.nf and it should still perform the same search.
If you are doing a large scale search (more than a single pointing), for example, a search of a supernova remnant, then you will likely have to play how you grid your pointings using
grid.py. If you want to do a single loop (
-l 1) of beams at the half-power point (
-f 0.5) then you could use the following command
grid.py -o <obsid> -l 1 -f 0.5 -d <fwhm_deg> -p <pointing>
<fwhm_deg> is the FWHM of the beam in degrees, this can be estimated using
If you want to fill a RA and dec range you could use a command like this
grid.py -o <obsid> -l 50 -f 0.8 -d <fwhm_deg> -p <pointing> --ra_range <min RA> <max RA> --dec_range <min dec> <max dec>
--dec_range values are in degrees.
If you want to fill a circle with beams you could use a command like this (note this is only available in the mwa_search devel branch/module version)
grid.py -o <obsid> --fill <radius_to_fill_in_degrees> -f 0.8 -d <fwhm_deg> -p <pointing>
It's always best to check the output png file to check that the grid looks reasonable. Once you are happy with your grid you can use it the search pipelines using
--pointing_file <grid.py output>
A common search command is:
mwa_search_pipeline.nf --obsid <obs ID> --calid <cal ID> --all (or --begin <begin GPS time> --end <end GPS time>) --pointings <"RA string">_<"DEC string">
The candidates will be output to
By default, the search is a simple periodic search. To perform an acceleration search use
--zmax 200 (this is extremely processing heavy so recommended you only do it on short observations)
By default, DMs 1 to 250 is searched. To change this use
The ATNF database is an abundant resource for published pulsar data. This may include flux densities over a broad range of frequencies. Should such data be available for a pulsar, we are able to make a first-order estimate of the flux we expect from a pulsar.
To view the spectral data on the ATNF database for any pulsar:
sn_flux_est.py --mode ATNF -p <Pulsar Name>
Which will output a plot such as this one:
Note that a spectral Index will be derived from the points. If there is sufficient data to do so, like in this example, this is calculated from a least squares approach. Otherwise, the standard 1.4 +/- 1.0 will be applied from Bates et al. 2013
We can also make an estimate of a pulsar's flux at from any observation ID:
sn_flux_est.py --mode SNFE -p <Pulsar Name> -o <Obs ID>
This will apply the radiometer equation and estimate the flux and signal to noise ratio at the observation's central frequency. It is also possible to specify beginning and end times if you don't intend to use the entire observation length by adding:
-b <beginning GPS time > -e <end GPS time>
Plotting the SED like before is also possible with the tag:
sn_flux_est.py --mode SNFE -p J0630-2834 -o 1258221008 --plot_est
Will output the following:
J0630-2834 derived spectral index: -1.3698868864530596 +/- 0.04796669612862415 J0630-2834 flux estimate at 154.24 MHz: 0.41368443304349944 +/- 0.006638533625983657 Jy Pulsar S/N: 747.0705031130714 +/- 161.9689693670181
This section explains the pros and cons of Nextflow and some tips on how to run the Nextflow scripts well
-resume) without having to rerun everything again
Screens allow you to run a command in the background that won't be interrupted when you log out of an ssh session. Here is a good guide of how to use screens: https://www.howtogeek.com/662422/how-to-use-linuxs-screen-command/
I will go through the basics that you will require for running Nextflow
To make a screen use the command
screen -S <screen_name>
Make sure the screen_name is descriptive enough so that you know what you're doing in that screen. You will then be put inside a screen where you can run a Nextflow pipeline. You can then detach from the screen by holding down
ALT and pressing
d. Your pipeline will then continue to run in the background and you can return to the screen using
screen -r <screen_name>
If you can't remember what the screen_name was then you can run
This will reattach you to your screen if you only have one or list all your screens. If you can't see the screen you've made then you may be on the wrong login node. To switch to the other login in node run
nswainston@garrawarla-1:~> ssh garrawarla-2
One large benefit of Nextflow pipelines is that you can resume the pipelines. Once you have fixed the bug that caused the pipeline to crash simply relaunch the pipeline with the
-resume option added. For the resume option to work you must run the command from the same directory and the working directory can't be deleted
Once the pipeline is done and you are confident you don't need to resume the pipeline or need the intermediate files then it is a good idea to remove the Nextflow work directories to save space. By default, the work directories are stored in