Skip to main content

ClusCo: clustering and comparison of protein models



The development, optimization and validation of protein modeling methods require efficient tools for structural comparison. Frequently, a large number of models need to be compared with the target native structure. The main reason for the development of Clusco software was to create a high-throughput tool for all-versus-all comparison, because calculating similarity matrix is the one of the bottlenecks in the protein modeling pipeline.


Clusco is fast and easy-to-use software for high-throughput comparison of protein models with different similarity measures (cRMSD, dRMSD, GDT_TS, TM-Score, MaxSub, Contact Map Overlap) and clustering of the comparison results with standard methods: K-means Clustering or Hierarchical Agglomerative Clustering.


The application was highly optimized and written in C/C++, including the code for parallel execution on CPU and GPU, which resulted in a significant speedup over similar clustering and scoring computation programs.


The development, optimization and validation of protein modeling methods require efficient tools for structural comparison. Frequently, a large number of models need to be compared with the target native structure. There are numerous measures of model similarity. The most popular is the cRMSD - coordinate Root Mean-Square Deviation (after the best superimposition) [1]. The other popular scores are: GDT_TS - Global Distance Test Total Score [2], MaxSub - Maximal Substructure [3], TM-Score - Template-Modeling Score [4], or dRMSD - distance Root Mean-Square Deviation [5].

One of the methodologies most widely used for protein modeling includes performing the clustering step after generating a protein conformation ensemble [6-10] followed by the selection of a representative model (or models) for refinement. To achieve this, we need a similarity matrix of the whole ensemble, which contains all-versus-all comparison (for N conformers it gives N(N−1)/2 of score calculation). However, many available applications are not optimized for running time, because they were developed rather for simple pair comparison.

The main reason for the development of Clusco software was to create a high-throughput tool for all-versus-all comparison, because calculating similarity matrix is the one of the bottlenecks in the protein modeling pipeline.


The implementation of the similarity measures was performed using OpenMP API which supports multiprocessing programming. Additionally, the cRMSD algorithm was coded on the Graphic Processor Unit (GPU) architecture using nvidia cuda, which gave an over ten fold speedup in comparison with one CPU.

We used an open source parallel K-means [11] clustering code, implemented with OpenMP and serial C Clustering Library [12] for Hierarchical Agglomerative Clustering (single-linkage, maximum-linkage, average-linkage).


cRMSD Coordinates Root Mean-Square deviation is defined as:

cRMSD= 1 N i = 1 N x i A x i B 2

after the optimal superimposition. In this equation N is the number of atoms, x i A - i-th atom position vector of protein A. There is no need to superimpose structures (calculating rotation matrix) to obtain the cRMSD. By the diagonalization of the 3×3 covariance matrix M, we obtain the cRMSD value by [13]:

cRMSD= R A 2 + R B 2 2 ( λ 1 + λ 2 + S λ 3 )

where R A is the radius of gyration of protein A, S is the sign of the covariance matrix determinant, λ is the eigenvalue (sorted in descending order) of the square of the covariance matrix. These eigenvalues can be computed by finding roots of the cubic equation instead of computational demanding Singular Value Decomposition of the covariance matrix.

GDT_TS Global Distance Test Total Score is defined as:

GDT_TS = 1 4 max C 1 Å + max C 2 Å + max C 4 Å + max C 8 Å

where C is the number of atom pairs below the 1Å distance. Max denotes here the maximal value for a series of superimpositions.

The Global Distance Test algorithm is NP-hard [14], and all the GDT_TS computing algorithms use their own heuristics. Our GDT_TS algorithm is as follows: 1) divide the chain into all possible continuous 4,N/4,N/2,N fragments, and 2) use them as initial superimposition fragments (i.e. superimpose the whole structure by a rotation matrix computed by superimposing each fragment), 3) find atom pairs which are closer by cutoff (1,2,4,8[Å]), 4) select atoms which are closer than 3.5Å and use them for another superimposition until the number of selected atoms does not change in four iterations.

TM-Score, MaxSub (Template Modeling Score and Maximum Subset, respectively) [3, 4] - both scores are variations of Levitt and Gerstein (1998) score.

TM-Score is defined as:

TMScore=max 1 N i N 1 1 + d i d 0 2

where d 0 =1.24 N 15 3 1.8[Å], and MaxSub is defined as the TM-Score with d0=3.5Å. For the calculation of both scores we used the same searching algorithm as for GDT_TS, which means that the computational costs of GDT_TS, MaxSub, and the TM-Score will be the same.

