Simulation von Phasenübergängen in Proteinmonoschichten · Report 2002-02. Impressum: Herausgeber: Robert Giegerich, Ralf Hofestädt, Peter Ladkin, Helge Ritter, Gerhard Sagerer,

Universität Bielefeld

Technische FakultätAbteilung InformationstechnikForschungsberichte

Simulation von Phasenübergängen inProteinmonoschichten

Johanna Alichniewicz Gabriele HolzschneiderMorris Michael Ulf Schiller Jan Stallkamp

Report 2002-02

Impressum: Herausgeber:Robert Giegerich, Ralf Hofestädt, Peter Ladkin, Helge Ritter,Gerhard Sagerer, Jens Stoye, Ipke Wachsmuth

Technische Fakultät der Universität Bielefeld,Abteilung Informationstechnik, Postfach 10 01 31,33501 Bielefeld, Germany

ISSN 0946-7831

Simulation von Phasenubergangenin Proteinmonoschichten

Projektseminar

Johanna Alichniewicz [email protected]

Gabriele Holzschneider [email protected]

Morris Michael [email protected]

Ulf Schiller [email protected]

Jan Stallkamp [email protected]

Betreut von

Prof. Dr. Robert Giegerich, Technische FakultatProf. Dr. Friederike Schmid, Fakultat fur Physik

Sommersemester 2001Wintersemester 2001/2002

Einleitung

Die vorliegende Arbeit entstand im Rahmen eines Projektseminars, das im Som-mersemester 2001 und im Wintersemester 2001/2002 an der Universitat Bielefeldstattfand.

Die Idee zu dieser Arbeit beruht auf einer Veroffentlichung [1], in der Phasen-ubergange in einer Proteinmonoschicht beschrieben und erste Ansatze zu ihrerErklarung gegeben werden. Ziel des Projektseminars war es, ausgehend von denexperimentellen Beobachtungen mittels Computersimulationen nach der Mon-te Carlo-Methode diese Erklarungsansatze zu uberprufen.

Durch experimentelle Arbeiten wurden bei Langmuir-Monolagen von Apolipo-protein C-I [1] und spater auch bei anderen Apolipoproteinen mit ahnlicherSekundarstruktur [2] Phasenubergange nachgewiesen. NMR-Strukturuntersuch-ungen [3] fur das Apolipoprotein C-I ergaben eine Sekundarstruktur bestehendaus zwei α-Helices, die durch einen nur schwach strukturierten Teil verbundensind. Dies gab Anlaß zu der Vermutung, dass Konformationsanderungen der Pro-teine bei zunehmendem Lateraldruck zu den beobachteten Phasenubergangenfuhren. Angenommen wurde hierbei, dass sich ab einem bestimmten Druck eineder beiden α-Helices aufgrund ihrer vergleichsweise geringen Hydrophilitat ausder Monoschicht hebt und so die Oberflachendichte senkt.

Anhand eines darauf aufbauenden, einfachen Proteinmodells wurde eine Mon-te Carlo-Simulation entwickelt, die Untersuchungen an einem System einiger hun-dert Proteine ermoglicht. Die Ergebnisse der damit durchgefuhrten Simulationenzeigen in ahnlicher Weise Phasenubergange auf. Es konnte so gezeigt werden,dass bereits ein relativ einfaches Modell Aussagen uber das Phasenverhalten desApolipoproteins C-I erlaubt.

i

ii

Inhaltsverzeichnis

1 Biochemische Grundlagen 1

1.1 Eigenschaften von Proteinen . . . . . . . . . . . . . . . . . . . . . 1

1.2 Phasenubergange in Monoschichten . . . . . . . . . . . . . . . . . 3

1.3 Was sind Apolipoproteine? . . . . . . . . . . . . . . . . . . . . . . 4

2 Physikochemische Grundlagen 7

2.1 Eigenschaften von Oberflachen: Monolagen . . . . . . . . . . . . . 7

2.2 Phasenubergange erster Ordnung . . . . . . . . . . . . . . . . . . 8

2.3 Flussigkristalle . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

3 Prinzipien des Softwareengineerings 11

4 Computersimulationen und MC-Methoden 15

4.1 Computersimulationen . . . . . . . . . . . . . . . . . . . . . . . . 15

4.2 Monte Carlo-Simulation . . . . . . . . . . . . . . . . . . . . . . . 16

4.3 Monte Carlo in verschiedenen Ensembles . . . . . . . . . . . . . . 18

5 Potentialmodellierung 19

5.1 Das Potential im Metropolis-Algorithmus . . . . . . . . . . . . . . 19

5.2 Paarpotentiale fur stabformige Teilchen . . . . . . . . . . . . . . . 20

5.2.1 Harte Spharozylinder . . . . . . . . . . . . . . . . . . . . . 20

5.2.2 Das Lennard-Jones-Potential . . . . . . . . . . . . . . . . . 24

5.2.3 Das Corner-Potential . . . . . . . . . . . . . . . . . . . . . 24

5.2.4 Potentialberechnung durch Uberlappungsintegrale . . . . . 25

5.3 Das Paarpotential fur APO C-I . . . . . . . . . . . . . . . . . . . 27

5.4 Intramolekulare Wechselwirkungen . . . . . . . . . . . . . . . . . 28

5.5 Externe Wechselwirkungen . . . . . . . . . . . . . . . . . . . . . . 28

5.6 Die vollstandige Form des Potentials . . . . . . . . . . . . . . . . 29

iii

iv INHALTSVERZEICHNIS

6 Auswertung von Monte Carlo-Daten 31

6.1 Der nematische Ordnungsparameter . . . . . . . . . . . . . . . . . 31

6.2 Statistik der Daten . . . . . . . . . . . . . . . . . . . . . . . . . . 32

6.2.1 Statistik unabhangiger Daten . . . . . . . . . . . . . . . . 32

6.2.2 Autokorrelationen und Autokorrelationszeit . . . . . . . . 33

6.2.3 Statistik der korrelierten Daten . . . . . . . . . . . . . . . 34

6.3 Anzahldichte und reduzierte Dichte . . . . . . . . . . . . . . . . . 34

7 Programmaufbau und Klassenstruktur 35

7.1 Allgemeines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

7.2 Programmbedienung und -ablauf . . . . . . . . . . . . . . . . . . 38

7.3 Boxing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

8 Visualisierung 45

8.1 Ziel der Visualisierung . . . . . . . . . . . . . . . . . . . . . . . . 45

8.2 Verwendete Programme . . . . . . . . . . . . . . . . . . . . . . . 45

8.3 Das Visualisierungsprogramm provis . . . . . . . . . . . . . . . . 45

9 Ergebnisse 49

9.1 Zweidimensionale Spharozylinder . . . . . . . . . . . . . . . . . . 49

9.1.1 Simulation . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

9.1.2 Ergebnisse . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

9.2 Simulation von APO C-I . . . . . . . . . . . . . . . . . . . . . . . 55

9.2.1 Simulation . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

9.2.2 Ergebnisse . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

9.3 Interpretation der Ergebnisse . . . . . . . . . . . . . . . . . . . . 64

9.3.1 Vergleich zwischen APO C-I und harten Spharozylindern . 64

9.3.2 Vergleich mit den experimentellen Ergebnissen fur APO C-I 65

9.4 Diskussion und Ausblick . . . . . . . . . . . . . . . . . . . . . . . 67

9.5 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

INHALTSVERZEICHNIS v

A Pflichtenheft 73

A.1 Zielbestimmung . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73

A.1.1 Mussziele . . . . . . . . . . . . . . . . . . . . . . . . . . . 73

A.1.2 Wunschziele . . . . . . . . . . . . . . . . . . . . . . . . . . 73

A.1.3 Negative Ziele . . . . . . . . . . . . . . . . . . . . . . . . . 73

A.2 Produkteinsatz . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74

A.3 Produktumgebung . . . . . . . . . . . . . . . . . . . . . . . . . . 74

A.4 Produktfunktionen aus Benutzersicht . . . . . . . . . . . . . . . . 74

A.5 Daten fur langfristige Speicherung . . . . . . . . . . . . . . . . . . 74

A.6 Programmleistungen . . . . . . . . . . . . . . . . . . . . . . . . . 74

A.7 Benutzeroberflache . . . . . . . . . . . . . . . . . . . . . . . . . . 74

A.8 Qualitatszielbestimmung . . . . . . . . . . . . . . . . . . . . . . . 74

A.9 Globale Testfalle . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

A.10 Entwicklungsumgebung . . . . . . . . . . . . . . . . . . . . . . . . 75

B Programmcode 77

C Glossar 115

Literaturverzeichnis 127

vi INHALTSVERZEICHNIS

Kapitel 1

Biochemische Grundlagen

1.1 Eigenschaften von Proteinen

Proteine sind an fast allen zellularen Prozessen beteiligt. Sie konnen anhand ihrerbiologischen Aufgaben klassifiziert werden. So unterscheidet man grob zwischenProteinen mit katalytischer Aktivitat (Enzyme), Transportproteinen, Struktur-proteinen und Abwehrproteinen. Proteine sind die am hochsten entwickelten Mo-lekule. Sie variieren in ihrer Struktur, d.h. jeder Proteintyp besitzt eine einzigar-tige dreidimensionale Gestalt, die Konformation.Alle Proteine sind Polymere, die basierend auf 20 verschiedenen Aminosaure-bausteinen aufgebaut sind. Ein Protein besteht aus einer oder mehreren Poly-peptidketten, die in spezifischer Konformation gefaltet und gewunden sind. Dieeinzelnen Aminosauren sind durch eine Peptidbindung miteinander verknupft. Aneinem Ende der Polypeptidkette befindet sich eine freie Aminogruppe (NH2), amanderen eine freie Carboxyl-Gruppe (COOH).Aminosauren bestehen aus einem asymmetrischen Kohlenstoff, der mit vier ver-schiedenen Partnern kovalent verknupft ist: Wasserstoffatom, Carboxylgruppe,Aminogruppe und ein Rest, der die einzigartigen Merkmale einer bestimmtenAminosaure bestimmt. Dieser Rest kann sein:

• unpolare Seitenkette (hydrophobe Aminosauren)

• polare Seitenketten (hydrophile Aminosauren)

• Dicarbon-Monoaminosaure (Carbonsaurerest)

• Monocarbon-Diaminosaure (Aminorest)

• aromatische Seitenkette

1

2 KAPITEL 1. BIOCHEMISCHE GRUNDLAGEN

Die vier Ebenen der Proteinstruktur

Die Primarstruktur eines Proteins ist die einzigartige Abfolge seiner Aminosaur-en. Selbst eine geringfugige Anderung der Primarstruktur kann die Konformationund Funktionsfahigkeit eines Proteins beeintrachtigen. Beispielhaft ist hier dieSichelzellenanamie: dabei ist die Primarstruktur des Hamoglobins so verandert,dass ein Glutaminsaurerest an Stelle 6 durch einen Valinrest ersetzt wurde. Diesfuhrt dazu, dass das Hamoglobin seine Funktion nicht mehr erfullen kann.

Unter Sekundarstruktur versteht man die Windungen und Faltungen der Po-lypeptidkette. Sie resultiert großtenteils aus den Wasserstoffbrucken, die in re-gelmaßigen Abstanden entlang des Polypeptidruckgrats auftreten. So hat bei-spielsweise das Sauerstoffatom eine hohe Affinitat zu nahegelegenen schwach po-sitiv geladenen Wasserstoffatomen.Es gibt zwei vorherrschende Arten von Sekundarstrukturen. Zum einen die α-Helix, eine feine Spirale, die durch Wasserstoffbrucken zwischen jeder viertenPolypeptidbindung zusammengehalten wird. Sie kommt z.B. im Strukturprote-in der Haare (α-Keratin) vor und bildet das Grundgerust des Bindegewebes derTiere (Collagen).Die zweite Art der Sekundarstruktur ist das β-Faltblatt. Es entsteht, wenn sichdie Polypeptidkette hin und zuruck faltet oder zwei Ketten parallel zueinanderlaufen. Auch diese Struktur wird durch Wasserstoffbrucken zusammengehalten.Ein Beispiel sind die Strukturproteine bei Seidenfaden einer Spinne (Fibroin).

Eine Aminosaurekette, die nacheinander mehrere Sekundarstrukturmuster ent-halten kann, ist raumlich zu einer Tertiarstruktur angeordnet. Diese wird unteranderem durch hydrophobe Wechselwirkungen erreicht, denn unpolare (hydro-phobe) Aminosaure-Seitenketten ordnen sich bevorzugt im Molekulinnern an.Ihr gegenseitiger Wasserausschluss halt sie in Clustern zusammen.Auch Wasserstoffbrucken zwischen den Seitenketten bestimmter Aminosaurenund Ionenbindungen zwischen negativen und positiv geladenen Seitenketten tra-gen zur Ausbildung der Tertiarstruktur bei. Die Konformation des Proteins kannauch durch Disulfidbrucken zwischen zwei Aminosauren mit Sulfhydrylgruppenausbilden. Der Schwefel des einen Cysteins bindet sich an den Schwefel des an-deren und es bildet sich eine Disulfidbrucke.

C – SH + HS – C → C – S – S – C

Die Quartarstruktur ist die Gesamtstruktur eines Proteins, die sich aus der Zu-sammenlagerung seiner Polypeptide ergibt, den sogenannten Untereinheiten. Mo-gliche Anordnungen sind Dimere, Ringe, Helices mit Polaritaten u.v.a.Ein Beispiel hierfur ist das Collagen, das aus drei helikalen Polypeptiden besteht,die zu einer seilahnlichen Struktur großer Starke superspiralisiert sind. Ein weite-res Beispiel ist das Hamoglobin, das sich aus vier Untereinheiten zusammensetzt,die alle durch Nebenvalenzen verbunden werden.

1.2. PHASENUBERGANGE IN MONOSCHICHTEN 3

1.2 Phasenubergange in Monoschichten

Langmuir-Monoschichten (siehe”Physikochemische Grundlagen“) auf einer Lo-

sungsmitteloberflache werden bereits seit einiger Zeit untersucht. Jedoch wurdenerst in den letzen Jahren sichtbare Erfolge erzielt, die auf verbesserten Technikenberuhen, wie z.B. Rontgenkristallographie, polarisierte Fluoreszenzmikroskopieund Brewsterwinkel-Mikroskopie. Damit konnte ein allgemeines Bild des Phasen-diagramms von Monoschichten sowie der Struktur ihrer Phasen gewonnen werden.Es zeigte sich, dass sich bei einer sehr geringen Oberflachendichte – wenn dieMolekule im Schnitt mehr Platz zur Verfugung haben, als die Querschnittsflacheeines isolierten Molekuls betragt – die Monoschicht wie ein zweidimensionalesGas verhalt. Dies bedeutet, dass die Molekule noch in der Lage sind, sich frei aufder Oberflache zu bewegen. Einen ersten Phasenubergang von gasformig nachflussig kann man unter einer Kompression der Monoschicht beobachten. Hattendie Molekule in der Gasphase noch durchschnittlich a=300-1500 A2/molec. mit(a = area/molecule) zur Verfugung, sind es in der flussigen Phase nur nocha=30-40 A2/molec., was ungefahr der Querschnittsflache eines isolierten Molekulsentspricht (vgl. Abbildung 1.1).

Der zweite Phasenubergang zum flussig-kondensierten Zustand wird bei einerweiteren Kompression der Monoschicht beobachtet. Hier ist a kaum großer alsdie Querschnittsflache einer vollstandig gedehnten Kette, also 22-25 A2/molec. Eszeigt sich jedoch, dass die kondensierte Phase aus einer Vielzahl unterschiedlicherMesophasen besteht, die sich unter anderem dadurch auszeichnen, dass sich dieMolekule mit einer unterschiedlichen Symmetrie kippen und neigen.

Abbildung 1.1: Π-a-Isotherme fur APO C-I bei 25,1◦C (Quelle: [1])


Die auftretenden Phasenubergange kann man auch uber Anderungen in der frei-en Energie der Monoschicht beschreiben: Dabei kann man die freie Energie derMonoschicht uber die Summe folgender vier Terme ausdrucken:

F = Ftrans + Fatt + Fconf + Fhead

Ftrans ist dabei die zweidimensionale Bewegungsentropie der Molekule. DieserTerm gibt also an, wie gut sich die Molekule auf der Oberflache fortbewegenkonnen. Fatt und Fhead bezeichnen die Interaktion zwischen den amphiphilen Mo-lekulschwanzen bzw. zwischen den polaren Kopfen. Fconf ist die Summe der Termealler inneren Freiheitsgrade in den Molekulen.

Bei den Untersuchungen der Monoschichten wurde der erste Phasenubergang (G–LE1) durch Anderungen von Ftrans und Fatt hervorgerufen. D.h., die Molekuleerfahren durch den erhohten Oberflachendruck einen Verlust der Bewegungsen-tropie, wohingegen die anziehenden Wechselwirkungen bedingt durch die großereNahe zunehmen. Dieser Phasenubergang ist typisch fur Flussigkristallsysteme.Im Falle des zweiten Phasenubergangs kann eine direkte Analogie mit Flussigkri-stallsystemen zu Missverstandnissen fuhren. Stabformige Molekule, die Flussig-kristallsysteme bilden, vollziehen einen isotrop-nematischen Ubergang in dreiDimensionen, wobei sich die vorher ungeordneten Molekule durch Kompressi-on parallel zueinander ausrichten. Man konnte also erwarten, dass der LE–LC-Ubergang2 ahnlich dem isotrop-nematischen Ubergang bei Flussigkristallen ist.Allerdings zeigen genauere Untersuchungen, dass der zweite Phasenubergang aufein Ausstrecken flexibler Teilchen bzw. auf eine Konformationsanderung zuruck-gefuhrt werden kann.

Insgesamt zeigt sich also, dass sich die Molekule zusammenschieben oder einigeihrer Segmente von der Oberflache abheben stehen mussen, um weniger Ober-flache in Anspruch zu nehmen, wenn die Monoschicht weiter unter Druck gesetztwird. Dieser Ubergang konnte von erster Ordnung sein, wenn die Molekule auf-grund ihrer Konformationsanderung betrachtlich nah aneinander kommen, undauf diese Weise die Anzahl der Wechselwirkungen zwischen den Ketten erhohtwird. Der Ubergang wird beherrscht von dem Wechselspiel zwischen Fconf undFatt, d.h., sowohl der Beitrag der inneren Freiheitsgrade der Molekule andert sichdurch die Konformationsanderung, wie auch der Beitrag der Anziehungskrafte,die auf die Molekulschwanze wirken.

1.3 Was sind Apolipoproteine?

Allgemein sind Apolipoproteine lipidbindende Proteine, die beispielsweise im Blutvorkommen und fur den Transport von Triacylglycerinen, Phospholipiden oder

1LE: liquid-expanded2LC: liquid-condensed

1.3. WAS SIND APOLIPOPROTEINE? 5

Cholesterin zwischen den Organen verantwortlich sind.”Apo“ bezeichnet das

Protein in seiner lipidfreien Form. Dieses Protein verbindet sich mit Lipidenzu verschiedenen Klassen von Lipoproteinpartikeln, kugelformigen Aggregatenmit hydrophoben Lipiden im Zentrum und hydrophilen Seitenketten von Ami-nosauren auf der Oberflache. Es gibt verschiedene Klassen von Lipoproteinen, dieverschiedene Kombinationen von Lipid und Protein aufweisen. Dadurch ergebensich Teilchen verschiedener Dichte. Lipide sind Verbindungen, die ein hydropho-bes Verhalten aufweisen, d.h. sie zeigen geringe bis gar keine Affinitat zu Wasser.Zu den biologisch wichtigsten gehoren Fette, Phospholipide und Steroide.

Das Apolipoprotein C-I

Bei den dieser Arbeit zu Grunde liegenden Experimenten [1] wurde das menschli-che Apolipoprotein C-I auf eine stark ionische Flussigkeit aufgetragen, so dass eseine Langmuir-Monoschicht bildete. Danach wurde ein Druck-Flachen-Diagrammfur diese Monoschicht erstellt (siehe Abb. 1.1), sowie das Verhalten der Mono-schicht bei Druckveranderungen anhand der Brewsterwinkel-Mikroskopie beob-achtet. Experimentell konnten zwei Phasenubergange erster Ordnung gefundenwerden: Beim ersten Phasenubergang koexistieren die flussige und gasformigePhase; der zweite Phasenubergang ist ein Ubergang zwischen zwei flussigen Pha-sen.

Auf Grund dieser experimentellen Ergebnisse wurde ein Proteinmodell entwickelt,nach dem das Apolipoprotein C-I aus zwei amphiphilen α-Helices besteht, diedurch ein schwach strukturiertes Polypeptid-Fragment verbunden sind. Mit die-sem Modell kann man die experimentellen Ergebnisse erklaren, insbesondere denzweiten Phasenubergang, der mit einer Konformationsanderung des Proteins ein-hergeht. Wird ein lateraler Druck auf die Protein-Monoschicht ausgeubt, so hebtsich eine der amphiphilen α-Helices aus der Subphase.

Das Apolipoprotein ist ein ca. 6 kDa schweres Protein. Seine Sequenz aus 57 Ami-nosauren ist in Abbildung 1.2 angegeben. Die Aminosaure-Reste 1-4 und 55-57bilden jeweils eine Schleife, die Aminosaure-Reste 8-29 und 33-52 bilden die bei-den α-Helices. Sie werden durch eine kurze unstrukturierte Region verbunden.Die erste α-Helix (Reste 4-30) umfasst 7,5 Windungen, die zweite (35-53) 5,2.Dabei enthalt eine Windung 3,6 Aminosaure-Reste. Beide α-Helices haben am-phiphile Eigenschaften, was bedeutet, dass sie sich sowohl in polaren, als auch in

LLLL***HHH HHHHLH*HHH HHHHHHHH* ** HHHHHHHH HHHHHHHHHH HH**LLL

TPDVSSALDK LKEFGNTLED KARELISRIK QSELSAKMRE WFSETFQKVK EKLKIDS

Abbildung 1.2: In der oberen Zeile ist die Aminosauresequenz des ApolipoproteinsC-I angegeben. In der unteren Zeile die Ergebnisse einer Computervorhersage fur dieSekundarstruktur. Dabei steht L fur Loop und H fur Helix. Ergebnisse ubernommenaus [1].


unpolaren Losungsmitteln losen. Jedoch ist die Gewichtung zwischen Lipid- undWasserloslichkeit bei den beiden Helices unterschiedlich stark ausgepragt. DieserUnterschied ist u.a. dafur verantwortlich, dass sich die lipophilere Helix leich-ter von der Wassroberflache lost, als die hydrophilere. In Abbildung 1.3 ist dieSekundarstruktur des Apolipoproteins C-I gezeigt. Die unstrukturierte Regionzwischen den Helices ist deutlich zu erkennen.

Abbildung 1.3: Die Sekundarstruktur des Apolipoproteins C-I setzt sich aus zweiα-Helices zusammen, die durch eine schwach gebundene Region verbunden sind. DieAbbildung wurde mit vmd (http://www.ks.uiuc.edu/Research/vmd/) basierend aufDaten aus der PDB [5] erstellt. Die Strukturdaten wurden von Rozek et al. [3] ermittelt.

Kapitel 2

Physikochemische Grundlagen

2.1 Eigenschaften von Oberflachen: Monolagen

Das im Rahmen dieses Projektseminars entwickelte Programm dient dazu, eineMonolage von Apolipoproteinen auf einer Wasseroberflache zu simulieren. Dochwas genau zeichnet eine Monolage aus?Monolagen, in der Literatur auch als Langmuir-Blodgett-Schichten bezeichnet,sind nur eine Molekullage dicke Oberflachenschichten. An ihnen werden haufigBeziehungen zwischen der Oberflachenspannung und -konzentration untersucht,und damit auch die raumliche Enge, auf die man die Molekule dieser Schichtkomprimieren kann.Zur Untersuchung verwendet man in der Regel eine sogenannte Langmuir-Waage:Diese besteht aus einer Wanne, die die Flussigkeit (oft Wasser) und die darauf be-findliche Monolage enthalt. Ferner existieren verschiebbare Barrieren, mit denenman die zur Verfugung stehende Oberflache begrenzen kann, und Vorrichtungen,um die Anderung des Oberflachendrucks zu messen.

Der Oberflachendruck Π wird durch die Differenz der Oberflachenspannungen desreinen Losungsmittels (γ0) und der Losung (γ) berechnet:

Π = γ0 − γ

Fur jede Substanz gibt es einen spezifischen Grenzdruck, der unter anderem durchdie Geometrie der Molekule bestimmt ist. Erreicht der Oberflachendruck diesenGrenzdruck, so zerbricht die Monolage und die Molekule beginnen, sich uberein-ander zu schieben.

Monolagen, denen genug Platz zur Verfugung steht, so dass sich die einzelnenMolekule frei bewegen konnen, kann man als zweidimensionales Gas auffassen.Durch Verringerung der verfugbaren Oberflache kann man dieses Gas dann so-weit komprimieren, dass es (analog zu gewohnlichen dreidimensionalen Gasen)kondensiert. Es entsteht also eine zweidimensionale Flussigkeit.

7

8 KAPITEL 2. PHYSIKOCHEMISCHE GRUNDLAGEN

2.2 Phasenubergange erster Ordnung

Weist Materie eine homogene chemische Zusammensetzung und einen raumlichkonstanten Zustand auf, so sagt man, dass sie sich in einer (homogenen) Pha-se befindet. Ein Beispiel fur eine Phase ist die Gasphase. Andert die Materieihre Phase, beispielsweise auf Grund einer Temperaturanderung, so andern sichauch die physikalischen Eigenschaften, bzw. es kommt zu einer spontanen Um-wandlung. Solche Umwandlungen bezeichnet man auch als Phasenubergange. Siefinden fur gegebenen Druck bei einer charakteristischen Temperatur statt. Einprominentes Beispiel fur einen Phasenubergang ist der Wechsel des Aggregatzu-standes, wenn z.B. Eis schmilzt und zu Wasser wird oder wenn ein Gas zu einerFlussigkeit kondensiert. Neben den haufig auftretenden stabilen Phasen gibt esnoch sogenannte metastabile Phasen, die thermodynamisch instabil sind, derenKinetik jedoch so langsam verlauft, dass sie trotzdem beobachtbar sind.

Bei einem Phasenubergang gilt, dass das chemische Potential beider Phasen gleichist; fur den Ubergang zwischen dem festen (solid, s) und flussigen (liquid, l)Zustand gilt also:

µ(s) = µ(l)

Phasenubergangen wurden von Ehrenfest eine Ordnung zugewiesen, die daruberAuskunft gibt, die wievielte Ableitung des chemischen Potentials nach der Tempe-ratur am Punkt des Phasenubergangs als erste nicht mehr stetig ist. Bei den hiervorkommenden Phasenubergangen erster Ordnung ist schon die erste Ableitungam Punkt des Phasenubergangs sprunghaft, bei Ubergangen zweiter Ordnung istsie hingegen stetig (und erst die Ableitungen ab der zweiten Ableitung sprung-haft). Phasenubergange zweiter Ordnung bezeichnet man nach der Klassifikationvon Fischer auch als kontinuierliche Phasenubergange.

In welcher Phase sich eine Substanz befindet, hangt von der vorherrschendenTemperatur und dem außeren Druck ab. Daher kann man alle von einer Sub-stanz einnehmbaren Phasen als Temperatur-Druck-Diagramm darstellen, demsogenannten Phasendiagramm.

2.3 Flussigkristalle

Die in dieser Arbeit betrachtete Monoschicht kann jedoch nicht nur als zweidimen-sionales Gas aufgefasst werden, sondern sie stellt gleichzeitig gewissermaßen einenFlussigkristall dar: Flussigkristalle (die auch Mesophasen genannt werden) zeich-nen sich dadurch aus, dass sie in mindestens einer Raumrichtung die Fernordnungeines Festkorpers (Kristalls) besitzen, in mindestens einer Richtung aber so unge-ordnet wie eine Flussigkeit sind. Flussigkristalle konnen beispielsweise entstehen,

2.3. FLUSSIGKRISTALLE 9

wenn beim Schmelzen einer Substanz die Kristallordnung teilweise erhalten bleibt(also in mindestens einer, maximal aber in zwei Raumrichtungen). Extrem lange,dunne Molekule begunstigen die Ausbildung von Flussigkristallen aufgrund ihrerAnisotropie. Die Ausbildung von Flussigkristallphasen in verschiedenen Systemenist aus der Literatur bekannt (vgl. [15], [23], [34]).

Bei Flussigkristallen kann man grob zwischen drei Phasen unterscheiden:

1. In der nematischen Phase sind Stabe zwar parallel zueinander ausgerichtet,doch in den beiden anderen Raumrichtungen ist keinerlei Ordnung erkenn-bar.

2. In der smektischen Phase sind die parallel zueinander liegenden Molekulezusatzlich in ubereinanderliegenden Schichten angeordnet.

3. In der cholesterischen Phase schließlich sind diese Schichten gegeneinanderverdreht, so dass sich von oben betrachtet ein Gitter zeigt.

cholesterischnematischisotropisch smektisch

Das von uns untersuchte Apolipoprotein weist einen nematischen Ubergang auf,was bedeutet, dass die zuvor ungeordneten Molekule sich bei Druckerhohung par-allel zueinander ausrichten. Eine cholesterische Phase kann bei der Simulation vonProteinmonoschichten schon deshalb nicht beobachtet werden, da diese Phasenmehrere Schichten benotigen, Monolagen aber per Definition nur aus einer einzi-gen Molekullage bestehen.

10 KAPITEL 2. PHYSIKOCHEMISCHE GRUNDLAGEN

Kapitel 3

Entwicklung des Programmsnach den Prinzipien desSoftwareengineering

Bekanntermaßen bieten objektorientierte Analyse und objektorientiertes Designviele Vorteile. Die wichtigsten sind, dass nach diesen Prinzipien entwickelte Pro-gramme wiederverwendbar, an geanderte Aufgabenstellungen anpassbar und bes-ser in Gruppenarbeit zu entwickeln sind, da sie sich leichter in Module aufteilenlassen, die unabhangig von verschiedenen Gruppenmitgliedern bearbeitet werdenkonnen. Um das von uns entwickelte Simulationsprogramm erweiterbar zu haltenund die iterative Entwicklung durch eine Gruppe zu ermoglichen, wurde es vonuns nach diesen Prinzipien entwickelt:

Das Softwareengineering hat im Laufe der Zeit viele sogenannte Vorgehensmodel-le hervorgebracht, die einen Rahmen fur die strukturierte Entwicklung großererSoftwareprojekte vorgeben. Gemeinsam ist den meisten dieser Vorgehensmodel-le, dass man in der Regel zyklisch die Phasen der Problemanalyse, des Entwurfs,der Umsetzung, der Einfuhrung, der Wartung, der erneuten Problemanalyse, etc.durchlauft.

Da unser Problem, im Gegensatz zu in der freien Wirtschaft auftauchenden Pro-blemen, bereits in einem Fachaufsatz beschrieben worden war, beschrankte sichbei uns die

”Problemanalyse“ auf das Durchsehen dieser Arbeit und erganzender

Literatur. Nachdem wir uns durch Lekture von Fachartikeln und durch Vortragezu einzelnen Aspekten in das Thema eingearbeitet hatten, haben wir als erstenSchritt ein Pflichtenheft (siehe Anhang A) erstellt, in dem neben Muss- undKann-Zielen auch negative Ziele festgehalten wurden. So haben wir beispielswei-se beschlossen, dass unser fertiges Programm auf jeden Fall Zylindermodelle (furdie Helices) unter einem harten Potential simulieren sollte. Nach Moglichkeit soll-ten jedoch weitere Potentiale anwendbar sein. Bewusst haben wir uns gegen einen

11

12 KAPITEL 3. PRINZIPIEN DES SOFTWAREENGINEERINGS

Problemanalyse Entwurf

Wartung Umsetzung

Einfuehrung

Abbildung 3.1: Zyklus der Softwareentwicklung

Vergleich unseres Monte Carlo-Programms mit molekulardynamischen Ansatzenentschieden, da ein Vergleich zwischen der Behandlung dieses Problems durcheine Monte Carlo- und eine molekulardynamische Simulation zu aufwendig ge-worden ware und den Rahmen der Veranstaltung bei Weitem gesprengt hatte.Das Pflichtenheft sollte uns zum einen dabei helfen, das gestellte Problem besserzu verstehen, indem wir gezwungen waren, uns detailliert uber einzelne AspekteGedanken zu machen, zum anderen sollte das Pflichtenheft uns davor bewah-ren, uns in Teilaspekten des Problems zu

”verzetteln“ oder erst in einem spaten

Stadium zu bemerken, dass wir uns in wichtigen Punkten doch nicht einig waren.

Aufbauend auf das Pflichtenheft konnten wir mit dem Entwurf beginnen: In die-ser Phase werden (beim objektorientierten Entwurf) zunachst die Klassen desProgramms entwickelt. Das Vorgehen dabei verlauft haufig iterativ: Auf Grundvon Intuition und dem Vergleich mit der realen Welt sucht man zunachst einige

”sichere“ Klassen. Das sind zu Beginn haufig solche Klassen, zu denen es Ent-

sprechungen in der realen Welt gibt. Zwischen den gefundenen Klassen fuhrt manals nachstes Assoziationen und Aggregationen ein und ordnet ihnen die nahelie-genden Attribute und Operationen zu. Die dabei entstehende Liste von Attribu-ten und Operationen auf diesen Attributen wird man in aller Regel im weiterenVerlauf der Entwicklung abandern und erganzen, bis ein stabiles, vollstandigesProgramm entstanden ist.Uns war beispielsweise bald klar, dass wir mindestens eine Klasse fur die zusimulierenden Proteine brauchen wurden, die wiederum in einer Konfiguration

13

zusammengefasst werden mussten. Weiterhin waren wir uns sicher, je eine Klassefur das Potential, den Zufallszahlengenerator und fur die Programmkontrolle zubrauchen (letztere sollte u.a. die main-Methode enthalten). Auch die dazugehori-gen Methoden waren bald gefunden. Ausgehend von diesen ersten Klassen habenwir iterativ immer mehr Klassen hinzugefugt, deren Notwendigkeit uns ganz zuAnfang noch nicht bewusst gewesen war, die sich aber im spateren Verlauf alssehr hilfreich erwiesen.

Nachdem wir das so entstandene Klassendiagramm (siehe Abb. 7.1 auf Seite 37)verfeinert hatten und es in sich stimmig war, konnten wir mit der Umsetzungbeginnen. Jedoch wurde es auch spater noch abgeandert, weil uns einige Aspekteder Problemstellung erst im Verlauf der Arbeit richtig klar wurden, bzw. wir sieerst richtig verstanden, wahrend wir versuchten, sie im Programm umzusetzen.Als abzusehen war, dass wir unser Muss-Ziel (ein Programm zur Simulation) wohlerreichen wurden, haben wir uns auch an die Erfullung einiger Kann-Ziele (z.B.die Realisierung einer graphischen Benutzeroberflache) gemacht.

Da das von uns entwickelte Programm nicht fur den Gebrauch durch weiterePersonen gedacht ist, sondern uns nur die Simulation des Verhaltens des Apoli-poproteins C-I ermoglichen sollte, mussten die Phasen der Programmeinfuhrungund Wartung stark abgeandert werden: Da nur wir funf Entwickler mit dem Pro-gramm arbeiten wurden, entfiel die Schulung. Auch die Installation des fertigenProgramms war so nicht notig, da es z.T. auf dem selben System laufen sollte, aufdem es auch entwickelt und getestet worden war, namlich auf dem Linuxclusterder Arbeitsgruppe

”Theorie der kondensierten Materie“. Auch bei der Portie-

rung in die Technische Fakultat gab es fast keine Probleme. Die Wartung entfielebenfalls, da das Programm nur fur eine begrenzte Zeit benutzt wurde.

14 KAPITEL 3. PRINZIPIEN DES SOFTWAREENGINEERINGS

Kapitel 4

Computersimulation undMonte Carlo-Methoden

4.1 Computersimulationen

In vielen Anwendungen stellt sich das Problem, dass Systeme mit extrem vielenVariablen untersucht werden sollen, was zu sehr umfangreichen Datenbestandenfuhren kann. Beipiele fur solch umfangreiche Aufgabenstellungen, die nicht mehrmit herkommlichen Methoden bearbeitet werden konnen, sind sowohl etablierteModelle, die auf Grund ihrer vielen Freiheitsgrade nur noch unter großen Muhenzu berechen sind, als auch Fragestellungen, bei denen die Modellbildung und-uberprufung einen Teil der Aufgabenstellung bilden. In solchen Fallen sind Com-putersimulationen oft die eleganteste oder gar die einzige Methode zur Losungder Aufgabe (vgl. [10] bis [15]).

Computersimulationen konnen sowohl zur Verifikation von Theorien, als auch zurUberprufung experimenteller Ergebnisse genutzt werden. Weiterhin kann mansie nutzen, um

”experimentelle Ergebnisse“ unter schwer zuganglichen oder phy-

sikalisch unmoglichen Bedingungen zu errechnen. So kann man mit Hilfe vonComputersimulationen beispielsweise die Materialeigenschaften von Stoffen beiextrem hohen Drucken und Temperaturen vorhersagen, ohne diese Eigenschaftenmessen zu mussen, oder man kann die Eigenschaften von Materialien vorhersa-gen, bevor man den entsprechenden Stoffe zum ersten Mal hergestellt hat, wasman bei ungunstigen Eigenschaften dann auch unterlassen kann. Eine andere An-wendungsmoglichkeit der Computersimulation, die speziell fur unser Projekt vonInteresse ist, ist die Moglichkeit, experimentell gewonnene Daten nachzuvollzie-hen, um darauf aufbauend Hypothesen und Theorien begrunden zu konnen. Sosoll im vorliegenden Fall die Isotherme nachvollzogen werden, die entsteht, wennman den Oberflachendruck Π gegen die Flache pro Molekul a auftragt. Daraufaufbauend soll danach die vorhergesagte Molekulstruktur bewertet werden.

15

16 KAPITEL 4. COMPUTERSIMULATIONEN UND MC-METHODEN

Aus der Ergodizitatshypothese folgt, dass fur beliebige glatte Messgrossen A(Γ(t))das Scharmittel gleich dem Zeitmittel ist. Um also den Mittelwert einer Grossezu berechnen, kann man entweder ihr Zeitmittel oder ihr Scharmittel berechnen;ersteres wird bei der Molekulardynamik verwendet, letzteres bei der Monte Carlo-Simulation [11]. Dabei sollte man jedoch bedenken, dass in der Praxis viele Sy-steme nicht ergodisch sind, die Gleichheit von Zeit- und Scharmittel also nichtstreng gegeben ist, obwohl man aus Grunden der Einfachheit oft die Gleichheitdieser beiden Mittelwerte postuliert.Um also das Zeitmittel durch Molekulardynamik zu berechen, werden nicht nurdie Molekule des betrachteten Stoffes simuliert, sondern auch alle weiteren vor-liegenden Molekule. So werden beispielsweise die Bewegungen der Losungsmittel-molekule genau berechnet, um die durch sie auf das geloste Molekul wirkendenKrafte bestimmen zu konnen. Die so zustande kommende Dynamik eines einzigenSystems wird uber einen langeren Simulationszeitraum beobachtet. Uber diesenZeitraum werden spater die Mittelwerte der gesuchten Großen gebildet.

4.2 Monte Carlo-Simulation

Im Gegensatz zur Molekulardynamik, bei der die Dynamik eines Systems in Formseiner Trajektorien berechnet werden soll, verfolgt die Monte Carlo-Simulationeinen statistischen Ansatz: Die Molekule des betrachteten Systems werden zufalligum kleine Strecken bewegt – wobei diese Bewegung nach den Gesetzen der klas-sischen Mechanik nicht unbedingt erlaubt sein muß. So ist es moglich, dass dasbewegte Molekul von einem Ort zu einem anderen wechselt, ohne die dazwi-schenliegenden Bereiche zu durchlaufen. Durch dieses plotzliche Andern der Mo-lekulzustande erreicht man, dass die Simulation von einer Konfiguration in eineandere (wenn auch weitgehend ahnliche) wechselt. Mit der Zeit kann damit dasScharmittel uber eine Anzahl verschiedener Konfigurationen bestimmt werden.Um dabei den Mittelwert einer Messgrosse A zu bestimmen, wird das Integral

< A >=1

N !

∫p(Γ)A(Γ)dΓ (4.1)

berechnet. Dabei bezeichnet A(Γ) den Wert der zu messenden Große A in derKonfiguration Γ und p(Γ) ist die Wahrscheinlichkeit, dass gerade diese Konfigu-ration angenommen wird.Um diese Berechnung nicht uber den ganzen Bereich ausfuhren zu mussen, fuhrtman geeignete Stutzstellen ein, die man so wahlt, dass man viele Stutzstellen aus

”interessanten“ Bereichen und moglichst wenige aus

”uninteressanten“ Bereichen

hat (importance sampling).Die Stutzstellen werden aus Zufallszahlen generiert (daher auch der Name

”Mon-

4.2. MONTE CARLO-SIMULATION 17

te Carlo“). Eine solche Stutzstelle ist beispielsweise eine Konfiguration des Sy-stems, die man gemaß einer vorgegebenen Verteilung ziehen muss. Denn wennman die Stutzstellen rein zufallig ziehen wurde, also mittels gleichverteilter Zu-fallszahlen, hatte man den bereits oben angedeuteten Fall des simple samplings,was dazu fuhren wurde, dass man zu viele uninteressante Bereiche untersuchenwurde.

Um also eine vorgegebene Verteilung anzustreben, die die interessanten Bereichebevorzugt, generiert man eine Markov-Kette, also einen stochastischen Prozessohne Gedachtnis. Dabei werden die Ubergangswahrscheinlichkeiten so konstru-iert, dass sie die gewunschte Verteilung erzeugen. In dem vorliegenden Programmwird dabei der Metropolis-Algorithmus verwendet, was bedeutet, dass die ange-strebte Verteilung genau der Boltzmannverteilung entspricht. Um die Stutzstel-len des Integrals zu finden, fuhrt man beim Metropolisalgorithmus – wie auchbei anderen Monte Carlo-Methoden – einen random walk durch das zu messendeGebiet durch. Jedoch vermeidet man Gebiete, in denen die zu messende Großeverschwindet. Die grundlegende Idee des importance sampling ist also, dass einrandom walk durch die Regionen des Phasenraums generiert wird, die einen wich-tigen Beitrag zum Ensemblemittelwert leisten.Beim random walk geht man vom aktuellen Standpunkt zufallig an einen anderenPunkt; existiert die zu bestimmende Große an diesem Punkt, so misst man sieund bewegt sich nach dem selben Schema weiter. Verschwindet die zu messendeGroße jedoch an dem neuen Punkt, so geht man zum vorherigen Punkt zuruckund misst die Große an dieser Stelle noch einmal. Fur die Simulation eines Viel-teilchensystems bedeutet dies nun, dass zufallig ein Protein bewegt wird, wasdem Aufsuchen eines neuen Punktes im Phasenraum entspricht. Danach wirduberpruft, ob die durch diese Bewegung entstandene neue Konfiguration z.B. zuUberlappungen von Teilchen oder Ahnlichem fuhrt und in einem solchen Fallverworfen. Lag keine Uberlappung oder sonstige grobe Verletzung der physikali-schen Gesetzmassigkeiten vor, wird in der vorliegenden Simulation eine Konfigu-rationsanderung immer dann angenommen, wenn das neue Potential niedriger istals das alte. Eine Konfigurationsanderung kann aber auch angenommen werden,wenn sie zu einer Verschlechterung, also einem hoheren Potential, fuhrt. Dies ge-schieht aber nur mit einer Wahrscheinlichkeit von exp(−∆E/kT ) und dient dazu,die Boltzmannverteilung als Grenzverteilung zu erreichen.

Der Grundgedanke der Monte Carlo-Simulation ist also, dass mittels einer Mar-kovkette Stutzstellen (d.h. Konfigurationen) entsprechend einer vorgegebenenVerteilung P (Γ), aber ansonsten zufallig, zur Verfugung gestellt werden, um dar-auf aufbauend die gesuchten Mittelwerte berechnen zu konnen.

Ein Nachteil der Monte Carlo-Simulation ist, dass man durch diese Methode nichtdie reale Dynamik der Teilchen nachvollziehen kann. Andererseits kann man sichdiesen Nachteil zunutze machen, indem man diese unphysikalischen Bewegungenzur Beschleunigung verwendet, also den Teilchen erlaubt, durch das System zu

”hupfen“.

18 KAPITEL 4. COMPUTERSIMULATIONEN UND MC-METHODEN

4.3 Monte Carlo in verschiedenen Ensembles

In Monte Carlo-Simulationen nach dem Metropolis-Algorithmus wird naturli-cherweise das kanonische Ensemble simuliert, in dem Teilchenzahl, Volumen undTemperatur konstant sind. Fur die Simulation anderer Ensembles, die fur vieleFragestellungen von großer Bedeutung sind, mussen Erweiterungen an den Al-gorithmen vorgenommen werden. Einige dieser Moglichkeiten sollen hier kurzvorgestellt werden (vgl. [12]).

Isobar-isothermes Ensemble

In diesem Ensemble sind Teilchenzahl, Druck und Temperatur konstant. Da dasVolumen variieren darf, mussen bei der Konstruktion der Markov-Kette nebenTeilchenbewegungen auch Volumenfluktuationen durchgefuhrt werden. Bei einerVolumenanderung mussen die Teilchenpositionen entsprechend reskaliert wer-den. Ebenso wie einer Teilchenbewegung wird auch einer Volumenanderung eineAkzeptanzwahrscheinlichkeit zugeordnet. In einem Metropolis-Schritt wird dannentweder eine Teilchenbewegung oder eine Volumenanderung durchgefuhrt.

Großkanonisches Ensemble

In diesem Ensemble werden Temperatur, Volumen und das chemische Potentialkonstant gehalten. Die Teilchenzahl und der Druck variieren dagegen. In diesemFall wird der Metropolis-Algorithmus um Teilchenerzeugungen und -ausloschun-gen erganzt. Entsprechend berechnet man die Akzeptanzwahrscheinlichkeiten ausder potentiellen Energie.

Gibbs-Ensemble

Das Gibbs-Ensemble eignet sich zur Untersuchung von Mehr-Phasen-Systemen.In den ubrigen Ensembles ist die Simulation verschiedener Phasen aufgrund sehrlangsamer Equilibrierung nur schlecht moglich. Im Gibbs-Ensemble werden Sub-systeme ohne Grenzflache betrachtet, so dass Teilchen zwischen den Systemenausgetauscht werden konnen. Dazu wird das Systemvolumen in zwei Bereicheaufgeteilt, zwischen denen die Teilchen ausgetauscht werden konnen. Die Teil-chen in einem dieser Bereiche wechseln nur untereinander, nicht jedoch mit denTeilchen aus dem anderen Bereich. Fur die Simulation des Gibbs-Ensembles wirdder Metropolis-Algorithmus um den Teilchenaustausch erganzt und die Energieentsprechend fur die Subsysteme berechnet.

Kapitel 5

Potentialmodellierung

5.1 Das Potential im Metropolis-Algorithmus

Wie in Abschnitt 4.2 erlautert, konnen die zur Monte Carlo-Integration von (4.1)benotigten Stutzstellen durch den Metropolis-Algorithmus erzeugt werden. Da-bei wird zur Berechnung der Akzeptanzwahrscheinlichkeit in Gleichung (7.1) dieEnergiedifferenz ∆E benotigt. Diese Energiedifferenz stellt sich als Potentialdiffe-renz zwischen zwei Konfigurationen dar. Somit benotigt man ein fur jede moglicheKonfiguration wohldefiniertes Potential V . Ein solches Potential kann durch eineAufspaltung in intermolekulare, intramolekulare und externe1 Wechselwirkungendargestellt werden:

V = Vinter + Vintra + Vextern (5.1)

Fur den intermolekularen Beitrag betrachtet man in der Regel nur Paarwech-selwirkungen.2 Da im vorliegenden Modell die Teilchen als zusammengesetzteSpharozylinder betrachtet werden, soll im folgenden zunachst betrachtet werden,welche Moglichkeiten zur Modellierung eines entsprechenden Paarpotentials beistabformigen Teilchen bestehen (Abschnitt 5.2). Im Anschluss wird beschrieben,wie diese Moglichkeiten auf das untersuchte Apolipoprotein C-I angewandt wer-den konnen (Abschnitt 5.3), und welche zusatzlichen Anteile zur Berucksichtigungder intramolekularen und externen Wechselwirkungen notwendig sind (Abschnitt5.4 und 5.5). Daraus ergibt sich dann die vollstandige Form des Potentials inAbschnitt 5.6.

1Unter den externen Wechselwirkungen kann man auch alle Einflusse verstehen, die von nichtexplizit mit simulierten Teilchen (z.B. Losungsmittelmolekule) ausgehen. Die Hydrophilitatkann als externe Wechselwirkung aufgefasst werden.

2Theoretisch sind auch Drei-Korper-Potentiale denkbar.

19

20 KAPITEL 5. POTENTIALMODELLIERUNG

5.2 Paarpotentiale fur stabformige Teilchen

5.2.1 Harte Spharozylinder

Die einfachste Moglichkeit, ein Paarpotential zwischen Teilchen zu modellieren,besteht in der Annahme harter, wechselwirkungsfreier Teilchen. Dabei durfensich zwei Teilchen nicht uberlappen, konnen sich aber ansonsten frei bewegen.Attraktive (z.B. Van-der-Waals) oder repulsive (z.B. Coulomb) Krafte werden indiesem Modell nicht berucksichtigt. Als Paarpotential zwischen zwei Teilchen iund j ergibt sich dann:

uij(dij) =

{ ∞ : dij < Ri + Rj

0 : sonst(5.2)

Hierin ist dij der minimale Abstand der Lininensegmente li und lj , die auf denAchsen der Spharozylinder liegen und die Mittelpunkte der jeweiligen Kugelkap-pen verbinden (vgl. Abbildung 5.1). Zur Berechnung des Paarpotentials muss alsoder Abstand dij ermittelt werden.

d

lii

ZylinderR

ij

i

jZylinder lj

Rj

Abbildung 5.1: Minimaler Abstand dij zwischen zwei Spharozylindern

Parallele Spharozylinder

Liegen die Sparozylinder parallel, so lasst sich der Verbindungsvektor rij zwischenzwei Punkten auf den Liniensegmenten zerlegen in

rij = dij r⊥ij + r

‖ij (5.3)

wobei

r‖ij = (rij · ui)ui (5.4)

r⊥ij =rij − r

‖ij

‖rij − r‖ij‖

(5.5)

5.2. PAARPOTENTIALE FUR STABFORMIGE TEILCHEN 21

Fur den minimalen Abstand zwischen den Spharozylindern ergibt sich dann

dij = ‖rij − (rij · ui)ui‖ (5.6)

Fur den Fall, dass die Spharozylinder nicht parallel liegen, sind mehrere Schrittezur Berechnung von dij notwendig. Das Verfahren dafur ist im wesentlichen aus[23] ubernommen.

Minimaler Abstand zwischen zwei Geraden

Im ersten Schritt des Verfahrens wird der minimale Abstand zwischen den Gera-den, die durch die Achsen der Spharozylinder laufen, berechnet. Die parametri-sierten Gleichungen lauten fur die Gerade durch li

ri(λ) = ri + λui (5.7)

und fur die Gerade durch lj

rj(µ) = rj + µuj (5.8)

Dabei sind ri und rj die Mittelpunkte der Liniensegmente und ui und uj derenRichtungsvektoren. Der parametrisierte Distanzvektor zwischen den Linien istdann

rij(λ, µ) = rij + λui − µuj (5.9)

wobei die Abkurzung rij = ri − rj verwendet wurde.

Da der kurzeste Distanzvektor zu den beiden Richtungsvektoren ui und uj senk-recht stehen muss, ergibt sich das folgende Gleichungssystem:

rij · ui + λui · ui − µuj · ui = 0 (5.10)

rij · uj + λui · uj − µuj · uj = 0 (5.11)

Das Gleichungssystem hat die Losung3

(λ∗

µ∗

)=

1

1 − (ui · uj)2

( −ui · rij + (ui · uj)(uj · rij)+uj · rij − (ui · uj)(ui · rij)

)(5.12)

Der kurzeste Abstandsvektor ist also r(λ∗, µ∗). Allerdings liegen die durch λ∗ undµ∗ parametrisierten Punkte zwar auf den Geraden, im Allgemeinen jedoch nichtauf den Liniensegmenten li und lj. Fur die Berechnung des Abstandes zwischenden Liniensegmenten sind weitere Schritte notig.

3Die Losung gilt nur fur den hier betrachteten Fall, dass ui und uj nicht parallel sind.


Minimaler Abstand zwischen zwei Liniensegmenten

Der Abstandsvektor rij(λ, µ) zwischen den Geraden kann aufgespalten werden ineine Komponente senkrecht zu ui und uj und eine Komponete, die in der von ui

und uj aufgespannten Ebene liegt. Durch die Variation von λ und µ kann nur dieletztere Komponente verandert werden. Damit reduziert sich das Problem auf dieFrage nach dem kurzesten Abstand zweier Liniensegmente in einer Ebene (vgl.Abbildung 5.2).

Schneiden sich die Liniensegmente in der Ebene, minimiert dieser Schnittpunktden Abstand. Dies ist gerade der durch λ∗ und µ∗ parametrisierte Punkt P ∗.Wenn sich die Liniensegmente in der Ebene nicht schneiden, muss mindestenseiner der Parameter λ∗ und µ∗ variiert werden, weil P ∗ ausserhalb des entspre-chenden Liniensegments liegt. Dazu halt man den Parameter des Liniensegments,

lj

P

lambda

li

min

*P

mu

Abbildung 5.2: Projektion des Abstandes zwischen zwei Geraden auf den λ-µ-Parameterraum mit Ursprung bei P ∗. Die Ellipsen sind Linien konstanten Abstands.Das schattierte Rechteck kennzeichnet den fur endliche Liniensegmente erlaubten Pa-rameterbereich. Der Punkt Pmin mit minimalem Abstand liegt auf einer Seite diesesRechtecks.


das weiter von P ∗ entfernt ist, an dessen Endpunkt fest, und minimiert die qua-dratische Distanz

(rij(λ, µ))2 = r2ij + λ2 + µ2 + 2λrij · ui − 2µrij · uj − 2λµui · uj (5.13)

O.B.d.A. sei λ der bei λmin = |li|2

festgehaltene Parameter 4. Minimierung von(5.13) liefert dann die Gleichung

∂((rij(λmin, µ))2)

∂µ= 2µ − 2rij · uj − 2λminui · uj

!= 0 (5.14)

woraus sichµmin = r · uj + λminui · uj (5.15)

ergibt. Liegt der durch µmin parametrisierte Punkt außerhalb des Liniensegmentslj , wird µmin auf den naheren Endpunkt ± |lj |

2des Liniensegments gestzt. Der

minimale Abstand zwischen den Liniensegmenten ist dann

dij = ‖rij(λmin, µmin)‖ (5.16)

Dieser Abstand wird in (5.2) zur Berechnung des Potentials zwischen den Spharo-zylindern eingesetzt.

Obwohl das Modell harter Spharozylinder sehr einfach ist, konnte es erfolgreichin Simulationen verwendet werden [32]. Bolhuis und Frenkel haben das kom-plette Phasendiagramm des Modells untersucht [33]. Eine einfache Erweiterungzu einem Rechteckpotential der Form

uij(dij) =

∞ : dij < Ri + Rj

−ε : Ri + Rj ≤ dij ≤ k · (Ri + Rj)0 : k · (Ri + Rj) < dij

(5.17)

wurde in [35] zur Untersuchung eines Phasenubergangs verwendet. Das Phasen-verhalten des tobacco mosaic virus konnte mit dem Modell harter Spharozylinderuntersucht werden [36], bis hin zum Verhalten stabformiger Kolloide in Mischungmit Polymeren [37].

4Andernfalls werden die Bezeichnungen vertauscht und gegebenenfalls die Richtung von ui

umgedreht.


5.2.2 Das Lennard-Jones-Potential

Um die Wechselwirkungen realistischer zu modellieren, fuhrt man sogenannteweiche Potentiale ein. Die Bezeichnung

”weich“ ruhrt von der Tatsache her, dass

sich die Teilchen bei Zusammenstoßen teilweise durchdringen konnen. Ausserdembieten weiche Potentiale die Moglichkeit, attraktive oder repulsive Wechselwir-kungen mit gewissen Starken und Reichweiten zu berucksichtigen. Die haufigsteForm eines weichen Potentials ist das Lennard-Jones Potential

u(r) = ε

[(σ

r

)12

−(σ

r

)6]

(5.18)

Hierin ist ε die Wechselwirkungsstarke und σ die Wechselwirkungsreichweite. DasLennard-Jones-Potential ist ein rein abstandsabhangiges Potential. Es kann direktauf stabformige Teilchen angewendet werden, indem man den in Abschnitt 5.2.1bestimmten Abstand dij in (5.18) einsetzt [25]. Dabei wird jedoch die Orientie-rung der Teilchen vernachlassigt. Im folgenden werden zwei Methoden vorgestellt,die neben dem Abstand auch die Orientierung von stabformigen Teilchen in dieBerechnung eines weichen Potentials einbeziehen.

5.2.3 Das Corner-Potential

Die Tatsache, dass die Orientierung bei spharisch-symmetrischen Teilchen keinenEinfluss auf das Potential hat, nutzte Corner in [26], um stabformige Teilchendurch mehrere kugelformige Teilchen anzunahern (vgl. Abbildung 5.3).

Das Potential entsteht dann durch Superposition der Beitrage der Lennard-Jones-Potentiale der einzelnen Kugeln:

u(r, u1, u2) =∑i,j

εo

[(σ0

rij(r, u1, u2)

)12

− 2

(σ0

rij(r, u1, u2)

)6]

(5.19)

Insgesamt soll das Potential wieder Lennard-Jones-Form haben:

u(r, u1, u2) = ε(r, u1, u2)

[(σ(r, u1, u2)

r

)12

− 2

(σ(r, u1, u2)

r

)6]

(5.20)

Abbildung 5.3: Das Modell von Corner. Das Potential wird von Lennard-Jones-Kraftzentren auf der Achse des Spharozylinders erzeugt. Bereits vier Kraftzentren rei-chen fur eine gute Approximation der Stabform.


Durch Entwicklung von (ε(r, u1, u2)

εo

) 12

(5.21)

und (σ(r, u1, u2)

σ0

) 13

(5.22)

nach Basisfunktionen und anschließende Interpolation bestimmte Corner diePotentialstarke ε(r, u1, u2) und die Reichweite σ(r, u1, u2). Diese hangen nebender Orientierung von der Anisotropie χ der Teilchen ab.5Fur vier Kugelzentren aufden Achsen liefert dieses Verfahren gute Ergebnisse bis zu einem Langen-Breiten-Verhaltnis l

dder Spharozylinder von 2, 5. Daruber werden die Fehler schnell groß.

Das Verfahren ist jedoch wegen des numerischen Aufwandes nicht leicht uber-tragbar auf andere Situationen, z.B. Teilchen mit nichtzylindrischer Symmetrie.

5.2.4 Potentialberechnung durch Uberlappungsintegrale

Ein anderes Verfahren zur Berechnung eines orientierungsabhangigen, weichenPotentials fur stabformige Teilchen wurde von Berne und Pechukas vorge-schlagen und spater von Gay und Berne modifiziert ([27],[28]). Die Teilchenwerden darin durch Ellipsoide

G(r) = exp

[−r2

x + r2y

σ2⊥

− r2z

σ2‖

](5.23)

angenahert, die eine gaußverteilte Masse haben (vgl. Abbildung 5.4). In Gleichung(5.23) sind x, y und z die kartesischen Komponenten von r, σ‖ und σ⊥ sind dieAchsen der Ellipsoids.

Die Wechselwirkung ist dann proportional zum Uberlappungsintegral

S(r, u1, u2) = |γγγ1|− 12 |γγγ2|− 1

2

∫exp

[−x · γγγ−11 · x − (x − r) · γγγ−1

2 · (x − r)]dx

(5.24)worin |γγγi| die Determinante der Reichweitenmatrix γγγi mit

γγγi = (σ2i‖ − σ2

i⊥)uiui + σ2i⊥I (5.25)

ist. Dieses Integral laßt sich darstellen in der Form

S(r, u1, u2) = ε(u1, u2) exp

[− r2

σ(r, u1, u2)

](5.26)

5Die Anisotropie ist definiert als χ = l2−d2

l2+d2 , wobei l die Lange und d der Durchmesser desStabteilchens ist.


x-Rx

R

u2u1

Abbildung 5.4: Modell von Berne et al. Die Teilchen werden als Ellipsoide mit gauß-verteilter Masse gedacht. Das Potential ist dann proportional zum Uberlappungsinte-gral (5.24).

Fur ε(u1, u2) und σ(r, u1, u2) lassen sich explizite Ausdrucke angeben, die auchhier von der Anisotropie χ = κ2−1

κ2+1, κ =

σ‖σ⊥

abhangen.

Die entsprechenden Ausdrucke fur die Starke und Reichweite werden in die Len-nard-Jones-Form eingesetzt und liefern

u(r, u1, u2) = 4ε(u1, u2)

[(σ(r, u1, u2)

r

)12

−(

σ(r, u1, u2)

r

)6]

(5.27)

Das aus den Uberlappungsintegralen gewonnene Potential zeigt im Vergleichmit dem Corner-Potential aus Abschnitt 5.2.3 einige unrealistische Eigenschaften([34],[35]). Zum einen ist die Potentialstarke ε(u1, u2) unabhangig vom Abstands-vektor r und die Reichweite ist proportional zu σ⊥. Gay und Berne definiertendaher eine neue Potentialstarke der Form

ε(r, u1, u2) = ε0εν(u1, u2)ε

′µ(r, u1, u2) (5.28)

und fuhrten eine Verschiebung in der Lennard-Jones-Form ein. Das modifizierteUberlapp-Potential ist dann gegeben durch

u(r, u1, u2) = 4ε(r, u1, u2)

[(σ0

r − σ(r, u1, u2) + σ0

)12

−(

σ0

r − σ(r, u1, u2) + σ0

)6]

(5.29)

Darin ist r = σ(r, u1, u2) mit guter Genauigkeit der Beruhrungsabstand, d.h.der Abstand, bei dem sich zwei Ellipsoiden mit der gegebenen Orientierungberuhren.6 Durch das so modifizierte Potential konnen die Wechselwirkungen

6Bemerkung: Es ist im Allgemeinen analytisch nicht bestimmbar, ob sich zwei Ellipsoidenmit gegebener Orientierung uberlappen.

5.3. DAS PAARPOTENTIAL FUR APO C-I 27

stabformiger Teilchen ausreichend gut modelliert werden. Ein Vergleich mit demCorner-Potential wird in [35] durchgefuhrt. Zewdie fuhrt in [34] ein Potentialein, bei dem beide Methoden kombiniert werden.

5.3 Das Paarpotential fur APO C-I

Um das gesamte intermolekulare Potential zu berechnen, muss uber das Paar-potential zweier Teilchen summiert werden. Im Falle des Apolipoproteins C-I istzu berucksichtigen, dass ein Molekul bereits aus zwei Spharozylindern (Helices)zusammengesetzt ist. Das Paarpotential vij zweier Molekule i und j ergibt sichdaher als Summe uber Paarpotentiale zwischen den Helices iA, iB, jA und jB:

vij({risjt}, {uis}, {ujt}) =∑

s∈{A,B}

∑t∈{A,B}

uisjt(risjt , uis, ujt) (5.30)

Darin ist uisjt(risjt , uis, ujt) eines der Potentiale aus Abschnitt 5.2.1 bis 5.2.4,wobei die r die Zentrumsdistanzen der Spharozylinder und die u die Richtungs-vektoren angeben. Die Doppelindizes geben die jeweilige Helix A oder B an (vgl.Abbildung 5.5).

Die Summe uber alle Paarbeitrage liefert dann das gesamte Paarpotential desSystems:

Vinter =∑i<j

vij({risjt}, {uis}, {ujt}) (5.31)

B

Helix

AjHelix

i B

j

Helix

iAHelix

Abbildung 5.5: Zwei Modellteilchen fur APO C-I mit den Bezeichnungen fur die He-lices. Die gestrichelten Linien stellen die Beitrage zum Paarpotential dar.


5.4 Intramolekulare Wechselwirkungen

Neben den Wechselwirkungen zwischen verschiedenen Teilchen, liefern auch dieWechselwirkungen eines Proteins mit sich selbst Beitrage zur Energie des Sy-stems. NMR-Messungen zeigen, dass das APO C-I bevorzugt einen bestimmtenWinkel φ0 zwischen seinen Helices einstellt [3]. Eine Abweichung von diesemWinkel ist aufgrund des Steifheit des Proteins energetisch ungunstiger, so dassdadurch die potentielle Energie des Molekuls steigt. Dieser Zusammenhang kanndurch ein Knickpotential modelliert werden, wie es auch fur Kettenmolekule ver-wendet wird (vgl. [38],[39],[40]):

vknicki (uiA, ujB

) = kstiff(1 − cos(φi − φ0)) (5.32)

kstiff ist eine Konstante fur die Steifheit und φi ist der Winkel zwischen denHelices des Teilchens i (vgl. Abbildung 5.6).

Wegen des Zusammenhangs cosφi = uiA · uiB ist vknicki eine Funktion der Rich-

tungsvektoren uiA und uiB . Das gesamte intramolekulare Potential des Systemsergibt sich dann durch Summation:

Vintra =∑

i

vknicki (uiA , uiB) (5.33)

Dieses Potential fuhrt dazu, dass die Proteine vorzugsweise den optimalen Knick-winkel einnehmen.

5.5 Externe Wechselwirkungen

Als externe Wechselwirkung kann man neben dem Einfluss außerer Felder (z.B.elektrische oder Magnetfelder) auch die Wechselwirkung mit einem weiteren Me-dium auffassen, dessen Teilchen nicht explizit mit simuliert werden. Im betrach-teten System spielen außere Felder keine Rolle, jedoch muss die hydrophile In-teraktion mit dem Losungsmittel der Monoschicht berucksichtigt werden. Dazu

iAHelix

BHelix

z

z

phi

theta

Abbildung 5.6: Die intramolekularen und externen Beitrage zum Potential einesAPO C-I Molekuls hangen von der Orientierung seiner Helices ab. Die entsprechen-de Abhangigkeit kann durch die eingezeichneten Winkel ausgedruckt werden.

5.6. DIE VOLLSTANDIGE FORM DES POTENTIALS 29

ist es notig, das Herausstehen der Helices mit einem Strafterm zu versehen. Dieskann man folgendermaßen modellieren

vhydroi (uiB) = khydrozi (5.34)

wobei khydro eine Konstante fur die Starke der hydrophilen Wechselwirkung istund zi die z-Komponente des Richtungsvektors uiB ist. Durch Summation erhaltman das externe Potential

Vextern =∑

i

vhydroi (uiB) (5.35)

Dieses sorgt dafur, dass die Energie des Systems geringer ist, wenn die Proteineflach auf der Monolage liegen.

5.6 Die vollstandige Form des Potentials

Fur das vollstandige Potential mussen die verschiedenen Beitrage aus den voran-gegangenen Abschnitten aufsummiert werden. Es ergibt sich der Ausdruck

V =∑i<j

vij({risjt}, {uis}, {ujt})

+∑

l

vknickl (ulA , ulB)

+∑m

vhydrom (umB

)

=∑i<j

vij({risjt}, {uis}, {ujt})

+ kstiff

∑l

(1 − cos(φl − φ0))

+ khydro

∑m

zm

(5.36)

In jedem Metropolis-Schritt muss dieses Potential fur das System berechnet wer-den, um die Energiedifferenz ∆E und daraus die Akzeptanzwahrscheinlichkeitdes Schritts zu ermitteln. Da (5.36) die quadratische Summation

∑i<j enthalt,

sind erweiterte Techniken (Boxing) notwendig, um die Berechnung effizient durch-fuhren zu konnen. Diese werden in Abschnitt 7.3 beschrieben.


Kapitel 6

Auswertung vonMonte Carlo-Daten

Die Auswertung von Monte Carlo-Daten erfordert nach Kapitel 4 die Auswertungdes Scharmittels (4.1) fur die relevanten Messgroßen. Dazu werden wahrend derSimulation die Werte ai der Messgroßen an den Stutzstellen protokolliert undanschließend der Mittelwert ausgerechnet:

〈A〉 =1

N

N∑i=1

ai (6.1)

Da die im Experiment beobachteten Phasenubergange auf eine kollektive Aus-richtung der Proteine zuruckgefuhrt wurden, liegt eine Auswertung der Starkedieser Ausrichtung auch fur die Simulation nahe. Der zu untersuchende Ord-nungsparameter sollte daher ein Maß fur die Orientierung der Teilchen entlangeiner Vorzugsrichtung sein. Diese Eigenschaften hat der im folgenden beschriebe-ne nematische Ordnungsparameter.

6.1 Der nematische Ordnungsparameter

Der nematische Ordnungsparameter ist definiert als

S = 〈P2(cos θ)〉 = 〈P2(u · n)〉 =

∫P2(cos θ)f(θ)d cos θ (6.2)

worin θ der Winkel zwischen der Teilchenrichtung u und der Vorzugsrichtung nist, P2 das zweite Legendre-Polynom und f die Winkelverteilung des Systemsbeschreibt [23]. Weil die Vorzugsrichtung n nicht a priori bekannt ist, kann man

31

32 KAPITEL 6. AUSWERTUNG VON MONTE CARLO-DATEN

aus (6.2) den nematischen Ordnungsparameter nicht ohne weiteres berechnen.S ist jedoch auch ohne Kenntnis von n zuganglich. Dazu bildet man

〈P2(u · e)〉 =1

N

N∑i=1

e> ·(

3

2ui ⊗ ui − 1

2I

)· e ≡ e> ·Q · e (6.3)

Gleichung (6.3) definiert den nematischen Tensor Q. Dieser hat folgende Eigen-schaften:

Spur(Q) = 0 (6.4)

Qαβ = Qβα (6.5)

Seine Diagonalform lautet:

S 0 0

0 −12(S − η) 0

0 0 −12(S + η)

(6.6)

Als Vorzugsrichtung n des Systems wird dann der zum großten Eigenwert Svon Q gehorende Eigenvektor definiert. Auf diesem Weg kann man dann dennematischen Ordnungsparameter S aus den Simulationsdaten bestimmen. Er gibtan, wie stark die Ausrichtung des Systems in die Vorzugsrichtung ausgepragt ist.Bei S = 0 ist das System nicht ausgerichtet (isotrope Phase), bei S = 1 istdas System perfekt ausgerichtet (nematische Phase oder Phasen noch hohererOrdnung bis hin zum Festkorper).

Der in der Diagonalform (6.6) auftretende Parameter η heißt Biaxialitat und istein Maß fur die Eindeutigkeit der axialen Ausrichtung von n. Bei η = 1 ist dieAusrichtung nicht eindeutig, es gibt noch eine weitere bevorzugte Richtung; beiη = 0 gibt es keine weitere Vorzugsrichtung, die Orientierung von n ist eindeutig.

6.2 Statistik der Daten

6.2.1 Statistik unabhangiger Daten

Aufgrund ihrer statistischen Natur sind Monte Carlo-Daten mit statistischen Feh-lern behaftet. Im Falle vieler statistisch unabhangiger Stutzstellen1 ist die Varianzeiner Messgroße

σ2(A) = 〈(ai − 〈A〉)2〉 =1

N − 1

N∑i=1

(ai − 〈A〉)2 (6.7)

1Aus dem zentralen Grenzwertsatz folgt dann eine Gaußverteilung fur die Stutzstellen.

6.2. STATISTIK DER DATEN 33

wobei 〈A〉 der Mittelwert nach (6.1) ist. Dieser Mittelwert selber hat dann eineVarianz von

σ2(〈A〉) =σ2(A)

N(6.8)

Allerdings kann man in Monte Carlo-Simulationen nicht von unabhangigen Stutz-stellen ausgehen, da die erzeugten Konfigurationen korreliert sind. Daher mussenbei der Berechnung der Varianz die Korrelationen berucksichtigt werden. Dasfolgende Vorgehen dazu ist [20] entnommen.

6.2.2 Autokorrelationen und Autokorrelationszeit

Da die Konfigurationen in einer Markov-Kette erzeugt werden, gilt im Gleichge-wicht fur den Erwartungswert einer Messgroße

A =∑

i

A(Zi)p(Zi) (6.9)

worin Zi die i-te Konfiguration bezeichnet und p die Wahrscheinlichkeitsdichte derKonfigurationen ist, also die Boltzmann-Verteilung. Die Autokorrelationsfunktionvon A ist dann definiert als

CAA(t) = 〈aiai+t〉 − 〈A〉2 (6.10)

Daraus erhalt man die normierte Autokorrelationsfunktion oder den Korrelati-onskoeffizienten von A:

ρAA(t) =CAA(t)

CAA(0)(6.11)

Dieser fallt typischerweise exponentiell mit t ab

ρAA(t) ∝ e−|t|τ (6.12)

so dass man die exponentielle Autokorrelationszeit definieren kann:

τexp,A = limt→∞

supt

− ln |ρAA(t)| (6.13)

Da man den Limes t → ∞ jedoch in der Simulation nicht bilden kann, definiertman außerdem die integrierte Autokorrelationszeit

τint,A =1

2

∞∑t=−∞

ρAA(t) =1

2+

∞∑t=1

ρAA(t) (6.14)

Im Falle eines exponentiell abfallenden Autokorrelationskoeffizienten ist die Sum-me in (6.14) eine konvergente geometrische Reihe, so dass sich durch Entwicklungder Exponentialfunktion schreiben laßt

τint,A = τ − 1

2+

1

2τ∓ . . . (6.15)

34 KAPITEL 6. AUSWERTUNG VON MONTE CARLO-DATEN

6.2.3 Statistik der korrelierten Daten

Mit Hilfe der integrierten Autokorrelationszeit kann man nun den statistischenFehler in Monte Carlo-Daten angeben. Fur die Varianz des Mittelwerts (6.1)ergibt sich:

σ2(〈A〉) = 〈(〈A〉 − A)2〉 =1

N2

N∑i,j=1

〈(ai − A)(aj − A)〉

=1

N2

N∑i,j=1

CAA(i − j)

=1

N2

N−1∑t=−(N−1)

(N − |t|)CAA(t) ; t = i − j

...

= 2τint,Aσ2(A)

N

(6.16)

Der statistische Fehler ist also um einen Faktor 2τint,A großer als bei unkorrelier-ten Messungen. Diese Tatsache sollte bei der Auswertung von Monte Carlo-Datenberucksichtigt werden. In der vorliegenden Arbeit war dies aufgrund der Daten-lage jedoch nicht moglich, so dass die Auswertung in Kapitel 9 ohne Berucksich-tigung der Korrelationen erfolgt.

6.3 Anzahldichte und reduzierte Dichte

In den Experimenten von Bolanos-Garcia et al. wurde die freie Flache pro Mo-lekul variiert. Die entsprechende Große, die in der Simulation verwendet werdenkann, ist die Anzahl N der Proteine im System, die in die Anzahldichte eingeht:

ρ =N

V(6.17)

Ublicherweise wird die reduzierte Dichte angegeben, die die Anzahldichte insVerhaltnis zur dichtesten Packung ρCP von Spharozylindern setzt:

ρ∗ =ρ

ρCP(6.18)

Dabei gilt fur die dichteste Packung von Spharozylindern in drei Dimensionen

ρCP =2√

2 + ld

√3

(6.19)

In den durchgefuhrten Simulationen wurde die Anzahl Proteine in einem Systemfester Große als variabler Parameter verwendet. Gemessen wurde die Abhangig-keit des nematischen Ordnungsparameters S von der Anzahl der Proteine imSystem. Die Ergebnisse werden in Kapitel 9 vorgestellt.

Kapitel 7

Programmaufbau undKlassenstruktur

7.1 Allgemeines

Das Programm wurde weitestgehend objektorientiert entwickelt und entsprichtgewissermaßen dem Schichtmodell des Software-Engineering: Die Klassen einesnach dem Schichtmodell aufgebauten Programms teilt man haufig in vier ver-schiedene Schichten auf, so dass Klassen in der Regel nur Klassen ihrer eigenenSchicht oder darunter liegender Schichten aufrufen durfen. Diese Hierarchie derSchichten soll nicht nur die Ubersichtlichkeit des Systems erhohen und wechselsei-tige Aufrufe der Klassen untereinander auf ein absolut erforderliches Minimumreduzieren, sondern sie gliedern auch die Programmbausteine nach ihrem Ab-straktionsgrad:

• Die oberste Schicht enthalt alle diejenigen Klassen, die die direkte Kommu-nikation mit dem Benutzer ermoglichen, also vor allem die Klasse(n) dergraphischen Benutzeroberflache.

• Unmittelbar darunter liegt die Kontrollschicht, die dafur sorgt, dass dervorgesehene Programmablauf eingehalten wird. Hier gibt es auch die einzi-ge Abweichung von der oben genannten Regel, da die Kontrollschicht aufKlassen der hoherliegenden Benutzerschicht zugreifen darf.

• Unter der Kontrollschicht liegen die anwendungsbezogenen Klassen, die zurBerechnungsschicht zusammengefasst werden. Sie sind in hohem Grad pro-blemspezifisch.

• Die unterste der vier Schichten realisiert die Anbindung an Datenbanken,die Hardware, etc. – sie ist somit am weitesten vom Benutzer entfernt. Da

35

36 KAPITEL 7. PROGRAMMAUFBAU UND KLASSENSTRUKTUR

das hier behandelte Programm jedoch nicht in diesem Sinne auf Daten einerDatenbank oder auf andere Komponenten zugreift, entfallt in diesem Falldie unterste Schicht.

Die Schicht fur die Interaktion mit dem Benutzer bzw. fur die Bildschirmausgabebesteht aus folgenden Dateien:

Histogram.C/.h bindet die in der GSL (Gnu Standard Library) definiertenC-Funktionen als C++Methoden ein und stellt sie zur Berechnung vonHistogrammen zur Verfugung.

PovUtils.h legt das Povray-Koordinatensystem, den Parametersatz, die Kame-raposition und die einzubindenden Dateien fur die Povray-Darstellung fest.

ProVis.cpp erzeugt aus den Daten einer erzeugten Konfiguration Dateien, diedurch povray in Bilder umgesetzt werden konnen.

Darunter angesiedelt ist die Kontrollschicht/Steuerungschicht. Ihre Dateien sindkeine Klassen im engeren Sinne.

Constants.h enthalt alle Konstanten, die zur Definition des Systems benotigtwerden. Aus Grunden der Ubersichtlichkeit und damit man schneller Ande-rungen einfugen kann, wurden diese Daten in einer eigenen Datei gesam-melt.

Control.cpp/.h beinhaltet das main-Programm.

und die Berechnungsschicht:

Box.h enthalt Methoden, mit der man

• zu einer Box die Indices der in ihr enthaltenen Proteine

• die Nachbarboxen einschließlich der Bezugsbox in einer Richtung

• die acht Nachbarboxen und die Bezugsbox, um zu prufen, ob sich dasPotential lokal geandert hat

abfragen kann.

Boxing.cpp/.h ist fur das Einsortieren der Proteine in die Boxen zustandig.Proteine werden in Boxen einsortiert, damit nicht immer die Wechselwir-kung mit allen anderen Proteinen berechnet werden muss, sondern nurWechselwirkungen zu Proteinen, die nah genug sind, um noch wechselwir-ken zu konnen (also zu Proteinen aus der selben oder einer Nachbarbox).

7.1. ALLGEMEINES 37

Abbildung 7.1: Klassendiagramm des Programms


Configuration.cpp/.h fuhrt Buch uber alle Proteine, die in der Simulation be-nutzt werden und uber ihre Bewegungen. Im Verlauf der Simulation werdenhier zufallig ausgewahlte Proteine zufallig verandert, indem sie bewegt wer-den, ihre neue Energie berechnet wird und dann entschieden wird, ob dieseKonfigurationsanderung akzeptiert wird. Weiterin kann durch diese Klas-se die dreidimensionale Anordnung aller Proteine in eine Datei ausgegebenwerden. Diese Datei kann dann von PovRay eingelesen und visualisiert wer-den.

MatrixA.C berechnet aus einer Ausgabedatei, in der die Komponenten des dya-dischen Produktes zwischen den Richtungsvektoren der Helices stehen, dienematischen Ordnungsparameter und gibt sie aus.

Potential.cpp/.h enthalt die Methoden, um das Paarpotential zwischen zweiSpharozylindern oder fur den Knick zwischen den beiden Helices zu be-rechnen. Weiterhin existieren Methoden, die Potentiale fur eine kompletteKonfiguration berechnen, bzw. deren Wert in Abhangigkeit von der Ande-rung eines Proteins verandern.

Protein.cpp/.h beschreibt die zu simulierenden Objekte je uber die Koordina-ten des Knickpunktes (d.h. des Punktes zwischen den beiden Helices) unduber je drei Variablen pro Helix. Es existieren Methoden, um eine ausfuhr-liche Beschreibung des Proteins oder nur die Koordinaten des

”Knickpunk-

tes“ auszugeben.

Random.cpp/.h ist der von uns verwendete Zufallszahlengenerator.

7.2 Programmbedienung und -ablauf

Die graphische Oberflache (GUI) wird durch ein Skript (”gui“) gestartet. In die

Eingabefelder kann der Benutzer die fur den Pogrammablauf benotigten Kon-stanten eingeben. Alternativ kann auch eine bereits vorhandene

”Constants.h“

oder eine”.mex“-Datei uber den

”load“-Button geladen werden.

Die zu spezifizierenden Variablen sind

fur die Proteine die Grosse (LENGTH A, LENGTH B, RADIUS A, RADI-US B)

fur die Konfiguration die Anzahl der Proteine (N PROT) und die Grosse derSimulationsflache (AREA X)

fur die Verschiebungen die maximale Beweglichkeit der Proteine in der Fla-che (MAX TRANSLATION, MAX ROTATION A, MAX ROTATION B)und aus der Flache hinaus (MAX LIFTING B)

7.2. PROGRAMMBEDIENUNG UND -ABLAUF 39

Abbildung 7.2: Die graphische Benutzeroberflache

fur die Potentialberechnung Straffaktoren fur Abweichungen vom naturlich-en Winkel (STIFFNESS FACTOR) und fur das Herausklappen aus derWasseroberlache (LIFT FACTOR)

fur den Zufallszahlengenarator der Initialisierungswert(INITIAL SEED)

fur den Metropolis-Algorithmus die Temperatur (TEMP), die Anzahl derIterationen (N ITERATIONS), die gewunschte Akzeptanzwahrscheinlich-keit (GOAL RATE), die Anzahl der Equilibrierungs- und Adaptionsschritte(EQUI STEPS, ADAPT STEPS)

fur die Ausgabe die Anzahl der Schritte, nach denen ein neuer Sweep protokol-liert wird (SWEEP STEPS) und nach denen eine komplette Konfigurationgespeichert wird (N SKIP)

fur die Programmausfuhrung die Rechner (HOST), auf denen das Pro-gramm mit den Rechten des Benutzers (USERNAME) ausgefuhrt werdensoll. Ferner kann der Name fur die Ergebnisdateien (FILE NAME) angege-ben werden

Durch den Button”MAIN DIR“ wird das Hauptverzeichnis ausgewahlt, in dem

die Ergebnisse gespeichert werden.Nach dem Start des Programms uber den

”run“ -Button der graphischen Benut-

zerschnittstelle werden die eingegebenen Daten in Dateien (fur jeden gewunschtenLauf eine) gespeichert und der unter

”Command“ angegebene Befehl gestartet.


Dieser sorgt dann dafur, dass das Programm auf dem Zielrechner mit den richtigenEingabedaten kompiliert und gestartet wird. Vom Programm werden im Verlaufder main-Methode die erforderlichen Objekte, wie der Zufallszahlengenerator,die Konfiguration, und Zwischenergebnisse, initialisiert. Wurde das Programmnicht uber die graphische Benutzerschnittstelle, sondern uber die Kommando-zeile aufgerufen, und wurde ihm nicht die Anzahl der Iterationen als Parametermitgegeben, so wird im Folgenden die default-Konstante N ITERATIONS ver-wendet und so oft die Hauptschleife des Programms durchlaufen. In dieser soll proIterationsschritt (Monte Carlo-Schritt) jedes Protein im Schnitt einmal bewegtwerden; d.h. wenn N Proteine vorliegen, werden pro Iterationsschritt N zufalligausgewahlte Proteine bewegt, was in der Regel dazu fuhrt, dass manche Proteinegar nicht, andere hingegen mehrfach bewegt werden.

Die Startkonfiguration, die beim Starten des Programms erzeugt wird, bestehtdarin, dass die Halfte der Helices (alle A-Helices) auf der Wasseroberflache liegenund die ubrigen Helices (alle B-Helices) senkrecht stehen. Durch die im verwende-ten Potential berucksichtigte hydrophile Wechselwirkung dieser Helices mit demLosungsmittel senken sich diese auf die Oberflache ab, soweit dies nicht durchandere Wechselwirkungen verhindert wird.

In der Methode Configuration::nextConfiguration wird ein Protein bewegtund uber die Annahme der Bewegung entschieden. Zunachst wird zufallig einProtein ausgewahlt, dessen Parameter im Folgenden geandert werden. Zeigt sichspater, dass die aus diesem veranderten Protein resultierende Konformation nichtangenommen wird, so werden die vorgenommenen Anderungen wieder ruckgangiggemacht. Dazu werden die alten Daten uber einen Pointer auf das alte Proteinfestgehalten.Die Bewegung eines Proteins setzt sich zusammen aus der Translationsbewe-gung, der Anderung der Ausrichtung von Helix A und der von Helix B, sowieeinem

”Flip“. Bei der Translation wird zu den vorherigen Koordinaten jeweils

eine Zufallszahl zwischen der negativen maximalen Translation und der positivenmaximalen Translation addiert. Analog dazu wird bei der Anderung der Helixaus-richtung von Helix A zum alten Ebenenwinkel eine Zufallszahl aus dem Bereichzwischen der negativen maximalen Rotation und der positiven maximalen Rota-tion addiert. Da uns bei den Helices jedoch nicht nur die Winkel, sondern auch dieKoordinaten der Richtungsvektoren interessieren, mussen als nachstes aus demneuen Ebenenwinkel die geanderten Koordinaten berechnet werden. Die Ande-rung der Ausrichtung von Helix B verlauft zunachst analog wie die fur Helix Ajedoch muss zusatzlich bedacht werden, dass sich Helix B aus der Ebene abhe-ben kann. Hier muss also auch der Aufstellsinus, der den Grad des Hinaustretensvon Helix B aus der Ebene angibt, ermittelt werden. Aufgrund der Benutzungvon Zufallszahlen konnte der Aufstellsinus kleiner als null oder großer als einswerden, was physikalisch jedoch nicht sinnvoll ist. Deshalb muss diese Moglich-keit abgefragt und gegebenfalls der alte Aufstellsinus beibehalten werden. Bei

7.3. BOXING 41

einem”Flip“ wird versucht, das Protein um 180◦ zu drehen. Kommt es dabei

zu keiner Uberlappung, wird der Flip akzeptiert. Flips dienen dazu, metastabileZwischenkonfigurationen zu vermeiden und die Equilibrierung zu beschleunigen.

Durch die Translationsbewegung konnte es passieren, dass das bewegte Proteindie Boxgrenze uberschreitet. Das verschobene Protein braucht jedoch noch nichtsofort in seine neue Box einsortiert zu werden, weil die Boxgrosse so gewahltist, dass noch keine Uberlappung mit der ubernachsten Box auftreten kann. DasProtein kann also maximal in die nachste Box rutschen. Solange es jedoch inseiner alten Box bleibt oder in eine der Nachbarboxen wandert, beeinflusst es diePotentialberechnung nicht. Deshalb braucht das verschobene Protein an dieserStelle noch nicht richtig einsortiert zu werden, sondern man kann damit warten,bis das Potential berechnet und die Bewegung akzeptiert wurde.

Um nun die Akzeptanz des Schrittes zu uberprufen, wird zunachst getestet, obeine Uberlappung zwischen dem bewegten Protein und einem der festgehaltenenProteine entstanden ist. Weiterhin wird uberpruft, ob die Veranderung akzeptiertwird. Dies geschieht auf jeden Fall, wenn der neue Zustand energetisch gunstigerist als der alte. Ist er es nicht, so wird er trotzdem mit einer Wahrscheinlichkeitvon

P = exp

(−∆E

kT

)(7.1)

akzeptiert. Wurde der Schritt angenommen, kann das ursprungliche Proteinob-jekt verworfen werden und das neue Proteinobjekt wird korrekt in die Boxeneinsortiert. Wurde die Veranderung hingegen nicht akzeptiert, so wird einfachmit den ursprunglichen Daten weitergerechnet.Dabei werden zunachst Mittelwerte aus den Daten des Programmdurchlaufs be-rechnet, die dann in die Datei geschrieben werden. Aus dieser Datei berechnetschliesslich das Programm Nematic.C die nematischen Ordnungsparameter, an-hand derer das Verhalten des Systems beurteilt werden kann.Es werden außerdem alle N SKIP Iterationen komplette Konfigurationen gespei-chert. Aus diesen konnen zum einen PovRay-Dateien erzeugt werden, zum ande-ren dienen sie zum Zwischenspeichern, falls das Programm zwischendurch beendetwird.

7.3 Boxing

Da die Energie- bzw. Potentialberechnung bei der Simulation oft den weitausgroßten Bedarf an Rechenzeit fur sich beansprucht, empfiehlt es sich, genau andieser Stelle mit der Optimierung anzusetzen. Eine gute Moglichkeit, dies zu tun,ist, nicht die Paarpotentiale zwischen allen Teilchen zu berechnen, sondern nurzwischen Teilchen, die einen vorgegebenen Maximalabstand nicht uberschreiten.


Dies ist gerade dann sehr zu empfehlen, wenn man periodische Randbedingun-gen verwendet und bei nicht abschneiden des Potentials die Abstande zu allenBildern eines Teilchens berechnen musste. Jedoch ist auch zu bedenken, dass dasAbschneiden von Wechselwirkungen Probleme bei der Energieerhaltung hervor-rufen kann.

Eine Moglichkeit, den Wechselwirkungsradius sinnvoll zu begrenzen, ist die Ver-lettabelle: Neben den Teilchen, die innerhalb des Wechselwirkungsradius einesgegebenen Teilchens liegen, speichert man auch noch die Partikel in der unmit-telbaren Umgebung, also im Abstand des sogenannten Verletradius mit rv > rc.Dabei ist rv der Verletradius und rc der Cut-off-Radius, ab dem die Wechselwir-kungen abgeschnitten werden. Solange sich das betrachtete Teilchen nicht weiterals die Differenz rv − rc bewegt, braucht man nur die Wechselwirkung zu denTeilchen innerhalb des Wechselwirkungsradius zu berechnen. Andernfalls wirdzunachst die Verlettabelle aktualisiert. Da dieser Fall aber vergleichsweise selteneintritt, ist der Rechenaufwand insgesamt ein wenig niedriger.

Eine weitere – und von uns praferierte – Moglichkeit, die Berechnung uberflussi-ger Paarpotentiale zu vermeiden, ist das

”Boxing“ : Das Simulationsvolumen wird

in kleinere Felder unterteilt, die jeweils eine Seitenlange haben, die gleich odergeringfugig großer als der Wechselwirkungsradius ist. Jedes Teilchen interagiertdann nur mit Partikeln aus seiner eigenen Box oder den unmittelbaren Nachbar-boxen. Dieses Verfahren ist jedoch erst dann von Vorteil, wenn die Anzahl derBoxen in mindestens einer Raumrichtung grosser als drei ist [13]. Denn hatte manin jeder Richtung maximal drei Boxen, so ware jede Box Nachbarbox zu allen an-deren, was im Endeffekt wieder darauf hinauslauft, dass doch alle Paarpotentialeberechnet werden mussen.

In unserem Programm ist die Klasse Boxing fur das Einsortieren der Proteine indie Boxen zustandig: Proteine werden in Boxen einsortiert, damit nicht immerdie Wechselwirkungen mit allen anderen Proteinen berechnet werden mussen.Dazu wird das Simulationsvolumen in mehrere Boxen unterteilt, deren Anzahlentsprechend der Grosse des Simulationsraumes, der maximalen Translation unddem Wechselwirkungsradius berechnet wird. Auf diese

”Facher“ werden dann die

Proteine der aktuellen Konfiguration verteilt, wobei ein neues Boxing nur dannkonstruiert werden kann, wenn man die entsprechende Konfiguration als Para-meter mitgibt.Nachdem ein Boxing bereits existiert und ein Protein bewegt wurde, kummertsich die Methode void resort(int protein,double oldX,double oldY) dar-um, dass das Protein wieder in die richtige Box kommt: Um Rechenzeit zu sparen,wird zunachst gepruft, ob das Protein vielleicht nur innerhalb seiner bisherigenBox verschoben wurde, so dass es deshalb nicht neu einsortiert werden muss. Istdas Protein durch seine Translationsbewegung in eine andere Box geraten, wirdes aus der alten Box geloscht und in die neue Box einsortiert.

7.3. BOXING 43

Abbildung 7.3: Die beiden verwendeten Nachbarschaftsmodelle. Links dargestellt dasgerichtete Nachbarschaftsmodell, rechts das ungerichtete. Blau dargestellt ist jeweilsdie aktuelle Box, rot die entsprechenden Nachbarboxen.

In unserer Simulation gibt es dazu in der Klasse Box Methoden

• um zu einer Box die Nummern (Indizes) der in ihr enthaltenen Proteinezuruckzugeben (list<int>& getProteins()),

• um durch das System zu gehen, und dabei die Nachbarn in einer Richtungeinschließlich der Bezugsbox zu erhalten (nur in einer Richtung, damit mannichts doppelt zahlt; list<Box*>& getDirectedNeighbours())

• und um die acht Nachbarboxen und die Bezugsbox zu erhalten, umzu prufen, ob sich das Potential lokal geandert hat (list<Box*>&getAllNeighbours()).

Dabei wird in Bezug auf die direkten Nachbarboxen auch darauf geachtet, obeventuell die periodischen Randbedingungen beachtet werden mussen. Und beinur ein oder zwei Boxen (in einer Richtung) wird darauf geachtet, dass dann dieBox ihre eigene Nachbarbox ist, bzw. dass beide Nachbarn identisch sind. Indemhierauf geachtet wird, kann der Berechnungsaufwand wiederum reduziert werden.Bei den Nachbarboxen wird zwischen den gerichteten Nachbarn und allen Nach-barn unterschieden: Unter letztere fallen die betrachtete Box selbst und alle ihreacht Nachbarn. Zu den gerichteten Nachbarn gehoren dagegen nur die aktuelleBox, die Box uber ihr und die drei Boxen auf der rechten Seite.

Die gerichteten Nachbarn werden verwendet, wenn man das Gesamtpotential be-rechnet und dazu sowieso alle Boxen der Reihe nach durchgeht. Denn wenn mander Reihe nach alle Boxen durchgeht, besteht keine Gefahr, eine bei der Berech-nung zu vergessen. Alle Nachbarn einer Box sind dagegen dann interessant, wennman nur ein lokales Potential berechnen will: da man in diesem Fall nicht dieBoxen in einer geregelten Reihenfolge durchlauft, konnte bei Verwendung dergerichteten Nachbarn nicht sichergestellt werden, dass wirklich alle benotigtenBoxen betrachtet werden.


Kapitel 8

Visualisierung

8.1 Ziel der Visualisierung

Eine Visualisierung der bei den Simulationslaufen entstanden Daten war sowohlfur die Entwicklung der Simulation, als auch fur die Auswertung von großer Be-deutung. Durch die erfolgte Visualisierung ließen sich Fehler im Programm, diesonst erst durch aufwendige Datenanalyse gefunden worden waren, leicht auf-spuren. So wurde beispielsweise ein Fehler in den periodischen Randbedingungendurch Betrachtung der Abbildung 8.1 gefunden.

8.2 Verwendete Programme

Fur die Visualisierung wurde auf bestehende Programmpakete zuruckgegriffen,um den Entwicklungsaufwand moglichst gering zu halten. Nachdem erste Visua-lisierungsansatze mit dem pdb-Format unter rasmol keinen Erfolg zeigten, undeine Darstellung im VRML-Format aufgrund der Systemabhangigkeit der Viewerausschied, fiel die Wahl auf eine Darstellung mittels des Raytracing-Programmspovray1. Um die Umsetzung der Konfigurationsdateien in die Szenenbeschrei-bungssprache zu ermoglichen wurde das Programm provis (PROteinVISualisie-rung) erstellt.

8.3 Das Visualisierungsprogramm provis

Aufgabe des Programms provis ist es, aus einer Konfigurationsdatei im simula-tionseigenen cnf-Format eine povray-Szenenbeschreibungsdatei zu erzeugen. Fur

1http://www.povray.org

45

46 KAPITEL 8. VISUALISIERUNG

Abbildung 8.1: Visualisierung einer Konfiguration eines Testlaufs. Aufgrund fehler-hafter Randbedingungen bildet sich ein Randmuster aus.

8.3. DAS VISUALISIERUNGSPROGRAMM PROVIS 47

verschiedene Phasen der Simulationsentwicklung waren verschiedene Visualisie-rungen notig, so dass innerhalb des Programms die Moglichkeit bestehen sollteeinzelne Teile der Proteine auszublenden. Dies erfolgt uber die Kommandozeilen-optionen plotA, plotB, hideA und hideB. Zusatzlich stehen Optionen zum Anzei-gen eines Koordinatensystems (axes), zur Wahl eines Blickwinkels (viewpoint),zur Darstellung der kontinuierlichen Randbedingungen (continuous) und zurVerbesserung der Darstellung uber den Einsatz von Texturen fur die Wassero-berflache (spice) zur Verfugung. Fur die Implementation dieser Kommandozei-lenoptionen wurde die C++ -Bibliothek CmdLine von Brad Appleton2 verwendet.Die Syntax des Programms provis lautet zusammengefasst:

Usage: provis [--plotA] [--plotB] [--hideA] [--hideB] [--spice] [--continious][--axes] [--output-file filename] [--viewpoint] input-file

Options/Arguments:--plotA plot helix A.--plotB plot helix B.--hideA hide helix A.--hideB hide helix B.--spice spice up the image (textures...).--continuous continuous borders (use with care).--axes plot axes.--output-file filename output file to write.--viewpoint set viewpoint.input-file input file to read.

2http://www.cmcrossroads.com/bradapp/ftp/src/libs/C++/CmdLine.html

48 KAPITEL 8. VISUALISIERUNG

Kapitel 9

Ergebnisse

9.1 Zweidimensionale Spharozylinder

9.1.1 Simulation

Als Test und zum Vergleich wurden zunachst Simulationen durchgefuhrt, beidenen der zweite Spharozylinder (Helix B) abgeschaltet war1. Als Parametersatzwurden die in Tabelle 9.1 aufgefuhrten Werte verwendet.

Die Startkonfiguration wurde als regelmaßiges Gitter aus Spharozylindern, dieparallel zur y-Achse des Systems ausgerichtet sind, aufgesetzt. Alle 10 Itera-tionen wurden die relevanten Daten aus der aktuellen Konfiguration berechnetund in eine Ausgabedatei geschrieben. Zusatzlich wurde alle 5000 Iterationen diekomplette Konfiguration gesichert. Insgesamt wurden 4 500 000 Iterationen simu-liert. Die ersten 1 500 000 Iterationen wurden als Equilibrierungsphase gewahlt, sodass von den insgesamt erzeugten 450 000 Stutzstellen die letzten 300 000 zur Er-mittlung der statistischen Mittelwerte herangezogen wurden. Die Teilchenanzahlwurde dabei von 100 bis 720 variiert.2

1Technisch wurde dies durch einen Compilerschalter realisiert.2Mit 720 Proteinen ist das System vollstandig gefullt.

Simulationsparameter WertSystemgroße 120 x 120Lange des Spharozylinders lA 8.0Radius des Spharozylinders rA 1.0Anzahl Iterationen insgesamt 4 500 000Iterationen zwischen Stutzstellen 10Equilibrierungsschritte 1 500 000gemittelt uber 300 000

Tabelle 9.1: Parameter fur die Simulation ohne Helix B

49

50 KAPITEL 9. ERGEBNISSE

0.2

0.3

0.4

0.5

0.6

0.7

0.8

0.9

1

0 50000 100000 150000 200000 250000 300000 350000 400000 450000

S

Iterationen

560 Teilchen570 Teilchen580 Teilchen590 Teilchen600 Teilchen610 Teilchen

Abbildung 9.1: Der Verlauf des nematischen Ordnungsparameters. Fur Teilchenzahlen<590 equilibriert S schnelle gegen Null. Ab 600 Teilchen wird eine nematische Phasestabil.

9.1.2 Ergebnisse

Die Ergebnisse fur ein solches zweidimensionales System von Spharozylindernsind in den Abbildungen 9.1 bis 9.2 und in Tabelle 9.2 auf Seite 52 dargestellt.

Der Verlauf des nematischen Ordnungsparameters fur Teilchenzahlen im interes-santen Bereich (Abbildung 9.1) zeigt, dass sich das System bis zu einer Zahl von580 Teilchen (ρ = 40, 28·10−3) vom geordneten Anfangszustand in einen ungeord-neten Zustand bewegt. Der nematische Ordnungsparameter fluktuiert nahe Null.Bei 590 Teilchen (ρ = 40, 97 · 10−3) scheint sich das System auch in einen unge-ordneten Zustand zu entwickeln, jedoch sehr viel langsamer. Das System scheintwahrend der 4 500 000 Iterationen jedoch noch kein Gleichgewicht erreicht zu ha-ben, so dass eine klare Aussage uber die vorliegende Phase nicht moglich ist.Unter Umstanden handelt es sich um eine Region, in der die isotrope oder dienematische Phase metastabil ist. Moglicherweise koexistieren die beiden Phasenauch. Ab 600 Teilchen (ρ = 41, 67 · 10−3) liegt ganz klar eine geordnete Phasevor. Der nematische Ordnungsparameter fluktuiert um Werte nahe Eins.

Es liegt also im Bereich von 590 Teilchen ein Phasenubergang vor. Auf Grund desstarken Sprungs in den Mittelwerten des nematischen Ordnungsparamters (Ab-bildung 9.2) kann man darauf schließen, dass es sich um einen Phasenubergangerster Ordnung handelt. Dieser Phasenubergang wird getrieben durch die sinken-de freie Flache pro Molekul zu hoheren Anzahldichten. Das System versucht, dasSinken der Translationsenergie auszugleichen, indem es durch die Ausrichtung der

9.1. ZWEIDIMENSIONALE SPHAROZYLINDER 51

0.3

0.4

0.5

0.6

0.7

0.8

0.9

1

100 200 300 400 500 600 700 800

S

Anzahl Proteine

Abbildung 9.2: Der Mittelwert des nematischen Ordnungsparameters. Der deutlicheSprung bei ≈590 Teilchen deutet auf einen Phasenubergang erster Ordnung hin.

Teilchen die Orientierungsentropie senkt, dafur aber wieder mehr freie Flache ge-winnt. Die leichte Delle in der Kurve im Bereich nach 600 Teilchen konnte einEffekt der Startkonfigurationen oder einer zu kurzen Equilibrierungsphase sein.Im Bereich um 700 Teilchen sind aufgrund der Randbedingungen des Systems(Helix A wird in der z-Ebene festgehalten) keine Aussagen mehr moglich. Es istanzunehmen, dass in diesem Bereich die Monoschicht kollabiert.

In den Abbildungen 9.3 bis 9.6 auf Seite 53 bis 54 sind Momentaufnahmen vonKonfigurationen gezeigt, in denen man die verschiedenen Phasen erkennen kann.Uber den Bereich der durchgefuhrten Simulationen treten eine isotrope und einenematische Phase auf. Die isotrope Phase hat bei niedrigen Dichten Ahnlich-keit mit einer Gasphase (Abbildung 9.3): die Teilchen sind vollig ungeordnetund haben einen großen intermolekularen Abstand. Bei hoheren Dichten sind dieTeilchen naher aneinandergeruckt, zeigen aber nach wie vor ungeordnet in alleRichtungen (Abbildung 9.4). In der nematischen Phase (Abbildung 9.6) schließ-lich richten sich die Teilchen in eine gemeinsame Vorzugsrichtung aus. In Ab-bildung 9.5 ist eine Konfiguration aus dem Ubergangsbereich zwischen isotropund nematisch dargestellt. Diese Ergebnisse fur das System zweidimensionalerSpharozylinder stimmen mit bekannten Ergebnissen aus der Literatur uberein[33].3

3Die ubrigen bekannten Phasen fur harte Spharozylinder lassen sich mit unseren Methodennicht identifizieren bzw. treten in zwei Dimensionen nicht auf. Durch Einfuhrung attraktiverWechselwirkungen ließe sich auch ein Gas-Flussig-Ubergang feststellen.


N ρρρ/ [N ][V ]

S Phase

100 6, 94 · 10−3 0.320938 isotrop150 10, 42 · 10−3 0.310401 isotrop200 13, 89 · 10−3 0.305503 isotrop250 17, 36 · 10−3 0.303917 isotrop300 20, 83 · 10−3 0.304360 isotrop350 24, 31 · 10−3 0.306911 isotrop400 27, 78 · 10−3 0.311348 isotrop450 31, 25 · 10−3 0.314308 isotrop500 34, 72 · 10−3 0.319597 isotrop510 35, 42 · 10−3 0.318021 isotrop520 36, 11 · 10−3 0.314186 isotrop530 36, 81 · 10−3 0.317162 isotrop540 37, 50 · 10−3 0.313722 isotrop550 38, 19 · 10−3 0.311464 isotrop560 38, 89 · 10−3 0.314552 isotrop570 39.58 · 10−3 0.323916 isotrop580 40, 28 · 10−3 0.336863 isotrop590 40, 97 · 10−3 0.588103600 41, 67 · 10−3 0.844228 nematisch610 42, 36 · 10−3 0.942823 nematisch620 43, 06 · 10−3 0.918031 nematisch630 43, 75 · 10−3 0.908573 nematisch640 44, 44 · 10−3 0.919809 nematisch650 45, 14 · 10−3 0.945529 nematisch700 48, 61 · 10−3 0.921781 nematisch710 49, 31 · 10−3 0.990223 nematisch720 50, 00 · 10−3 1.000000 nematisch

Tabelle 9.2: Ergebnisse der Simulationen ohne Helix B. Die Werte des nematischenOrdnungsparameters springen von ≈0,3 fur N < 590 auf ≈0,9 fur N > 590.

9.1. ZWEIDIMENSIONALE SPHAROZYLINDER 53

Abbildung 9.3: Isotrope Phase (gasartiger Charakter) (300 Teilchen): Die Teil-chen sind vollig ungeordnet und haben einen großen intermolekularen Abstand.

Abbildung 9.4: Isotrope Phase (flussiger Charakter) (570 Teilchen): Die Teilchensind dichter zusammen, zeigen nach wie vor aber ungeordnet in alle Richtungen.


Abbildung 9.5: Ubergangsbereich (590 Teilchen) Eine gewisse Ordnung der Teil-chen ist erkennbar. Moglicherweise handelt es sich um eine metastabile Phase oder einKoexistenzgebiet.

Abbildung 9.6: Nematische Phase (610 Teilchen): Die Teilchen sind in eine gemein-same Richtung orientiert.

9.2. SIMULATION VON APO C-I 55

9.2 Simulation von APO C-I

9.2.1 Simulation

Nachdem sich das implementierte System als korrekt und tauglich erwiesen hat-te, wurden Simulationen des vollstandigen APO C-I Molekuls durchgefuhrt. ZurPotentialberechnung wurde das in Abschnitt 5.2.1 beschriebene Modell harterSpharozylinder zusammen mit den intramolekularen und externen Wechselwir-kungen aus Abschnitt 5.4 und 5.5 verwendet. Die Parameter fur die Simulationensind in Tabelle 9.3 angegeben.

Als Anfangskonfiguration wurden jeweils equilibrierte Konfigurationen von denSimulationen aus Abschnitt 9.1 verwendet. Da die Helix B in den vorherigenSimulationen in der Potentialberechnung nicht berucksichtigt wurde, musstenmogliche Uberlappungen in den Konfigurationen ausgeschlossen werden. Die He-lices B wurden daher senkrecht zur Monoschicht stehend aufgesetzt. Das Systemwurde 5 000 000 Iterationen lang simuliert. Alle 10 Konfigurationen wurden dierelevanten Daten berechnet und in eine Ausgabedatei geschrieben. Alle 10 000 Ite-rationen wurde die aktuelle Konfiguration gespeichert. Von den 500 000 erzeugtenStutzstellen wurden die letzten 200 000 zur Berechnung der Ensemblemittelwerteherangezogen. Es wurden Simulationen fur Proteinzahlen im Bereich von 50 bis720 durchgefuhrt.

Simulationsparameter WertSystemgroße 120 x 120Lange lA von Helix A 8Radius rA von Helix A 1Lange lB von Helix B 5Radius rB von Helix B 1Steifigkeit kstiff 10Hydrophilitat khydro 10Anzahl Iterationen insgesamt 5 000 000Iterationen zwischen Stutzstellen 10Equilibrierungsschritte 3 000 000gemittelt uber 200 000

Tabelle 9.3: Parameter fur die Simulation von APO C-I


0

0.2

0.4

0.6

0.8

1

0 50000 100000 150000 200000 250000 300000 350000 400000 450000 500000

S

Iterationen

250 Proteine400 Proteine500 Proteine580 Proteine590 Proteine600 Proteine610 Proteine

Abbildung 9.7: Der Verlauf des nematischen Ordnungsparameters fur verschiedeneProteinzahlen. An der Kurve fur 400 Proteine erkennt man, daß sich durch die hinzu-gekommene Helix B schon fruher eine nematische Ordnung einstellt als bei einfachenSpharozylindern.

9.2.2 Ergebnisse

Die Ergebnisse aus den Simulationen von APO C-I sind in den Abbildungen 9.7bis 9.9 auf Seite 56 bis 58 und in Tabelle 9.4 auf Seite 60 dargestellt.

Die berechneten Mittelwerte bei 510 Proteinen zeigen deutliche Abweichungenvon ihrer Umgebung. Momentaufnahmen der Konfiguration zeigen jedoch keineBesonderheiten, die dies erklaren konnten. Dieser Wert wurde daher als Ausrei-ßer interpretiert, der moglicherweise auf die Rahmenbedingungen der Simulationzuruckzufuhren ist.4

Bis zu 400 Proteinen (ρ = 27, 78 · 10−3) zeigt sich fur das Apolipoprotein C-Iqualitativ dasselbe Verhalten wie fur zweidimensionale Spharozylinder, die ne-matische Phase wird jedoch aufgrund der hinzugekommenen zweiten Helix jetzteher erreicht.

4Vgl. Abschnitt 9.4. Erganzende Simulationen deuten darauf hin, dass die vorliegende Kon-figuration mit 510 Proteinen sehr langsam equilibriert und im hier ausgewerteten Bereich dasGleichgewicht noch nicht erreicht hat.


0

0.1

0.2

0.3

0.4

0.5

0.6

0.7

0.8

0.9

1

0 100 200 300 400 500 600 700 800

S

Anzahl Proteine

Helix AHelix B

beide Helices

Abbildung 9.8: Der Mittelwert der nematischen Ordnungsparameter fur Helix A, HelixB und fur beide Helices. Man erkennt zwei isotrop-nematische Ubergange bei ungefahr350 bzw. 600 Proteinen. Beim ersten Phasenubergang richten sich Helix A und B ge-meinsam aus, beim zweiten steht Helix B aus der Monoschicht heraus.

Fur 400 Proteine sieht man am Verlauf des nematischen Ordnungsparameters inAbbildung 9.7, dass das System aus der Anfangskonfiguration in eine geordne-tere Konfiguration equilibriert, weil die anfangs hochstehende Helix B aufgrunddes hydrophilen Potentials auf die Monolage sinkt. Dadurch steht in der Schichtweniger freie Flache zur Verfugung, so dass die Proteine nicht mehr vollig un-geordnet in alle Richtungen zeigen. Am Mittelwert des nematischen Ordnungs-parameter in Abbildung 9.8 kann man ablesen, dass bei 400 Proteinen die erstenematische Phase erreicht ist, bei der sowohl Helix A als auch Helix B in derEbene z = 0 liegen und sich in eine gemeinsame Vorzugsrichtung orientieren.Die niedrige Biaxialitat (Abbildung 9.9) in diesem Bereich zeigt, dass die Ori-entierungsrichtung fur Helix A und Helix B die selbe ist. Der starke Sprung imnematischen Ordnungsparamter lasst darauf schließen, dass der Phasenubergangvon isotrop nach nematisch ein Ubergang erster Ordnung ist.

Wird die Anzahldichte weiter erhoht, verschwindet diese Ordnung jedoch wiederund die Helices A bilden ab 500 Proteinen (ρ = 34, 72 ·10−3) wieder eine isotropePhase, ebenso sind auch die Helices B nicht mehr ausgerichtet. Aufgrund dermodellierten Eigenschaften des simulierten Systems kann man dies nur dadurch


0

0.1

0.2

0.3

0.4

0.5

0.6

0.7

0.8

0 100 200 300 400 500 600 700 800

Bia

xial

itaet

Anzahl Proteine

Helix AHelix B

beide Helices

Abbildung 9.9: Der Mittelwert der Biaxialitat fur Helix A, Helix B und fur beideHelices. Beim ersten Phasenubergang ist die Orientierungsrichtung fur beide Heliceseindeutig. Fur Helix B bleibt sie niedrig, weil Helix B aus der Monoschicht heraussteht.Gegen Ende gehen die Einzelbiaxialitaten gegen Null und die gemeinsame gegen Eins,da sich Helix A und Helix B in verschiedene Richtungen ausrichten.

erklaren, dass die Helices sich kollektiv gegen die Hydrophilitat aus der Monolageherausheben. Darauf deutet auch die niedrig bleibende Biaxialitat von Helix Bhin (vgl. Abbildung 9.9), und die Momentaufnahme einer entsprechenden Konfi-guration (Abbildung 9.13) bestatigt dies ebenfalls. Durch das Herausheben vonHelix B entsteht in der Schicht wieder mehr freie Flache, so dass sich die Helices Awieder ungeordnet in alle Richtungen orientieren konnen. Dieser Phasenubergangwird also getrieben durch einen Ausgleich zwischen einer Erhohung der Energiedurch die Hydrophilitat auf der einen zugunsten einer hoheren Translations- undOrientierungsentropie auf der anderen Seite. Die Phasen mit aus der Monolageherausstehender Helix B bezeichnen wir mit dem Zusatz desorbiert. Entsprechendnennen wir die Phase zwischen 500 und 580 Proteinen desorbiert-isotrope Phase.

Mit weiter steigender Anzahldichte stellen sich dann wieder nematische Ord-nungen der Helices ein, und zwar zunachst fur Helix A ab 600 Proteinen (ρ =41, 67 ·10−3) und dann fur Helix B bei ungefahr 690 Proteinen (ρ = 47, 92 ·10−3).Die Biaxialitat fur beide Helices wird dabei fast Eins, die einzelnen Biaxialitatendagegen gehen gegen Null. Dies bedeutet, dass die Orientierungsrichtungen von


Helix A und Helix B verschieden sind. Die Helices A sind in der Ebene ausgerich-tet, wahrend die Helices B aus der Ebene herausstehen. Dabei sind die Proteineso orientiert, dass sich die Helix B immer an der gleichen Seite befindet wie beiden Nachbarproteinen. Schließlich ist im gesamten System eine entsprechendeOrientierung der Proteine vorhanden. Diese Phase bezeichnen wir als desorbiert-nematische Phase. Wiederum kann man aufgrund des Sprunges im nematischenOrdnungsparameter den Phasenubergang als Ubergang erster Ordnung charak-terisieren.

In den Abbildungen 9.10 bis 9.15 auf Seite 61 bis 63 sind Momentaufnahmen derauftretenden Zustande gezeigt. Folgende Zustande konnten identifiziert werden:isotroper (gasartig), isotroper (flussig), nematischer, desorbiert-isotroper und de-sorbiert-nematischer Zustand. Im gasartigen Zustand haben die Proteine einengroßen intermolekularen Abstand und sind vollig ungeordnet. Die Helix B liegtaufgrund der Hydrophilitat in der Monoschicht (Abbildung 9.10). Der gasarti-ge Zustand entwickelt sich wie bei zweidimensionalen Spharozylindern zu einemZustand mit flussigem Charakter, in der die Teilchen dichter zusammen liegen, je-doch bezuglich ihrer Orientierung immer noch ungeordnet sind (Abbildung 9.11).Zu hoheren Anzahldichten hin entsteht dann der nematische Zustand (Abbildung9.12), in der sich Helix A und Helix B – die aufgrund der Hydrophilitat immernoch in der Schichtebene liegt – in eine gemeinsame Richtung orientieren. Wirddie Anzahldichte weiter erhoht, hebt sich Helix B aus der Monolage heraus, sodass desorbierte Zustande entstehen. Zunachst entsteht durch das Aufrichten vonHelix B in der Schicht wieder mehr freie Flache pro Molekul, so dass die Helices Awieder ungeordnet in alle Richtungen zeigen konnen. Diesen Zustand haben wirals desorbiert-isotropen Zustand bezeichnet (Abbildung 9.13). Bei sehr hohen An-zahldichten schließlich zeigt sich wiederum, dass sich die Proteine zur Erhohungder freien Flache nematisch anordnen. Dies gilt sowohl fur Helix A als auch furHelix B. Der enstehende desorbiert-nematische Zustand ist in Abbildung 9.15dargestellt.

60K

AP

ITE

L9.

ER

GE

BN

ISSE N ρρρ/ [N ]

[V ] SA ηAηAηA SB ηBηBηB SAB ηABηABηAB Phase50 3, 47 · 10−3 0.351244 0.648756 0.338626 0.619478 0.340552 0.638066 isotrop

100 6, 94 · 10−3 0.330678 0.669322 0.316866 0.637760 0.321053 0.656029 isotrop150 10, 42 · 10−3 0.329737 0.670263 0.314081 0.635905 0.320065 0.654760 isotrop200 13, 89 · 10−3 0.343117 0.656883 0.324111 0.618685 0.332508 0.638748 isotrop250 17, 36 · 10−3 0.375693 0.624307 0.350316 0.579296 0.362371 0.602295 isotrop300 20, 83 · 10−3 0.477326 0.522674 0.437668 0.465940 0.457252 0.494388 isotrop350 24, 31 · 10−3 0.675118 0.324882 0.600009 0.242165 0.637442 0.283376400 27, 78 · 10−3 0.796970 0.203030 0.659644 0.056832 0.728153 0.128319 nematisch450 31, 25 · 10−3 0.525532 0.474468 0.345550 0.153067 0.435214 0.312083500 34, 72 · 10−3 0.328695 0.671305 0.117400 0.112504 0.222022 0.388721 desorbiert-isotrop510 35, 42 · 10−3 0.606195 0.393805 0.303192 0.129624 0.453597 0.135397 desorbiert-isotrop520 36, 11 · 10−3 0.447618 0.552382 0.175856 0.067077 0.308924 0.249565 desorbiert-isotrop530 36, 81 · 10−3 0.387501 0.612499 0.112233 0.086751 0.247081 0.283249 desorbiert-isotrop540 37, 50 · 10−3 0.390720 0.609280 0.106573 0.093947 0.243231 0.257355 desorbiert-isotrop550 38, 19 · 10−3 0.409297 0.590703 0.142925 0.103791 0.251149 0.224868 desorbiert-isotrop560 38, 89 · 10−3 0.284057 0.715943 0.086351 0.049368 0.139353 0.297988 desorbiert-isotrop570 39, 58 · 10−3 0.338697 0.661303 0.105668 0.102835 0.170938 0.231695 desorbiert-isotrop580 40, 28 · 10−3 0.319299 0.680701 0.140409 0.079409 0.145784 0.219326 desorbiert-isotrop590 40, 97 · 10−3 0.458250 0.541750 0.192877 0.204003 0.243503 0.089511600 41, 67 · 10−3 0.732462 0.267538 0.270333 0.398887 0.436936 0.130365 desorbiert-nematisch610 42, 36 · 10−3 0.827115 0.172885 0.260072 0.520529 0.489227 0.228167 desorbiert-nematisch620 43, 06 · 10−3 0.792344 0.207656 0.297049 0.458416 0.450309 0.219748 desorbiert-nematisch630 43, 75 · 10−3 0.819091 0.180909 0.396730 0.397220 0.461873 0.254159 desorbiert-nematisch640 44, 44 · 10−3 0.813358 0.186642 0.388661 0.409407 0.444565 0.267806 desorbiert-nematisch650 45, 14 · 10−3 0.876851 0.123149 0.402778 0.459284 0.454372 0.353518 desorbiert-nematisch660 45, 83 · 10−3 0.975584 0.024416 0.477439 0.450500 0.502251 0.437282 desorbiert-nematisch670 46, 53 · 10−3 0.985150 0.014850 0.558532 0.374810 0.494139 0.457522 desorbiert-nematisch680 47, 22 · 10−3 0.988354 0.011646 0.610685 0.326078 0.427657 0.528977 desorbiert-nematisch690 47, 92 · 10−3 0.993267 0.006733 0.673468 0.277265 0.416149 0.551915 desorbiert-nematisch700 48, 61 · 10−3 0.916929 0.083071 0.937380 0.053951 0.218792 0.639952710 49, 31 · 10−3 0.978951 0.021049 0.944735 0.047550 0.260035 0.704543 kollaps720 50, 00 · 10−3 1.000000 0.000000 1.000000 0.000000 0.250000 0.750000 kollaps

Tabelle 9.4: Ergebnisse der Simulation des Apolipoproteins C-I. Aufgefuhrt sind der nematische Ordnungsparameter und dieBiaxialitat fur Helix A und B getrennt und fur beide Helices zusammen. In der letzten Spalte sind die jeweiligen Phasen eingetragen,sofern sie eindeutig identifiziert werden konnten.


Abbildung 9.10: Isotroper Zustand (gasartiger Charakter) (150 Proteine): Derintermolekulare Abstand der Proteine ist groß. Beide Helices liegen auf der Monolageund sind bezuglich ihrer Richtung ungeordnet.

Abbildung 9.11: Isotroper Zustand (flussiger Charakter) (250 Proteine): DerAbstand zwischen den Teilchen ist geringer, die Helices zeigen aber nach wie vor unge-ordnet in alle Richtungen.


Abbildung 9.12: Nematischer Zustand (400 Proteine): Die Proteine haben sich mitbeiden Helices entlang einer Vorzugsrichtung angeordnet. Beide Helices liegen noch aufder Monoschicht.

Abbildung 9.13: Desorbiert-isotroper Zustand (580 Proteine): Helix B hat sich vonder Monolage gelost und steht heraus. Dadurch ist in der Schicht Flache frei geworden,so daß Helix A wieder ungeordnet in alle Richtungen zeigt.


Abbildung 9.14: Desorbiert-nematischer Zustand (610 Proteine): Die Helices wei-sen wieder nematische Ordnungen auf. Helix A hat sich in der Monoschicht ausgerichtet,und die Helices B stehen in einer kollektiven Richtung heraus.

Abbildung 9.15: Moglicher Kollaps (680 Proteine): Diese Phase ist vollig geord-net. Moglicherweise ware eine reale Langmuir-Schicht bei dieser Anzahldichte schonkollabiert.


9.3 Interpretation der Ergebnisse

9.3.1 Vergleich zwischen APO C-I und harten Spharozy-

lindern

Das simulierte Modell von APO C-I kann als Erweiterung des Modells harterSpharozylinder aufgefasst werden. Ein Vergleich der Ergebnisse aus Abschnitt5.2.1 und dem vorigen Abschnitt 9.2.2 bietet sich daher an.

Wahrend bei den harten Spharozylindern nur die Phasen isotrop und nematischauftreten, konnen in der Simulation von APO C-I zwei weitere Phasen identifiziertwerden: die desorbiert-isotrope und die desorbiert-nematische Phase. Diese tretenin Richtung hoherer Anzahldichten nach den anderen drei Phasen auf und sindauf den Einfluss der zweiten Helix B zuruckzufuhren. Durch die Helix B stehtweniger freie Flache pro Molekul in der Monoschicht zur Verfugung. Dies hatzur Folge, dass die von den harten Spharozylindern bekannten Phasenubergangesich zu niedrigeren Anzahldichten verschieben. Der isotrop-nematische Ubergangverschiebt sich von 600 Teilchen bei harten Spharozylindern zu ungefahr 300Teilchen. Dies ist auch zu erwarten, da sich durch die hinzugekommene Helix Bdie Teilchendichte ungefahr verdoppelt. Außerdem ist der Sprung im nematischenOrdnungsparameter nicht mehr so deutlich, was daran liegen konnte, dass bereitsin der nicht-desorbierten Phase einige wenige Proteine thermisch von der Monola-ge abheben konnen und so mehr freie Flache zur Verfugung steht. Der Ausgleichzwischen Translations- und Orientierungsentropie wird dadurch wahrscheinlichweniger drastisch.

Das erneute Sinken des nematischen Ordnungsparameters ab 400 Proteinen kanndadurch erklart werden, dass sich die zweite Helix B von der Monolage abhebt,damit mehr freie Flache pro Molekul zur Verfugung steht. Es ensteht zunachst diedesorbiert-isotrope Phase, die dann bei ungefahr 600 Proteinen in die desorbiert-nematische Phase ubergeht. Die Lage bei 600 Proteinen dieses Phasenubergangsstimmt mit dem isotrop-nematischen Ubergang bei harten Spharozylindern ube-rein. Dies liegt daran, dass in der desorbierten Phase nur noch die Helices A inder Monoschicht liegen und sich im Prinzip verhalten wie harte Spharozylinder.Der isotrop-nematische Ubergang der desorbierten Phasen von APO C-I ist alsoidentisch mit dem isotrop-nematischen Ubergang bei harten Spharozylindern.

Unsere Simulationen zeigen, dass sich die Eigenschaften harter Spharozylinderauch im von uns simulierten Modell des Apolipoproteins C-I widerspiegeln. Durchdie Erweiterung des Modells treten jedoch auch neue Effekte auf. So verschiebtsich der erste isotrop-nematische Phasenubergang zu niedrigeren Anzahldichtenund es treten die neuen desorbierten Phasen auf, die direkt auf die hydrophilenEigenschaften des Modells zuruckgefuhrt werden konnen. Im folgenden Abschnittsollen die neuen Effekte mit experimentellen Untersuchungen verglichen werden.

9.3. INTERPRETATION DER ERGEBNISSE 65

9.3.2 Vergleich mit den experimentellen Ergebnissen fur

APO C-I

Das Apolipoprotein C-I wurde von Bolanos-Garcia et al. in einer Langmuir-Blodgett-Wanne experimentell untersucht [1]. Uber Messungen der Oberflachen-spannung und Brewsterwinkel-Mikroskopie konnten zwei Phasenubergange be-obachtet werden. Entsprechende Aufnahmen sind in Abbildung 9.16 gezeigt. Dieverschiedenen Phasen wurden als gasformig, liquid-expanded (LE) und liquid-condensed (LC) bezeichnet; die Phasenubergange wurden als Ubergange ersterOrdnung charakterisiert. In [2] wurde auch fur andere Apolipoproteine ein Pha-senubergang zwischen zwei flussigen Phasen L1 = LE und L2 = LC identifiziert.Durch Rontgenstrukturanalyse konnte nachgewiesen werden, dass die L1-Phasekeine molekulare Ordnung aufweist. Die L2-Phase wurde diesbezuglich bis jetztnoch nicht naher untersucht.

Aufgrund des Fehlens einer molekularen Ordnung muss die L1-Phase aus den Ex-perimenten mit der isotropen Phase aus der Simulation identifiziert werden. Vonden ubrigen drei Phasen, die in der Simulation beobachtet werden (nematisch,desorbiert-isotrop, desorbiert-nematisch) treten offenbar in realen Experimentennicht alle auf. Da die L2-Phase von den Experimentatoren mit dem Heraushe-ben einer Helix des Proteins in Verbindung gebracht wurde, sollte sie mit einerdesorbierten Phase aus der Simulation identifiziert werden. Dies konnte sowohldie desorbiert-isotrope als auch die desorbiert-nematische Phase sein. Weitereexperimentelle Untersuchungen der Struktur der L2-Phase konnten diese Frageklaren.5 Uns erscheint es wahrscheinlicher, dass es sich bei der L2-Phase um diedesorbiert-isotrope handelt, weil die desorbiert-nematische Phase bei sehr hohenAnzahldichten auftritt, wo die Monoschicht moglicherweise schon nicht mehr sta-bil ist.6

Die flussig-nematische Phase mit molekularer Orientierungsordnung konnte inden Untersuchungen der APO C-I Langmuir-Schicht nicht beobachtet werden.Eine mogliche Erklarung dafur konnte in einer unrealistischen Wahl der Kon-stante fur die hydrophile Interaktion liegen, so dass die Helix B zu stark andie Monolage gebunden ist. Bei einer geringeren Hydrophilitat ware es moglich,dass sich die Helix B leichter aus der Ebene herausstellt, so dass der Ubergangzu einer desorbierten Phase schon bei niedrigeren Dichten auftreten konnte. Einzusatzliches attraktives Potential zwischen den Teilchen wurde diesen Effekt nochverstarken, da die erste herausstehende Helix durch attraktive Wechselwirkungenbenachbarte Helices ebenfalls

”hochziehen“ konnte. Moglicherweise wurde unter

Berucksichtigung dieser Aspekte die flussig-nematische Phase instabil, weil dasHerausstellen der Helices B energetisch gunstiger ware als die Verringerung der

5Die Experimentatoren vermuten, dass es sich um eine nematische Phase handelt [4].6Vgl. Abschnitt 9.4 zur Frage, wie die Randbedingungen der Simulation abgeandert werden

konnten, um den Kollaps der Monoschicht zu untersuchen.


Abbildung 9.16: Brewsterwinkel-Aufnahmen der verschiedenen Phasen einer APO C-IMonoschicht. Ganz links oben erkennt man ein gas-flussig Koexistenzgebiet (Π ∼ 0,a = 6500A2

/molec). Die nachsten vier Aufnahmen zeigen verschiedene Beobachtungenin der LE-LC-Koexistenzregion (Π ∼ 37mN/m, a ∼ 1200A2

/molec). Auf dem letztenBild unten rechts handelt es sich um eine kollabierte Monoschicht bei Π ∼ 47mN/m

und a ∼ 550A2/molec (Quelle: [1]).

9.4. DISKUSSION UND AUSBLICK 67

Orientierungsentropie durch Herausbildung einer nematischen Ordnung. Es fandedann ein Phasenubergang direkt zwischen der flussig-isotropen und der desorbier-ten Phase statt, wie im Experiment beobachtet. Die Verringerung der Konstantenfur die Hydrophilitat wurde auch das obige Argument bestarken, dass im Bereich,wo die desorbiert-nematische Phase auftritt, die Monoschicht bereits kollabiert.

Unter diesen Gesichtspunkten kann man die in der Simulation auftretenden Pha-senubergange wie folgt mit den experimentellen Beobachtungen in Verbindungbringen: Der Ubergang zwischen gasformiger und flussiger Phase im Experimententspricht keinem Ubergang in der Simulation7. Der beobachtete Ubergang zwi-schen den flussigen Phasen L1 = LE und L2 = LC korrespondiert zum Ubergangzwischen der flussig-isotropen und der desorbierten Phase in den Simulationen.

Im Rahmen der relativen Einfachheit des simulierten Modells konnen also diePhasenubergange in der APO C-I Monoschicht erklart werden. Es handelt sichum Ubergange erster Ordnung, die getrieben werden vom Ausgleich zwischen frei-er Flache pro Molekul, Orientierungsentropie und hydrophiler Interaktion. Dasvorgestellte Modell reicht aus, um diese konkurrierenden Aspekte qualitativ zubeschreiben und das Phasenverhalten des Apolipoproteins C-I zu reproduzieren.Im folgenden Abschnitt 9.4 werden Vorschlage gemacht, wie man auch quantitati-ve Aspekte genauer untersuchen konnte, um die hier beschriebenen Vermutungenweiter zu stutzen.

9.4 Diskussion und Ausblick

Die in dieser Arbeit beschriebenen Simulationen wurden mit dem Ziel durchge-fuhrt, die in Monoschichten von Apolipoproteinen auftretenden Phasenubergangein einem einfachen Modell nachzuvollziehen. Die Ergebnisse des vorigen Ab-schnitts zeigen, dass das gewahlte Modell ein sinnvoller Ausgangspunkt fur dieUntersuchung ist. In diesem Abschnitt soll diskutiert werden, welche weiterenSchritte gemacht werden konnten, um die bisherigen Ergebnisse zu stutzen undzu verfeinern. Insbesondere soll dabei auf mogliche Erweiterungen des Modellseingegangen werden, die einige Eigenschaften der untersuchten Phasenubergangedetaillierter erklaren konnten.

Eine bekannte Schwierigkeit in Monte Carlo-Simulationen ist die Wahl der Langeder Equilibrierungsphase. Die Stutzstellen fur die Berechnung des Scharmittelsmussen Konfigurationen entsprechen, die im Gleichgewicht eine Boltzmannvertei-lung haben. Damit dies erreicht wird, mussen vor Beginn der Mittelung genugendEquilibrierungsschritte durchgefuhrt werden. Im Bereich nematischer Phasenkonnen sehr viele Equilibrierungsschritte notig sein, so dass leicht durch einen zu

7Durch Hinzunahme attraktiver Wechselwirkungen konnte man auch diesen Phasenubergangreproduzieren.


fruhen Beginn der Mittelung systematische Fehler entstehen konnen. Dies sollteman durch sorgfaltige Analyse der Simulationsdaten moglichst vermeiden, wasjedoch schwierig ist8.

Eine wichtige Rolle bei der Equilibrierung spielt auch die Startkonfiguration.Wird diese ungunstig aufgesetzt, equilibriert das System nur sehr langsam oderkann sogar in Zwischenkonfigurationen stecken bleiben. Dies kann auch in derNahe von Phasenubergangen vorkommen. Es ist daher sinnvoll, Simulationenmit verschiedenen Startkonfigurationen durchzufuhren.9 Insbesondere im Bereichzwischen 400 und 600 Proteinen konnte dies noch durchgefuhrt werden, da dortdie Konfigurationen am langsamsten equilibrierten und dort auch der Vergleichmit dem Experiment nicht vollstandig geklart ist.

Weiterhin konnten Simulationen mit veranderlicher Systemgroße (NPT-En-semble) und Form durchgefuhrt werden. Die Veranderung der Form des Systemsschließt aus, dass unerwunschte Effekte augrund der rechteckigen Box, diesimuliert wurde, auftreten. Dazu kann z.B. die Ausrichtung der Teilchen ent-lang der Kanten oder Diagonalen des Systems gehoren. Durch die Anderungder Systemgroße wahrend der Simulation kann der Druck konstant gehaltenwerden. Dadurch wurde auch die freie Energie des Systems zuganglich (Virial-entwicklung, thermodynamische Integration), die weiteren Aufschluss uber dieStabilitat einzelner Phasen geben kann. Die Zustandsgleichung ließe sich damitebenfalls ermitteln. Außerdem wird durch die Einfuhrung dieser Veranderungendie Equilibrierungsphase zusatzlich beschleunigt.

Im Bereich der Phasenubergange konnten genauere Untersuchungen Aufschlussgeben uber Koexistenzgebiete und metastabile Phasen. Moglicherweise tretenauch Hystereseeffekte auf, die durch Simulation unter Expansion bzw. Kompres-sion entdeckt werden konnten. Durch die Untersuchung von Korrelationsfunk-tionen konnte man die Lage des Gas-Flussigkeit-Ubergangs bestimmen und dieEigenschaften der einzelnen Phasen genauer charakterisieren.

Schließlich konnte man durch Anderung der Randbedingungen und Erweite-rungen des Modells und seiner Parameter insgesamt realistischere Simulationendurchfuhren. So konnte man beispielsweise das Festhalten von Helix A in derMonoschicht aufheben und durch eine explizite Hydrophilitat modellieren. Damitkonnte man den Kollaps der Monoschicht bei hohen Anzahldichten untersuchen.Die Verwendung weicher Potentiale, wie sie in Kapitel 5 beschrieben werden,konnte eine genauere Charakterisierung der Phasenubergange moglich machen,da als treibender Faktor die attraktive Wechselwirkung hinzugenommen werden

8Kushick und Berne schreiben in [31]: ”One can never be certain that a given system hasattained thermodynamic equilibrium. [...] Therefore, one must be guided to some degree byintuition and by past experience in the interpretation of these studies.“

9Eine Moglichkeit ware beispielsweise das Aufsetzen von Kugeln in dichtester Packung, diedann auf die Lange von Spharozylinder skaliert werden.

9.5. ZUSAMMENFASSUNG 69

konnte. Die Parameter des Modells konnten dabei an realistischere Werte an-genahert werden. Hinweise fur den tatsachlichen Wert der Konstante khydro furdie Hydrophilitat kann z.B. das hydrophobe Moment geben, das in [1] angege-ben ist. Denkbar ware auch eine Ermittlung samtlicher relevanter Parameter desApolipoproteins C-I, indem man ein einzelnes APO C-I Molekul auf Ebene dereinzelnen Atome simuliert.10 Mit den so ermittelten Parametern ware dann ei-ne Simulation durchfuhrbar, mit der man zu quantitativen Aussagen uber Lageder Phasenubergange, die freie Energie der Phasen usw. kommen konnte. Diebisherigen Simulationen sind dahingehend vielversprechend, dass mit den vor-geschlagenen Erweiterungen ein noch dichterer Kontakt zu den experimentellenErgebnissen hergestellt werden konnte.

9.5 Zusammenfassung

Die in dieser Arbeit dokumentierten Simulationen konnten die Vermutungen aus[1] uber die Natur des L1/L2-Phasenubergangs in einer Monoschicht von Apolipo-protein C-I bestatigen. Es handelt sich um einen Phasenubergang zwischen einerflussig-isotropen Phase und einer desorbierten Phase, bei der eine Helix des Apo-lipoproteins von der Monolage abhebt. Der Ubergang ist von erster Ordnung undwird getrieben von einem Ausgleich zwischen freier Flache pro Molekul, Orien-tierungsentropie und hydrophiler Wechselwirkung. Er lasst sich im Rahmen einesrelativ einfachen Modells, in dem das Apolipoprotein C-I als aus zwei Spharozy-lindern zusammengesetztes Teilchen betrachtet wird, erklaren. Das Modell bietetzudem Ansatzpunkte fur Erweiterungen, die eine genauere quantitative Untersu-chung von APO C-I erlauben. Die zugrundeliegenden Ideen sind ubertragbar undkonnen zur Simulation ganzer Klassen von Proteinen verwendet werden.

10Dies ist moglich, da Sekundarstruktur und Lage der einzelnen Atome im Proteinmolekulmittlerweile bekannt sind.


Danksagungen

Wir danken der Arbeitsgruppe”Theorie der Kondensierten Materie“ der Univer-

sitat Bielefeld fur ihre standige Unterstutzung bei diesem Projekt. Guido Germa-no steuerte ein erstes Quellcodefragment zur Berechnung des Kihara-Potentialsbei, an dem sich unsere Implementation orientiert. Er war außerdem unsere An-laufstelle fur chemische Fragen. Harald Lange, Martin Streek und Torsten Wirsigversorgten uns mit CPU-Power und ließen den

”Condor“ fliegen. Torsten half

uns außerdem beim Druck unseres Projektposters und Harald suchte mit unsnach manchem Bug. Olaf Lenz hat uns durch viele interessante Diskussionenund hilfreiche Tips besonders geholfen und motiviert. Steffen Neumann standuns ebenfalls oft mit Rat und Tat zur Seite. Alexander Sczyrba danken wir furdie schnelle und undiplomatische Bereitstellung von Plattenplatz und Rechner-zugangen. Weiterhin bedanken wir uns bei unserem Betreuer seitens der Tech-nischen Fakultat, Robert Giegerich. Ganz besonders herzlich bedanken wir unsbei unserer Betreuerin Friederike Schmid, die sich immer viel Zeit fur uns undunser Projekt genommen hat, uns in allen Dingen hervorragend unterstutzt undmotiviert hat, und ohne die dieses Projekt in dieser Form einfach nicht moglichgewesen ware.

71


Anhang A

Pflichtenheft

A.1 Zielbestimmung

A.1.1 Mussziele

• Lauffahige Simulation eines Zylindermodells unter einem harten Potential

• Ausgabe der Durchschnittswerte und mindestens zweier Ordnungsparame-ter

A.1.2 Wunschziele

• Experimentelle Ergebnisse reproduzieren

• Mehrere Potentiale/Modelle testen

• Graphische, komfortable Steuerung

• Komfortable Protokollfunktion

• Implementierung der Auswertungsverfahren

• Visualisierung der Ergebnisse

A.1.3 Negative Ziele

• Mit molekulardynamischen Ansatzen vergleichen

• Parallelisierung

• Datenhaltung

73

74 ANHANG A. PFLICHTENHEFT

A.2 Produkteinsatz

Batch-gesteuerter Einsatz (24h-Betrieb). Zielgruppe sind primar die Teilnehmerdes Projektseminar. Eine Weiterverwendungsfahigkeit ist wunschenswert, abernicht unabdingbar.

A.3 Produktumgebung

Standard-UNIX-Umgebung mit optionalem X. Ausgabe muß gnuplot-lesbar sein.Ein- und Ausgabe basierend auf ASCII (human-readable).

A.4 Produktfunktionen aus Benutzersicht

Grey-Box-Aufbau. Nach Wahlen der Parameter keine Steuerungseingriffemoglich.

A.5 Daten fur langfristige Speicherung

Keine Datenbankkonzepte notwendig, Ergebnisarchivierung liegt beim Benutzer.

A.6 Programmleistungen

Datengenauigkeit: 32-Bit, abhangig vom Algorithmus. Pro Start des ProgrammsBerechnung fur kanonisches Ensemble (festes Volumen, feste Temperatur, festeTeilchenzahl).

A.7 Benutzeroberflache

Steuerung uber Input-files ist ausreichend, graphische und komfortable Bedienungist ein Wunschziel.

A.8 Qualitatszielbestimmung

Stabiles Programm, das die Berechnung der thermodynamischen Großen des Sy-stems mittels Monte Carlo-Integration ermoglicht.

A.9. GLOBALE TESTFALLE 75

A.9 Globale Testfalle

Vergleiche innerhalb eines Modells und der Modelle gegeneinander unter repro-duzierten Zufallszahlen.

A.10 Entwicklungsumgebung

Standard Entwicklungstools, d.h.

• g++ und entsprechende Tools (gdb, ...)

• RCS

• Java (falls GUI)

• vi

• emacs

• make

76 ANHANG A. PFLICHTENHEFT

Anhang B

Programmcode

Auf den folgenden Seiten ist der Quellcode abgedruckt, der zur Simulation ver-wendet wurde. Ab Seite 78 befinden sich die Klassendefinitionen und -implemen-tationen des Simulationsprogramms. Die Visualisierung folgt ab Seite 108, dieAuswertungsroutinen ab Seite 111.

77

/* $Id: Configuration.h,v 1.44 2002/03/22 07:46:45 usprosim Exp $ * $Locker: $ */

#ifndef CONFIGURATION_H#define CONFIGURATION_H#include " Boxing.h"#include " Potential.h"#include " Protein.h"#include " Random.h"#include " Constants.h"#include <math.h>#include <cmath>#include <string.h>#include <iostream.h>#include <fstream.h>#include <stdio.h>#include <utility>

class Boxing; // [us] forward declarationclass Potential; // [us] forward declaration

/** Um f"ur das ProVis−Tool die Konstanten "ubergeben zu k"onnen wird eine geeignete Datenstruktur ben"otigt. Diese wird hier als struct definiert.*/struct constants { double temp; double area_x; double area_y; int n_prot; int n_iterations; double length_a; double length_b; double radius_a; double radius_b; double max_translation; double max_rotation_a; double max_rotation_b; int initial_seed; double cut_off;}; /** * Die Configuration beinhaltet alle Proteine, die in der Simmulation * benutzt werden. * @version $Revision: 1.44 $ **/

class Configuration {public: inline double Configuration::getAreaX() { return vAREA_X; } inline double Configuration::getAreaY() { return vAREA_Y; } inline double Configuration::getMaxTranslation() { return vMAX_TRANSLATION; } inline double Configuration::getMaxRotationA() { return vMAX_ROTATION_A; } inline double Configuration::getMaxRotationB() { return vMAX_ROTATION_B; } inline void Configuration::setAreaX( double area_x) { vAREA_X = area_x; } inline void Configuration::setAreaY( double area_y) { vAREA_Y = area_y; } inline void Configuration::setMaxTranslation( double value) { if (value < AREA_X/2 && value < AREA_Y/2) vMAX_TRANSLATION = value ;

Configuration.h if (vMAX_TRANSLATION < 1.0e−2) vMAX_TRANSLATION = 1.0e−2 ; } inline void Configuration::setMaxRotationA( double rotationA) { if (rotationA < M_PI) vMAX_ROTATION_A = rotationA ; if (vMAX_ROTATION_A < 1.0e−3) vMAX_ROTATION_A = 1.0e−3 ; } inline void Configuration::setMaxRotationB( double rotationB) { if (rotationB < M_PI) vMAX_ROTATION_B = rotationB ; if (vMAX_ROTATION_B < 1.0e−3) vMAX_ROTATION_B = 1.0e−3 ; } /** * Konstruktor f"ur diese Klasse. * @param rand Ein Zufallsgenerator, der myRandom zugewiesen werden soll * @see Configuration#myRandom **/ Configuration(Random* rand);

/** * Konstruiert die Configuration aus vorher gespeicherten Daten. * Hierbei wird darauf geachtet, dass die Konstanten aus dem Speicher * und die aktuellen gleich sind. Es wird die Anzahl der bereits * gemachten Iterationen gespeichert. * @param fileName der DateiName, in dem die Daten der Configuration * stehen. * @param count Referenz auf den Wert, in dem die Anzahl der Iterationen * gespeichert wird. * @see Configuration#toString **/ Configuration( char * fileName, long * count);

/** * ein weiterer Konstruktor, der f"ur das ProVis−tool benoetigt * wird. Die "Uberpr"ufung der Werte unterbleibt. * @param fileName Name der einzulesenden Datei// * @param consts struct mit den globalen Konstanten **/ Configuration( struct constants & consts, const char * fileName);

/** * Destruktor **/ ~Configuration();

/** * Diese Methode erzeugt ein neues Boxing * entsprechend den aktuellen Schrittweiten **/ void Configuration::newBoxing() ;

/** * "Andert ein zuf"allig ausgew"ahltes Protein zuf"allig. * Diese Methode bewegt ein Protein, berechnet die neue Energie und * entscheidet dann ob die Konfiguration akzeptiert wird. **/ int nextConfiguration();

/** * Flippt ein zuf"allig ausgew"ahltes Protein * Diese Methode flippt die Helix B ans andere Ende von Helix A * und akzeptiert nach Metropolis−Algorithmus **/ int nextFlip();

Configuration.h

Configuration.h

78

/** * Berechnet die Akzeptanswahrscheinlichkeit f"ur eine neue * Configuration mit der Energie e2 im Vergleich zur aktuellen * mit der Energie e1. * @param e1 Energie der aktuellen Configuration * @param e2 Energie der zu testenden Configuration * @return die Akzeptanswahrscheinlichkeit f"ur eine neue * Configuration mit der Energie e2 im Vergleich zur aktuellen mit * der Energie e1. **/ double calcAcProbability( double e1, double e2);

/** Falls das neue Potential (try) gr"osser ist, als das * bisherige (current), wird es trotzdem mit einer Wahrscheinlichkeit * proportioanl zur Boltzmanverteilung angenommen. * @return die Entscheidung, ob der neue Zustand angenommen wird. **/ bool acNewConfig( double tryPot, double currentPot);

/** * gibt die dreidimensionale Anordnung aller Proteine in eine Datei * aus, die von PovRay eingelesen und visualisiert werden kann. * @param fileName wo sollen die Povraydaten gespeichert werden? * @param comment Komentar, der mit in die Datei soll **/ void outVisual( char * fileName, const char * coment); /*sicher, dass es nur ein m sein soll? */

/** * Gibt alle Daten zur"uck, die notwendig sind, um diese Configuration * wieder herzustellen. Ferner werden auch die aktuellen Konstanten * mit ausgegeben, um sie mit den beim Einlesen vorhandenen vergleichen * zu k"onnen. * @param count Die Anzahl der bereits gemachten Iterationen, die ebenfalls mit ausgegeben werden. * @return alle Daten, die notwendig sind, um diese Configuration wieder herzustellen **/ char * toString( long count);

/** * gibt die statistischen Daten dieser Konfiguration zur"uck * @return die statistischen Daten dieser Konfiguration **/ char * outFile();

/** * liefert die Bewegungsdaten eines Proteins **/ char * getMotionTrack( const int num);

/** * Gibt das i−te Protein der Configuration zur"uck. **/ inline Protein* protein( int n) { return myProteins[n]; };

Configuration.h /** * Bewirkt, dass alle B−Helixes im 90Grad−Winkel auf der * Wasserogerfl"ache stehen. **/ void standUp();

private:

double vAREA_X ; double vAREA_Y ; double vMAX_TRANSLATION ; double vMAX_ROTATION_A ; double vMAX_ROTATION_B ; //double vMAX_LIFTING_B ;

char line[5000]; // das M"adchen f"ur alles

/** * als Zwischenspeicher f"ur toString */ char constString[505+1];

/** * als Zwischenspeicher f"ur toString */ /* string enth"alt die Ausgabe einer Configuration; ausgegeben werden Konstanten, pro Protein je einmal die Proteinausgabe und der Zufalls− zahlengenerator(um den aktuellen Zustand wiederherstellen zu k"onnen) */ char string[505+N_PROT*(PROTEIN_TEXT_LENGTH+20)+1+(23*102+10 /*Random*/ )]; /** * das Boxing, das f"ur diese Konfiguration bei der Potentialberechnung * verwendet wird * @link aggregation * @supplierCardinality 1 * @clientCardinality 1 **/ Boxing* myBoxing;

/** * das der Berechnung dieser Konfiguration zugrundeliegendes Potential * @see Potential * @clientCardinality 1 * @supplierCardinality 1 * @link aggregation **/ Potential* myPotential;

/** * Die gesamten Proteine, die in dieser Konfiguration vorhanden sind * @see Protein * @directed * @link aggregation * @clientCardinality 1 * @supplierCardinality N+1 */ Protein** myProteins;

/**

Configuration.h

Configuration.h

79

* Der Zufallsgenerator, der f"ur Entscheidungen genutzt wird * @supplierCardinality 1 * @link aggregation * @clientCardinality 1 **/ Random* myRandom;

/** @link dependency */ /*# constants lnkconstants; */};#endif CONFIGURATION_H

Configuration.h/* $Id: Configuration.cpp,v 1.95 2002/03/26 11:26:13 usprosim Exp $ * $Locker: $ */

//#define Configuration_Debug_cerr //#define TEST_SAMPLING

#include " Configuration.h"#include " PovUtils.h"

/* Wenn TEST_CYLINDERS definiert ist soll nur Helix A simuliert werden, Helix B wird daher aus der Ausgabe gestrichen */#ifdef TEST_CYLINDERS#ifndef HIDE_HELIX_B#define HIDE_HELIX_B#endif#endif

/** Die Formatierung der Configurationsausgabe, die von * Configuration::toFile und von * Configuration::Configuration(char* fileName,long& count) benutzt wird. **/

const char * CONFI_CONST_OUT_FORMAT = " TEMP:" " %0.16le"" \tAREA_X:" " %0.16le"" \tAREA_Y:" " %0.16le"" \tN_PROT:" " %22i"" \tN_ITERATIONS:" " %22i"" \tLENGTH_A:" " %0.16le"" \tLENGTH_B:" " %0.16le"" \tRADIUS_A:" " %0.16le"" \tRADIUS_B:" " %0.16le"" \tMAX_TRANSLATION: " " %0.16le"" \tMAX_ROTATION_A:" " %0.16le"" \tMAX_ROTATION_B:" " %0.16le"" \tINITIAL_SEED:" " %22i"" \tCUT_OFF:" " %0.16le"" \tcount:" " %22i"" \n";

/* OUT_FORMAT kann nicht zum Einlesen verwendet werden, da dort zu genaue Angaben "uber die L"ange der Variablen gemacht werden −> deshalb wird IN_FORMAT ben"otigt */

const char * CONFI_CONST_IN_FORMAT = " TEMP:" " %le"" \tAREA_X:" " %le"" \tAREA_Y:" " %le"" \tN_PROT:" " %i"" \tN_ITERATIONS:" " %i"" \tLENGTH_A:" " %le"" \tLENGTH_B:" " %le"" \tRADIUS_A:" " %le"" \tRADIUS_B:" " %le"" \tMAX_TRANSLATION: " " %le"" \tMAX_ROTATION_A:" " %le"" \tMAX_ROTATION_B:" " %le"" \tINITIAL_SEED:" " %i"" \tCUT_OFF:" " %le"" \tcount:" " %i"" \n";

Configuration.cpp

Configuration.h, Configuration.cpp

80

/* der folgende Konstruktor liest eine schon bestehende Konfiguration aus einer Datei aus, vergleicht deren Konstanten mit den aktuellen und nutzt sie f"ur die weitere Berechnung d.h. nach einem Programmabsturz wird "uberpr"uft, ob die gespeicherten Konstanten sinnvoll/konsistent sind */

Configuration::Configuration( char * fileName, long * count){#ifdef Configuration_Debug_cerr cerr << " Configuration::Configuration(" << fileName << " ," << count << " ) gestartet\n";#endif FILE *inFile; if ((inFile = fopen(fileName," r")) == NULL ) { cerr << " Configuration::Configuration(" << fileName

<< " ," << count << " ):\n\n"; cerr << " \t FEHLER: kann Datei nicht (zum lesen) oeffene!!\n\n"; }

double aTEMP,aAREA_X,aAREA_Y; int aN_PROT,aN_ITERATIONS; double aLENGTH_A,aLENGTH_B,aRADIUS_A,aRADIUS_B, aMAX_TRANSLATION,aMAX_ROTATION_A,aMAX_ROTATION_B; int aINITIAL_SEED; double aCUT_OFF;

fscanf(inFile,CONFI_CONST_IN_FORMAT, &aTEMP, &aAREA_X,&aAREA_Y, &aN_PROT,&aN_ITERATIONS, &aLENGTH_A,&aLENGTH_B, &aRADIUS_A,&aRADIUS_B, &aMAX_TRANSLATION,&aMAX_ROTATION_A,&aMAX_ROTATION_B, &aINITIAL_SEED,&aCUT_OFF,count);

/* im Folgenden werden alle wichtigen Variablen der eingelesenen * und der aktuellen Konfiguration verglichen und eventuelle * Abweichungen angezeigt */

if (aTEMP!=TEMP) cerr << " aktuelle Temperatur(" << TEMP

<< " ) und geladene (" << aTEMP << " ) differieren. Fahre (trotzdem) mit dem alten Wert fort.\n";

if (aN_PROT!=N_PROT) { cerr << " aktuelle Anzahl Proteine(" << N_PROT

<< " ) und geladene (" << aN_PROT << " ) differieren. Ich kann leider nicht fortfahren und beende mich hoefflich.\n";

exit(1); } if (aN_ITERATIONS!=N_ITERATIONS) cerr << " aktuelle N_ITERATIONS(" << N_ITERATIONS

<< " ) und geladene (" << aN_ITERATIONS << " ) differieren. Fahre (trotzdem) mit dem alten Wert fort.\n";

if (aLENGTH_A!=LENGTH_A) cerr << " aktuelle LENGTH_A(" << LENGTH_A

<< " ) und geladene (" << aLENGTH_A << " ) differieren. Fahre (trotzdem) mit dem alten Wert fort.\n";

if (aLENGTH_B!=LENGTH_B) cerr << " aktuelle LENGTH_B(" << LENGTH_B

<< " ) und geladene (" << aLENGTH_B << " ) differieren. Fahre (trotzdem) mit dem alten Wert fort.\n";

Configuration.cpp if (aRADIUS_A!=RADIUS_A) cerr << " aktueller RADIUS_A(" << RADIUS_A

<< " ) und geladener (" << aRADIUS_A << " ) differieren. Fahre (trotzdem) mit dem alten Wert fort.\n";

if (aRADIUS_B!=RADIUS_B) cerr << " aktueller RADIUS_B(" << RADIUS_B

<< " ) und geladene (" << aRADIUS_B << " ) differieren. Fahre (trotzdem) mit dem alten Wert fort.\n";

if (aINITIAL_SEED!=INITIAL_SEED) cerr << " aktuelle INITIAL_SEED(" << INITIAL_SEED

<< " ) und geladene (" << aINITIAL_SEED << " ) differieren. Fahre (trotzdem) mit dem alten Wert fort.\n";

if (aCUT_OFF!=CUT_OFF) cerr << " aktueller CUT_OFF(" << CUT_OFF

<< " ) und geladener (" << aCUT_OFF << " ) differieren. Fahre (trotzdem) mit dem alten Wert fort.\n";

/* es werden nun die Attribute der Configuration erzeugt: */

vAREA_X = aAREA_X ; vAREA_Y = aAREA_Y ; vMAX_TRANSLATION = aMAX_TRANSLATION ; vMAX_ROTATION_A = aMAX_ROTATION_A ; vMAX_ROTATION_B = aMAX_ROTATION_B ;

myProteins = new (Protein*)[N_PROT+1]; myProteins[0]= new Protein(); for ( int i=1;i<=N_PROT;i++) { myProteins[i]= new Protein(inFile); } myRandom= new Random(inFile); myBoxing = new Boxing( this ); myPotential = new Potential( this ); myPotential−>setCurrentPotential(myPotential−>calculate(myBoxing).first); fclose(inFile);

#ifdef Configuration_Debug_cerr cerr << " Configuration::Configuration:\n\t"; cerr << " fertig\n";#endif}

/** Dieser Konstruktor liest eine bestehende Configuration ein. Im Gegensatz zum vorigen schreibt er jedoch die Variablen in consts. Daf"ur verzichtet er auf eine "Uberpr"ufung der Konstanten mit Constants.h, da diese f"ur den Anwendungsfall ProVis nicht gegeben sind. VORSICHT: Kein Vollstaendiger Konstruktor*/ Configuration::Configuration( struct constants & consts, const char * fileName){

long count; FILE *inFile; if ((inFile = fopen(fileName," r")) == NULL ){ cerr << " Configuration::Configuration(" << fileName << " ):\n\n"; cerr << " \t FEHLER: kann Datei nicht (zum lesen) oeffene!!\n\n"; exit(1);

Configuration.cpp

Configuration.cpp

81

} fscanf(inFile,CONFI_CONST_IN_FORMAT,

&consts.temp, &consts.area_x, &consts.area_y, &consts.n_prot, &consts.n_iterations, &consts.length_a, &consts.length_b, &consts.radius_a, &consts.radius_b, &consts.max_translation, &consts.max_rotation_a, &consts.max_rotation_b, &consts.initial_seed, &consts.cut_off, &count);

vAREA_X = consts.area_x ; vAREA_Y = consts.area_y ; vMAX_TRANSLATION = consts.max_translation ; vMAX_ROTATION_A = consts.max_rotation_a ; vMAX_ROTATION_B = consts.max_rotation_b ;

myProteins = new (Protein*)[consts.n_prot+1]; myProteins[0] = new Protein(); for ( int i=1;i<=consts.n_prot;i++) myProteins[i] = new Protein(inFile); fclose(inFile);}

/* um die Ergebnisse visualisieren zu k"onnen, werden sie in einem von povray lesbaren Format "uber einen filestream ausgegeben */void Configuration::outVisual( char * fileName, const char * comment){ fstream f; f.open(fileName, ios::trunc|ios::out); /* Nun doch ein wenig povray...*/ printPovRayHeader(f,comment, this ); printCoordSystem(f, this );

/* um alle Proteine darzustellen, werden je Protein die Helix A, eine Halbkugel f"ur ihr Ende, das Verbindungsst"uck zwischen den Helices, die Helix B und ihr Endst"uck gezeichnet */ for ( int i = 1; i < N_PROT+1; i++) { /* plot helix A */#ifndef HIDE_HELIX_A

f << " cylinder{<" << myProteins[i]−>getX() << " ," << " 0" << " ," << myProteins[i]−>getY() << " >,<" << (myProteins[i]−>getX())+(LENGTH_A*(myProteins[i]−>getA1())) << " ," << myProteins[i]−>getA3()*LENGTH_A << " ," << (myProteins[i]−>getY())+(LENGTH_A*(myProteins[i]−>getA2())) << " >," << RADIUS_A << " pigment{color Red} finish{phong 1}}\n";

/* plot ending sphere of helix A */f << " sphere{<" << (myProteins[i]−>getX())+(LENGTH_A*(myProteins[i]−>getA1()))

Configuration.cpp << " ," << myProteins[i]−>getA3()*LENGTH_A << " ," << (myProteins[i]−>getY())+(LENGTH_A*(myProteins[i]−>getA2())) << " >," << RADIUS_A << " pigment{color Red} finish{phong 1}}\n";

/* plot sphere as proteins center */f << " sphere{<" << myProteins[i]−>getX() << " ," << " 0" << " ," << myProteins[i]−>getY() << " >," << max(RADIUS_A,RADIUS_B) << " pigment{color Red} finish{phong 1}}\n";

#endif /* wenn Helix A nicht gezeichnet wird, aber Helix B,

dann mu"s die verbindende Kugel noch gezeichnet werden */#ifdef HIDE_HELIX_A#ifndef HIDE_HELIX_B /* plot sphere as proteins center */

f << " sphere{<" << myProteins[i]−>getX() << " ," << " 0" << " ," << myProteins[i]−>getY() << " >," << max(RADIUS_A,RADIUS_B) << " pigment{color Green} finish{phong 1}}\n";

#endif#endif#ifndef HIDE_HELIX_B /* plot helix B */

f << " cylinder{<" << myProteins[i]−>getX() << " ," << " 0" << " ," << myProteins[i]−>getY() << " >,<" << (myProteins[i]−>getX())+(LENGTH_B*(myProteins[i]−>getB1())) << " ," << myProteins[i]−>getB3()*LENGTH_B << " ," << (myProteins[i]−>getY())+(LENGTH_B*(myProteins[i]−>getB2())) << " >," << RADIUS_B << " pigment{color Green} finish{phong 1}}\n";

/* plot ending sphere of helix B */f << " sphere{<" << (myProteins[i]−>getX())+(LENGTH_B*(myProteins[i]−>getB1())) << " ," << myProteins[i]−>getB3()*LENGTH_B << " ," << (myProteins[i]−>getY())+(LENGTH_B*(myProteins[i]−>getB2())) << " >," << RADIUS_B << " pigment{color Green} finish{phong 1}}\n";

#endif } f.close();

Configuration.cpp

Configuration.cpp

82

}

/* sobald diese Methode fertig ist, soll sie die Bewegung eines Proteins (Proteins[num]) verfolgen */char * Configuration::getMotionTrack( const int num){ sprintf

(line, " sphere{<%f,0,%f>,%f pigment{color Red} finish{phong 1}}\n" " cylinder{<%f,0,%f>,<%f,0,%f>,%f pigment{color Red} finish{phong 1}}\n" " sphere{<%f,0,%f>,%f pigment{color Green} finish{phong 1}}\n" " cylinder{<%f,0,%f>,<%f,%f,%f>,%f pigment{color Green} finish{phong 1}}\n" " sphere{<%f,%f,%f>,%f pigment{color Green} finish{phong 1}}\n", myProteins[num]−>getX()+myProteins[num]−>getA1()*LENGTH_A, // Sphere A myProteins[num]−>getY()+myProteins[num]−>getA2()*LENGTH_A, RADIUS_A, myProteins[num]−>getX(), // Cyl A myProteins[num]−>getY(), myProteins[num]−>getX()+myProteins[num]−>getA1()*LENGTH_A, // Cyl A myProteins[num]−>getY()+myProteins[num]−>getA2()*LENGTH_A, RADIUS_A, myProteins[num]−>getX(), // MiddleSphere myProteins[num]−>getY(), RADIUS_B, myProteins[num]−>getX(), // Cyl B myProteins[num]−>getY(), myProteins[num]−>getX()+myProteins[num]−>getB1()*LENGTH_B, // Cyl B myProteins[num]−>getB3()*LENGTH_B, myProteins[num]−>getY()+myProteins[num]−>getB2()*LENGTH_B, RADIUS_B, myProteins[num]−>getX()+myProteins[num]−>getB1()*LENGTH_B, // EndSpher

e myProteins[num]−>getB3()*LENGTH_B, myProteins[num]−>getY()+myProteins[num]−>getB2()*LENGTH_B, RADIUS_B );

return line;}

/* die folgende Methode gibt eine komplette Configuration als String aus, in dem sie der Reihe nach jedes Protein in einen String konvertiert (bis aus Proteins[0], da dies ja nur eine Hilfsvariable ist) */char * Configuration::toString( long count){ sprintf(constString,CONFI_CONST_OUT_FORMAT,

TEMP, vAREA_X,vAREA_Y, N_PROT,N_ITERATIONS, LENGTH_A,LENGTH_B, RADIUS_A,RADIUS_B, vMAX_TRANSLATION,vMAX_ROTATION_A,vMAX_ROTATION_B, INITIAL_SEED,CUT_OFF,count );

sprintf(string," %s",constString); for ( int i=1;i<=N_PROT;i++) { sprintf(string," %s%s",string,myProteins[i]−>toString()); } sprintf(string," %s%s",string,myRandom−>toString()); return string;}

Configuration.cpp

/* berechnet die Akzeptanzwahrscheinlichkeit */double Configuration::calcAcProbability( double e1, double e2){ double delta_E = e2 − e1; return exp(delta_E * INV_TEMP); }

/* falls das neue Potential (try) gr"osser ist, als das * bisherige (current), wird es trotzdem mit einer Wahrscheinlichkeit * proportioanl zur Boltzmanverteilung angenommen */bool Configuration::acNewConfig( double currentPot, double tryPot){ if (tryPot >= currentPot) { double acProbability = calcAcProbability(tryPot, currentPot); if (myRandom−>next_0_to_1() > acProbability) return false ; else return true ; } else return true ;}

/* Diese Methode bewegt ein Protein, berechnet die neue Energie und * entscheidet dann ob die Konfiguration akzeptiert wird. */ int Configuration::nextConfiguration(){

/* Flag−Variable, die angibt, ob der Schritt akzeptiert wurde */ int accept ;

#ifdef Configuration_Debug_cerr cerr << " Configuration::nextConfiguration\n";#endif

/* es wird zuf"allig ein Protein ausgew"ahlt, dessen Parameter dann ge"andert werden; wird die daraus resultierende Konformation nicht angenommen, so werden die vorgenommenen "Anderungen wieder r"uckg"angig gemacht */

/* zuf"allig ein Protein ausw"ahlen */ int currentProtein = ( int )ceil(N_PROT * (myRandom−>next_0_to_1()));

/* Pointer auf altes Protein merken */ Protein* oldProtein = myProteins[currentProtein];

/* Pointer auf das neue Protein (just a shorthand) */ Protein* newProtein = myProteins[0];

/* jetzt zeigt oldProtein auf das Objekt mit den alten Koordinaten und newProtein und myProteins[0] zeigen beide auf das zu manipulierende Objekt */

/* Translationsbewegung */ newProtein−>setX(oldProtein−>getX()

Configuration.cpp

Configuration.cpp

83

+(myRandom−>next_minus_eins_to_eins())*vMAX_TRANSLATION,vAREA_X) ; newProtein−>setY(oldProtein−>getY() +(myRandom−>next_minus_eins_to_eins())*vMAX_TRANSLATION,vAREA_Y) ;

#ifdef Configuration_Debug_cerr cerr << " \tcurrentProtein = " << currentProtein << " \n" << " \toldProtein* = " << oldProtein << " \tnewProtein* = " << newProtein << " \n" << " \toldProtein−>getX() = " << oldProtein−>getX() << " \tnewProtein−>getX() = " << newProtein−>getX() << " \n" << " \toldProtein−>getY() = " << oldProtein−>getY() << " \tnewProtein−>getY() = " << newProtein−>getY() << " \n";#endif

/* Ausrichtung von Helix A aendern */ double winkel=oldProtein−>getEbenenwinkelA(); // bisheriger Winkel winkel += myRandom−>next_minus_eins_to_eins()*vMAX_ROTATION_A ; newProtein−>setEbenenwinkelA(winkel); newProtein−>setA1(cos(winkel)); newProtein−>setA2(sin(winkel));

#ifdef Configuration_Debug_cerr cerr << " \toldProtein−>getA1() = " << oldProtein−>getA1() << " \tnewProtein−>getA1() = " << newProtein−>getA1() << " \n" << " \toldProtein−>getA2() = " << oldProtein−>getA2() << " \tnewProtein−>getA2() = " << newProtein−>getA2() << " \n" << " \toldProtein−>getA3() = " << oldProtein−>getA3() << " \t\tnewProtein−>getA3() = " << newProtein−>getA3() << " \n";#endif /* Ausrichtung von Helix B aendern */ double ebenenwinkel = oldProtein−>getEbenenwinkelB(); double aufstellsinus = oldProtein−>getAufstellSinusB(); ebenenwinkel += myRandom−>next_minus_eins_to_eins()*vMAX_ROTATION_B ; aufstellsinus += myRandom−>next_minus_eins_to_eins()*vMAX_ROTATION_B ;

/* * der Aufstellsinus muss zwischen 0 und 1 liegen * andernfalls wird der alte Wert beibehalten * der alte Wert aus oldProtein ist nur hier bekannt * daher erfolgt diese Abfrage hier, und nicht in Protein.h ! */ if ((aufstellsinus<0) || (aufstellsinus>1)) { aufstellsinus=oldProtein−>getAufstellSinusB(); }

newProtein−>setB(ebenenwinkel,aufstellsinus);

#ifdef Configuration_Debug_cerr cerr << " \toldProtein−>getB1() = " << oldProtein−>getB1() << " \t\tnewProtein−>getB1() = " << newProtein−>getB1() << " \n" << " \toldProtein−>getB2() = " << oldProtein−>getB2() << " \t\tnewProtein−>getB2() = " << newProtein−>getB2() << " \n" << " \toldProtein−>getB3() = " << oldProtein−>getB3() << " \t\tnewProtein−>getB3() = " << newProtein−>getB3() << " \n";#endif /* jetzt ist das neue Objekt manipuliert myProteins[current] soll auf das neue Objekt zeigen der alte Pointer steht ja noch in old */ myProteins[currentProtein] = newProtein;

Configuration.cpp /* das verschobene Protein im Boxing richtig einsortieren das braucht hier noch nicht geschehen, weil die Boxgr"osse so gew"ahlt ist, dass noch keine "Uberlappung mit der "ubern"achsten Box auftreten kann das Protein kann also maximal in die n"achste Box rutschen, es beeinflusst die Potentialberechnung also nicht, wenn es an dieser Stelle noch nicht richtig einsortiert wird − man kann damit warten, bis das Potential berechnet und der Move akzeptiert wurde */ //myBoxing−>resort(currentProtein, oldProtein−>getX(), oldProtein−>getY());

#ifndef TEST_SAMPLING //TEST_SAMPLING sorgt daf"ur, dass das Potential ausgeschaltet wird

/* das bisherige Potential wird angefordert */ double potentialAlt = oldProtein −> getEnergy();

/* es wird nur das bewegte Protein auf "Uberlapp getestet */ pair< double , bool > potentialNeuPaar = myPotential −> calculate(myBoxing,newProtein) ;

double potentialNeu = potentialNeuPaar.first ;

#ifdef Configuration_Debug_cerr cerr << " \tpotentialAlt = " << potentialAlt << " \n" ; cerr << " \tpotentialNeu = " << potentialNeu << " \n" ;#endif

/* der erste Ausdruck "uberpr"uft, ob es keinen "Uberlapp gegeben hat, der zweite, ob das neue Potential angenommen wird (weil es z.B. energetisch g"unstiger ist) */ if (potentialNeuPaar.second && acNewConfig(potentialAlt,potentialNeu)) {

/* Flag setzen, dass Schritt akzeptiert wurde */ accept = 1 ;

/* wenn das Potential akzeptiert wird, kann es gesetzt werden sowohl im Protein als auch im Potential */ newProtein −> setEnergy(potentialNeu); myPotential −> setCurrentPotential(myPotential −> getCurrentPotential()

− potentialAlt + potentialNeu);

/* das Protein im Boxing richtig einsortieren */ myBoxing−>resort(currentProtein,oldProtein−>getX(),oldProtein−>getY());

/* ausserdem kommt jetzt der Pointer von myProteins[0] auf old, denn old zeigt auf das alte Objekt, das nicht mehr gebraucht wird */ myProteins[0] = oldProtein;

#ifdef Configuration_Debug_cerr cerr << " \tSchritt akzeptiert\n\n";#endif

}

else {

/* Flag setzen, dass Schritt nicht akzeptiert wurde */ accept = 0 ;

/* wenn das Potential nicht akzeptiert wird, wird myProteins[currentProt] wieder auf old und damit auf das

Configuration.cpp

Configuration.cpp

84

alte Objekt gesetzt */ myProteins[currentProtein] = oldProtein; /* myProteins[0] zeigt noch auf das Objekt, das zwischenzeitlich manipuliert wurde, jetzt aber verworfen wird myProteins[0] braucht also nicht geandert werden */ // myProteins[0] = curr;

// das Protein im Boxing wieder zuruecksortieren // das braucht hier nicht geschehen (s.o) //myBoxing−>resort(oldProtein, newProtein−>getX(), newProtein−>getY());

#ifdef Configuration_Debug_cerr cerr << " \tSCHRITT NICHT AKZEPTIERT\n";#endif

}#endif // #ifndef TEST_SAMPLING

#ifdef TEST_SAMPLING /* beim Test des Samplings wird jeder Schritt akzeptiert daher braucht nur der Pointer myProteins[0] auf oldProtein gesetzt zu werden Potential setzen und resort kann entfallen */ myProteins[0] = oldProtein;

#endif // #ifdef TEST_SAMPLING

/* R"uckgabewert */ return accept ;

}

/** * Diese Methode fuehrt als Monte−Carlo−Move einen Flip * eines Proteins aus, d.h. die Helix A wird um ihren * Mittelpunkt gedreht, damit Helix B am anderen Ende * von Helix B landet **/int Configuration::nextFlip() {

/* Flag−Variable, die angibt, ob der Schritt akzeptiert wurde */ int accept ;

/* zuf"allig ein Protein ausw"ahlen */ int currentProtein = ( int )ceil(N_PROT * (myRandom−>next_0_to_1())); /* Pointer auf altes Protein merken */ Protein* oldProtein = myProteins[currentProtein];

/* Pointer auf das neue Protein */ Protein* newProtein = myProteins[0];

/* Flip ausfuehren */ newProtein−>setX(oldProtein−>getX()+LENGTH_A*oldProtein−>getA1(),vAREA_X) ; newProtein−>setY(oldProtein−>getY()+LENGTH_A*oldProtein−>getA2(),vAREA_Y) ; newProtein−>setA1(−oldProtein−>getA1()) ; newProtein−>setA2(−oldProtein−>getA2()) ; newProtein−>setA3(oldProtein−>getA3()) ; newProtein−>setEbenenwinkelA(oldProtein−>getEbenenwinkelA()+M_PI) ; newProtein−>setB(oldProtein−>getEbenenwinkelB()+M_PI,oldProtein−>getAufstellSinusB()) ;

Configuration.cpp /* Pointer umbiegen */ myProteins[currentProtein] = newProtein ;

/* das alte Potential holen */ double potentialAlt = oldProtein−>getEnergy() ;

/* neues Potential berechnen */ pair< double , bool > potentialNeuPaar = myPotential −> calculate(myBoxing,newProtein) ; double potentialNeu = potentialNeuPaar.first ;

/* Testen, ob Schritt akzeptiert wird */ if (potentialNeuPaar.second && acNewConfig(potentialAlt,potentialNeu)) { /* Flag setzen, dass Schritt akzeptiert wurde */ accept = 1 ;

/* neues Potential setzen */ newProtein −> setEnergy(potentialNeu) ; myPotential −> setCurrentPotential(myPotential −> getCurrentPotential()

− potentialAlt + potentialNeu) ;

/* Boxing updaten */ myBoxing −> resort(currentProtein,oldProtein−>getX(),oldProtein−>getY()) ;

/* Pointer auf das nicht mehr benoetigte Protein */ myProteins[0] = oldProtein ;

}

else {

/* Flag setzen, dass Schritt nicht akzeptiert wurde */ accept = 0 ;

/* Zeiger zurueckbiegen */ myProteins[currentProtein] = oldProtein ;

}

/* Rueckgabewert */ return accept ;

}

/* die folgende Methode bildet aus den Daten eines Programmdurchlaufs Mittelwerte und schreibt diese in eine Datei */char * Configuration::outFile(){#ifdef Configuration_Debug_cerr cerr << " Configuration::outFile() gestartet\n";#endif

#ifndef SAMPLE_ONE double energy=myPotential−>getCurrentPotential(); double averageOrientationA1 = 0.0; double averageOrientationA2 = 0.0; double averageOrientationA3 = 0.0; double averageOrientationB1 = 0.0; double averageOrientationB2 = 0.0; double averageOrientationB3 = 0.0; double averagePlaneAngleA = 0.0;

Configuration.cpp

Configuration.cpp

85

double averagePlaneAngleB = 0.0; double averageLiftSinB = 0.0; double squaredAverageA1 = 0.0; double squaredAverageA2 = 0.0; double squaredAverageA3 = 0.0; double squaredAverageB1 = 0.0; double squaredAverageB2 = 0.0; double squaredAverageB3 = 0.0; double averageA1A2 = 0.0; double averageB1B2 = 0.0; double averageB1B3 = 0.0; double averageB2B3 = 0.0;

for ( int i = 1; i <= N_PROT; i++) { averageOrientationA1 += (myProteins[i])−>getA1(); averageOrientationA2 += (myProteins[i])−>getA2(); averageOrientationA3 += (myProteins[i])−>getA3(); averageOrientationB1 += (myProteins[i])−>getB1(); averageOrientationB2 += (myProteins[i])−>getB2(); averageOrientationB3 += (myProteins[i])−>getB3(); averagePlaneAngleA += (myProteins[i])−>getEbenenwinkelA(); averagePlaneAngleB += (myProteins[i])−>getEbenenwinkelB(); averageLiftSinB += (myProteins[i])−>getAufstellSinusB(); squaredAverageA1 += pow(((myProteins[i])−>getA1()),2); squaredAverageA2 += pow(((myProteins[i])−>getA2()),2); squaredAverageA3 += pow(((myProteins[i])−>getA3()),2); squaredAverageB1 += pow(((myProteins[i])−>getB1()),2); squaredAverageB2 += pow(((myProteins[i])−>getB2()),2); squaredAverageB3 += pow(((myProteins[i])−>getB3()),2); averageA1A2 += myProteins[i]−>getA1() * myProteins[i]−>getA2(); averageB1B2 += myProteins[i]−>getB1() * myProteins[i]−>getB2(); averageB1B3 += myProteins[i]−>getB1() * myProteins[i]−>getB3(); averageB2B3 += myProteins[i]−>getB2() * myProteins[i]−>getB3(); } sprintf(line," %f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\n", energy,

averageOrientationA1/N_PROT, averageOrientationA2/N_PROT, averageOrientationA3/N_PROT, averageOrientationB1/N_PROT, averageOrientationB2/N_PROT, averageOrientationB3/N_PROT, averagePlaneAngleA/N_PROT, averagePlaneAngleB/N_PROT, averageLiftSinB/N_PROT, squaredAverageA1/N_PROT, squaredAverageA2/N_PROT, squaredAverageA3/N_PROT, squaredAverageB1/N_PROT, squaredAverageB2/N_PROT, squaredAverageB3/N_PROT, averageA1A2/N_PROT, averageB1B2/N_PROT, averageB1B3/N_PROT, averageB2B3/N_PROT);

return line;#endif // von ifndef SAMPLE_ONE

#ifdef SAMPLE_ONE int nr=42; // betrachte nur ein Protein double energy=myPotential−>getCurrentPotential();

Configuration.cpp sprintf(line," %f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\n",

energy, myProteins[nr]−>getX(), myProteins[nr]−>getY(), myProteins[nr]−>getA1(), myProteins[nr]−>getA2(), myProteins[nr]−>getA3(), myProteins[nr]−>getB1(), myProteins[nr]−>getB2(), myProteins[nr]−>getB3(), myProteins[nr]−>getEbenenwinkelA(), myProteins[nr]−>getEbenenwinkelB(), myProteins[nr]−>getAufstellSinusB() );

return line;#endif}

/* Diese Methode legt ein neues Boxing entsprechend den aktuellen Schrittweiten an */void Configuration::newBoxing() {

if ((myBoxing−>vN_BOXES_X != ( int )(vAREA_X/(CUT_OFF+max(vMAX_TRANSLATION,LENGTH_B+RADIUS_B−RADIUS_A)))) || (myBoxing−>vN_BOXES_Y != ( int )(vAREA_Y/(CUT_OFF+max(vMAX_TRANSLATION,LENGTH_B+RADIUS_B−RADIUS_A))))) {

delete (myBoxing) ; myBoxing = new Boxing( this ) ;

}

}

/* der Destruktor der Klasse Configuration sorgt daf"ur, dass am Ende des Objektlebenszykluses die Attribute freigegeben werden */Configuration::~Configuration(){ delete (myProteins); delete (myRandom); delete (myPotential); delete (myBoxing); }

/* stellt die B−Helix in aufrecht auf. */void Configuration::standUp(){ for ( int i=1;i<=N_PROT;i++) { myProteins[i]−>setB(M_PI/2,1); myProteins[i]−>setEnergy((myPotential−>calculate(myBoxing,myProteins[i])).first); }}

/* der Konstruktor baut eine Startkonfiguration, wobei er den Proteinen definierte Startwerte zuweist */Configuration::Configuration(Random* rand){

myRandom=rand;

vAREA_X = AREA_X ; vAREA_Y = AREA_Y ;

Configuration.cpp

Configuration.cpp

86

vMAX_TRANSLATION = MAX_TRANSLATION ; vMAX_ROTATION_A = MAX_ROTATION_A ; vMAX_ROTATION_B = MAX_ROTATION_B ;

myProteins = new (Protein*)[N_PROT+1];

/* die Proteine werden in einem Gitter angeordnet −> die Gittergr"osse wird dabei der Proteinanzahl angepasst. Diese Berechnung wird durchgef"uhrt, um ein m"oglichst quadratisches Feld zu erhalten */

double cols=ceil(sqrt(N_PROT*RATIO_BOTH)); double rows=ceil(N_PROT/cols); double xGap=vAREA_X/(cols); // die L"ucke zwischen zwei Proteinen double yGap=vAREA_Y/(rows);

/* die breite entspricht dem gr"osseren Durchmmesser */ double breite=2*((RADIUS_A<RADIUS_B)?RADIUS_B:RADIUS_A);#ifdef Configuration_Debug_cerr cerr << " cols=" << cols << " \nrows=" << rows << " \ncols*rows=" << cols*rows << " \nxGap=" << xGap << " \nbreite=" << breite << " \nyGap=" << yGap << " \nbreite*RATIO_BOTH=" << breite*RATIO_BOTH << " \n";#endif

if ((xGap< breite)||(yGap< (breite*RATIO_BOTH))) { cerr << " Configuration::Configuration(Random* rand):\n\t"

<< " die Proteine passen in dieser Groesse nicht in’s Feld\n"; exit(1); }

if (vAREA_X!=vAREA_Y) { cerr << " Der Positionierungs−Algo ist auf ein quadratisches Feld optimiert!"; }

/* alle Proteine erhalten vordefinierte Startwerte f"ur ihre Variablen */ for ( int i=1;i<=N_PROT;i++) { /* cerr << "===============\n"

<< " Protein " << i << "\n";*/ myProteins[i]= new Protein(); myProteins[i]−>setX(fmod(i−1,cols)*xGap,vAREA_X); myProteins[i]−>setY(floor((i−1)/(cols))*yGap,vAREA_Y); myProteins[i]−>setA1(0.0); myProteins[i]−>setA2(−1.0); myProteins[i]−>setA3(0.0); myProteins[i]−>setEbenenwinkelA(−M_PI/2); /*

myProteins[i]−>setB1(0.0); myProteins[i]−>setB2(0.0); myProteins[i]−>setB3(1.0); myProteins[i]−>setEbenenwinkelB(M_PI/2); myProteins[i]−>setAufstellwinkelB(M_PI/2); */

myProteins[i]−>setB(M_PI/2,1); myProteins[i]−>setEnergy(0.0); } myProteins[0]= new Protein();

Configuration.cpp myBoxing = new Boxing( this ); myPotential = new Potential( this ); myPotential −> setCurrentPotential(myPotential−>calculate(myBoxing).first); /* in allen Proteinen muss das Potential gesetzt werden */ for ( int i=1;i<=N_PROT;i++) { Protein* prot = myProteins[i] ; prot −> setEnergy((myPotential−>calculate(myBoxing,prot)).first); } /* cerr << "Hey, neue Configuration ist gebaut\n";*/}

Configuration.cpp

Configuration.cpp

87

/* $Id: Protein.h,v 1.37 2002/03/26 11:27:27 usprosim Exp $ * $Locker: $ */

#ifndef PROTEIN_H#define PROTEIN_H#include <iostream.h>#include <cmath>#include " Constants.h"

/** gibt die L"ange der Ausgabe von toString() an (aber ca. um den Faktor 3 zu gross) */const int PROTEIN_TEXT_LENGTH = 1000;

/** * beschreibt als Klasse die Objekte, die wir simulieren wollen * @version $Revision: 1.37 $ */class Protein {

public:

Protein(); Protein( void * data);

~Protein();

/* im Folgenden werden get− und set−Methoden f"ur die einzelnen Parameter definiert */

inline double getX() { return x; } inline double getY() { return y; } inline void setX( double x, double area_x) {

/* f"ur den Fall, dass der neue Wert ausserhalb der R"ander liegt, wird er (entsprechend den periodischen Randbedingungen) zurechtgestutzt */

if (x<0.0) {x += area_x ; if (x>=area_x) x = 0.0 ; // f"ur numerische Ungenauigkeiten

} else if (x>=area_x) {

x −= area_x ;if (x<0.0) x = 0.0 ; // f"ur numerische Ungenauigkeiten

}

this−>x = fmod(x,area_x) ; }

inline void setY( double y, double area_y) { if (y<0.0) {

y += area_y ;

Protein.hif (y>=area_y) y = 0.0 ; // f"ur numerische Ungenauigkeiten

} else if (y>=area_y) {y −= area_y ;if (y<0.0) y = 0.0 ; // f"ur numerische Ungenauigkeiten

} this−>y = fmod(y,area_y) ; } inline double getA1(){ return A1; } inline void setA1( double A1){ this−>A1 = A1; }

inline double getA2(){ return A2; } inline void setA2( double A2){ this−>A2 = A2; }

inline double getA3(){ return A3; } inline void setA3( double A3){ this−>A3 = A3; }

/* f"ur Helix B m"ussen alle drei Werte auf einmal gesetzt werden, damit sich die beiden Helices nicht zu nahe kommen */

inline double getB1(){ return B1; }



/* setzt alle drei Werte auf einmal, dabei werden die gew"unschten Winkel angegeben und in die entsprechenden Helixparameter umgerechnet */

inline void setB( double ebenenwinkel, double aufstellsinus) { /* der aufstellsinus wird hier NICHT auf Wertebereich "uberpr"uft! */ aufstellsinusB=aufstellsinus;

/* die Ebenenwinkel sollen im Bereich [0,2*pi) liegen */ while (ebenenwinkel>=2*M_PI) ebenenwinkel−=2*M_PI; while (ebenenwinkel<0) ebenenwinkel+=2*M_PI; ebenenwinkelB=ebenenwinkel;

/* die folgenden Zeilen benutzen bereits die neuen Winkel! */ double projektion = sqrt(1−aufstellsinusB*aufstellsinusB); B1=(cos(ebenenwinkel)*projektion); B2=(sin(ebenenwinkel)*projektion); B3=aufstellsinusB; }

/* es k"onnen nicht nur die Helixparameter A1, A2, ..., sondern auch die daraus berechneten Winkel abgefragt werden: */

inline double getEbenenwinkelA() { return ebenenwinkelA; } inline void setEbenenwinkelA( double winkel) { while (winkel>=2*M_PI) winkel−=2*M_PI; while (winkel<0) winkel+=2*M_PI; this−>ebenenwinkelA=fmod(winkel,2*M_PI); }

inline double getEbenenwinkelB() { return ebenenwinkelB; } inline void setEbenenwinkelB( double winkel) { this−>ebenenwinkelB=fmod(winkel,2*M_PI);

Protein.h

Protein.h

88

}

inline double getAufstellSinusB(){ return aufstellsinusB; } inline void setAufstellsinusB( double sinus) { this−>aufstellsinusB=sinus; }

inline double getEnergy(){ return energy; } inline void setEnergy( double energy){ this−>energy = energy; }

/** * gibt eine textuelle Representation des Proteins * @returns eine textuelle Representation des Proteins **/ char * toString();

/** * gibt eine kurze textuelle Beschreibung des Proteins * (also nur den "Knickpunkt") * kann z.B. zur schnellen "Uberpr"ufung der Werte benutzt werden * @returns eine kurze textuelle Beschreibung des Proteins **/ char * toShortString();

private:

/** * Die X−Koordinate des Protein−"Knickpunktes" */ double x;

/** * die Y−Koordinate des Protein−"Knickpunktes" */ double y;

/** * jede der beiden Helices A, B erh"alt einen Richtungseinheitsvektor, * der aus je drei doubles besteht */

double A1; double A2; double A3;

double B1; double B2; double B3;

/** * die Winkel der Richtungsvektoren * ebenenwinkelA ist der Winkel von Helix A in der Ebene * ebenenwinkelB ist der Winkel von Helix B in der Ebene * aufstellwinkelB ist der Winkel zwischen Helix B und der Ebene */ double ebenenwinkelA; double ebenenwinkelB; double aufstellsinusB;

/** * gibt die Summe der Paar−Wechselwirkungs−Energien

Protein.h * mit den anderen Proteinen an */ double energy;

/** * als Zwischenspeicher fuer die Methode toString */ char string[PROTEIN_TEXT_LENGTH];

/** * als Zwischenspeicher fuer die Methode toShortString */ char ret[47];};#endif //PROTEIN_H

Protein.h

Protein.h

89

/* $Id: Protein.cpp,v 1.15 2002/03/26 11:28:26 usprosim Exp $ * $Locker: $ */

#include " Protein.h"#include <stdio.h>

const char * TEXT_OUT_FORMAT = " x:" " %0.16le" " \ty:" " %0.16le" " \tA1:" " %0.16le" " \tA2:" " %0.16le" " \tA3:" " %0.16le" " \tB1:" " %0.16le" " \tB2:" " %0.16le" " \tB3:" " %0.16le" " \tebenenWinkelA:" " %0.16le" " \tebenenWinkelB:" " %0.16le" " \taufstellsinusB:" " %0.16le" " \tenergy:" " %0.16le" " \n";

const char * TEXT_IN_FORMAT = " x:" " %le" " \ty:" " %le" " \tA1:" " %le" " \tA2:" " %le" " \tA3:" " %le" " \tB1:" " %le" " \tB2:" " %le" " \tB3:" " %le" " \tebenenWinkelA:" " %le" " \tebenenWinkelB:" " %le" " \taufstellsinusB:" " %le" " \tenergy:" " %le" " \n";

Protein::~Protein(){}

Protein::Protein(){}

/* der folgende Konstruktor baut ein Protein entsprechend den Daten aus der Datei "data" */Protein::Protein( void * data){ Protein(); FILE * file = ( FILE *) data; fscanf(file,TEXT_IN_FORMAT,

& this −>x,& this −>y, & this −>A1,& this −>A2,& this −>A3, & this −>B1,& this −>B2,& this −>B3, & this −>ebenenwinkelA, & this −>ebenenwinkelB,& this −>aufstellsinusB, & this −>energy);

}

/* die Proteindaten x,y,... werden mit TEXT_OUT_FORMAT formatiert und in string geschrieben */

char * Protein::toString(){ sprintf(string,TEXT_OUT_FORMAT,x,y,A1,A2,A3,B1,B2,B3,ebenenwinkelA,ebenenwinkelB,aufstellsinusB,energy); return string;}

Protein.cppchar * Protein::toShortString(){ sprintf(ret," [Protein (X:%9.6f,Y:%9.6f)](%p)",x,y, this ); return ret;}

Protein.cpp

Protein.cpp

90

/* $Id: Boxing.h,v 1.30 2002/03/22 07:48:03 usprosim Exp $ * $Locker: $ */

#ifndef BOXING_H#define BOXING_H#include " Box.h"#include " Configuration.h"#include " Protein.h"#include " Constants.h"

class Configuration;class Box;class Protein;

/** * Ist f"ur das einsortieren der Proteine in Boxen zust"andig. Proteine * werden in Boxen einsortiert, damit nicht immer die Wechselwirkung mit * allen anderen Proteinen berechnet werden muss. * @version $Revision: 1.30 $ **/class Boxing { private:

/** * Dieses zweidimensionale Feld enth"alt die Boxen * (d.h. ein Feld enth"alt beliebig viele Boxen) * @link aggregation * @clientCardinality 1 * @supplierCardinality 1..* */ Box** boxes;

/** * das eine (in mehrere Boxen unterteilte Feld) enth"alt ferner * genau eine Configuration * @clientCardinality 1 * @link aggregation * @supplierCardinality 1 */ Configuration* myConfiguration;

/** @link dependency */ /*# Protein lnkProtein; */

public:

int vN_BOXES_X ; int vN_BOXES_Y ; double vBOX_WIDTH_X ; double vBOX_WIDTH_Y ;

/* konstruiert werden kann ein neues Boxing nur, wenn man die entsprechende Configuration als Parameter mitgibt */ Boxing(Configuration* config);

/** * Der Destruktor gibt den Speicher frei **/ ~Boxing() ;

/** * gibt die Box [x][y].

Boxing.h **/ inline Box* getBox ( int x, int y) { x %= vN_BOXES_X ; // zur Sicherheit wegen numerischer Fehler y %= vN_BOXES_Y ; return &boxes[x][y]; }

/** der Reihe nach werde alle Proteine in die Boxen sortiert */

void makeBoxing(); /** * K"ummert sich darum, dass ein Protein nach einer Bewegung wieder * in die richtige Box kommt. **/ void resort( int protein, double oldX, double oldY);

};#endif //BOXING_H

Boxing.h

Boxing.h

91

/* $Id: Boxing.cpp,v 1.41 2002/03/26 11:29:33 usprosim Exp $ * $Locker: $ */

#include " Boxing.h"#include <math.h>#include <cmath>#include <iostream.h>#include <list>

/* die folgende Methode sortiert ein verschobenes Protein neu ein */

void Boxing::resort( int protein, double oldX, double oldY){

#ifdef Boxing_Debug_cerr cerr << " Boxing::resort(" << protein << " ," << oldX << " ," << oldY << " ) gestartet.\n";#endif

int xBoxOld=(( int )floor(oldX/vBOX_WIDTH_X)) % vN_BOXES_X ; int yBoxOld=(( int )floor(oldY/vBOX_WIDTH_Y)) % vN_BOXES_Y ;

Protein* prot=myConfiguration−>protein(protein) ; int xBoxNew=(( int )floor(prot−>getX()/vBOX_WIDTH_X)) % vN_BOXES_X ; int yBoxNew=(( int )floor(prot−>getY()/vBOX_WIDTH_Y)) % vN_BOXES_Y ;

/* vielleicht wurde das Protein nur innerhalb seiner bisherigen Box verschoben, und muss deshalb nicht neu einsortiert werden */ if ((xBoxOld==xBoxNew)&&(yBoxOld==yBoxNew)) return ;

#ifdef Boxing_Debug // um zu "uberpr"ufen, ob keine Proteine verloren gehen list< int >::iterator current_prot; bool found= false ; for (current_prot = boxes[xBoxOld][yBoxOld].proteins.begin() ; current_prot != boxes[xBoxOld][yBoxOld].proteins.end() ; current_prot++ ) { if ((*current_prot)==protein){found= true ; break ;}}

if (!found) { cerr << " Boxing::resort(" << protein << " ," << oldX << " ," << oldY << " ):\n"; cerr << " \tFEHLER: Wir verlieren unsere Proteine aus den Boxen.\n\n"; }#endif //Boxing_Debug

/* sobald herausgefunden wurde, in welcher Box sich das verschobene Protein * vorher befand und wo es nun hin muss, wird es gel"oscht, bzw. einsortiert */ boxes[xBoxOld][yBoxOld].proteins.remove(protein); boxes[xBoxNew][yBoxNew].proteins.push_back(protein);

#ifdef Boxing_Debug // um zu "uberpr"ufen, ob Proteine zweimal existieren // weil sie versehentlich nicht gel"oscht wurden found= false ; for (current_prot = boxes[xBoxOld][yBoxOld].proteins.begin() ; current_prot != boxes[xBoxOld][yBoxOld].proteins.end() ; current_prot++ ) { if ((*current_prot)==protein){found= true ; break ;}}

if (found) { cerr << " Boxing::resort(" << protein << " ," << oldX << " ," << oldY << " ):\n"; cerr << " \tFEHLER: Wir loeschen unsere Proteine nicht aus den Boxen.\n\n"; }

Boxing.cpp#endif //Boxing_Debug

#ifdef Boxing_Debug_cerr cerr << " Boxing::resort(" << protein << " ," << oldX << " ," << oldY << " ) beendet.\n";#endif}

Boxing::Boxing(Configuration* config) {

int rechts,links,oben,unten; // die vier Nachbarboxen

myConfiguration = config;

vN_BOXES_X = ( int )(config−>getAreaX() / (CUT_OFF+max(config−>getMaxTranslation(),LENGTH_B+RADIUS_B−RADIUS_A))) ; vN_BOXES_Y = ( int )(config−>getAreaY() / (CUT_OFF+max(config−>getMaxTranslation(),LENGTH_B+RADIUS_B−RADIUS_A))) ; if (vN_BOXES_X == 0) vN_BOXES_X = 1 ; if (vN_BOXES_Y == 0) vN_BOXES_Y = 1 ; vBOX_WIDTH_X = config−>getAreaX()/vN_BOXES_X ; vBOX_WIDTH_Y = config−>getAreaY()/vN_BOXES_Y ;

/* Das Feld mit den Boxen erzeugen */ boxes = new Box*[vN_BOXES_X];

for ( int x=0;x<vN_BOXES_X;x++) { boxes[x] = new Box[vN_BOXES_Y]; }

for ( int x=0;x<vN_BOXES_X;x++) {

for ( int y=0;y<vN_BOXES_Y;y++) {

rechts = x + 1 ; links = x − 1 ; unten = y + 1 ; oben = y − 1 ;

/* evtl m"ussen bei den direkten Nachbarn die periodischen Randbedingungen beachtet werden */

if (rechts == vN_BOXES_X) rechts = 0 ; if (unten == vN_BOXES_Y) unten = 0 ; if (links < 0) links = vN_BOXES_X − 1 ; if (oben < 0) oben = vN_BOXES_Y − 1 ;

/* die Liste der Nachbarboxen setzen

nur (und gerade) diese vier, damit Potentiale nicht doppelt berechnet werden */

boxes[x][y].directedNeighbours.push_back(&boxes[x][y]); boxes[x][y].allNeighbours.push_back(&boxes[x][y]);

if (vN_BOXES_Y > 1) {boxes[x][y].directedNeighbours.push_back(&boxes[x][oben]);boxes[x][y].allNeighbours.push_back(&boxes[x][oben]);if (vN_BOXES_Y > 2) { boxes[x][y].allNeighbours.push_back(&boxes[x][unten]);}

}

Boxing.cpp

Boxing.cpp

92

if (vN_BOXES_X > 1) {boxes[x][y].directedNeighbours.push_back(&boxes[rechts][y]);boxes[x][y].allNeighbours.push_back(&boxes[rechts][y]);if (vN_BOXES_Y > 1) { boxes[x][y].directedNeighbours.push_back(&boxes[rechts][oben]); boxes[x][y].allNeighbours.push_back(&boxes[rechts][oben]); if (vN_BOXES_Y > 2) { boxes[x][y].directedNeighbours.push_back(&boxes[rechts][unten]); boxes[x][y].allNeighbours.push_back(&boxes[rechts][unten]); }}if (vN_BOXES_X > 2) { boxes[x][y].allNeighbours.push_back(&boxes[links][y]); if (vN_BOXES_Y > 1) { boxes[x][y].allNeighbours.push_back(&boxes[links][oben]); if (vN_BOXES_Y > 2) { boxes[x][y].allNeighbours.push_back(&boxes[links][unten]); } }}

}

}

}

/* alle Proteine aus der Configuration richtig einsortieren */ makeBoxing();

#ifdef Boxing_Debug_cerr cerr << " Boxing−Konstruktor beendet\n";#endif

}

/* der Destruktor gibt den Speicher frei */Boxing::~Boxing() { for ( int x=0; x<vN_BOXES_X; x++) delete [](boxes[x]) ; delete [](boxes);

}

/* der Reihe nach werde alle Proteine in die Boxen sortiert */void Boxing::makeBoxing() {

Protein* protein; int x,y;

for ( int i=1;i<=N_PROT;i++) { protein = myConfiguration−>protein(i); x = (( int )floor(protein−>getX()/vBOX_WIDTH_X)) % vN_BOXES_X ; y = (( int )floor(protein−>getY()/vBOX_WIDTH_Y)) % vN_BOXES_Y ; boxes[x][y].proteins.push_back(i); }}

Boxing.cpp/* $Id: Box.h,v 1.8 2002/03/22 07:49:24 usprosim Exp $ * $Locker: $ */

#ifndef BOX_H#define BOX_H

#include <list>

class Box {

friend class Boxing;

private:

list< int > proteins;

/** * @clientCardinality 1 * @supplierCardinality 5..* */ list<Box*> directedNeighbours;

/** * @clientCardinality 1 * @supplierCardinality 8..* */ list<Box*> allNeighbours;

public: /* gibt zu einer Box die Nummern (Indices) der in ihr enthaltenen zur"uck Proteine */ inline list< int >& getProteins() { return this−>proteins; } /* durchs System gehen −> gibt die Nachbarn in einer Richtung zur"uck (nur in einer Richtung, damit man nichts doppelt z"ahlt) */ inline list<Box*>& getDirectedNeighbours() { return this−>directedNeighbours; }

/* gibt die acht Nachbarboxen und die Bezugsbox zur"uck, um zu pr"ufen, ob sich das Potential lokal ge"andert hat */ inline list<Box*>& getAllNeighbours() { return this−>allNeighbours; } };

#endif

Box.h

Boxing.cpp, Box.h

93

/* $Id: Potential.h,v 1.21 2002/03/22 14:52:28 usprosim Exp $ * $Locker: $ */

#ifndef POTENTIAL_H#define POTENTIAL_H

#include <utility>#include <vector>#include " Configuration.h"#include " Boxing.h"#include " Protein.h"#include " Box.h"

class Configuration;class Boxing;class Protein;

class Potential {

private: double currentPotential;

/** * @link aggregation * @supplierCardinality 1 * @clientCardinality 1 */ Configuration* config;

// das Potential arbeitet "uber config mit den folgenden Objekten zusammen

/** @link dependency */ /*# LinkedList lnkLinkedList; */

/** @link dependency */ /*# Boxing lnkBoxing; */

/** @link dependency */ /*# Box lnkBox; */

/* die Methode pairPotential bildet die Differenz der Potentiale f"ur Protein proti und protj und gibt ein Paar zur"uck, das aus dem Paarpotential und einem boolschen Wert f"ur die Akzeptanz besteht */

static pair< double ,bool> pairPotential(Protein* proti, Protein* protj, Configuration* config, Boxing* boxing, bool border);

/* die folgende Methode berechnet das Paarpotential zwischen zwei Spherozylindern */

static pair< double ,bool> cylinderPotential(vector< double >& rij, vector< double >& ui, vector< double >& uj, double & length2i, double & radi, double & length2j, double & radj);

/* folgendes liefert das Potential f"ur den Knick zwischen den beiden Helices */

static pair< double ,bool> bendPotential(Protein* prot);

public:

Potential.h

Potential(Configuration* config);

inline void setCurrentPotential( double potential) { this−>currentPotential=potential; }

inline double getCurrentPotential() { return this−>currentPotential; }

/* die beiden folgenden Methoden berechnen die Potentiale f"ur eine komplette Configuration, bzw. "andern deren Wert in Abh"angigkeit von der "Anderung eines Proteins */

pair< double ,bool> calculate(Boxing* boxing); pair< double ,bool> calculate(Boxing* boxing, Protein* proti); };

#endif

Potential.h

Potential.h

94

/* $Id: Potential.cpp,v 2.3 2002/03/26 11:32:10 usprosim Exp $ * $Locker: $ */

//#define POTENTIAL_DEBUG//#define TEST_CYLINDERS

#include <stdlib.h>#include <iostream>#include <utility>#include <cmath>#include <vector>#include " Potential.h"#include " Constants.h"

/* diese Methode berechnet signum(x) */inline double sgn( double x) { if (x>0) return 1.0; else if (x<0) return −1.0; else return 0.0;}

/* diese Konstruktormethode setzt die Konfiguration */Potential::Potential(Configuration* config) { this −> config = config ;}

/* diese Methode berechnet das Gesamtpotential einer geboxten Konfiguration */pair< double , bool > Potential::calculate(Boxing* boxing) { // Variable f"ur das Potential double potential = 0.0 ;

// Variablen f"ur die Berechnung pair< double , bool > pairPotential; // Schleifenvariable int box_x, box_y; Protein *proti, *protj; Box *current_box; list<Box*> neighbour_boxes; list<Box*>::iterator neighbour_box; list< int > current_proteins, neighbour_proteins; list< int >::iterator current_prot, neighbour_prot;

/* Schleife "uber alle Proteine zur Berechnung * des Knickpotentials kann sp"ater in die anderen Schleifen eingeflochten * werden; dann umstellen der Schleifen n"otig */

#ifndef TEST_CYLINDERS for (box_x=0; box_x < boxing−>vN_BOXES_X; box_x++) {

Potential.cpp for (box_y=0; box_y < boxing−>vN_BOXES_Y; box_y++) { current_box = boxing −> getBox(box_x,box_y) ; current_proteins = current_box −> getProteins() ;

for (current_prot = current_proteins.begin(); current_prot != current_proteins.end(); current_prot++)

{ proti = config −> protein(*current_prot) ; pairPotential = Potential::bendPotential(proti) ; if (!pairPotential.second) { return pair< double , bool >(potential, false ); } potential += pairPotential.first ; } } }#endif

// Schleife "uber alle Zeilen for (box_x=0; box_x < boxing−>vN_BOXES_X; box_x++) { // Schleife "uber alle Spalten for (box_y=0; box_y < boxing−>vN_BOXES_Y; box_y++) { current_box = boxing −> getBox(box_x,box_y) ; current_proteins = current_box −> getProteins() ; neighbour_boxes = current_box −> getDirectedNeighbours() ;

// Schleife "uber alle Nachbarboxen for (neighbour_box = neighbour_boxes.begin() ; neighbour_box != neighbour_boxes.end() ; neighbour_box++ ) { neighbour_proteins = (*neighbour_box) −> getProteins() ; // Schleife "uber alle Teilchen in der Box for (current_prot = current_proteins.begin() ; current_prot != current_proteins.end() ; current_prot++ ) { /* in die Hilfsvariable proti wird ein Protein aus der Liste current_prot geschrieben */ proti = config −> protein((*current_prot)) ;

// Schleife "uber alle Partnerteilchen in der Nachbarbox for (neighbour_prot = neighbour_proteins.begin() ; neighbour_prot != neighbour_proteins.end() ; neighbour_prot++ ) {

protj = config −> protein((*neighbour_prot)) ;if (proti != protj) {

// Test ob Randbox if ((box_x==boxing−>vN_BOXES_X−1)

|| (box_y==0) || (box_y==boxing−>vN_BOXES_Y−1)) {

// Berechne Paarpotential zwischen m und n pairPotential =

Potential::pairPotential(proti,protj,config,boxing, true );

Potential.cpp

Potential.cpp

95

} else { pairPotential =

Potential::pairPotential(proti,protj,config,boxing, false );

}

// Paarpotential nicht akzeptiert if (!pairPotential.second)

{ // R"uckgabewert (potential ist noch 0.0) return pair< double , bool >(potential, false );}

// Paarpotential akzeptiert else { // Potential aufsummieren (fuer weiches Potential) }

} // if (proti != protj)

} // Ende Schleife "uber alle Partnerteilchen in der Nachbarbox } // Ende Schleife "uber alle Teilchen in der Box } // Ende Schleife "uber alle Nachbarboxen } // Ende Schleife "uber alle Spalten } // Ende Schleife "uber alle Zeilen

// R"uckgabewert return pair< double , bool >(potential, true );

} // pair<double,bool> calculate(Boxing* boxing)

/* diese Methode berechnet das Potential eines Proteins in einer geboxten Konfiguration */pair< double , bool > Potential::calculate(Boxing* boxing, Protein* proti) { double potential = 0.0; pair< double , bool > pairPotential; list<Box*> neighbour_boxes; list<Box*>::iterator neighbour_box; list< int > neighbour_proteins; list< int >::iterator neighbour_prot; Protein *protj;

#ifndef TEST_CYLINDERS /* Knickpotential berechnen */ pairPotential = Potential::bendPotential(proti) ;

/* Test ob Knickpotential akzeptiert */ if (!pairPotential.second) { return pair< double , bool >(potential, false ) ; }

/* Knickpotential ins Potential */ potential += pairPotential.first ;#endif

int x_box = ( int )floor(proti−>getX()/boxing−>vBOX_WIDTH_X); int y_box = ( int )floor(proti−>getY()/boxing−>vBOX_WIDTH_Y);

Potential.cpp

neighbour_boxes = (boxing −> getBox(x_box,y_box)) −> getAllNeighbours() ;

/* vielleicht kann man die Boxgr"osse dadurch jetzt "andern??? */ for (neighbour_box = neighbour_boxes.begin() ; neighbour_box != neighbour_boxes.end() ; neighbour_box++ ) { neighbour_proteins = (*neighbour_box) −> getProteins() ; for (neighbour_prot = neighbour_proteins.begin() ;

neighbour_prot != neighbour_proteins.end() ; neighbour_prot++ ) { protj = config −> protein(*neighbour_prot) ; if (proti != protj) { if ((x_box==0)

|| (x_box==boxing−>vN_BOXES_X−1) || (y_box==0) || (y_box==boxing−>vN_BOXES_Y−1)) {

pairPotential = Potential::pairPotential(proti,protj,config,boxing, true );

} else {

pairPotential = Potential::pairPotential(proti,protj,config,boxing, false );

}

if (!pairPotential.second) { return pair< double , bool >(potential, false ); } else { //hier sp"ater Potential aufsummieren!!! } } } }

return pair< double , bool >(potential, true );

} // pair<double,bool> calculate(Boxing* boxing, Protein* proti)

/* diese Methode berechnet das Paarpotential zwischen zwei Proteinen */pair< double , bool > Potential::pairPotential(Protein* proti, Protein* protj,

Configuration* config, Boxing* boxing, bool border)

{ // Variablen f"ur die Berechnung double length2i, radi, length2j, radj ; vector< double > rij(3), ui(3), uj(3) ; pair< double , bool > cylinderPotential ;

// Variable f"ur das Paarpotential der Teilchen double potij = 0.0 ;

/* falls TEST_CYLINDERS definiert wurde, wird das Potential nur aufgrund der beiden A−Helices berechnet, ansonsten werden auch die B−Helices

Potential.cpp

Potential.cpp

96

betrachtet */

#ifndef TEST_CYLINDERS // Schleife "uber Zylinder von Teilchen i for ( int cyli=0; cyli < 2; cyli++) { // Schleife "uber die Zylinder von Teilchen j for ( int cylj=0; cylj < 2; cylj++) {#endif

#ifdef TEST_CYLINDERS // nur Zylinder A von Teilchen i for ( int cyli=0; cyli < 1; cyli++) { // nur Zylinder A von Teilchen j for ( int cylj=0; cylj < 1; cylj++) {#endif

// Richtungsvektor des jeweiligen Zylinders holen if (cyli==0) { ui[0] = proti −> getA1() ; ui[1] = proti −> getA2() ; ui[2] = proti −> getA3() ; length2i = LENGTH_A / 2 ; radi = RADIUS_A ; } else { ui[0] = proti −> getB1() ; ui[1] = proti −> getB2() ; ui[2] = proti −> getB3() ; length2i = LENGTH_B / 2 ; radi = RADIUS_B ; }

// Richtungsvektor des jeweiligen Zylinders holen if (cylj==0) { uj[0] = protj −> getA1() ; uj[1] = protj −> getA2() ; uj[2] = protj −> getA3() ; length2j = LENGTH_A / 2 ; radj = RADIUS_A ; } else { uj[0] = protj −> getB1() ; uj[1] = protj −> getB2() ; uj[2] = protj −> getB3() ; length2j = LENGTH_B / 2 ; radj = RADIUS_B ; }

/* Verbindungsvektor zwischen den Zylindern Achtung: mit length2i ist nicht die doppelte, sondern nur die halbe L"ange der Helix gemeint − das Divisionszeichen wurde nur aus Gr"unden der Lesbarkeit weggelassen! die halbe L"ange wird verwendet, um zum Mittelpunkt der Helix zu kommen (und dort den Verbindungsvektor angreifen zu lassen) */ double ix = proti −> getX() ; double iy = proti −> getY() ;

Potential.cpp double jx = protj −> getX() ; double jy = protj −> getY() ; double ax = config −> getAreaX() ; double ay = config −> getAreaY() ;

/* Beruecksichtigung der periodischen Randbedingungen */ /* Bedingung: AREA >= 2*CUT_OFF */ if (border) {

if (ix−jx > ax/2)jx += ax ;

else if (jx−ix > ax/2)jx −= ax ;

if (iy−jy > ay/2)jy += ay ;

else if (jy−iy > ay/2)jy −= ay ;

}

rij[0] = ix + ui[0] * length2i − jx − uj[0] * length2j ; rij[1] = iy + ui[1] * length2i − jy − uj[1] * length2j ; rij[2] = ui[2] * length2i − uj[2] * length2j ;

// Potential der Zylinder berechnen cylinderPotential = Potential::cylinderPotential(rij, ui, uj,

length2i, radi, length2j, radj) ;

// Test ob Potential akzeptabel if (!cylinderPotential.second) {

#ifdef POTENTIAL_DEBUG cerr << " \tCYLINDER OVERLAP\n" << " \tproti* = " << proti << " \tprotj* = " << protj << " \n" << " \tZylinder i = " << cyli << " \t\tZylinder j = " << cylj << " \n" << " \tproti−>getX() = " << proti−>getX() << " \tprotj−>getX() = " << protj−>getX() << " \n" << " \tproti−>getY() = " << proti−>getY() << " \tprotj−>getY() = " << protj−>getY() << " \n" << " \tui[0] = " << ui[0] << " \t\tuj[0] = " << uj[0] << " \n" << " \tui[1] = " << ui[1] << " \tuj[1] = " << uj[1] << " \n" << " \tui[2] = " << ui[2] << " \t\tuj[2] = " << uj[2] << " \n" << " \tlength2i = " << length2i << " \t\tlength2j = " << length2j << " \n" << " \tradi = " << radi << " \t\tradj = " << radj << " \n" << " \trij[0] = " << rij[0] << " \n" << " \trij[1] = " << rij[1] << " \n" << " \trij[2] = " << rij[2] << " \n";#endif // R"uckgabewert return pair< double , bool >(potij, false ); } // Potential akzeptabel else

Potential.cpp

Potential.cpp

97

{ // Potential aufsummieren (fuer weiches Potential) } } // Ende Schleife "uber Zylinder von Teilchen j } // Ende Schleife "uber Zylinder von Teilchen i

// R"uckgabewert return pair< double , bool >(potij, true );

} // pair<double,bool> pairPotential(Protein* proti, Protein* protj)

/* diese Methode berechnet das Paarpotential zwischen zwei Spherozylindern */pair< double , bool > Potential::cylinderPotential(vector< double >& rij,

vector< double >& ui, vector< double >& uj, double & length2i, double & radi, double & length2j, double & radj)

{ // Konstanten f"ur die Berechnung const double & length2ij = length2i + length2j ; const double & cutoff = length2ij + radi + radj ; const double & cutoffsq = cutoff * cutoff ; const double & radsq = (radi + radj) * (radi + radj) ;

// Variablen f"ur die Berechnung double rijsq, dijsq ; double cosij, cosri, cosrj, sinijsq ; double lambda, mu, absla, absmu ;

// Variable f"ur das Paarpotential der Zylinder double potij = 0.0 ;

/* Abstandsquadrat zwischen den Schwerpunkten (wird ben"otigt, um herauszufinden, ob die Helices "uberhaupt nah genug beieinader sind, um wechselwirken zu k"onnen) */ rijsq = rij[0] * rij[0] + rij[1] * rij[1] + rij[2] * rij[2] ; // Test ob Verbindungsvektor k"urzer als Reichweite if (rijsq < cutoffsq) { // Skalarprodukt zwischen i und j (f"ur den Test auf Parallelit"at) cosij = ui[0] * uj[0] + ui[1] * uj[1] + ui[2] * uj[2] ;

// Skalarprodukt zwischen r und i cosri = rij[0] * ui[0] + rij[1] * ui[1] + rij[2] * ui[2] ;

// Skalarprodukt zwischen r und j cosrj = rij[0] * uj[0] + rij[1] * uj[1] + rij[2] * uj[2] ;

// Sinusquadrat des Winkels zwischen i und j sinijsq = 1 − cosij * cosij ;

// Test auf parallele Ausrichtung der Zylinder if (sinijsq == 0) { /* Parameter der Punkte auf den Geraden mit minimalem Abstand entsprechen Projektionen des Verbindungsvektors der Aufpunkte auf die Orientierungsrichtungen */

lambda = − cosri * length2i / length2ij ;

Potential.cpp mu = cosrj * length2j / length2ij ;

/* hier k"onnte man schon den Abstand der Geraden "uberpr"ufen ob sich das lohnt kommt drauf an: man spart 1 Vergleich und 2 Multiplikationen in der Behandlung endlicher Liniensegmente aber man hat im schlimmsten Fall die Berechnung von dijsq zweimal der erste Fall wird zwar "ofter vorkommen, muss aber auch ungef"ahr viermal mehr vorkommen, damit es sich lohnt das k"onnte man sp"ater mal ausprobieren */

/* Behandlung endlicher Liniensegmente Test ob Parameter ausserhalb des Liniensegment sind ein Liniensegment ist in diesem Zusammenhang der Abschnitt auf der Geraden, die durch den Richtungsvektor der Helix bestimmt wird, welcher die Lage der Helix auf eben dieser Geraden codiert */

if (abs(lambda) > length2i) { // Punkte mit minimalem Abstand sind die Endpunkte lambda = sgn(lambda) * length2i ; mu = sgn(mu) * length2j ; } // Ende Behandlung endlicher Liniensegmente } // Ende parallele Ausrichtung // nicht parallele Ausrichtung der Zylinder else { // Parameter der Punkte auf den Geraden mit minimalem Abstand lambda = (−cosri + cosij * cosrj) / sinijsq ; mu = (cosrj − cosij * cosri) / sinijsq ;

/* hier k"onnte man schon den Abstand der Geraden "uberpr"ufen hier w"urde es sich schon eher lohnen als oben k"onnte man auch sp"ater mal testen */

// Absolutbetr"ge absla = abs(lambda) ; absmu = abs(mu) ;

/* Behandlung endlicher Liniensegmente; Test ob Parameter ausserhalb Liniensegment */ if ( (absla > length2i) || (absmu > length2j) ) { // Test welches Teilchen n"aher am Schnittpunkt if ( absla−length2i < absmu−length2j ) { // mu ist sicher gr"osser length2j; setze mu auf Endpunkt des Segments mu = sgn(mu) * length2j ; // Minimierung bez"uglich lambda bei konstantem mu lambda = − cosri + mu * cosij ; // Test ob Parameter lambda ausserhalb Liniensegment if (abs(lambda) > length2i) { // setze lambda auf Endpunkt des Segments lambda = sgn(lambda) * length2i ; } } // Ende Minimierung f"ur (absla−length2i < absmu−length2j) else { /* lambda ist sicher gr"osser gleich length2i; setze lambda auf Endpunkt des Segments */ lambda = sgn(lambda) * length2i ; // Minimierung bez"uglich mu bei konstantem lambda mu = cosrj + lambda * cosij ;

Potential.cpp

Potential.cpp

98

// Test ob Parameter mu ausserhalb Liniensegment if (abs(mu) > length2j) { // setze mu auf Endpunkt des Segments mu = sgn(mu) * length2j ; } } // Ende Minimierung f"ur (absla−length2i >= absmu−length2j)

} // Ende Behandlung endlicher Liniensegmente } // Ende nicht parallele Ausrichtung

// Abstandsquadrat berechnen dijsq = rijsq + 2*lambda*cosri − 2*mu*cosrj + lambda*lambda + mu*mu − 2*lambda*mu*cosij ;

// Test ob "Uberlappung if (dijsq < radsq) { // R"uckgabewert return pair< double , bool >(potij, false ); } // keine "Uberlappung else { /* Berechnung des weichen Potentials sp"ater dann muss auch noch der Test ob Verbindungsvektor k"urzer als Reichweite modifiziert werden! auch cutoff dann anpassen! */ }

} // Ende Verbindungsvektor k"urzer als Reichweite

// R"uckgabewert return pair< double , bool >(potij, true );

} // pair<double,bool> cylinderPairPotential

/* diese Methode berechnet das Knickpotential eines Proteins */pair< double , bool > Potential::bendPotential(Protein* prot) {

vector< double > ui(3), uj(3) ; // Variablen f"ur die Richtungsvektoren double cosij ; // Variable f"ur den Cosinus zwischen den Helices double bendPotential ; // Variable f"ur das Knickpotential

ui[0] = prot −> getA1() ; ui[1] = prot −> getA2() ; ui[2] = prot −> getA3() ; uj[0] = prot −> getB1() ; uj[1] = prot −> getB2() ; uj[2] = prot −> getB3() ; /* Cosinus zwischen den Helices entspricht bei Einheitsvektoren dem Skalarprodukt */ cosij = ui[0]*uj[0] + ui[1]*uj[1] + ui[2]*uj[2] ;

/* Winkelanteil des Knickpotentials liegt zwischen 0 f"ur entgegengesetzte Richtungsvektoren und 2 f"ur kollineare Richtungsvektoren */ bendPotential = STIFFNESS_FACTOR * (1 + cosij) ;

Potential.cpp /* z−Komponente der B−Helix als additiver Term zum Knickpotential */ bendPotential += LIFT_FACTOR * (prot −> getB3()) ;

/* R"uckgabewert */ return pair< double , bool >(bendPotential, true ) ; }

Potential.cpp

Potential.cpp

99

/* $Id: Random.h,v 1.11 2002/03/22 07:25:01 usprosim Exp $ * $Locker: $ */

#ifndef RANDOM_H#define RANDOM_H

/** * @version $Revision: 1.11 $ */class Random {

public:

/** * l"adt aus dem FILE* data den internen Zustand **/ Random( void * data); Random( int seed); ~Random();

/** * gibt den internen Zustand als Zeichenkette zur"uck **/ char * toString();

/** * liefert Zufallszahlen zwischen 0 und 1 **/ double next_0_to_1();

/** * liefert Zufallszahlen zwischen 0 und pi **/ double next_0_to_pi(); /** * liefert Zufallszahlen zwischen 0 und 2pi **/ double next_0_to_2pi(); /** * liefert Zufallszahlen zwischen 0 und pi/2 **/ double next_0_to_pi_halbe(); /** * liefert Zufallszahlen zwischen −pi/2 und pi/2 **/ double next_minus_pi_halbe_to_pi_halbe(); /** * liefert Zufallszahlen zwischen −0.5 und 0.5 **/ double next_minus_ein_halb_to_ein_halb(); /** * liefert Zufallszahlen zwischen −1 und 1 **/ double next_minus_eins_to_eins();

private:

/* erzeugt eine Zufallszahl zwischen 0 und 1 (ausschliesslich) die Methode

Random.h ist privat, da nur skalierte Werte zur"uckgegeben werden sollen */ double RandomUniform(); double u[97],c,cd,cm; int j97,i97;

};#endif //RANDOM_H

Random.h

Random.h

100

/* $Id: Random.cpp,v 1.19 2002/03/26 11:33:35 usprosim Exp $ * $Locker: $ */

#include <stdio.h>#include <stdlib.h>#include <math.h>#include <iostream.h>#include " Random.h"#include " Configuration.h"

/* hier wird die Datei mit den Konfigurationen eingelesen, um beim Absturz des Programmes genau an der selben Stelle weiterzumachen */

Random::Random( void * data){ FILE * file = ( FILE *) data; fscanf(file," %i\t%i\t%le\t%le\t%le",

&j97,&i97, &c,&cd,&cm);

for ( int i=0;i<97;i++) { fscanf(file," %le",

&(u[i])); }}

/* Hier wird Random initialisiert mit einem Seed als Parameter. Der Seed muss zwischen 0 und 900000000 liegen */

Random::Random( int ijkl){ int ij = ijkl / 30082; int kl = ijkl − ij * 30082; float s,t; int i,j,k,l,m; int ii,jj; if (ijkl > 900000000 || ijkl < 0) { ij = 1802; kl = 9373; } i = (ij / 177) % 177 + 2; j = (ij % 177) + 2; k = (kl / 169) % 178 + 1; l = (kl % 169);

for (ii=0; ii<97; ii++) { s = 0.0; t = 0.5; for (jj=0; jj<24; jj++) { m = (((i * j) % 179) * k) % 179; i = j; j = k; k = m; l = (53 * l + 1) % 169; if (((l * m % 64)) >= 32) s += t;

Random.cpp t *= 0.5; } u[ii] = s; } c = 362436.0 / 16777216.0; cd = 7654321.0 / 16777216.0; cm = 16777213.0 / 16777216.0; i97 = 97; j97 = 33;}

/** * Destruktor von Random**/Random::~Random(){}

/* hier werden die Zufallszahlen berechnet, die Zahlen liegen ausschliesslich zwischen 0 und 1 es wird genau eine Zufallszahl von RandomUniform() zur"uckgegeben */

double Random::RandomUniform( void ){ double uni; uni = u[i97−1] − u[j97−1]; if (uni <= 0.0) uni++; u[i97−1] = uni; i97−−; if (i97 == 0) i97 = 97; j97−−; if (j97 == 0) j97 = 97; c −= cd; if (c < 0.0) c += cm; uni −= c; if (uni < 0.0) uni++; return (uni);}

/* RandomUniform wird nun verwendet, um einzelne, skalierte Zufallszahlen zur"uckzugeben */

double Random::next_0_to_pi(){ return RandomUniform()*M_PI;} // Zufallszahlen zwischen 0 und pi.

double Random::next_0_to_1(){ return RandomUniform();} // Zufallszahlen zwischen 0 und 1.

double Random::next_0_to_2pi(){ return RandomUniform()*2*M_PI;} // Zufallszahlen zwischen 0 und 2pi.

double Random::next_0_to_pi_halbe(){ return RandomUniform()*M_PI/2;} // Zufallszahlen zwischen 0 und pi/2.

Random.cpp

Random.cpp

101

double Random::next_minus_pi_halbe_to_pi_halbe(){ return RandomUniform()*M_PI−M_PI/2;} // Zufallszahlen zwischen −pi/2 und pi/2.

double Random::next_minus_ein_halb_to_ein_halb(){ return RandomUniform()−0.5;} // Zufallszahlen zwischen −0.5 und 0.5.

double Random::next_minus_eins_to_eins(){ return RandomUniform()*2−1;} // Zufallszahlen zwischen −1 und 1.

// erzeugt die Sicherheitskopie, die vom Konstruktor eingelesen werden kann

char * Random::toString(){ char * string = new char [23*102+10]; sprintf(string," %22i\t%22i\t%0.16e\t%0.16e\t%0.16e",

j97,i97, c,cd,cm);

for ( int i=0;i<97;i++) { sprintf(string," %s\t%0.16e",

string, u[i]);

} return string;}

Random.cpp/* $Id: PovUtils.h,v 1.7 2002/03/22 07:26:55 usprosim Exp $ * $Locker: $ */

/** * @version $Revision: 1.7 $ */

#ifndef POVUTILS_H#define POVUTILS_H

#include <fstream>#include " Constants.h"

class Configuration;

/** der Header f"ur die PovRay−Dateien; hier werden Parametersatz, aber auch Kameraposition und einzubindende Dateien festgelegt */ static void printPovRayHeader(fstream &f, const char * comment,

Configuration* config)

{ f << " /*\n PROSIMtoPOVRAY\n"; f << " render this file with povray to see the results\n"; f << " \n Parameter Set:"; f << " \n Temperature = " << TEMP; f << " \n Area Size = " << config−>getAreaX() << " x " << config−>getAreaY(); f << " \n Number of Proteins = " << N_PROT; f << " \n Number of iterations = " << N_ITERATIONS; f << " \n Helix A: Length = " << LENGTH_A <<" Radius = "<< RADIUS_A; f << " \n Helix B: Length = " << LENGTH_B <<" Radius = "<< RADIUS_B; f << " \n Maximum translation = " << config−>getMaxTranslation(); f << " \n Maximum rotation of helix A = " << config−>getMaxRotationA(); f << " \n Maximum rotation of helix B = " << config−>getMaxRotationB(); f << " \n Comment:\n " << comment << " \n*/ \n\n"; f << " #include \"colors.inc\"\n"; f << " #include \"textures.inc\"\n"; f << " background {color Blue}\n"; f << " camera {location <−30,30,−30> look_at <20,0,20>}\n"; f << " plane {<0,1,0>, 0 texture{Water scale 40}}\n"; f << " light_source { <0,30,0 > color White}\n"; } /** ein Povray−Koordinatensystem, das man immer gut gebrauchen kann */ static void printCoordSystem(fstream &f, Configuration* config) { f << " cylinder{<0,0,0><"

<< config−>getAreaX() << " ,0,0>,0.05 pigment{color Black}}\n";

f << " cylinder{<" << config−>getAreaX() << " ,0,0><" << config−>getAreaX() << " ,0," << config−>getAreaY() << " >,0.05 pigment{color Black}}\n";

f << " cylinder{<" << config−>getAreaX() << " ,0," << config−>getAreaY() << " ><0,0," << config−>getAreaY()

PovUtils.h

Random.cpp, PovUtils.h

102

<< " >,0.01 pigment{color Black}}\n"; f << " cylinder{<0,0,"

<< config−>getAreaY() << " ><0,0,0>,0.05 pigment{color Black}}\n";

f << " cylinder{<0," << LENGTH_B + RADIUS_B << " ,0><" << config−>getAreaX() << " ," << LENGTH_B + RADIUS_B << " ,0>,0.05 pigment{color Black}}\n";

f << " cylinder{<" << config−>getAreaX() << " ," << LENGTH_B + RADIUS_B << " ,0><" << config−>getAreaX() << " ," << LENGTH_B + RADIUS_B << " ," << config−>getAreaY() << " >,0.05 pigment{color Black}}\n";

f << " cylinder{<" << config−>getAreaX() << " ," << LENGTH_B + RADIUS_B << " ," << config−>getAreaY() << " ><0," << LENGTH_B + RADIUS_B << " ," << config−>getAreaY() << " >,0.05 pigment{color Black}}\n";

f << " cylinder{<0," << LENGTH_B + RADIUS_B << " ," << config−>getAreaY() << " ><0," << LENGTH_B + RADIUS_B << " ,0>,0.05 pigment{color Black}}\n";

f << " cylinder{<0,0,0><0," << LENGTH_B + RADIUS_B << " ,0>,0.05 pigment{color Black}}\n";

f << " cylinder{<" << config−>getAreaX() << " ,0,0><" << config−>getAreaX() << " ," << LENGTH_B + RADIUS_B << " ,0>,0.05 pigment{color Black}}\n";

f << " cylinder{<" << config−>getAreaX() << " ,0," << config−>getAreaY() << " ><" << config−>getAreaX() << " ," << LENGTH_B + RADIUS_B << " ," << config−>getAreaY() << " >,0.05 pigment{color Black}}\n";

f << " cylinder{<0,0," << config−>getAreaY() << " ><0," << LENGTH_B + RADIUS_B << " ,"

PovUtils.h << config−>getAreaY() << " >,0.05 pigment{color Black}}\n";

}#endif

PovUtils.h

PovUtils.h

103

/* $Id: Constants.h,v 1.25 2002/03/26 11:34:32 usprosim Exp $ * $Locker: $ */

#ifndef CONSTANTS_H#define CONSTANTS_H#include <algorithm>#include <math.h>

/** Diese Datei enth"alt alle Konstanten, die zur Definition des Systems ben"otigt werden. */

/** Schritte zum Equilibrieren */const int EQUI_STEPS = 0 ;

/** Schritte zum Adaptieren */const int ADAPT_STEPS = 1000 ;

/** Schritte zwischen Ausgaben */ const int SWEEP_STEPS = 10 ;

/** gewuenschte Akzeptanzrate */const double GOAL_RATE = 0.3 ;

/** Prozent Verschiebung der Schrittweiten waehrend der Adaption */const double STEP_SIZE = 0.05 ;

/** Faktor fuer das Knickpotential */const double STIFFNESS_FACTOR = 10 ;

/** Faktor fuer das Aufstellpotential */const double LIFT_FACTOR = 10 ;

/** Systemtemperatur */const double TEMP = 1 ;

/** horizontale Systemgr"osse */const double AREA_X = 100.0;

/** vertikale Systemgr"osse */const double AREA_Y = 100.0;

/** inverse Temperatur; wird f"ur die Akzeptanzwahrscheinlichkeit ben"otigt */ const double INV_TEMP = 1 / TEMP;

/** Anzahl der Proteine in der Simulation */const int N_PROT = 500;

/** Anzahl der Iterationen */const int N_ITERATIONS = 10000;

/** Schritte, pro die einmal geflippt wird */const int N_FLIP = 10 ;

/** L"ange der Helix A */ const double LENGTH_A = 5.0;

/** L"ange der Helix B */const double LENGTH_B = 5.0;

/** Radius von Helix A */const double RADIUS_A = 1.0;

Constants.h/** Radius von Helix B */const double RADIUS_B = 1.0;

/* Verh"altnis zwischen L"ange und Radius der Helix A *///const double RATIO_A = LENGTH_A / RADIUS_A;

/* Verh"altnis zwischen L"ange und Radius der Helix B *///const double RATIO_B = LENGTH_B / RADIUS_B;

/** Verh"altnis zwischen L"ange und Durchmesser von Helix A bei stehender Helix B, d.h., dass man die Breite der dickeren Helix nimmt (und diese auch f"ur die Grundfl"ache der stehenden Helix B verwendet) − als L"ange wird immer die L"ange von A genommen */const double RATIO_BOTH = (RADIUS_A<RADIUS_B)?

(LENGTH_A+ RADIUS_A +RADIUS_B)/(2*RADIUS_B):(LENGTH_A+ 2*RADIUS_A)/(2*RADIUS_A);

/** maximale Bewegung eines Proteins */const double MAX_TRANSLATION = 1.0;

/** maximale Winkel"anderung f"ur Helix A */const double MAX_ROTATION_A = 0.1;

/** maximale Winkel"anderung f"ur Helix B */const double MAX_ROTATION_B = 0.1;

/** maximale "Anderung des Cosinus des Polarwinkels von Helix B *///const double MAX_LIFTING_B = 0.1;

/** Seed f"ur die Initialisierung des Zufallszahlengenerators; die Zahl ist nicht theoretisch fundiert, sondern ganz simpel ein Geburtsdatum (modulo 128, damit sie im richtigen Bereich liegt) */const int INITIAL_SEED = 12051978 % 128;

/** Cut−Off−Radius, um festzulegen, bis zu welchem Abstand Wechselwirkungspotentiale berechnet werden */const double CUT_OFF = 2*max(LENGTH_A+RADIUS_A,LENGTH_B+RADIUS_B) ;

/** Anzahl der Boxen in x−Richtung *///const int N_BOXES_X = (int)(AREA_X / (CUT_OFF+MAX_TRANSLATION));//const int N_BOXES_X = 6 ;

/** Anzahl der Boxen in y−Richtung *///const int N_BOXES_Y = (int)(AREA_Y / (CUT_OFF+MAX_TRANSLATION));//const int N_BOXES_Y = 6;

/** die Breite einer Box in X−Richtung*///const double BOX_WIDTH_X = AREA_X/N_BOXES_X; /** die Breite einer Box in Y−Richtung*///const double BOX_WIDTH_Y = AREA_Y/N_BOXES_Y;

/** Zahl der Iterationen, nach denen eine volle Konfiguration ausgegeben werden soll */const int N_SKIP = 1000;

/** Name der Ausgabedatei */const char * const FILE_NAME = " results";

/** Name des aktuellen Arbeitsverzeichnisses */const char * const RUN_DIR = " /tmp/";

#endif //CONSTANTS_H

Constants.h

Constants.h

104

/* $Id: Control.h,v 1.14 2002/03/22 07:44:51 usprosim Exp $ * $Locker: $ */

#ifndef CONTROL_H#define CONTROL_H#include " Configuration.h"#include " GUI.h"#include " Constants.h"#include <iostream>#include <fstream>#include " Random.h"#include " Configuration.h"#include <stdlib.h>#include <stdio.h>#include <ctime>#include " PovUtils.h"

class Control {private:

/** @link dependency */ /*# Configuration lnkConfiguration; */

/** * @link aggregation * @clientCardinality 1 * @supplierCardinality 1 */// Configuration* myConfiguration;

/** * @link aggregation * @clientCardinality 1 * @supplierCardinality 1 */// Random* myRandom;

public:

void printHeader();

static int main();

Control();

~Control();

};#endif //CONTROL_H

Control.h/* $Id: Control.cpp,v 2.7 2002/03/26 11:36:43 usprosim Exp $ * $Locker: $ */

//#define SAMPLE_ONE

#include " Control.h"

/* Definition der Konstanten */fstream outputStream;fstream f;fstream MTStream;time_t* startTime;time_t start,init,stop;FILE * inStatus;FILE * outStatus;

/** Die folgende Methode gibt einmalig alle wichtigen Konstanten, etc. in die Datei aus, in die beim weiteren Durchlauf die Ergebnisse geschrieben werden. */void printHeader(Configuration* config){ outputStream << " ##################################################\n"

<< " # PROSIM: PROteinSIMulation Version: 0.1.1.b #\n" << " # Compiled on "<<__DATE__<<" #\n" << " # at "<<__TIME__<<" #\n" << " # a program written by: #\n" << " # + Johanna Alichniewicz #\n" << " # + Gabriele Holzschneider #\n" << " # + Morris Michael #\n" << " # + Ulf Schiller #\n" << " # + Jan Stallkamp #\n" << " # #\n" << " # Further Information: [email protected] #\n" << " ##################################################\n\n" << " # Parameter Set:" << " \n# Temperature = " << TEMP

<< " \n# Area Size = " << config−>getAreaX() << " x " << config−>getAreaY()

<< " \n# Number of Proteins = " << N_PROT << " \n# Number of iterations = " << N_ITERATIONS << " \n# Helix A: Length = " << LENGTH_A <<" Radius = "<< RADIUS_A << " \n# Helix B: Length = " << LENGTH_B <<" Radius = "<< RADIUS_B

<< " \n# Maximum translation = " << config−>getMaxTranslation() << " \n# Maximum rotation of helix A = " << config−>getMaxRotationA() << " \n# Maximum rotation of helix B = " << config−>getMaxRotationB() << " \n# CutOff−Radius = " << CUT_OFF

<< " \n\n# Your results:\n\n"

/* die folgende Zeile ist die "Uberschrift daf"ur, wenn alle N_SKIP Iterationen die aktuellen Daten in die Datei geschrieben werden (man erh"alt so also eine Art Tabelle) */

<< " # Number\tEnergy\t<A1>\t<A2>\t<A3>\t<B1>\t<B2>\t<B3>\t<AngelA>\t<AngleB>\t<LiftB>\t<A1^2>\t<A2^2>\t<A3^2>\t<B1^2>\t<B2^2>\t<B3^2>\t<A1*A2>\t<B1*B2>\t<B1*B3>\t<B2*B3>\n\n" ;}

int main( int argc, char ** argv){

Configuration* myConfiguration;

long dummy = 0; int run = 0;

Control.cpp

Control.h, Control.cpp

105

int iterations = 0; start=time(startTime); char * mtrName = new char [255]; char * runFileName = new char [255];

/* comment nimmt alle m"oglichen Kommentare aus */ char * comment = new char [255];

/* _?_:_ ist ein verk"urztes if−then−else wenn also dem Programm die Anzahl der Iterationen als Parameter nicht mitgegeben wurde, wird die Default−Konstante genommen, andernfalls wird die gew"unschte Anzahl eingelesen */ iterations = !(argc − 1) ? N_ITERATIONS : atoi(argv[1]);

/* erstmal den ioStream zur Ausgabedatei vorbereiten */ inStatus = fopen(" status"," r");

if (strcmp(argv[0]," standUp")==0){ //wenn Programmname=="standUp" if (!inStatus){

cerr<<" Programmname==standUp && status nicht verhanden\n" " Programm wird beendet\n";exit(−23);

} else {

fscanf(inStatus," %d",&run);fclose(inStatus);sprintf(runFileName," %s.%04u.cnf",FILE_NAME,run);myConfiguration = new Configuration(runFileName,&dummy);myConfiguration−>standUp(); //alle Proteine aufrichtenf.open(runFileName,ios::trunc|ios::out); //Ver"anderungen f << myConfiguration−>toString(( long )iterations); //speicherncout<< " standing UP and exiting\n";f.close();exit(0); //und beenden

} //sonst normal weiter... } //end Name == standUp

/* Test ob Statusfile eines abgebrochenen Laufs vorhanden */ if (!inStatus) {

/* kein Statusfile vorhanden, also neue Ausgabedatei anlegen */ outputStream.open(FILE_NAME,ios::trunc|ios::out);

/* Initialisierungen des Zufallszahlengenerators und der Configuration */ myConfiguration = new Configuration( new Random(INITIAL_SEED));

/* ein paar Infos zu Beginn in eben diese Datei ausgeben */ printHeader(myConfiguration);

/* die Startkonfiguration wird "uber outFile in die Datei ausgegeben */ outputStream << " #Die Startkonfiguration:\n0\t" << myConfiguration−>outFile(); init=time( NULL); // hiermit wird die Startzeit auf Null gesetzt

#ifdef SAMPLE_ONE /* Der MTStream nimmt die Bewegungsbahn eines Proteins auf,

an dieser Stelle wird er ge"offnet und passend benannt */ sprintf(mtrName," %s.mtr.pov",FILE_NAME); // MTStream = *(new fstream()); MTStream.open(mtrName,ios::trunc|ios::out); printPovRayHeader(MTStream, comment); // f"ugt die n"otigen Daten zu Anfang ein printCoordSystem(MTStream); // f"ugt das KoordinatenSystem ein#endif

Control.cpp

} // Ende von Status nicht vorhanden

else {

/* wenn Statusfile vorhanden, einlesen wo fortgesetzt wird */ fscanf(inStatus," %d",&run); fclose(inStatus);

/* die Konfiguration, mit der weitergemacht wird, * in debug.cnf speichern */ sprintf(runFileName," %s.%04u.cnf",FILE_NAME,run) ; myConfiguration = new Configuration(runFileName,&dummy); f.open(" debug.cnf",ios::trunc|ios::out); f << myConfiguration−>toString(( long )iterations); f.close();

/* Test, ob Datei mit Namen FILE_NAME vorhanden. */ inStatus = fopen(FILE_NAME," r"); if (!inStatus || run==0) {

outputStream.open(FILE_NAME,ios::trunc|ios::out);printHeader(myConfiguration);outputStream << " #Die Startkonfiguration:\n0\t"

<< myConfiguration−>outFile(); } else {

fclose(inStatus);outputStream.open(FILE_NAME,ios::in|ios::out);char * str = new char [1024]; // Platzhaltervariable zum Einlesen/* Durchgehen durch die Ergebnisdatei um an der passenden Stelle die Ergebnisse zu ueberschreiben. Es gibt hier genau 31 Zeilen Header, daher j=−31. */ for ( int j=−31;j<0;j++) outputStream.getline(str,1024);for ( int j=0;j<=run*N_SKIP;j+=SWEEP_STEPS) outputStream.getline(str,1024);

} }

run++ ; // run wird eins hoeher gebraucht

/* die zentrale Schleife alle N_SKIP Durchl"aufe werden die Daten in FILE_NAME gespeichert */ for ( ; run <= iterations / N_SKIP; run++) { /* i wird hier deklariert, da die folgenden for−Schleifen wie

while−Schleifen eingesetzt werden */ int i ; /* erstmal eine Schleife zum teilweisen Equilibrieren */ for (i=(run−1)*N_SKIP+SWEEP_STEPS; i <= min(EQUI_STEPS,run*N_SKIP);i+=SWEEP_STEPS) {

for ( int j=0; j<SWEEP_STEPS; j++) for ( int k=0; k<N_PROT; k+=N_FLIP) { for ( int l=0; l<min(N_FLIP−1,N_PROT−k); l++)

myConfiguration−>nextConfiguration() ; myConfiguration−>nextFlip() ; }outputStream << i << " \t" << myConfiguration−>outFile() ;

}

Control.cpp

Control.cpp

106

/* Adaptionsschleife zum Einregeln der Schrittweiten */ for ( ; i <= min(ADAPT_STEPS,run*N_SKIP);i+=SWEEP_STEPS) {

int accepts = 0 ;

for ( int k=0; k<SWEEP_STEPS; k++) for ( int l=0; l<N_PROT; l+=N_FLIP) { for ( int m=0; m<min(N_FLIP−1,N_PROT−l); m++)

accepts += myConfiguration−>nextConfiguration() ; accepts += myConfiguration−>nextFlip() ; }

outputStream << i << " \t" << myConfiguration−>outFile() ;

#ifndef NO_ADAPTdouble rate = ( double )accepts/(SWEEP_STEPS*N_PROT) ;

/* Anpassung der Schrittweiten fuer das Sampling */if (rate > GOAL_RATE) { myConfiguration−>setMaxTranslation (myConfiguration−>getMaxTranslation() * (1 + STEP_SIZE)) ; myConfiguration−>setMaxRotationA (myConfiguration−>getMaxRotationA() * (1 + STEP_SIZE)) ; myConfiguration−>setMaxRotationB (myConfiguration−>getMaxRotationB() * (1 + STEP_SIZE)) ;} else { if (rate < GOAL_RATE) { myConfiguration−>setMaxTranslation

(myConfiguration−>getMaxTranslation() * (1 − STEP_SIZE)) ; myConfiguration−>setMaxRotationA

(myConfiguration−>getMaxRotationA() * (1 − STEP_SIZE)) ; myConfiguration−>setMaxRotationB

(myConfiguration−>getMaxRotationB() * (1 − STEP_SIZE)) ; }}

/* neues Boxing entprechend der neuen Schrittweiten erzeugen */myConfiguration−>newBoxing() ;

#endif // NO_ADAPT

}

/* die eigentliche Messschleife */ for ( ; i <= min(iterations,run*N_SKIP);i+=SWEEP_STEPS) {

for ( int j=0; j<SWEEP_STEPS; j++) /* im Schnitt soll ja jedes Protein einmal pro sweep bewegt werden */ for ( int k=0; k < N_PROT; k+=N_FLIP) { for ( int l=0; l<min(N_FLIP−1,N_PROT−k); l++)

myConfiguration−>nextConfiguration() ; myConfiguration−>nextFlip() ; } /* die Ergebnisse jedes Sweeps werden ausgegeben */outputStream << i << " \t" << myConfiguration−>outFile();

/* Wenn man nur ein Protein betrachtet soll die Bewegung eines Proteins ausgegeben werden*/

#ifdef SAMPLE_ONEif ((i%50)==0) // damit man was sieht nur jeden 50ten Schritt ausgeben MTStream << myConfiguration−>getMotionTrack(42);

#endif } outputStream.flush();

Control.cpp sprintf(runFileName," %s.%04u.cnf",FILE_NAME,run); f.open(runFileName,ios::trunc|ios::out); f << myConfiguration−>toString(( long )iterations); f.flush(); f.close(); /* In Status−File den aktuellen Stand vermerken */ if (run*N_SKIP<=iterations){ //aber nur, wenn wir noch nicht fertig sind.

f.open(" status",ios::trunc|ios::out);f << run << " \n" ;f.close();

} } /* den ioStream wieder schliessen */ stop=time( NULL); outputStream << endl << endl; outputStream << " # Time for initialisation: "

<< difftime(init,start) << " sec" << endl; outputStream << " # Time for iterations: "

<< difftime(stop,init) << " sec" << endl; outputStream << " \n\n# End of output file, run finished\n"; outputStream.close();#ifdef SAMPLE_ONE MTStream.close();#endif}

Control::~Control(){}Control::Control(){}

Control.cpp

Control.cpp

107

#include <stdlib.h>#include <iostream.h>#include " cmdargs.h"#include " Configuration.h"#include " Protein.h"#include <cmath>

ProVis.h#include " ProVis.h"

struct constants consts;

inline double z_height(){ return consts.length_b + consts.radius_b;}

void printCoordSystem(){ cout << " #declare CoordSystem = union{" << endl; cout << " cylinder{<0,0,0><" << consts.area_x << " ,0,0>,0.05}" << endl; cout << " cylinder{<" << consts.area_x << " ,0,0><" << consts.area_x << " ,0," << consts.area_y << " >,0.05}" << endl; cout << " cylinder{<" << consts.area_x << " ,0," << consts.area_y << " ><0,0," << consts.area_y << " >,0.05}" << endl; cout << " cylinder{<0,0," << consts.area_y << " ><0,0,0>,0.05}" << endl; cout << " cylinder{<0," << z_height() << " ,0><" << consts.area_x << " ," << z_height() << " ,0>,0.05}" << endl; cout << " cylinder{<" << consts.area_x << " ," << z_height() << " ,0><" << consts.area_x << " ," << z_height() << " ," << consts.area_y << " >,0.05}" << endl; cout << " cylinder{<" << consts.area_x << " ," << z_height() << " ," << consts.area_y << " ><0," << z_height() << " ," << consts.area_y << " >,0.05}" << endl; cout << " cylinder{<0," << z_height() << " ," << consts.area_y << " ><0," << z_height() << " ,0>,0.05}" << endl; cout << " cylinder{<0,0,0><0," << z_height() << " ,0>,0.05 }" << endl; cout << " cylinder{<" << consts.area_x << " ,0,0><" << consts.area_x << " ," << z_height() << " ,0>,0.05}" << endl; cout << " cylinder{<" << consts.area_x << " ,0," << consts.area_y << " ><" << consts.area_x << " ," << z_height() << " ," << consts.area_y << " >,0.05}" << endl; cout << " cylinder{<0,0," << consts.area_y << " ><0," << z_height() << " ," << consts.area_y << " >,0.05}" << endl; cout << " pigment{color Black}" << endl; cout << " } " << endl; cout << " object{CoordSystem}" << endl;}

void declarations(){ cout << " #include \"colors.inc\"" << endl; cout << " #include \"textures.inc\"" << endl; cout << " background {color Blue}" << endl; cout << " light_source{<" << consts.area_x / 2 << " ," << 7 * z_height() << " ," << consts.area_y / 2 << " > color White}" << endl; cout << " #declare HelixA = merge{" << endl

<< " sphere{<0,0,0>,"<< consts.radius_a << endl << " translate " << consts.length_a << " *x " << endl << " } " << endl << " cylinder{<0,0,0>,<1,0,0>,1" << endl << " scale <" << consts.length_a << " ,1,1>" << endl << " }" << endl << " sphere{<0,0,0>," << consts.radius_a << endl << " } " << endl << " finish{phong 1}" << endl << " pigment{color Red}" << endl << " } " << endl;

cout << " #declare HelixB = merge{" << endl << " sphere{<0,0,0>,"<< consts.radius_b << endl << " translate " << consts.length_b << " *x " << endl << " } " << endl << " cylinder{<0,0,0>,<1,0,0>,1" << endl << " scale <" << consts.length_b << " ,1,1>" << endl << " }" << endl << " sphere{<0,0,0>," << consts.radius_b << endl << " } " << endl << " finish{phong 1}" << endl << " pigment{color Green}" << endl

ProVis.cpp

ProVis.h, ProVis.cpp

108

<< " } " << endl;

}

int main( int argc, char * argv[]){// CmdArgInt height(’h’, "height", "pixels", "image height in pixels (default: 640)."); // CmdArgInt width(’w’, "width", "pixels", "image width in pixels (default: 480)."); CmdArgSet plotA(’ A’, " plotA", " plot helix A."); CmdArgSet plotB(’ B’, " plotB", " plot helix B."); CmdArgClearRef hideA(plotA, ’ a’, " hideA", " hide helix A."); CmdArgClearRef hideB(plotB, ’ b’, " hideB", " hide helix B."); CmdArgSet spice(’ s’, " spice", " spice up the image (textures...).");// CmdArgSet movie(’m’, "movie", "animated flight over the scene."); CmdArgBool viewpoint(’ v’, " viewpoint", " set viewpoint."); CmdArgBool continuos(’ c’, " continious", " continious borders (use with care)."); CmdArgBool axes(’ x’, " axes", " plot axes.");// CmdArgBool title(’t’, "title", "plot title."); CmdArgStr output(’ o’, " output−file", " filename", " output file to write."); CmdArgStr input(" input−file", " input file to read."); // Declare command object and its argument−iterator // Declare arguments CmdLine cmd(*argv, &plotA, &plotB, &hideA, &hideB, &spice, &continuos, &axes, &output, &input, &viewpoint, NULL); CmdArgvIter arg_iter(−−argc, ++argv); // Initialize arguments to appropriate default values.// height = 640;// width = 480; plotA = 1; plotB = 1; spice = 0;// movie = 0; continuos = 0; axes = 0; viewpoint = 0;// title = 0;

// Parse arguments cmd.parse(arg_iter); // Read Data from input file Configuration * configuration = new Configuration(consts, input); // Open output−stream and redirect cout if neccessary ofstream out(output); if (!output.isNULL())

cout = out; // Print header cout << " //ProVis : Protein Visualisation" << endl

<< " //Copyright: 01/2002 Jan Stallkamp <[email protected]>" << endl << endl;

cout << " /* " << endl << " Parameter Set:" << endl

<< " Temperature = " << consts.temp << endl << " Area Size = " << consts.area_x <<" x " << consts.area_y << endl << " Number of Proteins = " << consts.n_prot << endl << " Number of iterations = " << consts.n_iterations << endl << " Helix A: Length = " << consts.length_a << " Radius = " << consts.radius_a <

< endl << " Helix B: Length = " << consts.length_b << " Radius = " << consts.radius_b <

ProVis.cpp< endl

<< " Maximum translation = " << consts.max_translation << endl << " Maximum rotation of helix A = " << consts.max_rotation_a << endl << " Maximum rotation of helix B = " << consts.max_rotation_b << endl << " */ " << endl << endl;

declarations();

// Camera position (NB: angle of normal camera is not mathmatically correct, just a good try if (viewpoint) cout << " camera{location<"

<< consts.area_x / 2 << " ," << 10 * z_height() << " ," << consts.area_y / 2

<< " > angle " << 1.8 * atan( consts.area_x/9/z_height()) * 180 / M_PI

<< " look_at <" << consts.area_x / 2 << " ,0," << consts.area_y / 2 << " >} " << endl; else cout << " camera{location<"

<< −consts.area_x / 5 << " ," << 5 * z_height() << " ," << −consts.area_y / 5

<< " > angle " << 1.25 * atan( consts.area_x/9/z_height()) * 180 / M_PI

<< " look_at <" << consts.area_x / 7 << " ,0," << consts.area_y / 7 << " >} " << endl;

if (axes) printCoordSystem(); if (spice) cout << " plane {<0,1,0>, 0 texture{Water scale 40}}" << endl;

// Plot helices cout << " #declare Config = union{" << endl; for ( int i = 1; i <= consts.n_prot; i++){

cout << " union{" << endl;if (plotA) cout << " object{HelixA rotate <0,"

<< −(configuration−>protein(i)−>getEbenenwinkelA())/M_PI*180

<< " ,0>}" << endl;if (plotB) cout << " object{HelixB rotate <0,0,"

<< asin(configuration−>protein(i)−>getAufstellSinusB())/M_PI*180

<< " > rotate <0," << −configuration−>protein(i)−>getEbenenwinkelB()/M_PI*1

80 << " ,0>}" << endl;

cout << " translate <" << configuration−>protein(i)−>getX() << " ,0," << configuration−>protein(i)−>getY()<< " >" << endl;cout << " }"<< endl;

} cout << " } " << endl << endl; // Plot continuos border // NB: produces very slow code if (continuos){

cout << " intersection {" << endl;cout << " union{" << endl;cout << " object{Config}" << endl;cout << " object{Config translate <0,0," << consts.area_y << " >} " << endl;cout << " object{Config translate <0,0," << −consts.area_y << " >} " << endl;cout << " object{Config translate <" << consts.area_x << " ,0,0>}" << endl;cout << " object{Config translate <" << −consts.area_x << " ,0,0>}" << endl;cout << " object{Config translate <" << consts.area_x << " ,0," << consts.area_

y << " >} " << endl;cout << " object{Config translate <" << −consts.area_x << " ,0," << −consts.area_

ProVis.cpp

ProVis.cpp

109

y << " >} " << endl;cout << " object{Config translate <" << consts.area_x << " ,0," << −consts.area_

y << " >} " << endl;cout << " object{Config translate <" << −consts.area_x << " ,0," << consts.area_

y << " >} " << endl;cout << " }" << endl;cout << " box{<0,0,0><"<< consts.area_x<<" ,"<< z_height()<<" ,"<< consts.are

a_y<<" >} " << endl;cout << " } " << endl;

} else

cout << " object{Config}" << endl << endl;

out.close();// !!!!!!!!! TO DO !!!!!!!!!!!!!!// Farben der Helices// count in die struct aufnehmen und im header ausgeben return 0;}

ProVis.cpp

ProVis.cpp

110

#ifndef HISTOGRAM_H#define HISTOGRAM_H

#include <gsl/gsl_histogram.h>

/* in der gsl (Gnu Standard Bibliothek) sind folgende Methoden definiert; um diese C−Funktionen als C++ verwenden zu k"onnen, werden sie hier in Methoden "verpackt" */

class Histogram {protected: gsl_histogram *histogram;

public: // constructors and destructor Histogram(size_t N) { histogram = gsl_histogram_calloc(N); }

Histogram(size_t N, double XMIN, double XMAX) { histogram = gsl_histogram_calloc_uniform(N, XMIN, XMAX); }

Histogram(size_t N, double RANGE[]) { histogram = gsl_histogram_calloc_range(N, RANGE); }

virtual ~Histogram() { gsl_histogram_free(histogram); histogram = NULL; }

virtual int increment( double X) { return gsl_histogram_increment(histogram, X); }

virtual int increment( double X, double WEIGHT) { return accumulate(X, WEIGHT); }

virtual int accumulate( double X, double WEIGHT) { return gsl_histogram_accumulate(histogram, X, WEIGHT); }

virtual double get(size_t I) { return gsl_histogram_get(histogram, I); }

virtual int get_range(size_t I, double * LOWER, double * UPPER) { return gsl_histogram_get_range(histogram, I, LOWER, UPPER); }

virtual void reset() { gsl_histogram_reset(histogram); }

};

#endif

Histogram.h/* $Id: Histogram.C,v 1.7 2002/03/22 14:52:46 usprosim Exp $ * $Locker: $ */

#include " Histogram.h"

int main( int argc, char ** argv) {

/* der erste Parameter gibt die Anzahl der Intervalle an, in die das Gesamt−Intervall aufgeteilt werden soll; der zweite gibt den Minimalwert des Hauptintervalls (z.B. Boxgr"osse) an; der dritte den entsprechenden Maximalwert; eingelesen wird von stdin (die Methode erwartet genau eine Zeile −> Kommentare vorher aus der Datei rausschneiden); geschrieben wird auf stdout */

double value,max,min; int intervalle = atoi(argv[1]); sscanf(argv[2]," %lf",&min); sscanf(argv[3]," %lf",&max); Histogram* histogram = new Histogram(intervalle,min,max);

while (!feof(stdin)) { scanf(" %lf",&value);

// pro Teilintervall wird eins hoch gez"ahlt histogram −> increment(value); }

// Ausgabeschleife for ( int i=0;i<intervalle;i++) {

value = histogram −> get(i); // holt die Anzahl aller reinfallenden Werte histogram −> get_range(i,&min,&max); // holt den Intervallbereich

/* Anzahl der in jeweiliges Intervall fallenden Objekte ausgegeben */ printf(" %f\t%f\n",min+(max−min)/2,value); }

}

Histogram.C

Histogram.h, Histogram.C

111

/* $Id: Nematic.C,v 1.4 2002/03/22 14:53:38 usprosim Exp $ * $Locker: $ */

/********************************************* * Dieses Programm liest zeilenweise die * Komponenten des dyadischen Produkts der * Richtungsvektoren beider Helices ein * und berechnet daraus die nematischen * Tensoren fuer Helix A, Helix B sowie * fuer beide Helices. Durch Diagonalisierung * werden die nematischen Ordnungsparameter * bestimmt und zeilenweise ausgegeben. *********************************************/

#include <stdio.h>#include <gsl/gsl_eigen.h>

int main( int argc, char ** argv) {

int i = 0 ; double sA1, sA, sB, sAB, etaA, etaB, etaAB ; double a[9], b[9], ab[9] ; double a11, a22, a12, p, q ;

/* Speicher fuer die Matrizen und Vektoren allokieren */ gsl_matrix* matrixA = gsl_matrix_alloc(3,3) ; gsl_matrix* matrixB = gsl_matrix_alloc(3,3) ; gsl_matrix* matrixAB = gsl_matrix_alloc(3,3) ; gsl_vector* eigenvaluesA = gsl_vector_alloc(3) ; gsl_vector* eigenvaluesB = gsl_vector_alloc(3) ; gsl_vector* eigenvaluesAB = gsl_vector_alloc(3) ; gsl_matrix* eigenvectorsA = gsl_matrix_alloc(3,3) ; gsl_matrix* eigenvectorsB = gsl_matrix_alloc(3,3) ; gsl_matrix* eigenvectorsAB = gsl_matrix_alloc(3,3) ;

/* Eine Kommentarzeile als Ausgabe */ printf(" #Output of Nematic.C\n") ; printf(" #n\t#sA1\t\t#sA\t\t#etaA\t\t#sB\t\t#etaB\t\t#sAB\t\t#etaAB\n") ;

while (!feof(stdin)) {

/* Komponenten einlesen */ scanf(" %lf%lf%lf%lf%lf%lf%lf%lf%lf%lf\n ",&a[0],&a[4],&a[8],&b[0],&b[4],&b[8],&a[1],&b[1],&b[2],&b[5]) ;

/* z−Komponente von Helix A ist immer 0 */ a[2] = 0 ; a[5] = 0 ;

/* Matrizen symmetrisch vervollstaendigen */ a[3] = a[1] ; a[6] = a[2] ; a[7] = a[5] ; b[3] = b[1] ; b[6] = b[2] ; b[7] = b[5] ;

/* Tensor fuer beide Helices berechnen */ ab[0] = 1.5 * (a[0]+b[0])/2 − 0.5 ; ab[4] = 1.5 * (a[4]+b[4])/2 − 0.5 ; ab[8] = 1.5 * (a[8]+b[8])/2 − 0.5 ; ab[1] = 1.5 * (a[1]+b[1])/2 ; ab[2] = 1.5 * (a[2]+b[2])/2 ;

Nematic.C ab[5] = 1.5 * (a[5]+b[5])/2 ; ab[3] = ab[1] ; ab[6] = ab[2] ; ab[7] = ab[5] ; *matrixAB = gsl_matrix_view(ab,3,3) ; /* Ordnungsparameter fuer Helix A auch * zweidimensional berechnen */ a11 = 2.0*a[0]−1.0 ; a22 = 2.0*a[4]−1.0 ; a12 = 2.0*a[1] ; p = 0.5*(a11+a22) ; q = sqrt(0.25*(a11−a22)*(a11−a22)+a12*a12) ; sA1 = p + q ;

/* Tensor fuer Helix A berechnen */ for ( int j=0; j<9; j++) a[j] *= 1.5 ; a[0] −= 0.5 ; a[4] −= 0.5 ; a[8] −= 0.5 ; *matrixA = gsl_matrix_view(a,3,3) ;

/* Tensor fuer Helix B berechnen */ for ( int j=0; j<9; j++) b[j] *= 1.5 ; b[0] −= 0.5 ; b[4] −= 0.5 ; b[8] −= 0.5 ; *matrixB = gsl_matrix_view(b,3,3) ;

/* Eigenwerte und Eigenvektoren berechnen */ unsigned int z ; gsl_eigen_jacobi_impl(matrixA,eigenvaluesA,eigenvectorsA,100,&z) ; gsl_eigen_jacobi_impl(matrixB,eigenvaluesB,eigenvectorsB,100,&z) ; gsl_eigen_jacobi_impl(matrixAB,eigenvaluesAB,eigenvectorsAB,100,&z) ;

/* Eigenwerte und Eigenvektoren sortieren */ gsl_eigen_sort_impl(eigenvaluesA,eigenvectorsA,GSL_EIGEN_SORT_VALUE) ; gsl_eigen_sort_impl(eigenvaluesB,eigenvectorsB,GSL_EIGEN_SORT_VALUE) ; gsl_eigen_sort_impl(eigenvaluesAB,eigenvectorsAB,GSL_EIGEN_SORT_VALUE) ;

/* Ordnungsparameter fuer Helix A */ sA = gsl_vector_get(eigenvaluesA,2) ; etaA = 2 * gsl_vector_get(eigenvaluesA,1) + sA ;

/* Ordnungsparameter fuer Helix B */ sB = gsl_vector_get(eigenvaluesB,2) ; etaB = 2 * gsl_vector_get(eigenvaluesB,1) + sB ;

/* Ordnugsparameter fuer beide Helices */ sAB = gsl_vector_get(eigenvaluesAB,2) ; etaAB = 2 * gsl_vector_get(eigenvaluesAB,1) + sAB ;

/* Ordnungsparameter ausgeben */ printf(" %u\t%f\t%f\t%f\t%f\t%f\t%f\t%f\n",i++,sA1,sA,etaA,sB,etaB,sAB,etaAB) ;

}

/* Speicher freigeben */ gsl_matrix_free(matrixA) ; gsl_matrix_free(matrixB) ; gsl_matrix_free(matrixAB) ; gsl_vector_free(eigenvaluesA) ; gsl_vector_free(eigenvaluesB) ; gsl_vector_free(eigenvaluesAB) ;

Nematic.C

Nematic.C

112

gsl_matrix_free(eigenvectorsA) ; gsl_matrix_free(eigenvectorsB) ; gsl_matrix_free(eigenvectorsAB) ;

}

Nematic.C/* $Id: Mean.C,v 1.2 2002/03/15 11:58:19 usprosim Exp $ * $Locker: $ */

#include <stdio.h>

/************************************ * Dieses Programm liest eine Spalte * Daten ein und berechnet daraus * den Mittelwert der Spalte ************************************/

int main( int argc, char ** argv){ int n = 0 ; double sum = 0.0 ; double value ; while (!feof(stdin)) { scanf(" %lf\n",&value) ; n++ ; sum += value ; }

printf(" Values: %u, Sum: %f, Mean: %f\n",n,sum,sum/n) ;

}

Mean.C

Nematic.C, Mean.C

113

114 ANHANG B. PROGRAMMCODE

Anhang C

Glossar

Akzeptanzwahrscheinlichkeit Bei Monte Carlo-Simulationen konnen neueZustande (hier: Konfigurationen) auch dann akzeptiert werden, wenn sieungunstiger sind, als ihr Vorgangerzustand. Sie werden dann jedoch nurmit einer Wahrscheinlichkeit akzeptiert, die proportional zur Boltzmann-verteilung ist (siehe dort).

Aminosaure Aminosauren sind Molekule, die neben mindestens einer organi-schen Sauregruppe −COOH auch mindestens eine Aminogruppe −NH2

enthalten. Aminosauren sind in der Lage, zu polymerisieren (siehe dort)und dadurch Proteine zu bilden (siehe dort).

amphiphil Eine chemische Substanz bezeichnet man als amphiphil, wenn siesich sowohl in polaren, als auch in unpolaren Losungsmitteln lost, also z.B.in Wasser und in Ol.

Analysephase Wahrend dieser Phase der Softwareentwicklung wird versucht,die Vorgange der realen Welt zu verstehen und zu modellieren.

Anisotropie Beschreibt bei Teilchen die Abweichung von der spharisch-symmetrischen Kugelform.

anisotrop Eine Eigenschaft ist anisotrop, wenn sie in verschiedenen Raumrich-tungen unterschiedlich ausgepragt ist.

Anzahldichte Teilchen pro Volumen.

Apolipoprotein ein Protein, dass ein Lipid enthalten kann (Lipoprotein), es indiesem speziellen Fall aber nicht tut (Apo-form des Proteins).

aromatisch In der Chemie bezeichnet man eine Gruppe als aromatisch, wenn dieentsprechenden Atome in einer Ebene liegen und sie 4n + 2 π−Elektronenhat, die konjugiert sind, d.h. sich uber das System gleichmaßig verteilen.

115

116 ANHANG C. GLOSSAR

Assoziation In diesem Zusammenhang bezeichnen Assoziationen die Beziehungzwischen Klassen.

asymmetrischer Kohlenstoff Ein Kohlenstoffatom wird als asymmetrisch be-zeichnet, wenn es mit vier verschiedenen Partnern je eine Bindung eingeht.

Attribut Die Variablen einer Klasse bezeichnet man als ihre Attribute; Attri-bute kann man nur uber die dafur vorgesehenen Operationen verandern.

Autokorrelationsfunktion Beschreibt die statistische Abhangigkeit verschie-dener Konfigurationen.

Autokorrelationszeit Beschreibt die Zeit, die zwischen statistisch unabhangi-gen Konfigurationen liegt. Aus Simulationen kann man die integrierte Au-tokorrelationszeit bestimmen, die in den statistischen Fehler eingeht.

Beruhrungsabstand Abstand, bei dem sich zwei Teilchen gerade beruhren.

Bewegungsentropie gibt an, wie gut sich die Molekule (auf der Oberflache)fortbewegen konnen

Biaxialitat In nematischen Phasen ein Maß fur die Eindeutigkeit der orientie-rungsrichtung.

Boxing, Klasse Diese Klasse unterteilt die modellierte”Wanne“ in einzelne Zel-

len (Boxen), um die Bewegung der Molekule besser verfolgen zu konnen.

Brewsterwinkel-Mikroskopie Verfahren, um Oberflachen zu untersuchen, beidem Licht unter einem definierten Winkel (dem Brewsterwinkel) verwendetwird.

Carboxyl-Gruppe Gruppe chemischer Atome, die aus einem Kohlenstoff-, zweiSauerstoff- und einem Wasserstoffatom aufgebaut ist und sauer reagiert.

chemisches Potential Diese Ableitung der Freien Enthalpie nach der Teilchen-zahl gibt an, in wie weit eine chemische Substanz reaktionsfahig ist.

cholesterisch Phase bei Flussigkristallen, bei der die Schichten gegeneinanderverdreht sind, so dass sich von oben betrachtet ein Gitter zeigt.

Configuration, Klasse Eine Konfiguration besteht aus N Proteinen und derenParametern (Winkel und Position). Im Verlauf der Simulation werden dieParameter der Proteine verandert und das Potential der so entstandenenneuen Konfigurationen berechnet. Zeigt sich dabei, dass die neue Konfigu-ration angenommen werden soll, so wird sie in dieser Klasse gespeichert.

Control, Klasse Diese Klasse ist fur die Steuerung des Programmablaufszustandig.

117

Corner-Potential Potentialmodell fur stabformige Teilchen, die als linear an-geordnete Kraftzentren betrachtet werden. Vgl. Abschnitt 5.2.3.

Coulombkraft Elektrostatische Kraft zwischen Ladungstragern.

Cystein Aminosaure, die als Seitenkette −S − H enthalt und somit Disulphid-brucken mit weiteren Cysteinen ausbilden kann.

Designphase Wahrend dieser Phase werden die in der Analysephase gewonne-nen Erkenntnisse in der Programmstruktur umgestezt.

desorbiert Phase, in der eine Helix des Proteins aus der Monoschicht heraus-steht.

dichteste Packung Die Anordnung von Teilchen, die das Volumen am bestenausfullt. Bei Kugeln ist dies die flachenzentrierte oder korperzentrierte An-ordnung.

Disulphidbrucke chemische Bindung zwischen zwei Schwefelatomen insbeson-dere so, dass sich zwei Cysteine (Aminosauren mit der Gruppe −S − Hmiteinander verbinden.

Ensemble Vielteilchensystem, das mit Methoden der statistischen Physik un-tersucht werden kann

Ensemblemittel Siehe Scharmittel.

Entropie Maß fur die Unordnung eines thermodynamischen Systems. Nachdem Maximum-Entropie-Prinzip versucht jedes statistische Ensemble, seineEntropie zu maximieren.

Equilibrierung Bezeichnet den Vorgang zum Erreichen des thermodynamischenGleichgewichts.

Ergodizitat Ein System ist ergodisch, wenn fast alle Trajektorien fast alle Pha-senraumpunkte beruhren. Aus der Ergodizitat folgt, dass das Zeitmittelgleich dem Scharmittel ist. Ergodizitat ist zugleich die schwachste Formder Unordnung in einem System; weitere Formen sind mischend und chao-tisch.

Ergodizitatshypothese Die Annahme, dass ein System ergodisch ist. Ein ma-thematisch exakter Beweis ist oft nicht moglich.

Faltblatt, β− siehe Sekundarstruktur

flussig-expandiert Flussige Phase mit kleinem intermolekularen Abstand undhoher Fluiditat. Entspricht der flussig-isotropen Phase.


flussig-isotrop Flussige Phase mit kleinem intermolekularen Abstand jedochohne Orientierungsordnung.

flussig-kondensiert Flussige Phase mit geringerer Fluiditat und anderem Bre-chungsindex. Entspricht der desorbierten Phase.

Flussigkristall siehe Mesophase

flussig-nematisch Flussige Phase, in der sich die Teilchen in eine gemeinsameRichtung ausrichten.

freie Energie Thermodynamische Große, die im Gleichgewicht minimiert wird.

Gasphase Phase mit hohem intermolekularen Abstand und keinerlei Ordnungs-struktur.

Gesamtheit siehe Ensemble

GSL (GNU Standard Library) Sammlung von C-Funktionen, großtenteilsaus der Numerik.

GUI (Graphical User Interface) graphische Benutzerschnittstelle, hier inJava programmiert.

Helix, α siehe Sekundarstruktur

hydrophil Ein Teilchen ist hydrophil, wenn es Wassermolekule um sich bindenkann.

hydrophob Ein Teilchen ist hydrophob, wenn es Wasser meidet, sich also z.B.leichter in Lipiden lost.

hydrophobes Moment Große, die die Starke der Wechselwirkung eines Mo-lekuls mit Wasserteilchen beschreibt.

Hysterese Bezeichnung fur das Phanomen, dass ein Zustand auch nach Wegfallseiner Ursache erhalten bleibt. Beipielsweise die Erhaltung durch Kompres-sion enstandener Ordnungsstrukturen bei Expansion.

importance sampling die Stutzstellen zur Integralberechnung werden mittelseiner Verteilung erzeugt, die an interessanten Bereichen starker ist, als anweniger interessanten Bereichen.

Ionenbindung chemische Bindung, die durch die Anziehung zwischen ge-gensatzlich geladenen Ionen zustande kommt

Isotherme Kurve, beispielsweise in einem Druck-Volumen-Diagramm, entlangder die Temperatur konstant bleibt

119

isotropisch siehe anisotropisch

Kann-Ziel vereinbartes Ziel, dass erfullt werden kann (wenn die Resourcen vor-handen sind), aber nicht muss (wenn die Resourcen knapp werden)

Klasse Programmabschnitt mit eigenen Methoden und Attributen. Auf die At-tribute kann nicht frei zugegriffen werden, sondern nur uber die Methoden.

Klassendiagramm In ihm sind alle wichtigen Klassen einschliesslich ihrer At-tribute, Methoden, Vererbungsbeziehungen und Assoziationen aufgefuhrt.

Knickpunkt Bei unserem Proteinmodell die Stelle, an der die beiden Helicesaufeinander treffen.

Knickpotential Potential, das den Beitrag aufgrund des Knicks im Protein an-gibt.

Koexistenzgebiet Region, in der zwei thermodynamische Phasen stabil sind.

Konfiguration hier: Systemzustand, der durch die Position und Ausrichtungaller zu simulierenden Proteine gekennzeichnet ist

Kolloid Gemisch mesoskopischer Korper

Langmuir-Blodgett-Schichten siehe Monolagen

Langmuir-Waage Experimentelle Vorrichtung, um Oberflachenspannung und -druck von Monolagen zu untersuchen, indem durch Verkleinerung der Ober-flache der zur Verfugung stehende Raum reduziert wird.

Lennard-Jones-Potential Weiches Potential, das eine teilweise Durchdringungder Teilchen zulasst. Es wird durch die Potentialstarke und die Potential-reichweite beschrieben.

Lipid unpolare Substanz, z.B. Fett oder Ol

lipophil Synonym fur hydrophob

Mesophase Flussigkristall, also ein Zustand der Materie, bei dem in minde-stens einer Raumrichtung die Fernordnung eines Feststoffes auftritt und inmindestens einer anderen Raumrichtung die Unordnung einer Flussigkeitvorliegt.

metastabil Bezeichnung fur eine Phase, die aufgrund eines lokalen Minimumsin der freien Energie langere Zeit stabil bleiben kann.

Metropolis-Algorithmus Algorithmus, der mittels importance sampling eineBoltzmann-Verteilung erzeugt.


Molekulardynamik Simulationsverfahren, bei dem die reale Dynamik uber dieSimulation der Krafte und Geschwindigkeiten aller Teilchen ermittelt wird.

Monolage Siehe unter Monoschicht.

Monoschichten Oberflachenschicht, die nur aus einer Molekullage besteht. Z.Bwie in dieser Simulation ein dunner Proteinfilm auf einer Wasseroberflache.

Monte Carlo-Integration Numerisches Integrationsverfahren, bei dem im Ge-gensatz zu anderen Verfahren (Trapezregel, Simpsonregel) die Stutzstellenzufallig im zu integrierenden Intervall verteilt gewahlt werden.

Monte Carlo-Schritt In einem MC-Schritt werden so viele Konfigurati-onsanderungen durchgefuhrt, wie Proteine vorhanden sind. Es wird also imMittel jedes Protein einmal bewegt. Es ist aber eher wahrscheinlich, dassmehrere Proteine mehrfach bewegt werden und manche (in diesem Schritt)gar nicht.

Monte Carlo-Simulation Simulationsverfahren, bei dem nicht die Dynamikdes Systems nachgebildet wird, sondern statistische Mittelwerte erzeugtwerden.

Muss-Ziel vereinbartes Ziel, dass auf jeden Fall erfullt werden muss

Negativ-Ziel vereinbartes Ziel, dass auf gar keinen Fall erfullt werden darf.

nematisch Phase, die bei Flussigkristallen auftritt und bei der die Molekule ineiner Raumrichtung parallel zueinander ausgerichtet, in den beiden anderenRaumrichtungen jedoch ungeordnet sind.

nematischer Ordnungsparameter Ordnungsparameter, der die Starke dernematischen Struktur eines statistischen Ensembles angibt.

nematischer Tensor Tensor, aus dessen Diagonalform man den nematischenOrdnungsparameter ermitteln kann.

NMR nuclear magnetic resonance; Verfahren zur Strukturaufklarung von Mo-lekulen

Oberflachendruck Differenz aus der Oberflachenspannung des reinen Losungs-mittels und des Oberflachendrucks der Losung.

Objekt angewandte Klasse

objektorientiert Programmierprinzip, bei dem einzelne Klassen (siehe dort)nicht auf die Methoden und Parameter der anderen Klassen zugreifendurfen. Dadurch wird eine großere Sicherheit und Portabilitat gewahrlei-stet.

121

Operation Methode einer Klasse, z.B. um auf die Attribute der Klasse zugreifenzu konnen

Ordnungsparameter Beschreibt eine bestimmtes Ordnungsmaß eines statisti-schen Ensembles.

Orientierungsentropie Beitrag zur Entropie, der sich aus der Orientierung vonTeilchen berechnet.

Paarpotential Siehe unter Wechselwirkung.

Paarwechselwirkung Siehe unter Wechselwirkung.

pdb-Format Format, das von der Protein Data Bank verwendet wird

Peptid chemisches Molekul, das aus wenigen Aminosauren besteht, also quasiein kleines Protein

Peptidbindung chemische Bindung zwischen einem Kohlenstoff- und einemStickstoffatom, die zwei Aminosauren miteinander zu einem Peptid ver-bindet

periodische Randbedingungen Verfahren, um ein endliches Simulationssy-stem unendlich groß erscheinen zu lassen. Dabei tritt ein Teilchen, dassdie Simulationsbox auf der einen Seite verlasst auf der anderen Seite wie-der ein, so dass es wirkt als ware die Simulationsbox von lauter identischenBoxen umgeben.

Pflichtenheft Sammlung von vereinbarten Zielen, technischen Details, etc. zueinem (geplanten) Programmierprojekt.

Phase Materie mit homogener chemischer Zusammensetzung und raumlich kon-stantem physikalischen Zustand. Z.B. sind die Aggregatzustande reinerStoffe Phasen.

Phasendiagramm Diagramm, in dem die einzelnen Phasen einer chemischenSubstanz in Abhangigkeit von chemischen Zustandsgroßen dargestellt wer-den

Phasenraum die Menge aller Konfigurationen, also der Raum, der durch alleKoordinaten und Impulse aufgespannt wird

Phasenubergang Die Umwandlung einer Phase in eine andere, so dass sichdie physikalischen Eigenschaften andern, die chemischen jedoch beibehaltenwerden.

Potential Ein Potential beschreibt die Wechselwirkungskrafte in einem physi-kalischen System. Siehe auch Wechselwirkung.


Potential, Klasse In dieser Klasse wird das Potential einer neuen Konfigurationberechnet, damit entschieden werden kann, ob diese neue Konfigurationangenommen wird.

Potentialreichweite Parameter zur Beschreibung der Reichweite eines Potenti-als. Beim Lennard-Jones-Potential gibt sie die Lage des Potentialminimumsan.

Potentialstarke Parameter zur Beschreibung der Starke eines Potentials. BeimLennard-Jones-Potential gibt sie die Tiefe des Potentialminimums an.

Polymer Molekul, das aus mehreren Untereinheiten aufgebaut ist, z.B. ein Pro-tein, das sich aus mehreren Aminosauren zusammensetzt

polymerisieren mehrere ahnlich aufgebaut Molekule bilden miteinander che-mische Bindungen und bauen so ein (meist strangformiges) Supermolekul

Povray Ein Raytracer, der zur Visualisierung eingesetzt wurde. Im Internet zufinden unter http://www.povray.org/

Primarstruktur Als Primarstruktur bezeichnet man die Aminosaureabfolge ei-nes Peptids oder Proteins.

Protein Proteine sind Molekule, die sich aus einigen Hundert bis Tausend Ami-nosauren (siehe dort) zusammen setzen. Sie spielen im Organismus einebedeutende Rolle.

Protein, Klasse In dieser Simulation wird das Apolipoprotein C-I auf ein Mo-dell aus zwei Zylindern reduziert, die durch ein Gelenk verbunden sind. Zurrechnerinternen Reprasentation reichen also zwei Raumkoordinaten unddrei Winkel. Diese Parameter werden von der Klasse Protein verwaltet.

Random, Klasse Diese Klasse stellt einen Zufallszahlengenerator zurVerfugung, mit dessen Hilfe zufallig Proteine ausgewahlt werden, deren Ko-ordinaten ebenfalls zufallig verandert werden, um eine neue Konfigurationzu erhalten.

Rechteckpotential Potential, das bezuglich seiner Abstandsabhangigkeit einenrechteckformigen Verlauf hat.

reduzierte Dichte Anzahldichte im Verhaltnis zur Dichte der dichtestenPackung.

Rontgenkristallographie Verfahren, um Molekulstrukturen aufzuklaren. Daszu untersuchende Molekul wird kristallisiert und dann mit Rontgenstrahlenbeschossen, die an den Elektronen gebeugt werden. Schwere Atome mitvielen Elektronen beugen demnach die strahlen starker als leichte Atome.

123

Aus dem erhaltenen Beugungsmuster kann mittels Fouriertransformationauf die zugrunde liegende Molekulstruktur geschlossen werden.

Scharmittel Mittelwert, der uber viele Konfigurationen gebildet wird, die inkeiner zeitlichen Reihenfolge vorliegen

Schichtmodell Modell, nachdem ein zu entwickelndes Programm in mehrere(ublicherweise vier) Schichten aufgeteilt wird, um die Ubersichtlichkeit desSystems zu erhohen und die Aufrufe der Klassen untereinander auf einMinimum zu reduzieren.

Seitenkette Teil eines Molekuls (hier vor allem einer Aminosaure), der fur dieFunktion wichtige Atome beinhaltet

Sekundarstruktur die raumliche Form, in der sich mehrere Aminosauren an-ordnen; man unterscheidet z.B. β− Faltblatt und α-Helix

simple sampling die Stutzstellen zur Integralberechnung werden aus einerGleichverteilung erzeugt

smektisch Phase bei Flussigkristallen, bei der die parallel zueinander liegendenMolekule zusatzlich in ubereinanderliegenden Schichten angeordnet sind.

Softwareentwicklung Teilbereich der Informatik, der sich mit der Theorie vonder planbaren Erstellung von Computerprogrammen beschaftigt. Hauptfra-gen sind, wie man moglichst einfach korrekte, nachvollziehbare, wiederver-wendbare und erweiterbare Programme entwickeln und umsetzen kann.

Startkonfiguration Konfiguration, mit der die Simulation beginnt.

statistischer Fehler Fehler, der durch die statistische Streuung von Messwertenentsteht.

Steifigkeit Gibt an, wie Beweglich die Sekundarstruktur eines Proteins an be-stimmten Stellen ist.

Strukturproteine Proteine, die im Gewebe vor allem fur Strukturbildungs- undStutzaufgaben zur Verfugung stehen

Stutzstellen Die Punkte eines Integrationsintervalls, an denen der Integrandzur numerischen Integration ausgewertet wird.

Sweep Jeden xten (x entspricht der Variablen SWEEP STEPS in der GUI, bzw.in Constants.h) Monte Carlo-Schritt werden die statistischen Daten derKonfiguration fur die anschließende Analyse gespeichert. Jeden xten MC-Schritt nennt man Sweep.


Tertiarstruktur dreidimensionale Struktur einer Aminosaurekette; also die Ab-folge von α−Helices und β−Faltblattern

thermodynamische Integration Verfahren, um aus einer Referenzkonfigura-tion die freie Energie eines statistischen Ensembles zu berechnen.

Translationsentropie Siehe unter Bewegungsentropie.

Triacylglycerine die einfachsten von Fettsauren gebildeten Lipide

Uberlappungsintegrale Methode zur Potentialmodellierung, bei der gaußver-teilte Kraftzentren miteinander wechselwirken. Vgl. Abschnitt 5.2.4.

UML, unified modeling language Konvention, um objektorientierte Pro-gramme graphisch abzubilden.

Van der Waals-Kraft Attraktive Kraft zwischen Teilchen.

Verletradius Abstand, bis zu dem Teilchen in der Verlettabelle berucksichtigtwerden

Verlettabelle Tabelle, die alle Teilchen innerhalb des Verletradius enthalt

Vorgehensmodell Schema, nach dem Programme entwickelt werden konnen

VRML Virtual Reality Modeling Language

Wasserstoffbrucken kommen zustande, wenn sich ein Wasserstoffatom zwi-schen negativ polarisierten Atomen anlagert.

Wechselwirkung Eigenschaft von Teilchen, Krafte aufeinander oder sich selbstauszuuben. Jede Wechselwirkung kann beschrieben werden durch ein Po-tential. Es gibt verschiedene Typen von Wechselwirkungen:

externe Wechselwirkung aufgrund eines außeren Feldes

intermolekulare Wechselwirkung zwischen verschiedenen Molekulen

intramolekulare Wechselwirkung eines Molekuls mit sich selbst

Spezielle Typen von Wechselwirkungen sind beispielsweise

attraktive Wechselwirkung, die anziehend wirkt

hydrophile Wechselwirkung mit Wassermolekulen aufgrund polarer Ei-genschaften von Teilchen

Paarwechselwirkung Wechselwirkung, die zwischen genau zwei Teilchenbesteht

125

Wechselwirkungsradius Abstand, bis zu dem Wechselwirkungen zwischenTeilchen berechnet werden; sind Teilchen weiter voneinander entfernt, wer-den ihre Wechselwirkungen zur Beschleunigung der Berechnung nicht be-rechnet.

Zeitmittel Mittelwert, der uber den zeitlichen Verlauf eines Systems berechnetwird.

Zufallszahlengenerator erzeugt zufallige Zahlen; wird in der Klasse Randomrealisiert.


Literaturverzeichnis

[1] V. M. Bolanos-Garcıa, J. Mas-Oliva: Phase Transitions in Monolayersof Human Apolipoprotein C-I. The Journal of Physical Chemistry B,Vol. 103, No. 30, 6236-6232, 1999.

[2] V. M. Bolanos-Garcıa, et al.: Monolayers of Apolipoproteins at theAir/Water Interface. The Journal of Physical Chemistry B, Vol. 105,No. 24, 5757-5765, 2001.

[3] A. Rozek, et al.: Conformation of Human Apolipoprotein C-I in aLipid-Mimetic Environment Determined by CD and NMR Spec-troskopy. Biochemistry, Vol. 38, No. 44, 14475-14484, 1999.

[4] V. M. Bolanos-Garcıa, et al., private Mitteilung.

[5] H. M. Berman, J. Westbrook, Z. Feng, G. Gilliland, T. M. Bhat, H. Weissig,I. N. Shindyalov, P. E. Bourne: The Protein Data Bank. Nucleic AcidsResearch, Vol. 28, 235-242, 2000.

[6] Lehninger, Nelson, Cox: Prinzipien der Biochemie. Spektrum Akade-mischer Verlag, 1994.

[7] P. W. Atkins: Physikalische Chemie. VCH Verlagsgesellschaft, 1996.

[8] H. Balzert: Lehrbuch der Softwaretechnik. Spektrum AkademischerVerlag, Heidelberg, 1998.

[9] B. Oestereich: Objektorientierte Softwareentwicklung. OldenbourgVerlag, Munchen, 1998.

[10] F. Schmid: Computersimulationen in der Physik, Unterlagen zurVorlesung. Universitat Bielefeld, Theorie der kondensierten Materie, Bie-lefeld, 2001.

[11] D. P. Landau, K. Binder: A Guide to Monte Carlo Simulations inStatistical Physics. Cambridge University Press, Cambridge, 2000.

127

128 LITERATURVERZEICHNIS

[12] J. M. Thijssen: Computational Physics. Cambridge University Press,Cambridge, 1999.

[13] D. Frenkel, B. Smit: Understanding molecular simulation: from al-gorithms to applications. Academic Press, 1996.

[14] M. P. Allen, D. J. Tildesley: Computer Simulation of Liquids. Claren-don Press, Oxford, 1987.

[15] M. P. Allen, D. J. Tildesley [Hrsg.]: Computer Simluation in Chemi-cal Physics. NATO ASI Series C, Vol. 397, Kluwer Academic Publishers,Dordrecht/Boston/London, 1993.

[16] B. Diu, C. Guthmann, D. Lederer, B. Roulet: Grundlagen der Statisti-schen Physik. De Gruyter, Berlin/New York, 1994.

[17] F. Reif: Grundlagen der Physikalischen Statistik und der Physikder Warme. De Gruyter, Berlin/New York, 1976.

[18] K. Huang: Statistical Mechanics. Wiley, New York, 1963.

[19] W. Nolting: Grundkurs Theoretische Physik, Bd. 6 StatistischePhysik. Vieweg, Braunschweig/Wiesbaden, 1998.

[20] J. Engels: Statistische und stochastische Methoden der Physik.Vorlesungsskript, Universitat Bielefeld, Elementarteilchenphysik, Bielefeld,2001.

[21] T. H. Cormen, C. E. Leiserson, R. L. Rivest: Introduction to Algo-rithms. MIT Press, Cambridge, 1997.

[22] W. H. Press, S. A. Teukolsky, W. T. Vetterling, B. P. Flannery: NumericalRecipes in C: The art of scientific computing. Cambridge UniversityPress, Cambridge, 1996.

[23] M. P. Allen, G. T. Evans, D. Frenkel, B. M. Mulder: Hard Convex BodyFluids. Adv. Chem. Phys., Vol. 86, 1-166, 1993.

[24] L. Onsager: The effects of shape on the interaction of colloidalparticles. Ann. N. Y. Acad. Sci., Vol. 51, No. 4, 627-659, 1949.

[25] T. Kihara: The Second Virial Coefficient of Non-Spherical Mole-cules. J. Phys. Soc. Jpn., Vol. 6, No. 5, 289-296, 1951.

[26] J. Corner: The second virial coefficient of a gas of non-sphericalmolecules. Proc. R. Soc. A, Vol. 192, 275-292, 1947.

[27] B. J. Berne, P. Pechukas: Gaussian Model Potentials for MolecularInteractions. J. Chem. Phys., Vol. 56, 4213-4216, 1972.

LITERATURVERZEICHNIS 129

[28] J. G. Gay, B. J. Berne: Modification of the overlap potential to mimica linear site-site potential. J. Chem. Phys., Vol. 74, 3316-3319, 1981.

[29] G. Tanaka, W. L. Mattice: Simulations of rodlike molecules repre-sented by anisotropic Lennard-Jones potentials. Macromol. TheorySimul., Vol. 6, 1119-1137, 1997.

[30] H. Zewdie: Computer simulation studies of liquid crystals: A newCorner potential for cylindrically symmetric particles. J. Chem.Phys., Vol. 108, 2117-2133, 1998.

[31] J. Kushick, B. J. Berne: Computer simulation of anisotropic mole-cular fluids. J. Chem. Phys., Vol. 64, No. 4, 1362-1367, 1976.

[32] D. Frenkel: Onsager’s Spherocylinders Revisited. J. Phys. Chem., Vol.91, 4912-4916, 1987.

[33] P. Bolhuis, D. Frenkel: Tracing the phase boundaries of hard sphe-rocylinders. J. Chem. Phys., Vol. 106, No. 2, 666-687, 1997.

[34] H. Zewdie: Computer simulation studies of liquid crystals: A newCorner potential for cylindrically symmetric particles. J. Chem.Phys., Vol. 108, No. 5, 2117-2133, 1998.

[35] D. C. Williamson, F. del Rio: The isotropic-nematic phase transitionin a fluid of square well spherocylinders. J. Chem. Phys., Vol. 109,No. 11, 4675-4688, 1998.

[36] H. Graf, H. Lowen: Phase diagram of tobacco mosaic virus solutions.Phys. Rev. E, Vol. 59, No. 2, 1932-1942, 1999.

[37] P. G. Bolhuis, A. Stroobants, D. Frenkel, H. N. W. Lekkerkerker: Numeri-cal study of the phase behavior of rodlike colloids with attractiveinteractions. J. Chem. Phys., Vol. 107, No. 5, 1551-1564, 1997.

[38] C. Stadler, H. Lange, F. Schmid: Short grafted chains: Monte Carlosimulations of a model for monolayers of amphiphiles. Phys. Rev.E, Vol. 59, No. 4, 4248-4257, 1999.

[39] C. Stadler, F. Schmid: Phase behavior of grafted chain molecules:Influence of head size and chain length. J. Chem. Phys., Vol. 110, No.19, 9697-9705, 1999.

[40] D. Duchs, F. Schmid: Phase behavior of amphiphilic monolayers:theory and simulation. Journal of Physics Condensed Matter, Vol. 13,T. 21, 4853-4862, 2001.

Bisher erschienene Reports an der Technischen FakultätStand: 5. April 2002

94-01 Modular Properties of Composable Term Rewriting Systems(Enno Ohlebusch)

94-02 Analysis and Applications of the Direct Cascade Architecture(Enno Littmann und Helge Ritter)

94-03 From Ukkonen to McCreight and Weiner: A Unifying View of Linear-Time Suffix Tree Construction(Robert Giegerich und Stefan Kurtz)

94-04 Die Verwendung unscharfer Maße zur Korrespondenzanalyse in StereoFarbbildern(André Wolfram und Alois Knoll)

94-05 Searching Correspondences in Colour Stereo Images — Recent ResultsUsing the Fuzzy Integral(André Wolfram und Alois Knoll)

94-06 A Basic Semantics for Computer Arithmetic(Markus Freericks, A. Fauth und Alois Knoll)

94-07 Reverse Restructuring: Another Method of Solving Algebraic Equations(Bernd Bütow und Stephan Thesing)

96-03 Correctness in System Engineering(Peter Ladkin)

96-04 An Algebraic Approach to General Boolean Constraint Problems(Hans-Werner Güsgen und Peter Ladkin)

96-05 Future University Computing Resources(Peter Ladkin)

96-06 Lazy Cache Implements Complete Cache(Peter Ladkin)

96-07 Formal but Lively Buffers in TLA+(Peter Ladkin)

96-08 The X-31 and A320 Warsaw Crashes: Whodunnit?(Peter Ladkin)

96-09 Reasons and Causes(Peter Ladkin)

96-10 Comments on Confusing Conversation at Cali(Dafydd Gibbon und Peter Ladkin)

96-11 On Needing Models(Peter Ladkin)

96-12 Formalism Helps in Describing Accidents(Peter Ladkin)

96-13 Explaining Failure with Tense Logic(Peter Ladkin)

96-14 Some Dubious Theses in the Tense Logic of Accidents(Peter Ladkin)

96-15 A Note on a Note on a Lemma of Ladkin(Peter Ladkin)

96-16 News and Comment on the AeroPeru B757 Accident(Peter Ladkin)

97-01 Analysing the Cali Accident With a WB-Graph(Peter Ladkin)

97-02 Divide-and-Conquer Multiple Sequence Alignment(Jens Stoye)

97-03 A System for the Content-Based Retrieval of Textual and Non-TextualDocuments Based on Natural Language Queries(Alois Knoll, Ingo Glöckner, Hermann Helbig und Sven Hartrumpf)

97-04 Rose: Generating Sequence Families(Jens Stoye, Dirk Evers und Folker Meyer)

97-05 Fuzzy Quantifiers for Processing Natural Language Queries in Content-Based Multimedia Retrieval Systems(Ingo Glöckner und Alois Knoll)

97-06 DFS — An Axiomatic Approach to Fuzzy Quantification(Ingo Glöckner)

98-01 Kognitive Aspekte bei der Realisierung eines robusten Robotersystemsfür Konstruktionsaufgaben(Alois Knoll und Bernd Hildebrandt)

98-02 A Declarative Approach to the Development of Dynamic ProgrammingAlgorithms, applied to RNA Folding(Robert Giegerich)

98-03 Reducing the Space Requirement of Suffix Trees(Stefan Kurtz)

99-01 Entscheidungskalküle(Axel Saalbach, Christian Lange, Sascha Wendt, Mathias Katzer, Guillau-me Dubois, Michael Höhl, Oliver Kuhn, Sven Wachsmuth und GerhardSagerer)

99-02 Transforming Conditional Rewrite Systems with Extra Variables into Un-conditional Systems(Enno Ohlebusch)

99-03 A Framework for Evaluating Approaches to Fuzzy Quantification(Ingo Glöckner)

99-04 Towards Evaluation of Docking Hypotheses using elastic Matching(Steffen Neumann, Stefan Posch und Gerhard Sagerer)

99-05 A Systematic Approach to Dynamic Programming in Bioinformatics. Part1 and 2: Sequence Comparison and RNA Folding(Robert Giegerich)

99-06 Autonomie für situierte Robotersysteme – Stand und Entwicklungslinien(Alois Knoll)

2000-01 Advances in DFS Theory(Ingo Glöckner)

2000-02 A Broad Class of DFS Models(Ingo Glöckner)

2000-03 An Axiomatic Theory of Fuzzy Quantifiers in Natural Languages(Ingo Glöckner)

2000-04 Affix Trees(Jens Stoye)

2000-05 Computergestützte Auswertung von Spektren organischer Verbindungen(Annika Büscher, Michaela Hohenner, Sascha Wendt, Markus Wiesecke,Frank Zöllner, Arne Wegener, Frank Bettenworth, Thorsten Twellmann,Jan Kleinlützum, Mathias Katzer, Sven Wachsmuth, Gerhard Sagerer)

2000-06 The Syntax and Semantics of a Language for Describing Complex Pat-terns in Biological Sequences(Dirk Strothmann, Stefan Kurtz, Stefan Gräf, Gerhard Steger)

2000-07 Systematic Dynamic Programming in Bioinformatics (ISMB 2000 TutorialNotes)(Dirk J. Evers, Robert Giegerich)

2000-08 Difficulties when Aligning Structure Based RNAs with the Standard EditDistance Method(Christian Büschking)

2001-01 Standard Models of Fuzzy Quantification(Ingo Glöckner)

2001-02 Causal System Analysis(Peter B. Ladkin)

2001-03 A Rotamer Library for Protein-Protein Docking Using Energy Calculationsand Statistics(Kerstin Koch, Frank Zöllner, Gerhard Sagerer)

2001-04 Eine asynchrone Implementierung eines Microprozessors auf einem FPGA(Marco Balke, Thomas Dettbarn, Robert Homann, Sebastian Jaenicke,Tim Köhler, Henning Mersch, Holger Weiss)

2001-05 Hierarchical Termination Revisited(Enno Ohlebusch)

2002-01 Persistent Objects with O2DBI(Jörn Clausen)