Available methods:

3D classification (Relion)

Protocol to classify 3D using Relion Bayesian approach. Relion employs an empirical Bayesian approach to refinement of (multiple) 3D reconstructions or 2D class averages in electron cryo-EM. Many parameters of a statistical model are learned from the data, which leads to objective and high-quality results.

3D Heterogeneous Refinement (Cryosparc2)

Heterogeneous Refinement simultaneously classifies particles and refines structures from n initial structures, usually obtained following an Ab-Initio Reconstruction. This facilitates the ability to look for small differences between structures which may not be obvious at low resolutions, and also to re-classify particles to aid in sorting.

3D subtomogram classification (RelionTomo)

Protocol to classify 3D using Relion. Relion employs an empirical Bayesian approach to refinement of (multiple) 3D reconstructions or 2D class averages in electron cryo-microscopy (cryo-EM). Many parameters of a statistical model are learned from the data,which leads to objective and high-quality results.

consensus clustering 3D (Xmipp3)

Compare several SetOfClasses3D. Return the consensus clustering based on a objective function that uses the similarity between clusters intersections and the entropy of the clustering formed.

frealign classify (Grigoriefflab)

Protocol to classify 3D using Frealign. Frealign employsmaximum likelihood classification for single particle electroncryo-microscopy.Particle alignment parameters are determined by maximizing ajoint likelihood that can include hierarchical priors, whileclassification is performed by expectation maximization of amarginal likelihood.

XmippProtDeepSimilarityCones3D (Xmipp3)

In development, 3D classifier

Available methods:

auto-picking (Relion)

This protocol runs Relion autopicking (version > 3.0). This Relion protocol uses the 'relion_autopick' program to pick particles from micrographs, either using references (2D averages or 3D volumes) The wrapper implementation does not read/write any FOM maps compared to Relion

auto-picking (Gautomatch)

Automated particle picker for SPA. Gautomatch is a GPU accelerated program for accurate, fast, flexible and fully automatic particle picking from cryo-EM micrographs with or without templates.

auto-picking LoG (Relion)

This Relion protocol uses 'relion_autopick' program for the Laplacian of Gaussian (LoG) option.

auto-picking (step 2) (Xmipp3)

Protocol to pick particles automatically in a set of micrographs using previous training

boxer (Eman2)

Semi-automated particle picker for SPA. Uses EMAN2 e2boxer.py.

boxer auto (Eman2)

Automated particle picker for SPA. Uses EMAN2 (versions 2.2+) e2boxer.py

center particles (Xmipp3)

Realignment of un-centered particles.

cryolo picking (Sphire)

Picks particles in a set of micrographs either manually or in a supervised mode.

cryolo tomo picking (Sphire)

Picks particles in a set of micrographs either manually or in a supervised mode.

cryolo training (Sphire)

Picks particles in a set of micrographs either manually or in a supervised mode.

dogpicker (Appion)

Protocol to pick particles in a set of micrographs using appion dogpicker.

ethan picker (Bamfordlab)

ETHAN is a program for automatic detection of spherical particles from electron micrographs. The ETHAN software was written at the Department of Computer Science of University of Helsinki, Finland by Teemu Kivioja.

extract movie particles (Xmipp3)

Extract a set of Particles from each frame of a set of Movies.

extract particles (Xmipp3)

Protocol to extract particles from a set of coordinates

find particles (Cistem)

Protocol to pick particles (ab-initio or reference-based) using cisTEM.

manual-picking (step 1) (Xmipp3)

Picks particles in a set of micrographs either manually or in a supervised mode.

particle boxsize (Xmipp3)

Given a set of micrographs, the protocol estimate the particle box size.

particle picking (BSOFT)

Protocol to pick particles in a set of micrographs using bsoft

picking consensus (Xmipp3)

Protocol to estimate the agreement between different particle picking algorithms. The protocol takes several Sets of Coordinates calculated by different programs and/or different parameter settings. Let's say: we consider N independent pickings. Then, a coordinate is considered to be a correct particle if M pickers have selected the same particle (within a radius in pixels specified in the form). If you want to be very strict, then set M=N; that is, a coordinate represents a particle if it has been selected by all particles (this is the default behaviour). Then you may relax this condition by setting M=N-1, N-2, ... If you want to be very flexible, set M=1, in this way it suffices that 1 picker has selected the coordinate to be considered as a particle. Note that in this way, the cleaning of the dataset has to be performed by other means (screen particles, 2D and 3D classification, ...).