dRMSD distance Root Mean-Square Deviation [5]. This score is the deviation of inter-molecular distance matrices:

dRMSD= 2 N ( N 1 ) i = 1 N 1 j = i + 1 N d ij A d ij B 2

where d ij A is the distance between i and j atoms of protein model A. Note that the representation of molecule as a distance matrix causes loss of information about chirality.

CMO Contact Map Overlap [15]. Using a representation of the protein structure as a binary matrix C, defined as:

C i , j = 1 if | x i x j | < cut-off 0 otherwise

we use Sørensen Similarity Index as a similarity score between the two proteins A, B:

S=100 2 n ( A B ) n ( A ) + n ( B )

where n(A) is the number of contacts in protein A.

Results and discussion

Using the cRMSD, dRMSD, MaxSub, GDT_TS, TM-Score, CMO as a similarity measure, Clusco can calculate all-versus-all (or with respect to the reference model) scores of proteins from a one-column list file or using multimodel pdb file. The calculated results may be used, for example, as a similarity matrix input for clustering algorithms or clustered by Clusco itself.

In this section we show the examples of usage and the performance of Clusco with respect to other similar programs. All tests were performed on a box with intel E5649 CPU (24 threads), nvidia GeForce GTX 470 GPU and 24GB of RAM. The computation time elapsed was assessed by the standard *NIX “time” program.

Selecting of pairs of models within a given cRMSD threshold

Recently, Fogolari and coworkers [16] described an algorithm for reducing the computational cost of all-versus-all comparison of protein models using cRMSD by inverse triangle inequality. As an example of that idea, the authors provided fsss software and 1ctf protein models from 4state_reduced decoy set (Decoys ’R’ Us) [17] as an input ensemble. The fsss software outputs pairs of models with cRMSD below a given threshold (3.2 Å in this example).

We compared fsss and Clusco based on this dataset, recording the time spent by one CPU performing the task. Note that Clusco computes all-versus-all scores by default, and to get results similar to the ones obtained from fsss (only pairs below given threshold) we needed to filter the output by awk (standard *NIX program): clusco -l 4state_reduced_1ctf.list -s rmsd -o 4state . tmp; awk ‘{if($3<3.2) print $line}' 4state.tmp > output.rmsd.

fsss software spent 149.14 seconds on this task, and Clusco+awk spent 0.46 (Clusco) + 0.11 (awk) seconds, which amounts to 261× speedup. Note that it is possible to improve these results, using parallel execution of Clusco (by simply defining shell variable OMP_NUM_THREADS before Clusco execution).

Clustering of protein decoys from five independent molecular dynamics trajectories

The decoy set vhp_mcmd [18] from Decoys ’R’ Us database contains the results of five (NATIVE, F1, F3, F4, F7) Molecular Dynamics simulations of the thermostable subdomain from chicken villin headpiece (36 residues, pdb code: 1vii), starting from different protein conformations. The set contains 6256 of villin conformations in total, in the range of 0.49 - 12.8 Å cRMSD to the experimental structure deposited in the Protein DataBank.

Using cRMSD and each of the Clusco clustering schemes, it is possible to separate this decoy set roughly into former trajectories, as we show in Additional file 1: Table S1. Each of the Hierarchical Agglomerative methods divides decoys into rather separate clusters i.e. more than 85% of trajectory models create a separated cluster, while of “NATIVE” and “F1” models create one common cluster (which is the result of “F1” convergence to the native structure during simulation - we refer the interested readers to Figure two in [18]). Other clustering scheme in K-means results in the grouping of “NATIVE” and “F1” models into four separated clusters.

Command to perform clustering described above: clusco -l vhp_mcmd . list -s rmsd <0 , 1 , 2 , 3> 8.

