Alignmentscore

Entwicklungstagebuch:

1. Woche (3.5. - 9.5.17):

  1. Treffen am 03.05.:
    Julian und Leonie bilden das Team Score
Ideen zur Implementation:
  • Das Puzzle ist ein globales Alignment: Der Needleman-Wunsch-Algorithmus bietet sich an, da er den optimalen Score berechnet.

2. Woche (10.05. - 16.05.17):

Besprechung beim 2.Treffen am 10.05.:
  • Implementationsideen:

    Als Scoring-Algorithmus wird der dynamische Needleman-Wunsch Programmieralgorithmus verwendet, der eine optimale Lösung des globalen Alignmentproblems bietet. Bei der Implentation muss eine übersichtliche Schnittstelle zum Benutzen der Berechnungsmethoden geschaffen werden, damit die anderen Gruppen wissen, wie sie den Programmcode verwenden können und dies möglichst sicher möglich ist.

    • Anforderungen an Team Webseite: HTML-Elemente auf Webseite bereitstellen, in denen die berechneten Scores eingetragen werden können. Möglich ist das über bestimmte HTML-Tag ids.
    • Absprache mit Team Puzzle: Es muss abgesprochen werden, was die Ein-/Ausgaben in die Methoden zur Berechnung des Scores sein werden.
  • Wichtige Entscheidung:

    Die Festlegung auf die Methoden, die bei einer bestimmten Veränderung des Spielfeldes aufgerufen werden soll.

  • Primärziele:

    Zunächst nur den besten und aktuellen Score für zwei Sequenzen berechnen können. Berechnen des MSA-Scores wird hinten angestellt.

3. Woche (17.05. - 23.05.17):

Besprechung beim 3.Treffen am 17.05:
  • Ein wichtiger Meilensteil bei der Score-Berechnung kann vorgestellt werden:
    Needleman-Wunsch ist implementiert und kann optimale Scores für zwei Sequenzen berechnen.
  • Essen der Woche: Party-Brötchen
Neue Zielsetzung:
  • Implementieren der Methode zur Berechnung des aktuellen Scores
  • MSA-Score Berechnung
  • Refractoring der Berechnungsfunktionen zur Klasse, um Bedienbarkeit und Kapselung zu verbessern
  • Prototyp der kompletten Seite mit funktionierendem Spiel für zwei Sequenzen

4. Woche (24.05. - 30.05.17):

Das Treffen am 24.05 wird verschoben aufgrund einer Klausur.

  1. Treffen am 29.05.:
    • Durch Zusammenfügen des Programmcodes aller Gruppen entsteht der erste Prototyp. Das Spiel ist in die Webseite der Gruppe von Pepi und Mario eingebunden und es kann sowohl der beste Score für zwei, als auch der aktuelle Score für beliebig viele Sequenzen berechnet werden.
Neue Zielsetzung:
  • Es soll später möglich sein, nach dem erfolgreichen Beenden eines Levels die Berechnungsparameter umstellen und anschließend weiterspielen zu können. So ergeben sich neue beste Alignments, die der/die Spielende herausfinden kann und für diese ein besseres Verständnis der Berechnung entsteht.
  • MSA-Score anzeigen können. Die Idee zum umsetzen des Problems ist, den Score für alle Spielfelder vorzuberechnen und lediglich anzuzeigen. Zum Speichern der vorberechneten Werte wird eine JSON-Datei angelegt, die für alle Spielfelder den Score beinhaltet
Implementation:
  • Idee des Speicherns von Sequenzen verworfen; es müssten zu viele Werte für ein Spielfeld gespeichert werden, um das Verändern der Parameter nach dem Spiel zu erlauben. Stattdessen wird der bisher für für zwei Sequenzen verwendete Needleman-Wunsch Algorithmus für multiple Sequenzalinierungen erweitert.

5. und 6. Woche (Ferien)(31.05. - 13.06.17):

Kein Treffen wegen der freien Tage.

Neue Ideen / Anforderungen:
  • MSA Berechnung:
    Für bis zu 10 Sequenzen der Länge 15 sollte der Score berechenbar sein. Dafür falls nötig auf Heuristiken zurückgreifen.
Implementation:
  • Heuristiken zeigen große Abweichung vom besten Score (nach Needleman-Wunsch)
  • Dynamischer Programmieralgorithmus wird implementiert
Wichtiger Meilenstein:
  • Bester Score für MSAs kann berechnet werden! Performance stellt noch ein großes Problem dar: Es kann bis zu einer halben Minute dauern für mehr als 4 Sequenzen den besten Score zu berechnen.

7. und 8. Woche (14.06. - 27.06.17):

Erfolge:
  • Optimierung der Berechnung des besten Scores führt zu einigen Sekunden Verbesserung der Performance
Zwischenpräsentation Vorbereitungen:
  • Bisheriger Fortschritt, Entwicklungsprozess und der aktuelle Stand des Score-Teams soll zusammengefasst werden und als Teil einer Präsentation vor Professor Kay Nieselt vorgetragen werden.
  • Probevortrag ist für den 04.07. angesetzt

9. Woche (28.06. - 04.07.17):

Präsentation am 05.07.

Neue Ideen:
  • MSA-Berechnen
    Es soll die Clustalo API benutzt werden um Alignments von mehr als 4 Sequenzen zu berechnen. Anhand des Alignments wird ein „Ziel“-Score (der nicht optimal ist) anhand der currentScore() Methode berechnet und als „best score“ angezeigt
Implementation:
  • Clustalo API wird erfolgreich verwendet für alle „großen“ Level von mehr als 4 Sequenzen. Akzeptabler Zwischenstand, Clustalo API Requests dauern aber immer noch mehrere Sekunden.
  • Die Berechnungszeit des Scores für 4 oder weniger Sequenzen konnte erfolgreich auf unter zwei Sekunden optimiert werden.

ab der 10. Woche (5.7. bis 31.08.17):

Neue Ideen:
  • Es sollen alle Scores optimal vorberechnet und zu diesem Zweck erneut eine JSON Datei angelegt werden. Um die Bedienbarkeit aufrecht zu erhalten wird es Skripte zum interagieren mit der JSON Datei, sowie zum Eintragen neuer Level und Sequenzen geben.
  • Es soll mit „echten“ Sequenzen gespielt werden. Zu diesem Zweck werden Gene gesucht, aus denen dann 15 Basen lange Sequenzen für das Spiel kopiert werden. BONUS-Idee: Es sollen kleine Texte erstellt werden, die die Funktion des Gens erklären. Zudem sollen die Level so gewählt werden, dass eine Sequenz entweder gegen eine verwandte Sequenz eines anderen Organismus oder eine mutierte (kranke/onkogene) Variante des Gens aligniert wird. Intention: Interesse wecken und einzelne tiefe, aber nicht überfordernde Einblick geben.

Der Alignment-Score:

Die Berechnung des Alignmentscores (oder auch nur Score) erfolgt im Hintergrund und nur das Ergebnis (im Falle des Alignmentpuzzles unserer Webseite der aktuelle und beste Score) ist für den Spieler sichtbar. Dennoch ist er essenziell und ohne ihn wäre das Spiel nicht funktionstüchtig. Im Folgenden soll der Score, dessen Berechnung und unsere Implementation näher erläutert werden.

Definition: Score

Die Güte eines Alignments wird mit dem Alignmentscore (englisch für Punktzahl) beschrieben, dem ein spezielles Bewertungsschema zugrunde liegt, das von den drei Parametern „Mismatch Score“, „Match Score“ und „Gap Penalty“ abhängt. Jede Spalte des Alignments wird nach diesen Parametern beurteilt und der entsprechende Wert ermittelt. Die Summe der Wertungen jeder Spalte ergibt schlussendlich den gesamten Score.

Bemerkung

Der Sum-of-Pairs-Score (SoP-Score) stellt eine Möglichkeit dar, ein Alignment zu evaluieren. Er repräsentiert die Summe der Bewertungen aller Spalten in einem Alignment, wobei jede Kombination von Paarungen in einer Spalte betrachtet wird. Die Bewertung einer Basenpaarung hängt dabei von den oben erwähnten Parametern Match Score, Mismatch Score und Gap Penalty ab.