pick noise (Xmipp3)

Protocol to pick noise particles

remove duplicates (Xmipp3)

This protocol removes coordinates that are closer than a given threshold. The remaining coordinate is the average of the previous ones.

sparx gaussian picker (Eman2)

Automated particle picker for SPA. Uses Sparx gaussian picker. For more information see http://sparx-em.org/sparxwiki/e2boxer

tilt pairs particle picking (Xmipp3)

Picks particles in a set of untilted-tilted pairs of micrographs.

tomo boxer (emantomo)

Manual picker for Tomo. Uses EMAN2 e2spt_boxer.py.

topaz training (Topaz)

Train and save a Topaz model

EmanProtTempMatch (Eman2)

In development, Eman template matching method for tomography

Available methods:

alphafold prediction (Chimera)

Protocol to import atomic structures generated by alphafold. If you choose the "Execute alphafold Locally" option you will need a local alphafold NO docker instalation as described here: https://github.com/kalininalab/alphafold_non_docker

alphafold prediction (ChimeraX)

Protocol to import atomic structures generated by alphafold. If you choose the "Execute alphafold Locally" option you will need a local alphafold NO docker instalation as described here: https://github.com/kalininalab/alphafold_non_docker

Base class for other ed Import protocols. (pwed)

Base class for other ed Import protocols.

cryolo import (Sphire)

Protocol to import an existing crYOLO training model. The model will be registered as an output of this protocol and it can be used later for further training or for picking.

import 3D coordinates from scipion (Tomo)

Protocol to import a set of 3d coordinates from Scipion sqlite file

import atomic structure (pwem)

Protocol to import an atomic structure to the project.Format may be PDB or MMCIF

import averages (pwem)

Protocol to import a set of averages to the project

import coordinate pairs (pwem)

Protocol to import a set of tilt pair coordinates

import coordinates (Deepfinder)

Protocol to import a DeepFinder object list as a set of 3D coordinates in Scipion

import coordinates (Relion)

Import coordinates from a particles star file.

import coordinates (pwem)

Protocol to import a set of coordinates

import coordinates 3D from a star file (RelionTomo)

Protocol to import a set of 3D coordinates from a star file

import ctf (pwem)

Common protocol to import a set of ctfs into the project

import experiment (Pkpd)

Protocol to import an PKPD experiment Protocol created by http://www.kinestatpharma.com

import from excel (Pkpd)

Import experiment from Excel. Protocol created by http://www.kinestatpharma.com

import from winnonlin (Pkpd)

Import experiment from Winnonlin. Protocol created by http://www.kinestatpharma.com

import mask (pwem)

Class for import masks from existing files.

import micrographs (pwem)

Protocol to import a set of micrographs to the project

import movies (pwem)

Protocol to import a set of movies (from direct detector cameras) to the project.

import particles (pwem)

Protocol to import a set of particles to the project

import sequence (pwem)

Protocol to import an aminoacid/nucleotide sequence file to the project

import set of atomic structures (pwem)

Protocol to import a set of atomic structure to the project. Format may be PDB or MMCIF

import set of coordinates 3D (Tomo)

Protocol to import a set of tomograms to the project

import star file PySeg (Pyseg)

This protocol imports subtomograms from a STAR file generated by PySeg

import subtomograms (Tomo)

Protocol to import a set of tomograms to the project

import subtomograms from a star file (RelionTomo)

Protocol to import a set of subtomograms from a star file

import subtomos from Dynamo (Dynamo)

This protocol imports subtomograms with metadata generated by a Dynamo table. A Dynamo catalogue can be also imported in order to relate subtomograms with their original tomograms.

import tilted micrographs (pwem)

Protocol to import untilted-tilted pairs of micrographs in the project

import tilt-series (Tomo)

Protocol to import tilt series.

import tilt-series movies (Tomo)

Protocol to import tilt series movies.

import tomo CTFs (Cistem)

Protocol to import CTF estimation of a tilt-series from CTFFIND4.

Import tomo CTFs (Imod)

Protocol to import estimations of CTF series from tilt-series into Scipion.

