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:
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.
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.
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.
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.
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 it the search pipelines using
--pointing_file <grid.py output>
Running the pipeline
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
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:
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