Beispiel zur Sum-Of-Pairs-Score Berechnung::

Match: +2, Mismatch: -1, Gap: -2

Sequenz 1: A T G T
Sequenz 2: G G G T
Sequenz 3: G G T
Spalten-Scores: -5 0 6 6

Für die erste Spalte berechnet sich der Score wie folgt:

S(A,G)+S(A,-)+S(G,-)= -1 -2-2 =-5

Die Berechnung der anderen Spalten erfolgt analog.

Aus allen Spalten ergibt sich dann der insgesamte SoP-Score von:

SoP-Score = (-5) + 0 + 6 + 6 = 7

Das Ziel in der Berechnung besteht maßgeblich in der Suche nach dem optimalen Score - also der maximalen Punktzahl, die erreicht werden kann. Es handelt sich dann um ein optimales Alignment und nur auf dessen Basis ist das Ergebnis relevant. Für das Ermitteln des bestmöglichen Scores gibt es verschiedene Ansätze, wichtig ist dabei vor allem eine schnelle und zuverlässige Berechnung.

Berechnung des Scores nach Needleman-Wunsch

Wie oben bereits erwähnt erfolgt die Berechnung des Scores anhand den Parametern Mismatch Score, Match Score und Gap Penalty. Der Score hängt dabei hauptsächlich von den jeweiligen Werten dieser Parameter ab; auch kann ein Variieren dieser Werte ein völlig anderes optimales Alignment bedeuten. Obwohl meist das Ziel verfolgt wird, so viele gleiche Basen wie möglich anzuordnen, um einen besonders hohen Score zu erreichen, ist es in manchen Situationen von Vorteil, eine Base mit einer Gap zu alignieren, um den bestmöglichen Score zu erzielen.

Für globale (und auch lokale) Alignments gibt es mehrere Berechnungsmöglichkeiten, die in ihrer Leistung und Korrektheit variieren können. Ein Algorithmus, der die möglichen optimalen Alignments der gegebenen Sequenzen kalkuliert, ist Needleman-Wunsch. Bei diesem handelt es sich um ein dynamisches Programmierverfahren (engl.: dynamic programming algorithm), das definitiv die möglichen optimalen Alignments liefert. Dazu zerlegt der Algorithmus das Hauptproblem - also das Erreichen des bestmöglichen Scores - in kleinere Probleme - das Berechnen des bestmöglichen Scores von Teilsequenzen. Aus diesen baut die Berechnungsmethode schließlich den optimalen Score für die gesamte Sequenz auf. Needleman-Wunsch basiert für 2 Sequenzen X und Y der Länge n und m auf der Formel

Formel von Needleman-Wunsch

wobei i der Index von X und j der Index von Y ist.

Bemerkung

Die beiden Sequenzen werden in eine n x m-Matrix eingetragen - eine Sequenz horizontal, die andere vertikal.

Ein kleines Beispiel, um das Prinzip zu veranschaulichen:

Sequenz A: AGTT
Sequenz B: CGT
  A G T T
C        
G        
T        

Mithilfe der Formel wird dann die Matrix befüllt, indem auf jedes einzelne Feld der Matrix der Algorithmus angewendet wird. Aus dieser Matrix lässt sich zum Schluss dann das optimale Alignment und dessen Score ermitteln.

Die einzelnen Zeilen der Formel repräsentieren die Nachbarn des zu berechnenden Felds und eine darauf angewendete Bewertung:

F(i-1,j-1) steht dabei für das diagonal gelegene Feld, wobei für s(x_i,y_j) der SoP-Score (siehe Definition: Score für eine genaue Erklärung) auf die entsprechenden Symbole angewendet wird.

F(i-1,j) repräsentiert den Nachbarn ein Feld weiter oben, während F(i,j-1) den Nachbarn ein Feld links bezeichnet. Bei beiden wird zusätzlich auf den Wert des Feldes noch der Score für eine Gap Penalty berechnet.

Der optimale Score des gesamten Alignments ist dann im letzten Eintrag F(n,m) gespeichert.

Während dieses Bewertungsschema für zwei zu vergleichende Sequenzen noch relativ übersichtlich ist, nimmt es bei wachsender Anzahl von Sequenzen, Multiple Sequence Alignment (kurz: MSA) genannt, rasant an Komplexität zu. Die Anzahl an Feldnachbarn wächst, wodurch mehr Abfragen in der Formel benötigt werden, die sämtliche Kombinationen abdecken. Die Anzahl dieser Einträge kann mithilfe

Formel zur Berechnung der Anzahl an Nachbarn

für n Sequenzen berechnet werden; i ist die Menge an Gaps. Anhand dessen wird jedoch deutlich, dass die Menge der angrenzenden Felder schnell in den mehrstelligen Bereich aufsteigt und somit einen massiven Rechenaufwand garantiert, was sich früher oder später in der Laufzeit des Programms manifestiert.

Heuristiken

Als Heuristik bezeichnet man in der Informatik ein bestimmtes Vorgehen zum Lösen eines Problems. Im Gegensatz zu der Alternative Needleman-Wunsch arbeiten Heuristiken wesentlich schneller und verbrauchen deutlich weniger Speicherplatz. Jedoch garantieren sie nicht ein optimales Alignment zu finden, was einen Nachteil darstellt. Dennoch liefern Heuristiken in den meisten Fälle optimale oder zumindest sehr gute Ergebnisse. Für Problemstellungen der Bioinformatik kommen Heuristiken sehr häufig zum Einsatz, um Lösungen zu approximieren, die sonst nur in sehr langer Rechenzeit bestimmt werden können. Ein sehr prominentes Beispiel für den Einsatz von Heuristiken ist der BLAST Algorithmus , der den Smith-Waterman Algorithmus für lokale Alignments approximiert. Mit Hilfe von BLAST können bei jeder Suche zehntausende von Sequenzen in den Datenbanken des NCBI (meist) innerhalb von Sekunden aligniert werden.

Implementation

Das Anzeigen der Scores basiert auf der Datei Sequences.json, die alle Level des Spiels mit zugehörigen Beschreibungen und Alignmentscores enthält. Es existieren JavaScript-Funktionen zum Erstellen eines Levels, oder die Rückgabe des besten Alignmentscores für ein Level, die die direkte Interaktion mit der JSON-Datei verbergen. Zum Anzeigen des aktuellen Scores muss nicht mit der JSON-Datei interagiert, sondern der Sum-of-Pairs-Score des aktuell auf dem Spielfeld sichtbaren Alignments berechnet werden. Es bleibt der komplexeste Teil zu erwähnen: Die eigentliche Berechnung der Alignmentscores der ausgewählten Sequenzen und das Füllen der JSON-Datei, sodass die JavaScript Funktionen im Browser aus ihr lesen können. Die Berechnung findet in Python statt.

Abrufen der gespeicherten Level

Ein selbst gestelltes Ziel bei der Umsetzung des Alignmentpuzzles ist immer das Verwenden von Sequenzen aus echten Genen gewesen. Um dies zu verwirklichen muss eine Möglichkeit bestehen, die ausgewählten Sequenzen zu speichern und abrufbar zu machen. Da ein Dantenbankserver für ein reines „front-end“ Projekt nicht als Möglichkeit in Betracht kommt, ist JSON hier die Lösung. Da alle Sequenzen manuell ausgesucht werden müssen, kann festgestellt werden, wie schwer ein Level ist. Somit eröffnet sich die Möglichkeit, den Benutzer vor jedem Spiel eine Schwierigkeitsstufe auswählen zu lassen.

Bemerkung

Die JavaScript Object Notation (JSON) ist ein Dateistandard zum Austauschen von Daten in einer für Menschen lesbaren Form. JSON wird oft in Webschnittstellen verwendet, wenn Daten abgefragt werden. Eine JSON Datei besteht aus einer Auflistung von „key: value“ Paaren.

Beispiel einer JSON-Datei:

{
        "name": "John Doe",
        "age": 42,
        "interests": ["boats", "cats", "mistery novels"],
        "place of residence": "Tübingen"
}

Methoden

getLevel(String difficulty)

Gibt ein JavaScript-Objekt zurück, das einem Level der gegebenen Schwierigkeit difficulty entspricht. Die Schwierigkeit muss eine der folgenden sein: „noob“, „basic“, „moderate“, „hard“, „veryHard“, „ultimate“.

Felder eines Levels:
  • alignment – Ein Array, der die Sequenzen des Levels mit zufällig eingefügten Gaps enthält. Stellt die Ausgangssituation des Levels dar
  • names – Ein Array, der die Namen der Gene, aus denen die Sequenzen des Levels entnommen sind, enthält.
  • descriptions – Ein Array, der für jede Sequenz eine Beschreibung enthält, die als Informationstext angezeigt werden kann.
  • organisms – Ein Array, der für jede Sequenz den Organismus enthält, aus dem das Gen Stammt
  • id – Ein String, der eine eindeutige Identifikation des Levels erlaubt
  • score – der Score des optimalen Alignments der Sequenzen.
getBestScore(String id, Integer match, Integer mismatch, Integer gap)

Gibt vorberechneten Alignmentscore für die Scoring-Parameter match, mismatch und gap für den mit id referenzierten Eintrag in der JSON-Datei sequences.json.

randomGaps(Array sequences)

Gibt für einen gegebenen Array an Sequenzen einen Array zurück, der in jeder enthaltenen Sequenz zufällig Gaps einfügt, sodass die Länge aller Sequenzen genau 20 ist. Es passen genau 20 Basen pro Reihe in das Puzzle.

randomOrder(Array a)

Gibt eine zufällige Permutation des gegebenen Arrays a zurück.

Bemerkung

Damit das Spiel abwechslungsreich bleibt werden die Funktionen randomGaps und randomOrder vor jedem Level auf die Sequenzen angewendet. Die Sequenzen bekommen eine zufällige Reihenfolge und jeweils zufällig eingefügte Gaps, ohne dabei die Reihenfolge der Basen zu verändern.

Berechnen des aktuellen Alignmentscores

Neben der Anzeige des besten erreichbaren Alignmentscores für ein Level braucht es für ein Spiel auch eine Art der Rückmeldung für den Spieler, um zu sehen wie gut er, oder sie sich schlägt. In der Bioinformatik wird zu diesem Zweck gerne der Sum-of-Pairs-Score verwendet.

Methode

getCurrentScore(Array alignment, Integer match, Integer, mismatch, Integer gap)

Gibt den Sum-of-Pairs-Score für ein im Array alignment beschriebenes Alignment zurück. Zur Bewertung aller Paare von Basen werden die Scoring-Parameter match, mismatch und gap verwendet.

Vorberechnen der besten Alignmentscores in Python

Warnung

Der im folgenden beschriebene Python Programmcode ist nicht von der Webseite aus ereichbar, sonder dient lediglich dem Vorbereiten des Alignmentpuzzles. Der Programmcode ist im Gitlab Projekt im Ordner computation zu finden.

Matrizen

Dynamische Datenstrukturen sind von zentraler Bedeutung für die Implementation von dynamischen Programmieralgorithmen. Der Needleman-Wunsch Algorithmus beruht auf dem Erstellen einer Scoring-Matrix, die den Alignmentscore der Präfixe aller alignierten Sequenzen beinhaltet. Diese benötigt für jede zu alignierende Sequenz eine eigene Dimension. Für multiple Sequenzalignments von mehr als zwei oder drei Sequenzen kann es schnell zu unüberschaubar komplexen Strukturen kommen und eine stabile Implementation ist wichtig. Da die Implementation von dynamischen Programmieralgorithmen nicht primärer Zweck der Programmiersprache JavaScript ist, sind jedoch keine performanten Bibliotheken für solche Datenstrukturen aus offiziellen Quellen vorhanden. Aus diesem Grund findet die Programmiersprache Python zum Vorberechnen der Needleman-Wunsch Scores für alle Level Verwendung, da sich mit Python die sehr effiziente Matrixbibliothek Numpy verwenden lässt.

Initialisiert wird eine Matrix anhand eines Arrays dimensions mit einer Länge in jeder Dimension. Für jeden Eintrag in dimensions existiert in der Matrix eine neue Dimension mit entsprechender Länge. Es muss beachtet werden, dass zum Initialisieren einer Scoring Matrix auf jede Längenangabe eins dazu addiert werden muss, da in alle Richtungen eine Zeile mit festen Initialwerten vorhanden sein muss.

Bemerkung

Für eine zweidimensionale Scoring-Matrix A für den Gebrauch im Needleman-Wunsch Algorithmus sind die Initialwerte in der ersten Zeile und Spalte wie folgt definiert:

A[i][0] = i * gap-penalty * -1

A[0][j] = j * gap-penalty * -1

Matrix A nach der Initialisierung mit Gap-Penalty 2:

0 -2 -4 -6 -8
-2        
-4        
-6        

Zum Ausfüllen der Matrix beim Berechnen, wird über sie von der Nullkoordinate, dem Vektor aller Indizes i=0 in der Matrix, bis zur Koordinate aller maximalen Indizes in der Matrix einmal komplett durchlaufen.

Vorbereiten der Level

Die Sequenzen aus echten Genen werden in FastA-Dateien im Ordner levels_fasta gespeichert. Sie sollten mit einer Raute beginnen, gefolgt von einer gültigen Schwierigkeitsstufe. Gültige Schwierigkeitsstufen sind: „noob“, „basic“, „moderate“, „hard“, „veryHard“ und „ultimate“.

Die Beschreibungszeile jeder Sequenz enthält in dieser Reihenfolge den Genname, eine Beschreibung der Funktion des Gens und den Organismus in dem dieses Gen vorkommt. Die drei Elemente der Beschreibungszeile werden durch das Symbol „|“ getrennt.

Bemerkung

Das FastA Format ist ein Standard, nach dem Sequenzen gespeichert werden. Ein Eintrag für eine Sequenz beginnt immer mit einer Beschreibungszeile, die den Name und weitere optionale Informationen enthalten kann. Eine Beschreibungszeile muss immer mit dem Symbol „>“ beginnen. Auf die Beschreibungszeile können dann beliebig viele Zeilen mit Sequenzabschnitten folgen, bis der nächste Eintrag wieder mit „>“ eingeläutet wird.

Beispiel FastA-Datei:

> Sequenz13498 | ATP7A | Mus musculus
ATGCCGCGCCGGAGAGCGTGTGTCCGCGCGAGATATTTG
ATAGACAGGATAGAGATACCCCAGATTTGAGACCAGAAG
ATGAC ...
> Sequenz13499 | ATP7B | Mus musculus
ATAGAATTTAGGAGCGGCGCCCAGATTTGAGACCAGAAG
ATAGACAGGATAGAGATTTAGGTTTATTGCGCGCGAAAA
ATGAC ...

Aus entsprechend formatierten FastA Dateien, können mit folgenden Befehlen Level in die Datei sequence.json geschrieben werden:

python3 manage.py --add-level=<levelname.fasta> --difficulty=<Schwierigkeitsstufe>

Fügt der Datei sequences.json ein Level an für eine gegebene Schwierigkeit

python3 manage.py --create-new

Erstellt die Datei sequences.json komplett neu anhand der im Ordner levels_fasta beschriebenen Levels. Der Aufruf wird die vorhande Datei sequences.json überschreiben!

Warnung

Beim Hinzufügen von einem, oder mehreren Leveln werden nicht automatisch die Alignmentscores berechnet. Dies muss mit einem separaten Befehl geschehen.

Berechnung des Optimalen Alignmentscores

Auf Grundlage der Datei sequences.json können die optimalen Alignmentscores nach dem Needleman-Wunsch Algorithmus berechnet werden. Es wird dabei für je fünf verschiedene Bewertungsparameter match, mismatch und gap der optimale Score berechnet und in einen dreidimensionalen Array geschrieben. Die redundante Berechnung wird vorgenommen, um den Modus „herum spielen“ nach erfolgreichem Beenden eines Levels auf der Spielseite zu ermöglichen. Dabei soll der Benutzer ein Gefühl für den Ablauf der Berechnung bekommen und sehen, wieso die standardmäßig gewählten Berechnungsparameter Matchscore=2, Mismatchscore=-1 und Gappenalty=2 für Sequenzalignments sinnvoller sind, als manche anderen Parameter. Der folgenden Befehle starten die Berechnung:

python3 manage.py --compute

Berechnet für alle Leveleinträge in der Datei sequences.json für die im Feld scores ein leerer Array steht die optimalen Alignmentscores.

python3 manage.py --verbose --compute

Empfohlener Aufruf. Berechnet für alle Leveleinträge in der Datei sequences.json für die im Feld scores ein leerer Array steht die optimalen Alignmentscores. Zeigt dabei den Fortschritt der Berechnung, sowie die verstrichene Zeit seit Beginn der Berechnung an.

Clustal Omega Client

Für den Fall, dass eine Sequenz mit der gespielt wird nicht in der Datei sequences.json erscheint, muss es eine Möglichkeit geben, denoch einen besten Score anzuzeigen. Das European Bioinformatics Institute (EMBL-EBI) stellt einen Webdienst der Software Clustal Omega zur Berechnung von Alignments frei zur Verfügung. Der Webdienst lässt sich via Anfragen auf eine API starten und das Ergebnis abfragen. Zum Verbessern der Ladezeiten bei der Berechnung des besten Scores für ein Level wird ein Client verwendet, der von Clustal Omega berechnete Alignments abfrägt und anschließend den Score des Alignments mit der Methode getBestScore berechnet.

Bemerkung

Als API bezeichnet man eine Anwendungs Programmierschnittstelle (engl: Application Programming Interface). Anders als Webseiten bieten APIs keine graphische Oberfläche, mit der interagiert werden kann, sondern dienen der direkten Interaktion mit den Anwendungen, die im Hintergrund der Webseiten laufen. So können wie im Fall der ClustalO-API Programme genutzt, oder gestartet werden, die auf einem entfernten Server laufen. Andere APIs erlauben zum Beispiel den Zugriff auf Datenbanken.

Clustal Omega verwendet eine Heuristik um ein gutes Alignment in kurzer Zeit berechnen zu können.

Methoden

ClustalCall(Array Sequences)

Konstruktor der Klasse. Aufruf des Konstruktors startet eine Abfrage an die ClustalO-API.

Attribute der ClustalCall-Klasse:
  • ClustalCall.alignment ist ein Array, in dem das von ClustalO berechnete Alignment gespeichert ist, sobald dieses berechnet ist.
  • ClustalCall.SLEEP_INTERVAL ist ein Integer. Beschreibt die Wartezeit in Milisekunden zwischen Statusabfragen an die ClustalO-API.
  • ClustalCall.POST_URL ist ein String, der die Url des Webdienstes repräsentiert.
  • ClustalCall.STATUS_URL ist ein String, der die Url zur Abfrage des Status der Berechnung repräsentiert.
  • ClustalCall.RESULT_RUL ist ein String, der die Url zur Abfrage des fertig berechneten Alignments repräsentiert.
  • jobID ist ein String, der die ID des Berechnungs-Jobs repräsentiert. Anhand der ID, können Status und Resultat der Berechnung abgefragt werden
  • data ist ein JSON Objekt, das die benötigten POST-Parameter für die Anfrage an den Webdienst enthält
getResult()

Frägt das Ergebnis der Berechnung des ClustalO Webdienstes ab.

Die Funktion muss nie explizit aufgerufen werden! Alle Ergebnisse sind als Attribute der Klasse gespeichert.

toFasta(Array sequences)

Wandelt ein Array mit Sequenzen um in einen String im FastA-Format.

toSequenceArray(String fastAString)

Wandelt einen String im FastA-Format um in einen Array, der alle Sequenzen des FastA-Strings enthält.