import tomograms (Tomo)

Protocol to import a set of tomograms to the project

import tomograms from Dynamo (Dynamo)

This protocols imports a series of Tomogram stored in a Dynamo catalogue into Scipion. In order to avoid handling a MatLab binary, the script relies on MatLab itself to turn a binary MatLab object into an Structure which can be afterwards read by Python.

import tomomasks (segmentations) (Tomo)

Protocol to import a set of tomomasks (segmentations) to the project

Import transformation matrix (Imod)

Import the transformation matrices assigned to an input set of tilt-series

import volumes (pwem)

Protocol to import a set of volumes to the project

topaz import (Topaz)

Protocol to import an existing topaz training model. The model will be registered as an output of this protocol and it can be used later for further training or for picking.

Available methods:

emx export (Emxlib)

Export micrographs, coordinates or particles to EMX format. EMX is a joint initiative for data exchange format between different EM software packages.

export coordinates (Relion)

Export coordinates from Relion to be used outside Scipion.

export ctf (Relion)

Export a SetOfCTF to a Relion STAR file.

export emdb (pwem)

generates files for volumes and FSCs to submit structures to EMDB

export particles (Relion)

Export particles from Relion to be used outside Scipion.

export to csv (Pkpd)

Export experiment to CSV. Protocol created by http://www.kinestatpharma.com

export to emdb/pdb (pwem)

generates files for elements to submit structures to EMDB/PDB. Since mmcif/pdb is only partially supported by some software the protocol creates 4 versions of the atomic struct file with the hope that at least one of them will work.

extract asymmetric unit (Xmipp3)

generates files for volumes and FSCs to submit structures to EMDB

Available methods:

annotate segmented membranes (TomosegmemTV)

Manual annotation tool for segmented membranes

apply 2d mask (Xmipp3)

Apply mask to a set of particles

apply 3d mask (Xmipp3)

Apply mask to a volume

create 2d mask (Xmipp3)

Create a 2D mask. The mask can be created with a given geometrical shape (Circle, Rectangle, Crown...) or it can be obtained from operating on a 2d image or a previuous mask.

create 2d mask (Spider)

This protocol creates a 2D mask using SPIDER. In the step following this one, dimension-reduction, the covariance of the pixels in all images will be computed. Only pixels under a given mask will be analyzed. If this step is performed, a mask that follows closely the contour the particle of interest will be used. Absent a custom-made mask, a circular mask will be used. For non-globular structures, this customized mask will reduce computational demand and the likelihood of numerical inaccuracy in the next dimension-reduction step. On the other hand, given the power of modern computers, this step may be unnecessary.

create 3d mask (Xmipp3)

Create a 3D mask. The mask can be created with a given geometrical shape (Sphere, Box, Cylinder...) or it can be obtained from operating on a 3d volume or a previous mask.

create 3d mask (Relion)

This protocols creates a 3D mask using Relion. The mask is created from a 3d volume or by comparing two input volumes.

Tomogram segmentation (TomosegmemTV)

Segment membranes in tomogram

Available methods:

crop/resize particles (Xmipp3)

Crop or resize a set of particles

crop/resize volumes (Xmipp3)

Crop or resize a set of volumes

join sets (pwem)

Protocol to join two or more sets of images. This protocol allows to select two or more set of images and will produce another set joining all elements of the selected sets. It will validate that all sets are of the same type of elements (Micrographs, Particles or Volumes)

metaprotocol heterogeneity subset (Xmipp3)

Metaprotocol to select a set of particles from a 3DClasses and a Volume from a SetOfVolumes

particles subset by micrograph (pwem)

Create a subset of those particles that come from a particular set of micrographs

ProtUserSubSet (pwem)

Create subsets from the GUI. This protocol will be executed mainly calling the script 'pw_create_image_subsets.py' from the ShowJ gui. The enabled/disabled changes will be stored in a temporary sqlite file that will be read to create the new subset.

Resize segmented or annotated volume (TomosegmemTV)

Resize segmented volumes or annotated (TomoMasks).

split sets (pwem)

Protocol to split a set in two or more subsets.

subset (pwem)

