1 package jalview.datamodel;
\r
3 import jalview.analysis.*;
\r
4 import jalview.util.*;
\r
7 /** Data structure to hold and manipulate a multiple sequence alignment
\r
9 public class Alignment implements AlignmentI
\r
12 protected Vector sequences;
\r
13 protected Vector groups = new Vector();
\r
14 public Hashtable[] cons;
\r
15 protected char gapCharacter = '.';
\r
17 /** Make an alignment from an array of Sequences.
\r
21 public Alignment(SequenceI[] seqs) {
\r
22 sequences = new Vector();
\r
24 for (int i=0; i < seqs.length; i++)
\r
25 sequences.addElement(seqs[i]);
\r
27 SequenceGroup all = new SequenceGroup();
\r
28 all.setName("Group 1");
\r
29 groups.addElement(all);
\r
33 while (i < seqs.length) {
\r
34 addToGroup(all,seqs[i]);
\r
41 public Vector getSequences() {
\r
45 public SequenceI getSequenceAt(int i) {
\r
46 if (i < sequences.size()) {
\r
47 return (SequenceI)sequences.elementAt(i);
\r
53 /** Adds a sequence to the alignment. Recalculates maxLength and size.
\r
54 * Should put the new sequence in a sequence group!!!
\r
58 public void addSequence(SequenceI snew) {
\r
59 sequences.addElement(snew);
\r
61 ((SequenceGroup)groups.lastElement()).addSequence(snew);
\r
64 public void addSequence(SequenceI[] seq) {
\r
65 for (int i=0; i < seq.length; i++) {
\r
66 addSequence(seq[i]);
\r
70 /** Adds a sequence to the alignment. Recalculates maxLength and size.
\r
71 * Should put the new sequence in a sequence group!!!
\r
75 public void setSequenceAt(int i,SequenceI snew) {
\r
76 SequenceI oldseq = getSequenceAt(i);
\r
77 deleteSequence(oldseq);
\r
79 sequences.setElementAt(snew,i);
\r
81 ((SequenceGroup)groups.lastElement()).addSequence(snew);
\r
84 public Vector getGroups() {
\r
88 /** Sorts the sequences by sequence group size - largest to smallest.
\r
91 public void sortGroups() {
\r
92 float[] arr = new float [groups.size()];
\r
93 Object[] s = new Object[groups.size()];
\r
95 for (int i=0; i < groups.size(); i++) {
\r
96 arr[i] = ((SequenceGroup)groups.elementAt(i)).sequences.size();
\r
97 s[i] = groups.elementAt(i);
\r
100 QuickSort.sort(arr,s);
\r
102 Vector newg = new Vector(groups.size());
\r
104 for (int i=groups.size()-1; i >= 0; i--) {
\r
105 newg.addElement(s[i]);
\r
111 /** Takes out columns consisting entirely of gaps (-,.," ")
\r
113 public void removeGaps()
\r
117 int iSize = getWidth();
\r
118 for (int i=0; i < iSize; i++)
\r
120 boolean delete = true;
\r
121 for (int j=0; j < getHeight(); j++)
\r
123 current = getSequenceAt(j);
\r
124 if (current.getLength() > i)
\r
126 /* MC Should move this to a method somewhere */
\r
127 if (current.getCharAt(i)!='-' && current.getCharAt(i)!='.' && current.getCharAt(i)!=' ')
\r
135 deleteColumns(i,i);
\r
144 /** Returns an array of Sequences containing columns
\r
145 * start to end (inclusive) only.
\r
147 * @param start start column to fetch
\r
148 * @param end end column to fetch
\r
149 * @return Array of Sequences, ready to put into a new Alignment
\r
151 public SequenceI[] getColumns(int start, int end) {
\r
152 return getColumns(0,getHeight()-1,start,end);
\r
155 /** Removes a range of columns (start to end inclusive).
\r
157 * @param start Start column in the alignment
\r
158 * @param end End column in the alignment
\r
160 public void deleteColumns(int start, int end) {
\r
161 deleteColumns(0,getHeight()-1,start,end);
\r
164 public void deleteColumns(int seq1, int seq2, int start, int end) {
\r
166 for (int i=0; i <= (end-start); i++) {
\r
167 for (int j=seq1; j <= seq2; j++) {
\r
168 getSequenceAt(j).deleteCharAt(start);
\r
173 public void insertColumns(SequenceI[] seqs, int pos) {
\r
174 if (seqs.length == getHeight()) {
\r
175 for (int i=0; i < getHeight();i++) {
\r
176 String tmp = new String(getSequenceAt(i).getSequence());
\r
177 getSequenceAt(i).setSequence(tmp.substring(0,pos) + seqs[i].getSequence() + tmp.substring(pos));
\r
183 public SequenceI[] getColumns(int seq1, int seq2, int start, int end) {
\r
184 SequenceI[] seqs = new Sequence[(seq2-seq1)+1];
\r
185 for (int i=seq1; i<= seq2; i++ ) {
\r
186 seqs[i] = new Sequence(getSequenceAt(i).getName(),
\r
187 getSequenceAt(i).getSequence().substring(start,end),
\r
188 getSequenceAt(i).findPosition(start),
\r
189 getSequenceAt(i).findPosition(end));
\r
194 public void trimLeft(int i) {
\r
195 for (int j = 0;j< getHeight();j++) {
\r
197 SequenceI s = getSequenceAt(j);
\r
198 int newstart = s.findPosition(i);
\r
200 s.setStart(newstart);
\r
201 s.setSequence(s.getSequence().substring(i));
\r
206 public void trimRight(int i) {
\r
207 for (int j = 0;j< getHeight();j++) {
\r
208 SequenceI s = getSequenceAt(j);
\r
209 int newend = s.findPosition(i);
\r
212 s.setSequence(s.getSequence().substring(0,i+1));
\r
216 public void deleteSequence(SequenceI s)
\r
218 for (int i=0; i < getHeight(); i++)
\r
219 if (getSequenceAt(i) == s)
\r
223 public void deleteSequence(int i)
\r
225 sequences.removeElementAt(i);
\r
229 public Vector removeRedundancy(float threshold, Vector sel) {
\r
230 Vector del = new Vector();
\r
232 for (int i=1; i < sel.size(); i++) {
\r
233 for (int j = 0; j < i; j++) {
\r
234 // Only do the comparison if either have not been deleted
\r
235 if (!del.contains((SequenceI)sel.elementAt(i)) ||
\r
236 !del.contains((SequenceI)sel.elementAt(j))) {
\r
238 float pid = Comparison.compare((SequenceI)sel.elementAt(j),
\r
239 (SequenceI)sel.elementAt(i));
\r
241 if (pid >= threshold) {
\r
242 // Delete the shortest one
\r
243 if (((SequenceI)sel.elementAt(j)).getSequence().length() >
\r
244 ((SequenceI)sel.elementAt(i)).getSequence().length()) {
\r
245 del.addElement(sel.elementAt(i));
\r
246 System.out.println("Deleting sequence " + ((SequenceI)sel.elementAt(i)).getName());
\r
248 del.addElement(sel.elementAt(i));
\r
249 System.out.println("Deleting sequence " + ((SequenceI)sel.elementAt(i)).getName());
\r
256 // Now delete the sequences
\r
257 for (int i=0; i < del.size(); i++) {
\r
258 System.out.println("Deleting sequence " + ((SequenceI)del.elementAt(i)).getName());
\r
259 deleteSequence((SequenceI)del.elementAt(i));
\r
265 public void sortByPID(SequenceI s) {
\r
267 float scores[] = new float[getHeight()];
\r
268 SequenceI seqs[] = new SequenceI[getHeight()];
\r
270 for (int i = 0; i < getHeight(); i++) {
\r
271 scores[i] = Comparison.compare(getSequenceAt(i),s);
\r
272 seqs[i] = getSequenceAt(i);
\r
275 QuickSort.sort(scores,0,scores.length-1,seqs);
\r
279 if (getHeight()%2 == 0) {
\r
280 len = getHeight()/2;
\r
282 len = (getHeight()+1)/2;
\r
285 for (int i = 0; i < len; i++) {
\r
286 SequenceI tmp = seqs[i];
\r
287 sequences.setElementAt(seqs[getHeight()-i-1],i);
\r
288 sequences.setElementAt(tmp,getHeight()-i-1);
\r
292 public void sortByID() {
\r
293 String ids[] = new String[getHeight()];
\r
294 SequenceI seqs[] = new SequenceI[getHeight()];
\r
296 for (int i = 0; i < getHeight(); i++) {
\r
297 ids[i] = getSequenceAt(i).getName();
\r
298 seqs[i] = getSequenceAt(i);
\r
301 QuickSort.sort(ids,seqs);
\r
305 if (getHeight()%2 == 0) {
\r
306 len = getHeight()/2;
\r
308 len = (getHeight()+1)/2;
\r
309 System.out.println("Sort len is odd = " + len);
\r
311 for (int i = 0; i < len; i++) {
\r
312 System.out.println("Swapping " + seqs[i].getName() + " and " + seqs[getHeight()-i-1].getName());
\r
313 SequenceI tmp = seqs[i];
\r
314 sequences.setElementAt(seqs[getHeight()-i-1],i);
\r
315 sequences.setElementAt(tmp,getHeight()-i-1);
\r
320 public SequenceGroup findGroup(int i) {
\r
321 return findGroup(getSequenceAt(i));
\r
325 public SequenceGroup findGroup(SequenceI s) {
\r
326 for (int i = 0; i < this.groups.size();i++)
\r
328 SequenceGroup sg = (SequenceGroup)groups.elementAt(i);
\r
329 if (sg.sequences.contains(s))
\r
337 public void addToGroup(SequenceGroup g, SequenceI s) {
\r
338 if (!(g.sequences.contains(s))) {
\r
339 g.sequences.addElement(s);
\r
343 public void removeFromGroup(SequenceGroup g,SequenceI s) {
\r
344 if (g != null && g.sequences != null) {
\r
345 if (g.sequences.contains(s)) {
\r
346 g.sequences.removeElement(s);
\r
347 if (g.sequences.size() == 0) {
\r
348 groups.removeElement(g);
\r
355 public void addGroup(SequenceGroup sg) {
\r
356 groups.addElement(sg);
\r
360 public SequenceGroup addGroup() {
\r
361 SequenceGroup sg = new SequenceGroup();
\r
362 groups.addElement(sg);
\r
367 public void deleteGroup(SequenceGroup g) {
\r
368 if (groups.contains(g)) {
\r
369 groups.removeElement(g);
\r
374 public SequenceI findName(String name) {
\r
376 while (i < sequences.size()) {
\r
377 SequenceI s = getSequenceAt(i);
\r
378 if (s.getName().equals(name))
\r
387 public SequenceI findbyDisplayId(String name) {
\r
389 while (i < sequences.size()) {
\r
390 SequenceI s = getSequenceAt(i);
\r
391 if (s.getDisplayId().equals(name))
\r
400 public int findIndex(SequenceI s) {
\r
402 while (i < sequences.size()) {
\r
403 if (s == getSequenceAt(i)) {
\r
411 public int getHeight() {
\r
412 return sequences.size();
\r
416 public int getWidth()
\r
418 int maxLength = -1;
\r
419 for (int i = 0; i < sequences.size(); i++)
\r
421 if (getSequenceAt(i).getLength() > maxLength)
\r
422 maxLength = getSequenceAt(i).getLength();
\r
429 public int getMaxIdLength() {
\r
433 while (i < sequences.size()) {
\r
434 SequenceI seq = getSequenceAt(i);
\r
435 String tmp = seq.getName() + "/" + seq.getStart() + "-" + seq.getEnd();
\r
437 if (tmp.length() > max) {
\r
438 max = tmp.length();
\r
446 public void setGapCharacter(char gc)
\r
448 char old = getGapCharacter();
\r
450 for (int i=0; i < sequences.size(); i++)
\r
452 Sequence seq = (Sequence)sequences.elementAt(i);
\r
453 seq.sequence = seq.sequence.replace(old, gc);
\r
457 public char getGapCharacter() {
\r
458 return gapCharacter;
\r
461 public Vector getAAFrequency()
\r
463 return AAFrequency.calculate(sequences, 0, getWidth());
\r