VCS pulsar data processing
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:
- We now have access to the Garrawarla cluster, which we should use for the bulk of our processing. Note Garrawarla does not have access to the
/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.profileor on Galaxy:
/group/mwavcs/PULSAR/psrBash.profile. One way to do this is to add the following to your .bashrc
Then just run the command
sp3to load all our software
There is a master branch and a development branch of the main codebase. By default,
psrBash.profilewill 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
The Nextflow scripts (.nf) are in the mwa_search module so to switch to the development version run
(Using module unload & load is preferable to using module switch on account of certain undesirable quirks of the Galaxy system.)
- There is a strict directory structure for VCS processing, given the large volumes of data involved. Raw/recombined and all other products (incoherent sum products, coherent sum products, calibration solutions, etc.) data is stored on the
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.
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:
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.
- If raw voltages are downloaded, then they will be placed in:
- If the processed/recombined data are downloaded, then the relevant files are placed in:
If the observation is recent (performed within 4 days) then it is best to first check if all the VCS files have been archived (moved from site to Pawsey). This can be done with the following command:
Which should output something like this:
In this example, 2.4% of the files are not yet archived so the user should wait until 100% of the files are archived. If all the files have not been archived in over 5 days you should contact someone on the MWA operations team to ask them what may have gone wrong.
To download an entire observation (referred to by their observation IDs, GPS seconds, as labelled on the MWA data archive), use:
otherwise, if you only want some interval [begin, end] of the full observation, then use:
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:
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.
Old Python Download Method
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:
otherwise, if you only want some interval [begin, end] of the full observation, then use:
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:
and you should see something like this:
Each user can have a maximum of 8 concurrent download jobs running.
Checking downloaded data
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 "
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:
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:
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).
Old Python Recombine Method
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
or, for only a subset of data, use
If you want to see the progress, then use:
Generally, this processing should not take too long, typically ~few hours.
Checking the recombined data
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:
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:
Then you can look through the produced .dat file for gaps using:
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:
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:
- in-beam calibrator: using data from the target observation itself, correlating a section offline, and using those visibilities. See Offline correlation.
In order to download the calibration observation, set your MW ASVO API key as an environment variable. Below are some steps to do so:
- First go to the website https://asvo.mwatelescope.org
- Login with your username and password, or via eduGAIN (using your institution details)
- Go to your profile and get your API key
- Copy this API key to your
.bashrcfile (i.e. export MWA_ASVO_API_KEY=<your API key>)
- For more information visit manta-ray-client github
To download a dedicated calibrator observation, use:
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:
- using the Real Time System (RTS);
- using the MWA imaging software pipeline, (i.e. AOFlagger, wsclean and cotter); or
- using the CASA software suite
We currently only use the RTS to produce solutions, though in principle the imaging software pipeline is just as valid.
Calibrating with the Real Time System (RTS)
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.
Getting calibrator source lists
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:
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:
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.
RTS configuration and tile/channel flagging
To create a RTS-specific configuration file (which the RTS reads to get all the information and file locations, etc, that it needs), use:
--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
- a configuration file,
rts_[cal obs ID].in, which is what the RTS will read during initialisation.
Inspecting the solutions
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.
Improving the RTS solutions
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:
- Amplitudes: the relative gain amplitude threshold used to determine whether tiles are bad. Default is 0.35.
- Phases: the phase deviation threshold (in degrees) used to determine bad tiles. Default is 30 degrees.
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:
- If there are any tiles with max>3 on multiple channels it is worth flagging.
- If there are any tiles that have a max=0 this is worth flagging (even if only one polarisation has max=0!) as it is contributing no signal and can cause errors in beamforming
- It is best to only flag up to ~3 tiles at a time as bad tiles can affect other potentially good tiles
- Sensitivity scales as ~sqrt(128-N) where N is the number of tiles flagged so if you start flagging more than 50 tiles will start to lower your sensitivity and maybe worth abandoning
- Make sure you put the number in the right of the key (between flag and ?) into the
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:
Here is an example output of the bash command
So for this example, you should flag tile 122.
If there is a single channel that is affecting your solution, you can flag it using the following method.
Make sure you have used the -X option when you ssh to enable an interactive terminal, then run:
This should create an interactive plot that looks like this
Use the magnifying glass symbol to drag a rectangle around the bad channel to zoom in like so
It is now clear that you should add 23 to flagged_channels.txt
Picket fence calibration with the RTS
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.
- The RTS basically does a "
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.
- You may find that some coarse channel solutions simply don't converge. In this case, look at those channels that did converge and flag any obviously bad tiles or fine frequency channels (by adding the relevant entry to either
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:
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:
Finding pulsars in the observation
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
Which will create a file
<obs ID>_analytic_beam.txt with all the pulsars in the beam.
You can also run
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.
Beamforming (Nextflow method)
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
["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:
[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] and
[channel] are defined as above.
Beamforming (old python method)
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:
["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
Splicing channels together
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:
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.
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.
Pulsar Processing on Garrawarla
PRESTO and DSPSR are not currently natively installed on Garrawarla so the following singularity commands.
For PRESTO commands use:
For DSPSR and PSRCHIVE commands use:
The Observation Processing Pipeline
The OPP is a piece of software available on Garrawarla designed to fold on all known pulsars in an observation. The OPP will also launch polarimetric processing for detected pulsars.
First estimate the number of pulsars that will be beamformed using
find_pulsar_in_obs.py -o <obsid> and checking the output file. The number of sources may be higher than this because we also search for other sources (FRBs, RRATs and Fermi candidates) and pulsars further away from the beam centre if we estimate them to be extremely bright. We can estimate the storage the beamformed fits files require using <number of pulsars> X <observation duration in minutes> TB. If this number is below 50 TB then use the method described in Beamforming on all pulsars and Launching the OPP, if it is over 50 TB use the method described in Running the OPP in chunks
Beamforming on all pulsars
Before running the OPP, we need to beamform on all pulsars in the field of view of the observation we're processing. This can done with the following command:
Like many nextflow scripts, it's recommended that you run this in a Documentation#screen as it may take some time to complete.
You can make sure you have the beamformed fits files by checking the following directory:
Launching the OPP
To run the OPP, ensure you have the vcstools and mwa_search modules loaded. Then, the following command will launch the OPP:
This will launch an instance of the Pulsar Processing Pipeline for each pulsar in the field. Additional run options can be accessed with the --help tag. This may take up to an hour for observations with many pulsars.
Currently, there are three run types:
- Fresh run: Creates a new config file for each pulsar, clears the working directories of any previous results and launches the PPP
- Rerun existing: Loads the existing config files in the 'dpp' directory and launches the PP for each of them without any modifications
- Rerun broken: Loads the existing config files, checks to see which did not complete properly and relaunches these jobs only
The Pulsar Processing Pipeline
The PPP is a piece of software designed to work in conjunction with the OPP. It handles the processing requirements for a single pulsar. You shouldn't need to interact with the PPP, however, this page will detail how it works.
When the PPP is launched, it checks the config file (.yaml) created by the OPP and decides what needs to be done. From here, it will create a job script and a relaunch script that will run the PPP script again. When the job has finished, the PPP will launch and read the config file again and decide what to do once again. This continues until there are no more things that can be done for the pulsar. Everything that happens in the PPP is documented in a .log file in the following directory:
The .log file contains all of the job information for the run. Similarly, the results of the run can be found in the config file and the resulting files will be found in the above directory.
Should you need to launch the PP manually, you can so so with the following command:
Note that by default, the PPP will continue where it left off. If you want to restart the pipeline, add the --fresh_run tag. You can use the --help tag for more information
Many observations will contain a large number of pulsars in their field of view. This makes it inconvenient to check each output of the PPP manually to check its outcome. Instead, you can use the following command to do so (provided the OPP run is completely finished):
An example output looks something like this:
Note that the positive detections are listed at the very top of the output. A detected pulsar is merely one that was classified as a detection by the LOTAAS classifier.
Running the OPP in chunks
This method explains how to run the OPP a chunk at a time so when you have a large number of pulsars in the FoV you can save storage space. It is best to run all of these commands in a Documentation#screen from your Nextflow work directory (
First, run all of the searches using
Once it is complete you can check the candidates in
/astro/mwavcs/pulsar_search/<obsid>_candidates and delete the contents of the Nextflow work directory using
Then run the following command to get all the required pointings and split them into 60 pointing chunks
This should output several pointing chunk files that look like this
Each file represents a chunk of the OPP you will run. For each file complete the following 4 steps (beamform, delete work files, run OPP and delete pointing files)
Run the beamformer using
The (–ipfb) option should only be used for the vdif sources (eg. 1275758864_fov_vdif_sources_1_25.txt). Once the beamforming has complete successfully delete the Nextflow work files
Then run the OPP
If this is your first chunk of data use
--run_type fresh run, if not use
Once all the OPP jobs have finished you can safely delete the pointing files using
Repeat these 4 steps until you have used all the pointing chunk files.
Multi-Gaussian Profile Fitting
Should you need to fit a pulse profile, vcstools contains a program to do so using multiple Gaussian components. The purpose of the fitter is not to attempt to model individual beam components, but rather to dissect the profile into a clean mathematical entity that can be used to attain some useful measurements of the profile. The script we use to run the fitter is prof_estimate.py. This script requires a single input file that is one of the following formats:
- PRESTO .pfd.bestprof
- PRSCHIVE .archive
- ASCII output of a .archive file
Note that even if a full-stokes .archive or ACII profile is provided, only Stokes I will be used, other stokes variants will be ignored.
The profile is the only required input for prof_estimate.py. However, I would recommend using the --clip_type input and setting it to verbose.
The verbose tag increases the number of alpha attempts when determining the optimal clipping verbosity. This is used to determine what part of the profile is noise and what is a real on-pulse region. A small alpha will not flag much of the profile as noise while a large alpha will be more aggressive with its flagging. The fitter decides which alpha value is most appropriate by attempting to fit a profile to ALL alpha variants and evaluating the result using the Bayesian Information Criterion.
An example run of the script using a command line interface looks like this:
Which will produce a logger output that looks something like this:
Here, the widths and maxima are measured in units of phase.
One additional feature of the fitter is the plotting capability. To plot your result, you need to supply a plot name. For example:
Which produces something like this:
The fitter is also capable of fitting noisy profiles:
The MWA Pulsar Database
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.
Setting up your account
To get an account email Nick Swainston (email@example.com) and then perform the following steps to set up your account on the Pawsey supercomputers.
Make a file with your username and password
Then write this to the file:
<password> with your username and password. Then we will change the permissions so no one else can open it
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
Uploaded detections to the database
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
<bestprof_file> file should end in .pfd.bestprof and the
<presto_plot> file should end in .pfd.ps
Pulsar search pipelines
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.
Working out a pointing grid
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
<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
--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)
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 the search pipelines using
--pointing_file <grid.py output>
The mwa_search_pipeline.nf will beamform and search. A common search command is:
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
To see all the available options use:
If you have already beamformed and have the fits files available, you can use pulsar_search.nf.
You should only input a single fits file to prevent errors in the single pulse searcher. The candidates will also be output to
Estimating pulsar fluxes at MWA frequencies
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:
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:
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:
Plotting the SED like before is also possible with the tag:
screen will output the following:
This section explains the pros and cons of Nextflow and some tips on how to run the Nextflow scripts well
- Shows you the progress of the pipeline
- Prints any errors that occur (no need to look through the batch scripts)
- Keeps all intermediate files in one place so they're easily deleted
- If one job breaks, the pipeline can be resumed (using
-resume) without having to rerun everything again
- Makes handling container images easier
- The Nextflow job runs as long as the pipeline so it's often best you put it in a screen (explained below)
- Newer so there may be more bugs
Using a screen
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
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
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
Resuming Nextflow Pipelines
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
Cleaning up the work directories
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