Create a set with the elements of an original set that are also referenced in another set. Usually there is a bigger set with all the elements, and a smaller one obtained from classification, cleaning, etc. The desired result is a set with the elements from the original set that are also present somehow in the smaller set (in the smaller set they may be downsampled or processed in some other way). Both sets should be of the same kind (micrographs, particles, volumes) or related (micrographs and CTFs for example).

trigger data (Xmipp3)

Waits until certain number of images is prepared and then send them to output. It can be done in 3 ways: - If "Send all items to output?" is _No_: Once the number of items is reached, a setOfImages is returned and the protocol finishes (ending the streaming from this point). - If "Send all items to output?" is _Yes_ and: - If "Split items to multiple sets?" is _Yes_: Multiple closed outputs will be returned as soon as the number of items is reached. - If "Split items to multiple sets?" is _No_: Only one output is returned and it is growing up in batches of a certain number of items (completely in streaming).

Available methods:

2D classification (Relion)

This protocol runs Relion 2D classification.

2D classification (Cryosparc2)

Wrapper to CryoSparc 2D clustering program. Classify particles into multiple 2D classes to facilitate stack cleaning and removal of junk particles. Also useful as a sanity check to investigate particle quality.

2D kmeans clustering (Xmipp3)

Classifies a set of particles using a clustering algorithm to subdivide the original dataset into a given number of classes.

ca pca (Spider)