The running time for this dataset varied from 5 seconds (for K-means clustering and GPU cRMSD comparison), to 3.5 minutes (for average-linkage, Hierarchical Agglomerative Clustering and CPU cRMSD comparison, see Additional file 1: Table S1.

Selecting representative model from de-novo modeling decoy set

Clustering of protein models after de-novo simulations is one the methods most commonly used for the selection of the representative model from the decoys set [6-10]. We compared Clusco with other clustering software (durandal[19], calibur[20], spicker[21]) in terms of results and computation time. To do this, we used public available I-Tasser [22] decoys set, containing 12500-32000 models for each of 56 modelled target protein.

calibur uses preprocessing of decoy set in three ways: screening-out unlikely candidates by setting lower and upper cRMSD bounds, using triangular inequality for assessing if particular model is within the threshold distance from a group of models (which reduces the number of structure comparisons), detecting and ignoring outlier decoys. durandal uses triangular inequality (like calibur) for the approximation of cRMSD value of randomly chosen decoy and fill-up distance matrix until it contains proper amount of information for the next, clustering step. spicker selects the decoy with the largest number of structurally similar decoys (by automatically detected threshold value) and creates the first cluster. The process is repeated to get a sufficient number of clusters.

Clusco was run with cRMSD as a similarity measure (just as durandal, calibur and spicker) and K-means as a clustering method. We set number of clusters to 20: clusco -l list -s rmsd 0 20.

The Clusco representative model was selected by min(<R>/f), where f denoted the fraction of elements in particular cluster and <R> - the average cRMSD between cluster elements.

For the comparison of software reliability, we calculated tm-score to the experimental structure (Additional file 1: Table S2) and Z-score of the tm-score (where Z-score <0 means that a model is worse than the average structure of the decoy set, for detailed results see Additional file 1: Table S3).

According to the average tm-score, all of the programs gave similar results: all, except durandal, gave the average tm-score 0.59, and durandal gave the score of 0.58. According to Z-score, the best algorithms were calibur and Clusco (49/56 of the models with Z-Score above zero), followed by spicker and durandal (45/56 and 41/56 respectively).

We recorded the execution time of each algorithm: durandal was the fastest (spending 140 minutes on the clustering of the whole dataset), then Clusco on one CPU (426 min), spicker (435 min) and calibur (856 min). If we allow for the possibility of parallel execution on GPU/CPU - Clusco finished calculations in 131 min on 4 CPU’s, in 106 min on 4 CPU’s and 1 GPU and in 47 min on 23 CPU’s. We summarized these results in Table 1.

Table 1 Total time for clustering of decoys

Analyzing the above results, we can conclude that Clusco gives results which are as good as the ones provided by the state-of-the-art calibur in half of the time, however, on the commonly used today multicore machines, our program gives results in the time about 18× shorter than calibur.

Comparison of structures with reference/experimental model

To compute the score between multi-model pdb file (tra.pdb) and the reference structure (ref.pdb), one should run Clusco in the following way:

This command will compute the tm-score for each of tra.pdb models, saving the results into output.txt. If OMP_NUM_THREADS variable was not set, program will utilize all available CPU’s.

We recorded the computation time of the tm-score to the reference (experimental) structure with Clusco and the original TM-Score software [4] using the decoy set mentioned in the previous paragraph. TM-Score performed the task in 68 minutes, Clusco on 1 CPU - in 53 minutes (speedup of about 1.2×), but when we ran Clusco on 12 CPU’s, it completed the task in 7 minutes (speedup about 10×) (detailed data in Additional file 1: Table S4).

It must be noted that the computation time for GDT_TS and MaxSub will be mostly identical, since all of these algorithms use the same method for selecting fragments of structure. Optionally, it is possible to compute more exact GDT_TS score with Clusco by using -s gdtExt flag - in this particular case Clusco will split structures into many more fragments.

For the comparison of cRMSD computation time, we used the qcprot algorithm [23] claimed by the authors to be probably the fastest available today. Recorded times were only for the cRMSD routine (without I/O time). In this comparison test, we got slightly better results than the qcprot: the speedup of 1.1−1.2× for Clusco on one CPU and the speedup of 12.7−16.1× on one GPU. See Figure 1 for details.

Figure 1
figure 1

Comparison of running time of all-versus-all Clusco and qcprot. cRMSD computation for three proteins of different length (71, 215 and 887 residues). For N models it compute N(N−1)/2 cRMSD values.

Recently Hung & Samudrala [24] published an algorithm for the computation of all-versus-all tm-score on amd GPU and CPU. We compared Clusco with this algorithm using the exemplary data attached to the program package (1000 models of 140 residues). Clusco on one CPU completed the computation in 53.65 minutes, Hung & Samudrala code - in 57.18 minutes, but Clusco can achieve pronounced speedup if executed in multi-CPU fashion (13.66 minutes on 4 CPU’s), which was not implemented in the Hung & Samudrala algorithm (see Figure S1 in Additional file 1 for tm-score values comparison). However, users with access to the amd GPU can complete this task significantly faster with Hung & Samudrala algorithm.


We presented here versatile software for comparison and clustering of protein structures, optimized for novel multicore computers. We showed cuda implementation of cRMSD algorithm which may be usable for creating of proteins similarity matrices (a bottleneck of the clustering software) as an input for more efficient clustering algorithms.

However, up till now, not many computers are equipped with graphics cards capable of floating point computation, but most of them are equipped with multicore processors. Our software accounts for this situation by containing a parallel code for all described here comparison methods. It results in great-to-moderate speedup over an existing serial execution algorithms, together with clustering results as good as obtained using the state-of-the-art method, calibur.

Clusco is able to cluster small-to-moderate protein decoys with scoring functions other than the cRMSD, i.e. the TM-Score, dRMSD, GDT_TS, MaxSub, Contact Map Overlap, especially on many-core machines, which is unique.

Clusco may be useful for protein modeling community as an all-in-one, fast and easy in use software for daily lab work. It may be used as a standalone program for comparison or clustering of protein models or as a preprocessing tool for clustering algorithms, either as a compiled program or a fragment of Clusco’s source code.

Availability and requirements

Project name: ClusCoProject home page: system: gnu/Linux Programming language: c/c++, cuda Other requirements: OpenMP library (included in gcc 4.2 compiler), optionally: cuda sdk and cuda compatible graphic cardLicense: gnu gpl (scoring functions), Python License (Hierarchical Clustering library), custom license for K-means library (included in package)


  1. Kabsch W: A solution for the best rotation to relate two sets of vectors. Acta Crystallogr 1976, 32: 922-923. 10.1107/S0567739476001873

    Article  Google Scholar 

  2. Zemla A: LGA: a method for finding 3D similarities in protein structures. Nucleic Acids Res 2003,31(13):3370-3374. 10.1093/nar/gkg571

    Article  PubMed Central  CAS  PubMed  Google Scholar 

  3. Siew N, Elofsson A, Rychlewski L, Fischer D: MaxSub: an automated measure for the assessment of protein structure prediction quality. Bioinformatics 2000,16(9):776-785. 10.1093/bioinformatics/16.9.776

    Article  CAS  PubMed  Google Scholar 

  4. Zhang Y, Skolnick J: Scoring function for automated assessment of protein structure template quality. Proteins 2004,57(4):702-710. 10.1002/prot.20264

    Article  CAS  PubMed  Google Scholar 

  5. Torda AE, van Gunsteren WF: Algorithms for clustering molecular dynamics configurations. J Comput Chem 1994,15(12):1331-1340. 10.1002/jcc.540151203

    Article  CAS  Google Scholar 

  6. Shortle D, Simons KT, Baker D: Clustering of low-energy conformations near the native structures of small proteins. P Natl Acad Sci USA 1998,95(19):11158-11162. 10.1073/pnas.95.19.11158

    Article  CAS  Google Scholar 

  7. Kolinski A: Protein modeling and structure prediction with a reduced representation. Acta Biochim Pol 2004,51(2):349-371.

    CAS  PubMed  Google Scholar 

  8. Roy A, Kucukural A, Zhang Y: I-TASSER: a unified platform for automated protein structure and function prediction. Nat Protoc 2010,5(4):725-738. 10.1038/nprot.2010.5

    Article  PubMed Central  CAS  PubMed  Google Scholar 

  9. Xu D, Zhang Y: Ab initio protein structure assembly using continuous structure fragments and optimized knowledge-based force field. Proteins 2012,80(7):1715-1735.

    PubMed Central  CAS  PubMed  Google Scholar 

  10. Rohl CA, Strauss CEM, Misura KMS, Baker D: Protein structure prediction using Rosetta. Methods Enzymol 2004, 383: 66-93.

    Article  CAS  PubMed  Google Scholar 

  11. MacQueen JB: Some methods for classification and analysis of multiVariate observations. In Proc. of the fifth Berkeley Symposium on Mathematical Statistics and Probability, Volume 1. Edited by: Cam LML, Neyman J.. Berkeley: University of California Press; 1967:281-297.

    Google Scholar 

  12. de Hoon MJL, Imoto S, Nolan J, Miyano S: Open source clustering software. Bioinformatics 2004,20(9):1453-1454. 10.1093/bioinformatics/bth078

    Article  CAS  PubMed  Google Scholar 

  13. Brüschweiler R: Efficient RMSD measures for the comparison of two molecular ensembles. Root-mean-square deviation. Proteins 2003, 50: 26-34.

    Article  PubMed  Google Scholar 

  14. Li SC, Bu D, Xu J, Li M: Finding nearly optimal GDT scores. J Comput Biol 2011,18(5):693-704. 10.1089/cmb.2010.0123

    Article  PubMed Central  CAS  PubMed  Google Scholar 

  15. Fraser R, Glasgow J: A demonstration of clustering in protein contact maps for alpha helix pairs. In Proceedings of the 8th international conference on Adaptive and Natural Computing Algorithms, Part I, Volume 4431. Berlin, Heidelberg: Springer-Verlag; 2007:758-766.

    Google Scholar 

  16. Fogolari F, Corazza A, Viglino P, Esposito G: Fast structure similarity searches among protein models: efficient clustering of protein fragments. Algorithms Mol Biol 2012, 7: 16. 10.1186/1748-7188-7-16

    Article  PubMed Central  CAS  PubMed  Google Scholar 

  17. Samudrala R, Levitt M: Decoys ‘R’ Us: a database of incorrect conformations to improve protein structure prediction. Protein Sci 2000,9(7):1399-1401. 10.1110/ps.9.7.1399

    Article  PubMed Central  CAS  PubMed  Google Scholar 

  18. Fogolari F, Tosatto SCE, Colombo G: A decoy set for the thermostable subdomain from chicken villin headpiece, comparison of different free energy estimators. BMC Bioinformatics 2005, 6: 301. 10.1186/1471-2105-6-301

    Article  PubMed Central  PubMed  Google Scholar 

  19. Berenger F, Shrestha R, Zhou Y, Simoncini D, Zhang KYJ: Durandal: fast exact clustering of protein decoys. J Comput Chem 2012,33(4):471-474. 10.1002/jcc.21988

    Article  CAS  PubMed  Google Scholar 

  20. Li SC, Ng YK: Calibur: a tool for clustering large numbers of protein decoys. BMC Bioinformatics 2010, 11: 25. 10.1186/1471-2105-11-25

    Article  PubMed Central  PubMed  Google Scholar 

  21. Zhang Y, Skolnick J: SPICKER: a clustering approach to identify near-native protein folds. J Comput Chem 2004,25(6):865-871. 10.1002/jcc.20011

    Article  CAS  PubMed  Google Scholar 

  22. Wu S, Skolnick J, Zhang Y: Ab initio modeling of small proteins by iterative TASSER simulations. BMC Biol 2007, 5: 17. 10.1186/1741-7007-5-17

    Article  PubMed Central  PubMed  Google Scholar 

  23. Theobald DL: Rapid calculation of RMSDs using a quaternion-based characteristic polynomial. Acta Crystallogr A 2005,61(Pt 4):478-80.

    Article  PubMed  Google Scholar 

  24. Hung LH, Samudrala R: Accelerated protein structure comparison using TM-score-GPU. Bioinformatics 2012,28(16):2191-2192. 10.1093/bioinformatics/bts345

    Article  PubMed Central  CAS  PubMed  Google Scholar 

Download references


We would like to thank Dr Sebastian Kmiecik for reading the manuscript.

MJ acknowledge the support from a Project operated within the Foundation for Polish Science MPD Programme, co-financed by the EU European Regional Development Fund.

AK acknowledge support from the Foundation for Polish Science TEAM project (TEAM/2011-7/6) co-financed by the European Regional Development Fund operated within the Innovative Economy Operational Program.

Author information

Authors and Affiliations


Corresponding author

Correspondence to Andrzej Kolinski.

Additional information

Competing interests

The authors declare that they have no competing interests.

Authors’ contributions

MJ wrote algorithms, manual and manuscript. AK corrected the manuscript. Both authors read and approved the final manuscript.

Electronic supplementary material

Authors’ original submitted files for images

Below are the links to the authors’ original submitted files for images.

Authors’ original file for figure 1

Rights and permissions

This article is published under license to BioMed Central Ltd. This is an Open Access article distributed under the terms of the Creative Commons Attribution License (, which permits unrestricted use, distribution, and reproduction in any medium, provided the original work is properly cited.

Reprints and permissions

About this article

Cite this article

Jamroz, M., Kolinski, A. ClusCo: clustering and comparison of protein models. BMC Bioinformatics 14, 62 (2013).

Download citation

  • Received:

  • Accepted:

  • Published:

  • DOI: