ISAC (Iterative Stable Alignment and Clustering) is a 2D classification algorithm. It sorts a given stack of cryo-EM particles into different classes that share the same view of a target protein. ISAC is based around iterations of alternating equal size k-means clustering and repeated 2D alignment routines.

• ISAC is the initial version as described in the original paper. At this point this implementation is obsolete and has been replaced by ISAC2 and GPU ISAC (see below).

• ISAC2 is an improved version of ISAC and used by default tool to produce 2D class averages in the SPHIRE (git) software package and the TranSPHIRE automated pipeline for processing cryo-EM data. ISAC2 is a CPU-only implementation and was developed to run on a computer cluster.

• GPU ISAC was developed to run ISAC2 on a single workstation by outsourcing its computationally expensive bottleneck calculations to any available GPUs, while simultaneously keeping its MPI-based CPU parallelization otherwise intact. GPU ISAC is provided as an add-on to SPHIRE that can be installed manually (see below).

• GPU ISAC is currently developed as a manually installed add-on for SPHIRE and distributed as a .zip file that can be found here: GPU ISAC download link.

Before you start, make sure your SPHIRE environment is activated.

GPU ISAC comes with a handy installation script that can be used as follows:

1. Extract the archive to your chosen GPU ISAC installation folder.
2. Open a terminal and navigate to your installation folder.
3. Run the installation script:

   ./install.sh

All done!

An example call to use GPU ISAC looks as follows:

mpirun /path/to/sxisac2_gpu.py bdb:path/to/stack path/to/output --CTF -–radius=160 --img_per_grp=100 --minimum_grp_size=60 --gpu_devices=0,1

Using the following mix of both mandatory and optional parameters (see below to learn which is which):

mpirun /path/to/sxisac2_gpu.py
bdb:path/to/stack
path/to/output
--CTF 
-–radius=160
--img_per_grp=100
--minimum_grp_size=60
--gpu_devices=0,1

[ ! ] - Mandatory parameters in the GPU ISAC call:

• mpirun is not a GPU ISAC parameter, but is required to launch GPU ISAC using MPI parallelization (GPU ISAC uses MPI to parallelize CPU computations and MPI/CUDA to distribute and parallelize GPU computations).
• /path/to/sxisac2_gpu.py is the path to your sxisac2_gpu.py file. If you followed these instructions it should be your/installation/path/gpu_isac_2.2/bin/sxisac2_gpu.py.
• path/to/stack is the path to your input .bdb stack. If you prefer to use an .hdf stack, simply remove the bdb: prefix.
• path/to/output is the path to your preferred output directory.
• --radius=160 is the radius of your target particle (in pixels) and has to be set accordingly.
• --gpu_devices tells GPU ISAC what GPUs to use by specifying their system id values.

[?] - Optional parameters recommended to be used when running GPU ISAC:

• Use the --CTF flag to apply phase flipping to your particles.
• Use --img_per_grp to limit the maximum size of individual classes. Empirically, a class size of 100-200 (30-50 for negative stain) particles has been proven successful when dealing with around 100,000 particles. (This may differ for your data set and you can use GPU ISAC to find out; see below.)
• Use --minimum_grp_size to limit the minimum size of individual classes. In general, this value should be around 50-60% of your maximum class size.

EXAMPLE 01: Test run

This example is a test run that can be used to confirm GPU ISAC was installed successfully. It is a small stack that contains 64 artificial faces and is already included in the GPU ISAC installation package. You can process it using GPU ISAC as follows:

1. In your terminal, navigate to your GPU ISAC installation folder:

   cd /gpu/isac/installation/folder

2. Run GPU ISAC:

   mpirun bin/sxisac2_gpu.py 'bdb:examples/isac_dummy_data_64#faces' 'isac_out_test/' --radius=32 --img_per_grp=8 --minimum_grp_size=4 --gpu_devices=0

Note that we don't care about the quality of any produced averages here; this test is used to make sure there are no runtime issues before a more time consuming run is executed.

EXAMPLE 02: TcdA1 toxin data

This example uses the SPHIRE tutorial data set (link to .tar file) described in the SPHIRE tutorial (link to .pdf file). The data contains about 10,000 particles from 112 micrographs and was originally published here (Gatsogiannis et al, 2013).

After downloading the data you'll notice that the extracted folder contains a multitude of subfolders. For the purposes of this example we are only interested in the Particles/ folder that stores the original data as a .bdb file.

You can process this stack using GPU ISAC as follows:

1. In your terminal, navigate to your GPU ISAC installation folder:

   cd /gpu/isac/installation/folder

2. Run GPU ISAC:

   mpirun bin/sxisac2_gpu.py 'bdb:/your/path/to/Particles/#stack' 'isac_out_TcdA1' --CTF --radius=145 --img_per_grp=100 --minimum_grp_size=60 --gpu_devices=0

   • Replace /your/path/to/Particles/ with the path to the Particles/ directory you just downloaded.
   • Optional: Replace --gpu_devices=0 with --gpu_devices=0,1 if you have two GPUs available (and so on).

The final averages can then be found in isac_out_TcdA1/ordered_class_averages.hdf. You can look at them using e2display.py (or any other displaying program of your choice) and should see averages like these:

Above: The first thirty class averages out of an overall set of 94 after processing the above data set using GPU ISAC.

Right now GPU ISAC is an excellent tool to screen your data which allows you to:

• Quickly generate 2D class averages.
• Quickly identify suitable parameters for your data set.
• Quickly gauge the quality of your data set before spending time on more costly processing steps.

Please note that the original version of ISAC was intended to run on a cluster, where resources like RAM are more plentiful than on a single machine running GPU ISAC. Therefore please be aware of the the following limitation of the current version of GPU ISAC:

Running memory check..
..avl sys mem (RAM): 60030.62 MB / 58.62 GB
..est mem req (raw data): 47265.62 MB / 46.16 GB
..est mem req (downsampled data): 8131.41 MB / 7.94 GB

For a quick screening of your data, 20,000 to 40,000 particles are usually already enough to produce quality class averages if the quality of your data set is sufficient.

GPU ISAC produces a multitude of output files that can be used to analyze the success of running the program, even while it is still ongoing. These include the following:

• Main iteration folders: As GPU ISAC is running, it performs multiple “main iterations” and “generations” that are stored within the output folder structure. New class averages are produced during every iteration / generation and can be looked at during runtime without having to wait for the overall process to conclude. This can help to quickly gauge the quality of a data set. Check path/to/output/mainXXX/generationYYY for the .hdf files to that contain any newly produced class averages.
• In both the main iteration folders and the base output folder you will find processed_images.txt files. These contain the indices of all processed particles and can be used to determine how many particles GPU ISAC did account for during classification.
• The final averages are stored in path/to/output/ordered_class_averages.hdf.