Protocol for Correspondence Analysis (CA) or Principal Component Analysis (PCA). CA is the preferred method of finding inter-image variations. PCA computes the distance between data vectors with Euclidean distances, while CA uses Chi-squared distance. CA is superior because it ignores differences in exposure between images, eliminating the need to rescale between images. In contrast, PCA seems to be more robust: less likely to be trapped in an infinite loop of numerical inaccuracy. For more info see: [[http://spider.wadsworth.org/spider_doc/spider/docs/techs/classification/tutorial.html#CAPCA][SPIDER MDA documentation]]

cl2d (Xmipp3)

Classifies a set of images using a clustering algorithm to subdivide the original dataset into a given number of classes.

classify 2D (Cistem)

Protocol to run 2D classification in cisTEM.

classify diday (Spider)

This protocol wraps SPIDER CL CLA command. Performs automatic clustering using Diday's method and Hierarchical Ascendant Classification (HAC) using Ward's criterion on factors produced by CA or PCA.

classify kmeans (Spider)

This protocol wraps SPIDER CL KM command. Performs automatic K-Means clustering and classification on factors produced by CA or PCA.

classify ward (Spider)

This protocol wraps SPIDER CL HC command. Finds clusters of images/elements in factor space (or a selected subspace) by using Diday's method of moving centers, and applies hierarchical ascendant classification (HAC) (using Ward's method) to the resulting cluster centers.

eliminate empty classes (Xmipp3)

Takes a set of classes (or averages) and using statistical methods (variances of sub-parts of input image) eliminates those samples, where there is no object/particle (only noise is presented there). Threshold parameter can be used for fine-tuning the algorithm for type of data. Also discards classes with less population than a given percentage.

gl2d (Xmipp3)

2D alignment using Xmipp GPU Correlation algorithm.

gl2d streaming (Xmipp3)

2D alignment in full streaming using Xmipp GPU Correlation. The set of classes will be growing whilst new particle images are received.

kerdensom (Xmipp3)

Classifies a set of images using Kohonen's Self-Organizing Feature Maps (SOM) and Fuzzy c-means clustering technique (FCM) . The kerdenSOM algorithm anneals from an initial high regularization factor to a final lower one, in a user-defined number of steps. KerdenSOM is an excellent tool for classification, especially when using a large number of data and classes and when the transition between the classes is almost continuous, with no clear separation between them. The input images must be previously aligned.

ml2d (Xmipp3)

Perform (multi-reference) 2D-alignment using a maximum-likelihood ( *ML* ) target function. Initial references can be generated from random subsets of the experimental images or can be provided by the user (this can introduce bias). The output of the protocol consists of the refined 2D classes (weighted averages over all experimental images). The experimental images are not altered at all. Although the calculations can be rather time-consuming (especially for many, large experimental images and a large number of references we strongly recommend to let the calculations converge.

msa (Imagic)

This protocols wraps MSA-RUN program of IMAGIC. It calculates eigenimages (eigenvectors) and eigenvalues of a set of input aligned images using an iterative eigenvector algorithm optimized for (extremely) large data sets.

msa-classify (Imagic)

This protocols wraps MSA-CLASSIFY program of IMAGIC. It is based on variance-oriented hierarchical ascendant classification program (an enhanced Ward-type algorithm).

refine 2D (Eman2)

This protocol wraps *e2refine2d.py* EMAN2 program. This program is used to produce reference-free class averages from a population of mixed, unaligned particle images. These averages can be used to generate initial models or assess the structural variability of the data. They are not normally themselves used as part of the single particle reconstruction refinement process, which uses the raw particles in a reference-based classification approach. However, with a good structure, projections of the final 3-D model should be consistent with the results of this reference-free analysis. This program uses a fully automated iterative alignment/MSA approach. You should normally target a minimum of 10-20 particles per class-average, though more is fine. Default parameters should give a good start, but are likely not optimal for any given system. Note that it does have the --parallel option, but a few steps of the iterative process are not parallellised, so don't be surprised if multiple cores are not always active.

refine 2D bispec (Eman2)

This protocol wraps *e2refine2d_bispec.py* EMAN2 program. This program is used to produce reference-free class averages from a population of mixed, unaligned particle images. These averages can be used to generate initial models or assess the structural variability of the data. They are not normally themselves used as part of the single particle reconstruction refinement process, which uses the raw particles in a reference-based classification approach. However, with a good structure, projections of the final 3-D model should be consistent with the results of this reference-free analysis. This variant of the program uses rotational/translational invariants derived from the bispectrum of each particle.

Available methods:

align ap sr (Spider)

This protocol wraps SPIDER AP SR command. Reference-free alignment (both translational and rotational) of an image series. See detailed description at: [[http://spider.wadsworth.org/spider_doc/spider/docs/man/apsr.html][SPIDER's AP SR online manual]]

align pairwise (Spider)

This protocol wraps SPIDER AP SR command (pairwise alignment). Reference-free alignment (both translational and rotational) of an image series. This alignment scheme aligns a pair of images at a time and then averages them. Then, the averages of each of those pairs are aligned and averaged, and then pairs of those pairs, etc. Compared to [[http://spider.wadsworth.org/spider_doc/spider/docs/man/apsr.html][AP SR]], this alignment scheme appears to be less random, which chooses seed images as alignment references. For more information, see Step 2b at [[http://spider.wadsworth.org/spider_doc/spider/docs/techs/MSA/index.html#pairwise][SPIDER's MDA online manual]]

Available methods:

reconstruct (Eman2)

This protocol wraps *e2make3d.py* EMAN2 program. Reconstructs 3D volumes using a set of 2D images. Euler angles are extracted from the 2D image headers and symmetry is imposed. Several reconstruction methods are available. The fourier method is the default and recommended reconstructor.

reconstruct (Relion)

This protocol reconstructs a volume using Relion. Reconstruct a volume from a given set of particles. The alignment parameters will be converted to a Relion star file and used as direction projections to reconstruct.

reconstruct fourier (Spider)

This protocol wraps SPIDER BP 32F command. Simple reconstruction protocol using Fourier back projection. Mainly used for testing conversion of Euler angles.

reconstruct fourier (Xmipp3)

Reconstruct a volume using Xmipp_reconstruct_fourier from a given set of particles. The alignment parameters will be converted to a Xmipp xmd file and used as direction projections to reconstruct.

Reconstruct tomograms from prepare data prot (RelionTomo)

This protocol reconstructs a single tomogram using Relion. It is very useful to check if the protocol "Prepare data" has been applied correctly (in terms of flip options, for example).

tomo ctf reconstruction (NovaCtf)

Tomogram reconstruction with ctf correction procedure based on the novaCTF procedure. More info: https://github.com/turonova/novaCTF

tomo reconstruct (RelionTomo)

This protocol reconstructs a volume using Relion. Reconstruct a volume from a given set of particles. The alignment parameters will be converted to a Relion star file and used as direction projections to reconstruct.

tomo reconstruction (emantomo)

This protocol wraps *e2tomogram.py* EMAN2 program. Tomogram reconstruction from aligned tilt series. Tomograms are not normally reconstructed at full resolution, generally limited to 1k x 1k or 2k x 2k, but the tilt-series are aligned at full resolution. For high resolution subtomogram averaging, the raw tilt-series data is used, based on coordinates from particle picking in the downsampled tomograms. On a typical workstation reconstruction takes about 4-5 minutes per tomogram.

Available methods:

3D auto-refine (Relion)

Protocol to refine a 3D map using Relion.Relion employs an empirical Bayesian approach to refinementof (multiple) 3D reconstructionsor 2D class averages in electron cryo-microscopy (cryo-EM). Manyparameters of a statistical model are learned from the data,whichleads to objective and high-quality results.

3D homogeneous refinement(Legacy) (Cryosparc2)

Protocol to refine a 3D map using cryosparc. Rapidly refine a single homogeneous structure to high-resolution and validate using the gold-standard FSC.

3D multi-body (Relion)

Relion protocol for multi-body refinement. This approach models flexible complexes as a user-defined number of rigid bodies that move independently of each other. Using separate focused refinements with iteratively improved partial signal subtraction, improved reconstructions are generated for each of the defined bodies. Moreover, using PCA on the relative orientations of the bodies over all particle images in the data set, we generate movies that describe the most important motions in the data.

3D non-uniform refinement(Legacy) (Cryosparc2)

Apply non-uniform refinement to achieve higher resolution and map quality, especially for membrane proteins. Non-uniform refinement iteratively accounts for regions of a structure that have disordered or flexible density causing local loss of resolution. Accounting for these regions and dynamically estimating their locations can significantly improve resolution in other regions as well as overall map quality by impacting the alignment of particles and reducing the tendency for refinement algorithms to over-fit disordered regions.

3D subtomogram auto-refine (RelionTomo)

Protocol to refine a 3D map using Relion. Relion employs an empiricalBayesian approach to refinement of (multiple) 3D reconstructionsor 2D class averages in electron cryo-microscopy (cryo-EM). Manyparameters of a statistical model are learned from the data,whichleads to objective and high-quality results.

ctf refinement (Relion)

Wrapper protocol for the Relion's CTF refinement.

define subparticles (Localrec)

This class contains a re-implementation to a method for the localized three-dimensional reconstruction of such subunits. After determining the particle orientations, local areas corresponding to the subunits can be extracted and treated as single particles.

highres (Xmipp3)

This is a 3D refinement protocol whose main input is a volume and a set of particles. The set of particles has to be at full size (the finer sampling rate available), but the rest of inputs (reference volume and masks) can be at any downsampling factor. The protocol scales the input images and volumes to a reasonable size depending on the resolution of the previous iteration. The protocol works with any input volume, whichever its resolution, as long as it is a reasonable initial volume for the set of particles. The protocol does not resolve the heterogeneous problem (it assumes an homogeneous population), although it is somewhat tolerant through the use of particle weights in the reconstruction process. It is recommended to perform several global alignment iterations before entering into the local iterations. The switch from global to local should be performed when a substantial percentage of the particles do not move from one iteration to the next. The algorithm reports the cross correlation (global alignment) or cost (local) function per defocus group, so that we can see which was the percentile of each particle in its defocus group. You may want to perform iterations one by one, and remove from one iteration to the next, those particles that worse fit the model.

localdeblur sharpening (Xmipp3)

Given a resolution map the protocol calculate the sharpened map.

projection matching (Xmipp3)

3D reconstruction and classification using multireference projection matching

refine 3D (Spider)

Reference-based refinement using SPIDER AP SHC and AP REF commands. Iterative refinement improves the accuracy in the determination of orientations. This improvement is accomplished by successive use of more finely-sampled reference projections. Two different workflows are suggested: with defocus groups or without (gold-standard refinement). For more information, see: [[http://spider.wadsworth.org/spider_doc/spider/docs/techs/recon/mr.html][SPIDER documentation on projection-matching]]

refine easy (Eman2)

This protocol wraps *e2refine_easy.py* EMAN2 program.This is the primary single particle refinement program in EMAN2.1+.It replaces earlier programs such as e2refine.py and e2refine_evenodd.py.Major features of this program: * While a range of command-line options still exist. You should not normally specify more than a few basic requirements. The rest will be auto-selected for you. * This program will split your data in half and automatically refine the halves independently to produce a gold standard resolution curve for every step in the refinement. * An HTML report file will be generated as this program runs, telling you exactly what it decided to do and why, as well as giving information about runtime, etc while the job is still running. * The gold standard FSC also permits us to automatically filter the structure at each refinement step. The resolution you specify is a target, NOT the filter resolution.

subtomogram refinement (emantomo)

This protocol wraps *e2spt_refine.py* EMAN2 program. Protocol to performs a conventional iterative subtomogram averaging using the full set of particles. It will take a set of subtomograms (particles) and a subtomogram(reference, potentially coming from the initial model protocol) and 3D reconstruct a subtomogram. It also builds a set of subtomograms that contains the original particles plus the score, coverage and align matrix per subtomogram .

Available methods:

CTF 3D estimation (RelionTomo)

Generates the CTF star and MRC files needed by relion for the CTF3D.

ctf auto (Eman2)

This protocol wraps *e2ctf_auto.py* EMAN2 program. It automates the CTF fitting and structure factor generation process.

ctf consensus (Xmipp3)

Protocol to make a selection of meaningful CTFs in basis of the defocus values, the astigmatism, the resolution, other Xmipp parameters, and the agreement with a secondary CTF for the same set of micrographs.

ctf estimation (Xmipp3)

Protocol to estimate CTF on a set of micrographs using Xmipp.

ctf estimation (emantomo)

Protocol for CTF estimation from tilt series using e2spt_tomoctf.py

ctf estimation (gCTF)

Estimates CTF on a set of micrographs using Gctf. To find more information about Gctf go to: https://www2.mrc-lmb.cam.ac.uk/research/locally-developed-software/zhang-software/#gctf

CTF estimation (Imod)

CTF estimation of a set of input tilt-series using the IMOD procedure. More info: https://bio3d.colorado.edu/imod/doc/man/ctfplotter.html

ctffind4 (Grigoriefflab)

Estimates CTF on a set of micrographs using either ctffind3 or ctffind4 program. To find more information about ctffind4 go to: http://grigoriefflab.janelia.org/ctffind4

ctffind4 (Cistem)

Estimate CTF for a set of micrographs with ctffind4. To find more information about ctffind4 visit: https://grigoriefflab.umassmed.edu/ctffind4

ctf refinement (gCTF)

Refines local CTF of a set of particles using Gctf. To find more information about Gctf go to: https://www2.mrc-lmb.cam.ac.uk/research/locally-developed-software/zhang-software/#gctf

ctftilt (Grigoriefflab)

Estimates CTF on a set of tilted micrographs using ctftilt program.

defocus group (Xmipp3)

Given a set of CTFs group them by defocus value. The output is a metadata file containing a list of defocus values that delimite each defocus group.

estimate local defocus (Xmipp3)

Compares a set of particles with the corresponding projections of a reference volume. The set of particles must have a 3D angular assignment. This protocol refines the CTF, computing local defocus change. The maximun allowed defocus is a parameter introduced by the user (advanced). The protocol gives back the input set of particles with the refine local defocus and the defocus change with relation to the global defocus.

simulate ctf (Xmipp3)

Simulate the effect of the CTF (no amplitude decay). A random defocus is chosen between the lower and upper defocus for each projection.

tilt-series ctffind4 (Cistem)

CTF estimation on a set of tilt series using CTFFIND4.

tiltseries ctffind4 (Cistem)

CTF estimation on a set of tilt series using CTFFIND4.

tilt-series gctf (gCTF)

CTF estimation on a set of tilt series using GCTF.

tomo ctf defocus (NovaCtf)

Defocus estimation of each tilt-image procedure based on the novaCTF procedure. More info: https://github.com/turonova/novaCTF

Available methods:

3D initial model (Relion)

This protocols creates a 3D initial model using Relion. Generate a 3D initial model _de novo_ from 2D particles using Relion Stochastic Gradient Descent (SGD) algorithm.

initial model (Cryosparc2)

Generate a 3D initial model _de novo_ from 2D particles using CryoSparc Stochastic Gradient Descent (SGD) algorithm.

initial model (Eman2)

This protocol wraps *e2initialmodel.py* EMAN2 program. It will take a set of class-averages/projections and build a set of 3-D models suitable for use as initial models in single particle reconstruction. The output set is theoretically sorted in order of quality (best one is numbered 1), though it's best to look at the other answers as well. See more details in: http://blake.bcm.edu/emanwiki/EMAN2/Programs/e2initialmodel

initial model SGD (Eman2)

This protocol wraps *e2initialmodel_sgd.py* EMAN2 program. This program makes initial models using a (kind of) stochastic gradient descent approach. It is recommended that the box size of particles is around 100.

ransac (Xmipp3)

Computes an initial 3d model from a set of projections/classes using RANSAC algorithm. This method is based on an initial non-lineal dimensionality reduction approach which allows to select representative small sets of class average images capturing the most of the structural information of the particle under study. These reduced sets are then used to generate volumes from random orientation assignments. The best volume is determined from these guesses using a random sample consensus (RANSAC) approach.

reconstruct significant (Xmipp3)

This algorithm addresses the initial volume problem in SPA by setting it in a Weighted Least Squares framework and calculating the weights through a statistical approach based on the cumulative density function of different image similarity measures.

tomo initial model (emantomo)

This protocol wraps *e2spt_sgd.py* EMAN2 program. It will take a set of subtomograms (particles) and a subtomogram(reference) and build a subtomogram suitable for use as initial models in tomography. It also builds a set of subtomograms that contains the original particles plus the score, coverage and align matrix per subtomogram .

Available methods:

align tilt-series movies (Motioncorr)

This protocol wraps motioncor2 movie alignment program developed at UCSF. Motioncor2 performs anisotropic drift correction and dose weighting (written by Shawn Zheng @ David Agard lab)

FlexAlign (Xmipp3)

Wrapper protocol to Xmipp Movie Alignment by cross-correlation

motion correction (Relion)

Wrapper for the Relion's implementation of motioncor algorithm.

movie alignment (Motioncorr)

This protocol wraps motioncor2 movie alignment program developed at UCSF. Motioncor2 performs anisotropic drift correction and dose weighting (written by Shawn Zheng @ David Agard lab)

movie average (Xmipp3)

Protocol to average movies

movie maxshift (Xmipp3)

Protocol to make an automatic rejection of those movies whose frames move more than a given threshold. Rejection criteria: - *by frame*: Rejects movies with drifts between frames bigger than a certain maximum. - *by whole movie*: Rejects movies with a total travel bigger than a certain maximum. - *by frame and movie*: Rejects movies if both conditions above are met. - *by frame or movie*: Rejects movies if one of the conditions above are met.

optical alignment (Xmipp3)

Wrapper protocol to Xmipp Movie Alignment by Optical Flow

optical alignment (Xmipp3)

Wrapper protocol to Xmipp Movie Alignment by Optical Flow

summovie (Grigoriefflab)

Summovie generates frame sums that can be used in subsequent image processing steps and optionally applies an exposure-dependent filter to maximize the signal at all resolutions in the frame averages.

unblur (Cistem)

This protocol wraps unblur movie alignment program.

unblur (Grigoriefflab)

Unblur is used to align the frames of movies recorded on an electron microscope to reduce image blurring due to beam-induced motion.

Available methods:

blocres (BSOFT)

Bsoft program: blocres It calculates the local resolution map from to half maps. The method is based on a local measurement inside a mobile window.

estimate resolution (Fsc3d)

Protocol to calculate 3D FSC. 3D FSC is software tool for quantifying directional resolution using 3D Fourier shell correlation volumes. Find more information at https://github.com/nysbc/Anisotropy

local filter (Sidesplitter)

Protocol for mitigating local over-fitting by filtering. Find more information at https://github.com/StructuralBiology-ICLMedicine/SIDESPLITTER

local MonoRes (Xmipp3)

Given a map the protocol assigns local resolutions to each voxel of the map.

local resolution (Relion)

This protocol does local resolution estimation using Relion. This program basically performs a series of post-processing operations with a small soft, spherical mask that is moved over the entire map, while using phase-randomisation to estimate the convolution effects of that mask.

local resolution (Resmap)

ResMap is software tool for computing the local resolution of 3D density maps from electron cryo-microscopy (cryo-EM). Please find the manual at https://sourceforge.net/projects/resmap-latest

local sharpening (Locscale)

This protocol computes contrast-enhanced cryo-EM maps by local amplitude scaling using a reference model.

Available methods: