updated the langfassung

5 files changed, 559 insertions, 225 deletions

diff --git a/langfassung/docs/1_kurzfassung.tex b/langfassung/docs/1_kurzfassung.tex
index e9aea85..b56b5a5 100644
--- a/langfassung/docs/1_kurzfassung.tex
+++ b/langfassung/docs/1_kurzfassung.tex
@@ -1,12 +1,19 @@
 \begin{abstract}
-\large
-Ziel meines Projektes war es, Galaxien zu generieren und diese mit den Modellen
-von echten Galaxien zu vergleichen um mit der Zeit immer bessere Simulationen
-zu generieren. Dies gelang mir im Verlauf des letzten Jahres immer besser, wobei
-ich zurzeit (\today) auf meinem Laptop ca. 1000 neue Sterne in 1.5 Stunden
-generieren kann.
-Zu dem Projekt bin ich während meines Praktikum im Zentrum für Astronomie in
-Heidelberg (ZAH) gekommen bei dem ich von Tim Tugendhat eine Einführung in das
-NFW-Profil bekommen habe, welches genutzt wird um Galaxien zu generieren.
-
+% \large
+Das Ziel meines Projektes ist es, Realitätsgetreue Galaxien und Dunkle Materie
+Halos zu generieren.
+Hierzu verwende ich das sogenannte ''Navarro-Frenk-White'' Profil welches in
+Kombination mit der ''Random Sampling'' Methode die Dichteverteilung
+der Sternenpositionen in Koordinaten für einzelne Sterne umgewandelt.
+\par
+Vergleicht man die generierten Galaxien mit echten Galaxien fällt auf das
+die Sterne sich anders verhalten. Dies lässt sich durch Dunkle Materie erklären,
+welche man jedoch nicht direkt beobachten kann. Es kann also
+nur aufgrund ihrer Auswirkungen auf andere Objekte auf sie geschlossen werden,
+weshalb es nicht ganz Trivial ist sie sichtbar darzustellen.
+\par
+Im Verlauf des Projektes haben sich mir jedoch auch andere Teilbereiche
+eröffnet wie z. B. die Generation von Spiralgalaxien, die Optimierung von
+Rechenprozessen und die Nutzung von einem neuronalen Netz zur Anpassung der
+generierten Galaxie an eine reale Galaxie.
 \end{abstract}
diff --git a/langfassung/docs/2_einleitung.tex b/langfassung/docs/2_einleitung.tex
index a204783..b450799 100644
--- a/langfassung/docs/2_einleitung.tex
+++ b/langfassung/docs/2_einleitung.tex
@@ -1,40 +1,47 @@
-Nach meinem letzten Jugend-Forscht Projekt ergab sich die Möglichkeit ein
+Nach meinem letzten Jugend-Forscht Projekt ergab sich mir die Möglichkeit ein
 Praktikum im Zentrum für Astronomie in Heidelberg zu absolvieren. Über die
-social-media Platform Reddit stellte ich den kontakt mit Tim Tugendkat her
+Social-Media Plattform Reddit stellte ich den Kontakt mit Tim Tugendhat her
 der zurzeit seinen PhD. in Physik an der Universität in Heidelberg macht.
-Dieser ermöglichte es mir, die Physikalische Fakultät an einer Uni mal genauer
+Dieser ermöglichte es mir, die physikalische Fakultät an einer Uni mal genauer
 zu sehen und das täglich leben eines Physikers mitzuerleben.
 \par
 Während des Praktikums stellte ich fest das ich die im letzten Jahr erlerne Fähigkeit mit
 Python\footnote{Programmiersprache} zu Programmieren und mit
 Blender\footnote{3D Software Suite} umzugehen nutzen konnte um Galaxien
 darzustellen.
-Dies war insgesamt unglaublich Interessant und zeigte mir zum wiederholten mal:
+Dies war insgesamt unglaublich interessant und zeigte mir zum wiederholten mal:
 Projekte sind sehr dazu geeignet um sich in neues einzuarbeiten oder neues
 zu lernen und bieten einem ein Ziel welches man erreichen möchte was einem
-immer genügend motivation bietet weiterzumachen.
+immer genügend Motivation bietet weiterzumachen.
 \par
-Eine frage die ich mir öfters gestellt habe war warum man eigentlich Galaxien
+Eine frage die ich mir öfters gestellt habe war, warum man eigentlich Galaxien
 simuliert? Wäre es nicht einfacher einfach in den Himmel zu gucken und
 die bereits bestehenden Galaxien zu beobachten?
-Nach kurzer recherche lag die Antwort auf der Hand: Galaxien brauchen mehrere
+Nach kurzer Recherche lag die Antwort auf der Hand: Galaxien brauchen mehrere
 Millionen Jahre um sich zu entwickeln, also kann man ihre Entwicklung als
-normaler Mensch nicht in dem Umfang beobachten, um dann daraus schlüsse zu
+normaler Mensch nicht in dem Umfang beobachten, um dann daraus Schlüsse zu
 ziehen. Daher simuliert man die Galaxien und kann dann somit vorhersagen oder
-herrausfinden wie die Galaxien entstanden sind bzw. was mit ihnen passieren
+herausfinden wie die Galaxien entstanden sind bzw. was mit ihnen passieren
 wird.
 
 \subsection{Themen}
 
 \begin{itemize}
-  \item Generierung von Elliptischen Galaxien
-  \item Generierung von einem Dark-Matter Halo um die Elliptische Galaxie
-  \item Stauchung und Streckung des Dark-Matter mit beinflussung der eigentlichen Galaxie
-  \item Beschleunigung des generierungsprozesses mithilfe einer sogennanten ''lookup-table``
+  \item Generierung von elliptischen Galaxien
+  \item Generierung von einem Dark-Matter Halo um die elliptische Galaxie
+  \item Stauchung und Streckung des Dark-Matter mit Beeinflussung der eigentlichen Galaxie
+  \item Beschleunigung des Generierungsprozesses mithilfe einer sogenannten ''lookup-table''
   \item Aufbau eines neuronalen Netzes für die unbeaufsichtigte Generation von Galaxien
   \item Generation von Spiralgalaxien
 \end{itemize}
 
 \subsection{Motivation}
 
-Ich habs einfach mal getan...
+Die Motivation für das Projekt kam praktisch direkt nach meinem letzten Jugend
+Forscht Projekt bei dem ich mich mit der Vorhersage von Satellitenkollisionen
+beschäftigt habe. Durch mein Praktikum im Zentrum für Astronomie der Uni Heidelberg
+kam ich auf die Idee, ich könnte mein Wissen im Bezug auf die Programiersprache
+Python und der 3D-Suite Blender mithilfe eines Projektes erweitern.
+Ein Projekt zu haben um sich an etwas Neues heranzuwagen ist sehr empfehlenswert
+wie ich schon in letzten Jahr gemerkt habe, ich hatte also wieder ein Projekt
+welches mich Tag für Tag motiviert hat etwas zu erreichen.
diff --git a/langfassung/docs/3_hauptteil.tex b/langfassung/docs/3_hauptteil.tex
index 617e4f9..c3edf57 100644
--- a/langfassung/docs/3_hauptteil.tex
+++ b/langfassung/docs/3_hauptteil.tex
@@ -1,27 +1,11 @@
-
-% \paragraph{ \( \Phi \) }
-%
-% \begin{equation}
-%   \Phi(r) = - \frac{4\pi G \rho_0 R_s^3}{r} \ln ( 1+ \frac{r}{R_s} )
-% \end{equation}
-%
-% with the limits
-%
-% \begin{equation}
-%   \lim_{r\to \infty} \Phi=0
-% \end{equation}
-%
-% and
-%
-
-
-\subsection{Generierung der Elliptischen Galaxien}
+\subsection{Generierung von elliptischen Galaxien}
 \subsubsection{Das Navarro-Frenk-White Profil}
 
-Das Navarro-Frenk-White profil (NFW-profil) ist im grunde genommen eine Funktion
-die einem die Warscheinlichkeit das ein Stern an einer bestimmten position ist
-liefert.
-Die Funktion ist im allgemeinen wie folgt aufgebaut:
+Das Navarro-Frenk-White Profil (NFW-profil) ist ein Profil zur Simulation
+von Masseverteilungen in N-Körper-Simulationen. Im Grunde genommen bekommt man durch das Profil die
+Wahrscheinlichkeit das ein Stern in einem Abstand \( r \) vom Mittelpunkt der
+Galaxie existiert.
+Die Funktion die dies bewerkstelligt ist im Allgemeinen wie folgt aufgebaut:
 
 \begin{equation} \label{eq:NFW_profile}
   \rho_{NFW}(r) = \frac{ 1 }{ \sqrt{ 2 \pi } \cdot \sigma } \cdot
@@ -33,87 +17,125 @@ Die Funktion ist im allgemeinen wie folgt aufgebaut:
   ln{ \left( 1 + \frac{ r }{ R_{s} } \right) }
 \end{equation*}
 
-Um die Formel (\ref{eq:NFW_profile}) einfach zu beschreiben kann man sie sich
-wie folgt vorstellen:
-Um zu gucken ob ein zufälliger Stern
-bei \( x_1 \), \( y_1 \) und \( z_1 \) generiert werden kann wird wie folgt
-vorgegangen: Aus den Koordinaten wird der Wert \( r \) mithilfe des Satz des
-Pytargoras berechnet ( \( r = \sqrt{{x_1}^2 + {x_2}^2 + {x_3}^2} \) ) , dieser gibt
-an wie weit der jeweilige Stern vom Zentrum der Galaxie entfernt ist. Um zu
-prüfen ob der Stern generiert wird, wird dieser \( r \)-wert in die Funktion
-\( \rho_{NFW} \) eingesetzt. Der entstehende Wert gibt an wie warscheinlich es ist,
-das ein Stern in der Entfernung zum Ursprung generiert wird.
+Beispiel Werte:
 
-\subsubsection{Random Sampling}
+\begin{tabular}{l l l}
+  \( sigma \) & = & 200 \\
+  \( f_0 \) & = & 0.1 \\
+  \( R_s \) & = & 10000 \\
+  \( pi \) & = & 3.141592 \\
+  \( e \) & = & 2.718281 \\
+  \( G \) & = & 4.302e-3 \\
+\end{tabular}
 
-Die sogennante ''Random Sampling`` Methode wird genutzt um herrauszufinden ob
-ein Stern generiert wird oder nicht.Es wird dazu ein zufälliger
-Wert \( x \) im bereich \( [~\rho_{max}~;~\rho_{min}~] \) generiert. Liegt dieser
-Wert über dem Wert aus der Funktion \( \rho \) wird kein Stern generiert.
-Liegt dieser Stern jedoch unter dem wert aus der \( \rho \) Funktion wird
-ein Stern an den Koordinaten \( x_1 \), \( y_1 \) und \( z_1 \) generiert.
+Möchte man herausfinden wie wahrscheinlich es ist das ein Stern generiert wird,
+setzt man den Abstand des Sternes vom Mittelpunkt der Galaxie in die Formel
+(\ref{eq:NFW_profile}) ein. Möchte man z. B. wissen wie wahrscheinlich es ist,
+das ein Stern der die Koordinaten \( (x_{1}, x_{2}, x_{3}) \) besitzt generiert
+wird, wird der Abstand zum Mittelpunkt der Galaxie mithilfe des Satzes des
+Pythagoras berechnet:
 
-Um das generieren zu Beschleunigen wird eine sogenneante ''lookuptable``
-verwendet. (\( \rightarrow \) \ref{subsec:lookuptable})
-
-Generiert man ein paar Sterne mithilfe des NFW-Profils hat man theoretisch
-schon eine Galaxie, jedoch ist diese nicht klar definiert. Um eine klare
-definition zu erreichen müssen mehrere hundert Sterne generiert werden.
-
-% \subsubsection{Das Einasto Profil}
-%
-% \begin{equation}
-%   \gamma(r) = \frac{ d \ln(\rho(r)) }{ d \ln(\rho) } \propto r^{\alpha}
-% \end{equation}
+\begin{equation}
+  r = \sqrt{ {x_{1}}^2 + {x_{2}}^2 + {x_{2}}^2 }
+\end{equation}
 
-% \subsubsection{Blender + Python}
-%
-% Blender is Awesome, Python is Awesome and together they are
-% \bold{SUPER AWESOME!!!}
-%
-% \begin{enumerate}
-%   \item Generate the galaxy-data using the NFW-Profile or the Einasto-profile
-%   \item Display the data in Blender and create an image using the OpenGL-renderer
-%   \item Train a Neural Network (NN) to classify galaxies
-%   \item Let the NN modify the galaxy to generate a perfect galaxy
-% \end{enumerate}
+In dem Beispiel wird also der Wert \( r \) in das NFW-Profil gegeben:
 
+\begin{equation*}
+  \rho_{NFW}(r) = \dots = s
+\end{equation*}
 
-\subsection{Generierung eines Dunkle-Materie Halos}
+Als Lösung erhält man einen Wert der in einem Intervall
+\( [~\rho(r_{min})~;~\rho(r_{max})~] \) liegt. Rechnet man \( \rho(r_{min}) \) und
+\( \rho(r_{max}) \) aus, ist es möglich den jeweiligen Ergebnissen anhand dieser
+Werte eine Wahrscheinlichkeit zwischen \( 0 \) und \( 100\% \) zuzuordnen Sodas
+es möglich ist zu entscheiden, ob ein Stern bei \( P(x_1 | x_2 | x_3) \) generiert
+werden soll oder nicht.
+
+\begin{figure}
+  \centering
+  \includegraphics[width=0.75\textwidth]{figs/galaxy}
+  \caption{Eine mit dem NFW-profil und der Random Sampling Methode generierte Galaxie}
+  \label{fig:galaxy}
+\end{figure}
+
+\begin{figure}
+  \centering
+  \includegraphics[width=0.75\textwidth]{figs/lookup_table_rho_r_function_grid}
+  \caption{
+  Die Rho Funktion im Intervall \( [~0~;~10^7 ~] \) geplottet mithilfe von Logarithmischen Achsen. \\
+  Die x-Achse beschreibt die Entfernung zum Mittelpunkt der Galaxie \\
+  Die y-Achse beschreibt die Warscheinlichkeit das ein Stern generiert wird
+  }
+  \label{fig:rho}
+\end{figure}
 
-Das sogennannte ''Dunkle-Materie Halo`` ist eine art Kugel die eine Galaxie
-umspannt: Duch dieses Halo ist die Dichte der Dunklen Materie welches sich um die
-Galaxie herum befindet definiert. Problematisch ist jedoch, dass wir dieses
-Halo nicht sehen können weshalb wir nur aufgrund anderer phänomäne welche durch
-die Halos verursacht werden auf die Eigenschaften des Halos schließen können.
-\par
-Um diese Halos darzustellen wird das NFW-Profil~(\ref{eq:NFW_profile})
-abgewandelt und quasi mit dem Profil für Elliptische Galaxien verbunden.
+\subsubsection{Random Sampling}
 
-...
+Um jetzt herauszufinden ob der Stern bei \( P(x_{1} | x_{2} | x_{3}) \) generiert
+wird, wird ein zufälliger Wert \( n \) im Intervall
+\( [~\rho(0)~;~\rho(r_{max})~] \) generiert und mit dem Wert \( x \)
+verglichen.
+Ein Stern wird generiert wenn gilt \( n < x \). Wenn jedoch \( n > x \) gilt
+wird kein Stern generiert.
+Dieser Prozess wird Random Sampling gennant und ist einer der Knackpunkte wenn
+es darum geht die Zeit in der ein Stern generiert wird zu reduzieren. Eine
+Möglichkeit dies zu tun sind sogenannten Lookuptabellen (siehe Sektion \ref{subsec:lookup})
+
+\subsubsection{Lookup Tabellen} \label{subsec:lookup}
+
+Um das generieren zu Beschleunigen wird eine sogenannte ``lookuptable''
+verwendet. (\( \rightarrow \) \ref{subsec:lookuptable}) dabei wird die Funktion
+aus dem NFW-profile (\ref{eq:NFW_profile}) in eine Tabelle geschrieben die im
+.csv-format in eine Datei gespeichert. Dies hat den Vorteil das die
+Ergebnisse gespeichert vorliegen und somit für andere Berechnungen weiterverwendet
+werden können und bei der Berechnung in den Arbeitsspeicher geschrieben werden,
+wodurch die Ergebnisse aus der Funkion bei Bedarf vorliegen und nicht erst
+berechnet werden müssen.
+
+\subsection{Generierung eines Dunkle-Materie Halos durch Anpassung des NFW-Profils}
+
+Die Rotationskurve von Spiralgalaxien verhält sich in der Realität anders als
+in einer Simulation. Der Unterschied lässt sich durch eine Kraft erklären
+die Auswirkungen auf Materie haben kann, jedoch nicht sichtbar ist. Dadurch
+kann diese Kraft nur durch Rückschlüsse beschrieben werden. Verhält sich ein
+Objekt also nicht so, wie es aufgrund der sichtbaren auf es einwirkenden Kräfte
+tun sollte, so muss eine andere Kraft vorhanden sein, die das Objekt beeinflussen.
+Diese ``Kraft'' entsteht voraussichtlich aufgrund von dunkler Materie.
+Dadurch das man Dunkle Materie durch beobachten von Sternen orten kann
+indem man berechnet wie sich die Sterne theoretische verhalten sollten und dies mit den
+realen Gegebenheiten vergleicht kann man die Funktion die eigentlich die Dichte der
+Sternenverteilung (NFW-profil) erklären soll so anpassen das man die Dichte der
+Verteilung von dunkler Materie berechnen kann.
+Das NFW-profil (\ref{eq:NFW_profile}) kann also so angepasst werden, dass es
+statt die Wahrscheinlichkeit das ein Stern generiert wird die Wahrscheinlichkeit
+das Dunkle Materie an einem zufälligem Ort existiert, umgebaut werden.
+Das NFW-profil (\ref{eq:NFW_profile}) wird also zu (\ref{eq:dark_matter})
+umgebaut.
 
-\subsubsection{Anpassung des NFW-Profils}
+\bigskip
 
-\begin{equation}
-  \rho(r) = \frac{1}{\sqrt{2 \cdot \pi} \cdot \sigma} \cdot
+\begin{equation}\label{eq:dark_matter}
+  \rho_{NFWDM}(r) = \frac{1}{\sqrt{2 \cdot \pi} \cdot \sigma} \cdot
   e^{\left( - \frac{(\Phi(r)}{\sigma^{2}} \right)}
 \end{equation}
 
 \begin{equation}
-  \rho(r) \cdot 1-\frac{1}{(2 \cdot sigma^{2} )} \cdot
-  ( Mxx \cdot x^{2} + 2 \cdot Mxy \cdot xy + Myy \cdot y^{2} ))
+  \Phi(r) = 1-\frac{1}{(2 \cdot \sigma^{2} )} \cdot
+  ( M_{xx} \cdot x^{2} + 2 \cdot M_{xy} \cdot xy + M_{yy} \cdot y^{2} ))
 \end{equation}
 
-\begin{lstlisting}
+\bigskip
 
-# new rho function
-def rho_new(x, y, z):
+Eine Mögliche Implementation in der Programiersprache Python als Funktion:
+
+\begin{lstlisting}
+def rho(x, y, z):
   a = (1 - ((1) / (2 * (sigma ** 2)))
   b = ( Mxx * x**2 + 2 * Mxy * x * y + Myy * y**2 ) )
   c = a * b
-return rho(x, y, z) * c
+  return rho(x, y, z) * c
 
-# phi function
 def phi(x):
   if x == 0:
     return -4 * pi * f_0 * G * R_s**2
@@ -122,10 +144,8 @@ def phi(x):
   b = np.log(1. + (x / R_s) )
   c = a * b
   return c
-
 \end{lstlisting}
 
-
 \subsection{Stauchung und Streckung der Galaxie}
 
 Wird eine Galaxie gestreckt oder gestaucht kann das an der umliegenden Dunklen
@@ -133,53 +153,118 @@ Materie liegen. Um solch eine Streckung darzustellen wird wie folgt vorgegangen:
 Die Position eines Sternes an einer Achse muss mit einem Skalar multipliziert
 bzw. dividiert werden.
 Dies ist relativ einfach machbar da die Koordinaten der jeweiligen Sterne
-in einer Datei nach dem Format \( [x, y, z] \) gespeichert sind.
-Um die Galaxie vertikal zu strecken wird z.B. für jeden Stern die z-Koordinate
-mit dem skalar \( s \) multipliziert. Da gestaucht werden soll liegt dieser
+in einer Datei nach dem Format \( x, y, z \) gespeichert sind.
+Um die Galaxie vertikal zu strecken wird z. B. für jeden Stern die z-Koordinate
+mit dem skalar \( s \) multipliziert. Wenn gestaucht werden soll liegt dieser
 Wert im Intervall \( 0 < s < 1 \). Die neue Koordinate für einen Stern ist also
-\( [x, y, z \cdot s] \). Möchte man die Galaxie strecken muss das Skalar \( s \)
+\( x, y, z \cdot s \). Möchte man die Galaxie strecken muss das Skalar \( s \)
 im Intervall \( 1 < s < \infty \) liegen.
 
-\subsection{Beschleunigung der Generierung}
+Indem man ganz grob feststellt in welchen Bereichen der Galaxie der Anteil an
+dunkler Materie höher ist kann man dies mit in die Berechnungen einfließen lassen.
+In meinem Fall habe ich z. B. ausprobiert einen Richtungsvektor \( \vec{r} \)
+zu generieren der von einem Stern in die Richtung der dunklen Materie zeigt.
+anschließend hab ich den Richtungsvektor mit einem Skalar \( s \) multipliziert
+um die Stärke mit der die Dunkle Energie auf einen jeweiligen Stern wirkt
+kontrollieren zu können. Als letztes habe ich dann den Richtungsvektor
+mit mit den Koordinaten des Sternes multipliziert um eine theoretische neue
+Position für den Stern zu generieren. Tut man dies für alle Sterne entstehen
+kleinere sogenannte ''cluster'' in denen sich die Sterne bündeln. Ein Problem
+hierbei war, dass es unglaublich rechenaufwendig ist dies für mehrere hunderte
+von Tausenden Sternen zu berechnen (siehe Sektion \ref{subsec:big_o}
+und \ref{subsec:speeding_things_up})
+
+\subsection{Rechenaufwand} \label{subsec:big_o}
+
+Um den Rechenaufwand in der Informatik darzustellen wird die sogenannte
+''O notation'' verwendet. Diese Notation wird verwendet um zu beschreiben
+wie viele schritte gebraucht werden um an ein Ziel zu kommen, abhängig von der
+Anzahl der ''Objekte'':
 
-Die Sterne schnell zu generieren ist natürlich energieeffizienter aber auch
-wichtig damit das neuronale netzt in unserer lebzeit fertig wird.
+\begin{equation}
+  O(n) = |\dots|
+\end{equation}
 
-Es gibt ein paar Aktionen die umgebaut werden können um das generieren zu
-beschleunigen:
+Beispiel:
 
-\subsubsection{n-Sterne}
+\begin{equation*}
+  O(n) = |n^2|
+\end{equation*}
 
-Statt am Anfang mehrere Millionen Sterne zu generieren wird wenn eine
-neue Koordinate benötigt wird eine neue erstellt. So erstellt man auf keinen
-Fall zu viele Koordinaten was Zeit spaart.
-Dem programm kann also gesagt werden, dass es genau \( n_1 \) Sterne aus
-\( m_1 \) potentiellen Sternen generieren soll, andernfalls werden \( n_2 \)
-Sterne aus \( m_2 > m_1 \) potentiellen Sternen generiert.
+Möchte man z. B. die Kräfte zwischen \( n = 100 \) Sternen
+berechnen werden \( O(100) = 100^2 = 10000 \) Rechnungen ausgeführt.
 
-\subsubsection{Lookuptable} \label{subsec:lookuptable}
+Bei einer ''O notation'' von \( n^2 \) bei der Berechnung von
+Kräften zwischen den Sternen kann also davon ausgegangen werden das desto
+mehr Sterne existieren, die Rechenleistung die gebraucht wird um in derselben
+Zeit dieselbe Anzahl an Sternen zu generieren Exponentiell für jeden Stern
+Steigen wird.
 
-Eine Weitere Möglichkeit für meherere Berechnungen Zeit zu Spaaren ist, den
-Entsprechenden Wert aus dem NFW-Profil (Formel \ref{eq:NFW_profile}) vorher zu
-berechnen und in eine Tabelle zu schreiben.
-Dies kann für z.B. \( 2e8 \) Werte getan werden was zwar eine 6 GB große Datei
-erzeugt, diese kann jedoch innerhalb weniger Sekunden eingelesen werden.
-
-\subsubsection{Weitere Optimierungen}
+Eines Optimales Ergebnis wäre eine ''Big O notation'' von \( n\log{n} \),
+jedoch ist dies zurzeit nicht ganz möglich.
 
-\paragraph{Nichts in der Konsole ausgeben:}
+\subsection{Beschleunigung der Generation} \label{subsec:speeding_things_up}
 
-Eine Vorgang der erstaunlicherweise sehr viel Rechenleistung erfordert, ist
-der Vorgang beim ausgeben von Text in die Konsole. Gibt man jede potentielle
-Koordinate in die Konsole aus, stürtzt das Programm aufgund von Überlast ab.
-Um dies zu umgehen kann z.B. nur jeder 100.000 Wert in die Konsole ausgegeben
-werden.
+Die Geschwindigkeit mit der die Sterne generiert werden ist ohne irgendeine Art
+von Optimierung unglaublich langsam. Die NFW-Funktion (\ref{eq:NFW_profile})
+wird für jeden Stern aufs neue vom Computer berechnet was auf mehrere Tausend
+Sterne hochgerechnet unglaublich rechenaufwendig ist.
+Ein Weiteres Problem ist, dass das Programm von alleine nur einen Kern
+verwendet und somit auf eine menge Rechenleistung verzichtet.
+Durch Nutzung von mehreren Kernen kann die Zeit
+um \( n \) Sterne zu generieren schnell halbiert oder sogar geviertelt werden.
 
-\paragraph{...}
+\subsubsection{Lookuptable} \label{subsec:lookuptable}
 
-\newpage
-\subsection{Nutzung eines Neuronalen Netzes zum unbeaufsichtigeten generieren}
-\subsubsection{Aufbau des Neuronalen Netzes}
+Eine weitere Möglichkeit für mehrere Berechnungen Zeit zu Sparen ist, den
+entsprechenden Wert aus dem NFW-Profil (Formel \ref{eq:NFW_profile}) vorher zu
+berechnen und in eine Tabelle zu schreiben.
+Dies kann für z. B. \( 2 \cdot 10^8 \) Werte getan werden was zwar eine ca. 6 GB große
+Datei erzeugt, diese kann jedoch innerhalb weniger Sekunden eingelesen werden
+und somit das "errechnen" eines entsprechenden Wertes praktisch innerhalb von
+Bruchteilen einer Sekunde simulieren indem das Ergebnis einfach aus dem
+Arbeitsspeicher ausgelesen wird.
+
+\subsubsection{Mehr Rechenleistung!}
+
+Um mehr Sterne in weniger Zeit zu generieren können verschiedene
+Aspekte der Software optimiert werden. Um jedoch ohne Optimierung mehr Sterne
+zu generieren kann einfach mehr Rechenleistung verwendet werden. Dies ist im
+Grunde genommen die einfachste Möglichkeit mehr Sterne in einer relativ kurzen
+Zeitspanne zu generieren: Schon die Verwendung von vier statt zwei Kernen
+ermöglicht es einem in 30 Min. statt ca. 300 Sterne ca. 600 Sterne zu generieren.
+
+\paragraph{Amazon Web Services} ~\\
+Um das Generieren von Galaxien so "profitabel" wie möglich zu machen können
+sogenannte ''Amazon Web Services\footnote{
+Amazon Web Services (AWS) ist ein US-amerikanischer Cloud-Computing-Anbieter,
+der 2006 als Tochterunternehmen des Online-Versandhändlers Amazon.com gegründet
+wurde. Zahlreiche populäre Dienste wie beispielsweise Dropbox, Netflix,
+Foursquare oder Reddit greifen auf die Dienste von Amazon Web Services zurück.
+2013 stufte Gartner AWS als führenden internationalen Anbieter im Cloud
+Computing ein.
+} ''
+(AWS) genutzt werden.
+Der Dienst ''EC2'' kostet z.B. mit 60 Kernen und 256GB RAM nur \$3.712 pro Stunde.
+Statt mit einem Kern in einer Stunde ca. 600 Sterne zu generieren können
+also in einer Stunde 38400 Sterne generiert werden! Möchte man \( 1 \cdot
+10 ^ 6 \) Sterne generieren bräuchte man mit einer Geschwindigkeit von
+ca. 600 Sternen pro Stunde und 64 Kernen ca. 26 Stunden. Dies kostet umgerechnet
+ca. 100\$ (83€).
+Eine weitere Möglichkeit besteht darin, Virtuelle Server von Netcup anzumieten.
+Hierbei kosten z.B. 6 Kerne für einen Monat 8€ wodurch man frei nach Belieben
+den ganzen Tag Galaxien generieren kann.
+
+\subsubsection{Nichts in der Konsole ausgeben}~\\
+Ein Vorgang der erstaunlicherweise sehr viel Rechenleistung erfordert, ist
+der Vorgang beim Ausgeben von Text in die Konsole. Gibt man jede potentielle
+Koordinate in die Konsole aus, stürzt das Programm aufgrund von Zuviel Daten im Arbeitspeicher ab.
+Um dies zu umgehen kann z. B. nur jeder 100.000 Wert in die Konsole ausgegeben
+werden was jedoch auch überflüssig ist wenn man ungefähr abschätzen kann, wann
+das Script fertig gelaufen ist.
+
+\subsection{Nutzung eines neuronalen Netzes zum unbeaufsichtigten generieren von Galaxien}
+\subsubsection{Aufbau des neuronalen Netzes}
 
 Ein Neuronales Netz ist wie folgt aufgebaut:
 
@@ -206,15 +291,19 @@ Ein Neuronales Netz ist wie folgt aufgebaut:
 \begin{center}
   \begin{tikzpicture}[x=2cm, y=1.5cm, >=stealth]
 
+  % Input nodes
   \foreach \m/\l [count=\y] in {1,2,3,missing,4}
     \node [every neuron/.try, neuron \m/.try] (input-\m) at (0,2.5-\y) {};
 
+  % Hidden nodes
   \foreach \m [count=\y] in {1,missing,2}
     \node [every neuron/.try, neuron \m/.try ] (hidden-\m) at (2,2-\y*1.25) {};
 
+  % Output nodes
   \foreach \m [count=\y] in {1,missing,2}
     \node [every neuron/.try, neuron \m/.try ] (output-\m) at (4,1.5-\y) {};
 
+  % Synapses
   \foreach \l [count=\i] in {1,2,3,n}
     \draw [<-] (input-\i) -- ++(-1,0)
       node [above, midway] {$I_\l$};
@@ -234,6 +323,7 @@ Ein Neuronales Netz ist wie folgt aufgebaut:
     \foreach \j in {1,...,2}
       \draw [->] (hidden-\i) -- (output-\j);
 
+  % Labels
   \foreach \l [count=\x from 0] in {Eingabe, Versteckte, Ausgabe}
     \node [align=center, above] at (\x*2,2) {\l \\ ebene};
 
@@ -243,64 +333,306 @@ Ein Neuronales Netz ist wie folgt aufgebaut:
 
 \hrule
 
-\bigskip
+Im Grunde genommen werden Daten eingespeist und miteinander verrechnet, wodurch
+am Ende ein oder mehrere Werte rauskommen mit denen man die verschiedensten
+Sachen tun kann. In meinem Fall konnte ich z. B. die durchschnittliche Dichte
+von Sternen, die Größe der Galaxie und viele andere Faktoren in das neuronale
+Netz einspeisen um am Ende zwei Werte entnehmen. Das neuronale Netz muss
+trainiert werden, dabei werden echte funktionierende Daten in das Netz eingespeist
+und mit bereits vorhandenen Ergebnissen verglichen. Ist das Ergebnis gut und
+stimmt ungefähr mit dem bereits vorhandenen Ergebnis überein wird am Netz selber
+nichts getan. Stimmt das Ergebnis aus dem Netz mit dem bereits vorhandenen
+jedoch nicht überein, dann werden im neuronalen Netz die sogenannten Synapsen
+(Die Verbindungen zwischen den Neuronen (Oben als Kreis dargestellt))
+entsprechend anders gewichtet.
+
+\paragraph{Neuronen und Synapsen}
+
+In einem neuronalen Netz sind sogenannte Neuronen (In der Abbildung oben als
+Kreis dargestellt) über sogenannte Synapsen (In der Abbildung oben als Linie
+zwischen zwei Neuronen dargestellt) miteinander verbunden.
+Die Neuronen können als eine Art Funktion gesehen werden. Sie Wandeln die Daten
+die sie bekommen mithilfe einer Aktivierungsfunktion in einen Zahlenbereich
+zwischen 0 und 1 um. Eine solche Aktivierungsfunktion kann die folgende Form
+haben:
+
+\begin{equation}
+  S(x) = \frac{1}{1 + e^{-x}}
+\end{equation}
+
+Die Synapsen können verschieden gewichtet sein. Bekommt eine Synapse z. B.
+einen Eingabewert \( x \), dann kann der Eingabewert mit der Gewichtung \( w \)
+der Synapse verrechnet werden um den Ausgabewert \( a \) zu erhalten:
+
+\begin{equation}
+  x \cdot w = a
+\end{equation}
 
-Das \textbf{Neuronale Netz} besitze mehrere Ebenen: die \textbf{Eingabe ebene},
-die \textbf{Versteckte Ebene(n)} und die \textbf{Ausgabe Ebene}.
-Diese Ebenen bestehen aus sogennanten \textbf{Neuronen} die wie im Menschlichen
-Gehirn Informationen aufnehmen und weitergeben. Die Eingabe kann verschieden
-gewichtet sein, es kann also sein das eine Eingabe eine Gewichtung von
-\( 10\% \) hat und eine andere eine Gewichtung von \( 90\% \).
-Die Eingabe Ebene ist dazu da eine Eingabe inform einer Matrix an die
-verschiedenen Neuronen in der Versteckten Ebene weiterzuleiten.
-Die Versteckte Ebene verarbeitet die Information aus der Matrix und leitet
-diese an die Ausgabe Ebene weiter die die Information ausgibt.
-\par
-Das sogennante ''Trainieren`` ist der Prozess, bei dem die Gewichtung der
-Neuronen so Verändert wird, damit ein gewünschtes Ergebnis herrauskommt.
-Beispiel: man möchte ein Neuronales Netz darauf Trainieren eine Galaxie zu
-Identifizieren, dann werden ganz viele positiv Beispiele durch das Netz gejagt
-welche die Gewichtung immer weiter anpassen. In der Ausgangs Ebene wird dann
-mithilfe zweier Neuronen entweder dargestellt das das eingegebene Bild eine
-Galaxie ist oder das das eingegebene Bild eben keine Galaxie ist.
+Für eine weite Ausführung in den Bereich der neuronalen Netze reicht die vorgegebene
+Maximalanzahl an Seiten leider nicht, deshalb hier kurz das wesentliche:
+Um neuronale Netze effektiv nutzen zu können wird unglaublich viel
+Rechenleistung benötigt. Diese habe ich nicht einfach so zur Verfügung, weshalb
+ich Kontakt mit verschiedenen Unis und Unternehmen aufgenommen haben um dort
+vielleicht Zugang zu einem Hochleistungsrechner zu bekommen. Zum Zeitpunkt der
+Abgabe dieser Langfassung (\today) habe ich jedoch noch keine Möglichkeit gehabt
+meine Software auf einem solchen Hochleistungs-Rechner laufen zu lassen. Deshalb
+habe ich beschlossen die Nutzung von neuronalen Netzen nach hinten zu verschieben,
+auch wenn das Thema unglaublich spannend ist.
 
-\subsubsection{Nutzung eines Neuronalen Netztes zur verbesserung von Galaxien Simulationen}
+\bigskip
+%
+% \paragraph{Was ist ein Neuronales Netz?}
+% Ein Neuronales Netz ist ein Gebilde das aus Neuronen und Synapsen besteht.
+%
+% \paragraph{Was ist ein Neuron?}
+% Ein Neuron ist ein Knotenpunkt in einem Neuronalen Netz. Es summiert die
+% einkommenden synapsen.
+%
+% \paragraph{Was ist eine Synapse}
+% Eine Synapse ist eine Verbindung zwischen zwei Neuronen. Die Synapsen
+% können verschiden gewichtet sein wobei der Eingabewert mit der Gewichtung der
+% Synapse multipliziert wird.
+%
+% \paragraph{Was ist eine Aktivierungsfunktion?}
+% Eine Aktivierungsfunktion ist die Funktion die genutzt wird um einen beliebigen
+% Wert in einen Wert \( x \) für den gilt \( 0 < x < 1 \).
+% Beispiel einer Aktivierungsfunktion:
+% Die Funktion (\ref{eq:pyth}) ist der Satz des Pythagoras.
+%
+% \begin{equation}\label{sigmoid}
+%   \frac{1}{1+e^{-x}}
+% \end{equation}
+%
+% \begin{equation}
+%   2 + 2 = 4
+% \end{equation}
+%
+% \begin{equation}
+%   1 + 1 = 2
+% \end{equation}
+%
+% \begin{equation}\label{eq:pyth}
+%   a^2 + b^2 = c^2
+% \end{equation}
+%
+% \paragraph{Was haben die verschiedenen Ebenen zu bedeuten?}
+% Die Verschiedenen Ebenen in einem Neuronalen Netzt haben verschiedene
+% Funktionen: Die erste Ebene, die sogennante Eingabe Ebene, ist dazu da, eine
+% Eingabe in das Netzt einzuschleusen.
+% Die Ebenen zwischen der Eingabeebene und er Ausgabeebene werden als Versteckte
+% Ebenen bezeichten. Es muss mindestens eine Versteckte Ebene geben damit das
+% Netz lernfähig ist, es gibt jedoch keine Begrenzung wieviele Ebenen es geben
+% kann.
+% Die Ausgabe Ebene ist dazu da die Verarbeiteten Werte auszugeben.
+% Hier Bekommt man bei einer Aktivierungsfunktion (\ref{sigmoid}) die eine Ausgabe
+% zwischen 0 und 1 liefert einen Wert zwischen 0 und 1.
+%
+% \paragraph{Was bringen die ``versteckten Ebenen''?}
+% Die Versteckten Ebenen liegen zwischen den Ein- und Asugabeebenen. Sie sind
+% dazu da das lernen im Neuronalen Netz zu ermöglichen.
+%
+% \paragraph{Was ist ``Foward Propagation''?}
+% Als "Foward Propagation" wird der Vorgang bezwichten, bei dem ein Wert durch
+% das Neuronale Netz geschleust wird.
+%
+% \paragraph{Wie lernt das Neuronale Netz?}
+% Das Neuronale Netz lernt indem es immer wieder die Eingabewerte durch das
+% Neuronale Netz schiebt. Hierbei werden am Ende die Gewichtugnen der Synapsen
+% verändert wodurch das Netz sich immer weiter verändert.
+%
+% \paragraph{Was ist ``Backward Propagation?''}
+% Als "Backward Propagation" wird der Vorgang bezeichnet indem man nachdem man
+% einen Wert duch das Netz geschoben hat im Netz zurück geht und mögliche
+% Fehlerquellen sucht. Damit kann wenn bereits ein richtiges Ergebniss vorhanden
+% ist, wie z.B. bei der Digitalen Bilderkennung eine Zahl, einen Fehlerkoeffizinet
+% berechnet werden der dazu genutzt wird ein besseres Ergebniss zu erzielen.
+%
+%
+% Das \textbf{Neuronale Netz} besitze mehrere Ebenen: die \textbf{Eingabe ebene},
+% die \textbf{Versteckte Ebene(n)} und die \textbf{Ausgabe Ebene}.
+% Diese Ebenen bestehen aus sogennanten \textbf{Neuronen} die wie im Menschlichen
+% Gehirn Informationen aufnehmen und weitergeben. Die Eingabe kann verschieden
+% gewichtet sein, es kann also sein das eine Eingabe eine Gewichtung von
+% \( 10\% \) hat und eine andere eine Gewichtung von \( 90\% \).
+% Die Eingabe Ebene ist dazu da eine Eingabe inform einer Matrix an die
+% verschiedenen Neuronen in der Versteckten Ebene weiterzuleiten.
+% Die Versteckte Ebene verarbeitet die Information aus der Matrix und leitet
+% diese an die Ausgabe Ebene weiter die die Information ausgibt.
+% \par
+% Das sogennante ''Trainieren`` ist der Prozess, bei dem die Gewichtung der
+% Neuronen so Verändert wird, damit ein gewünschtes Ergebnis herrauskommt.
+% Beispiel: man möchte ein Neuronales Netz darauf Trainieren eine Galaxie zu
+% Identifizieren, dann werden ganz viele positiv Beispiele durch das Netz gejagt
+% welche die Gewichtung immer weiter anpassen. In der Ausgangs Ebene wird dann
+% mithilfe zweier Neuronen entweder dargestellt das das eingegebene Bild eine
+% Galaxie ist oder das das eingegebene Bild eben keine Galaxie ist.
+%
+% \subsubsection{Nutzung eines Neuronalen Netztes zur verbesserung von Galaxien Simulationen}
+%
+% Möchte man mithilfe eines Neuronalen Netztes vorhandene Galaxiensimulationen
+% verbessern, wird wie im folgenden Diagramm zusehen vorgegangen:
+%
+% \begin{tikzpicture}
+% [node distance = 4cm, auto, ->, on grid]
+%
+% \node [draw, minimum width=3cm, text depth = 1cm] (galaxy) {Galaxie};
+% \node [draw, right of=galaxy] (neural_net) {Neuralonales Netz};
+%
+% \node [draw] (yes) [right of=neural_net] {Ja}
+% node [right=3cm of yes, align=center] {Galaxie ist eine Galaxie};
+%
+% \node [draw] (no) [below=2cm of neural_net] {Nein}
+% node [right=3.5cm of no, align=center] {Galaxie ist keine Galaxie \\
+% \( \rightarrow \) ändere parameter und \\generiere eine neue Galaxie};
+%
+%
+% \draw[->, line width=0.25mm] (galaxy) -- (neural_net)
+% node [above=1cm of neural_net, align=center] {Testet ob die Eingabe \\eine
+% Galaxie ist oder nicht};
+%
+% \node[draw, yshift=5mm] (paramter) at (galaxy.south) {paramter};
+%
+% \draw[->, line width=0.25mm] (neural_net) -- (yes);
+% \draw[->, line width=0.25mm] (neural_net) -- (no);
+%
+% \path[line width=0.25mm] (no) edge [bend left] node {} (paramter);
+%
+% \end{tikzpicture}
 
-Möchte man mithilfe eines Neuronalen Netztes vorhandene Galaxiensimulationen
-verbessern, wird wie im folgenden Diagramm zusehen vorgegangen:
+\subsection{Spiralgalaxien}
 
-\begin{tikzpicture}
-[node distance = 4cm, auto, ->, on grid]
+Spiralgalaxien sind im allgemeinen faszinierende Gebilde: Aus mehreren Millionen
+Sternen entsteht eine Reisige Spirale. Dies zu simulieren ist jedoch unglaublich
+Rechenaufwendig weshalb ich dies bisher nur mir kleineren Galaxien durchgeführt
+habe. Das Problem ist, dass die Kräfte zwischen jedem Stern und jedem anderem
+Stern ausgerechnet werden müssen was wie in Sektion \ref{subsec:big_o} beschrieben
+mit steigender Anzahl an Sternen eine Exponentielle Steigerung der Rechenzeit
+hervorruft.
 
-\node [draw, minimum width=3cm, text depth = 1cm] (galaxy) {Galaxie};
-\node [draw, right of=galaxy] (neural_net) {Neuralonales Netz};
+\par Ein interessanter Aspekt der Spiralgalaxien den ich in die Simulationen
+einzubauen ist die Diskrepanz zwischen der realen Position
+der Sterne und der berechneten Position durch die Auf Dunkle Materie geschlossen
+wird.
 
-\node [draw] (yes) [right of=neural_net] {Ja}
-node [right=3cm of yes, align=center] {Galaxie ist eine Galaxie};
+\subsubsection{Das n-Körper Problem}
 
-\node [draw] (no) [below=2cm of neural_net] {Nein}
-node [right=3.5cm of no, align=center] {Galaxie ist keine Galaxie \\
-\( \rightarrow \) ändere parameter und \\generiere eine neue Galaxie};
+(nach der Ph.D. Thesis von Jakub Schwarzmeier s. 18 - 22, Pilsen 2007)
 
+Das sogenannte \( N \)-Körper Problem wird dazu genutzt um ein System mit
+\( N \)-Körpern zu simulieren. Hierbei müssen alle von außen einwirkenden
+Kräfte \(\vec{F_{i}} \) mit eingerechnet werden, im falle von Galaxien also die
+universelle Gravitationsregel von Newton.
 
-\draw[->, line width=0.25mm] (galaxy) -- (neural_net)
-node [above=1cm of neural_net, align=center] {Testet ob die Eingabe \\eine
-Galaxie ist oder nicht};
+\begin{equation}
+  m_{i} \cdot \frac{d\vec{v_{i}}}{dt} = \vec{F_i}
+\end{equation}
 
-\node[draw, yshift=5mm] (paramter) at (galaxy.south) {paramter};
+Für zwei Punkte in einer Galaxie gilt nach der universellen Gravitationsregel von
+Isaac Newton:
 
-\draw[->, line width=0.25mm] (neural_net) -- (yes);
-\draw[->, line width=0.25mm] (neural_net) -- (no);
+\begin{equation}
+  m_{i} \cdot \frac{d\vec{v_{i}}}{dt} =
+  G \cdot \frac{m_{i} \cdot m_{j}}{r^{3}_{ij}} \cdot \vec{r_{ij}}
+\end{equation}
 
-\path[line width=0.25mm] (no) edge [bend left] node {} (paramter);
+bzw.
 
-\end{tikzpicture}
+\begin{equation}\label{eq:n-body-2nd}
+  \frac{d^{2}\vec{r_{i}}}{dt^{2}} =
+  G \cdot \sum_{j = 1} \frac{m_j}{r^{3}_ij} \cdot \vec{r_{ij}}
+\end{equation}
 
-\subsection{Spiralgalaxien}
-\subsubsection{Das n-Körper Problem}
+Die neue Position und Geschwindigkeit eines Körpers wird mithilfe der bereits
+bekannten Beschleunigung berechnet, was zu der Formel (\ref{eq:n-body-2nd}), die
+eine zweite Ableitung enthält, führt. Die Formel (\ref{eq:n-body-2nd}) kann
+jedoch in zwei neue Formeln umgeschrieben werden, die jeweils nur eine erste
+Ableitung enthalten:
+
+\begin{align}\label{eq:hamilton}
+  \frac{d\vec{r_{i}}}{dt} &= \vec{v_i} \\
+  \frac{d\vec{v_{i}}}{dt} &= G \cdot \sum_{j = 1} \frac{m_j}{r^{3}_{ij}}
+  \cdot \vec{r_{ij}}
+\end{align}
+
+Die Formeln (\ref{eq:hamilton}) entsprechen der Bewegungsgleichung nach
+Hamilton. Möchte man nun die Position der einzelnen Sterne berechnen, müssen
+die Werte aus der Funktion in für einen Computer darstellbare Werte umgewandelt
+werden.
 
-\subsection{Größeneinheiten}
+Eines der Probleme um die Bewegung eines Sternes zu formulieren liegt dabei,
+einen Anfangswert für die Bewegung zu finden. Dies wird durch die folgende
+Formel gelöst:
 
 \begin{equation}
-  3.086 \cdot 10^{36} m
+  x_{t + 1} = x_{t} + \Delta t \cdot F(x_{i}, t_{i})
+\end{equation}
+
+Die Position eines Sternes nach einer Zeit von \( \Delta t \) wird durch die
+vorherige Position und die auf der Stern wirkenden Kräfte bestimmt.
+Der Term \( \Delta t \cdot F(x_{i}, t_{i}) \) wird auch als erster Schritt in
+der Taylor-reihe bezeichnet mit der weitere Punkte anhand der Ableitung
+vorheriger Punkte errechnet werden können.
+Die Veränderung der Position kann aus der Formel (\ref{eq:hamilton}) abgeleitet
+werden:
+
+\begin{align}
+  \Delta \vec{r_{i}} &=
+  \vec{v_{i}} \cdot \Delta t \\
+  \Delta \vec{v_{i}} &=
+  G \cdot \Delta t \cdot \sum_{j = 1} \frac{m_{j}}{r^{3}_{ij}} \vec{r_{ij}}
+\end{align}
+
+\subsubsection{Unterteilung des Vektorraumes in verschiedene Zellen}
+Die Kräfte die innerhalb der Galaxie wirken können mithilfe eines Vektorraumes
+dargestellt werden. Dabei kann jedem Punkt im Raum ein Vektor zugewiesen werden.
+Der Vektorraum im falle von Galaxien stellt erstmal nur die Kräfte, die die
+Sterne aufeinander auswirken da.
+Um nicht unendlich viel rechnen zu müssen wird der Vektorraum in verschiedene
+Zellen unterteilt in denen jeweils die mittlere Kraft berechnet wird.
+
+\subsubsection{Berechnung der wirkenden Kräfte}
+Die wirkenden Kräfte können wie in Formel (\ref{eq:gravitation_law}) zu sehen
+berechnet werden:
+
+\begin{equation}\label{eq:gravitation_law}
+  F_{1} = F_{2} = G \cdot \frac{m_{1} \cdot m_{2}}
+  {\sqrt{(a_1 - b_1)^2 + (a_2 - b_2)^2 + (a_3 - b_3)^2}}
 \end{equation}
+
+\begin{tabular}{l l}
+\( F_1 , F_2 \) & Wirkende Kräfte zwischen zwei Massen \\
+G & Gravitationskonstante \( 6,67408 \cdot 10^{-11} \frac{m^3}{kg \cdot s^2} \) \\
+\( m_1 \) & Erste Masse \\
+\( m_2 \) & Zweite Masse \\
+\( r \) & Abstand der Massen
+\end{tabular}
+
+\paragraph{Masse der Sterne}
+Die Masse der Sterne ist einer der entscheidende Faktoren wenn es darum geht
+Galaxien zu generieren: verändert man die Masse der Sterne verändert sich sofort
+das gesamte Gleichgewicht in der Galaxie was zu unerwarteten Ereignissen führen
+kann.
+\par Allgemein gesehen werden zwei Variablen gebraucht: die
+\textbf{Minimalmasse} und die \textbf{Maximalmasse}. Zwischen diesen beiden
+Werten werden zufällig Werte generiert und den Sternen zugewiesen.
+\par Die Veränderung der Masse wird erstmal nicht berücksichtigt.
+
+\paragraph{Abstand der Sterne}
+Der Abstand der Sterne kann mit dem Satz des Pythagoras (Formel
+(\ref{eq:pytagoras})) berechnet werden.
+
+\begin{equation}\label{eq:pytagoras}
+  r_{a, b} = \sqrt{(a_x - b_x)^2 + (a_y - b_y)^2 + (a_z - b_z)^2)}
+\end{equation}
+
+\subsection{Weiteres}
+Um die Simulation zu beschleunigen können andere Simulationsmodelle
+verwendet werden wie z. B. die Kräfte in verschiedenen Feldern berechnen um
+diese anschließend weiter zu evaluieren.
+
+\begin{figure}
+  \centering
+  \includegraphics[width=0.75\textwidth]{figs/spiralgalaxy}
+  \caption{Eine Spiralgalaxie generiert mithilfe von Daten aus dem Max-Plank-Institut in Heidelberg}
+  \label{fig:spiralgalaxy}
+\end{figure}
diff --git a/langfassung/docs/4_ergebnisse.tex b/langfassung/docs/4_ergebnisse.tex
index 088b13e..f398f55 100644
--- a/langfassung/docs/4_ergebnisse.tex
+++ b/langfassung/docs/4_ergebnisse.tex
@@ -1,31 +1,24 @@
-Ergebnisse
+\subsection{Simulations Geschwindigkeit}
 
-\subsection{Simulation Speed}
+Insgesamt bin ich zu folgenden Ergebnissen zusammengekommen:
 
-Nach mergen des speed-branches sind folgende Ergebnisse zusammengekommen:
+\begin{itemize}
+  \item
+  \begin{tabular}{l | l | l}
 
-\begin{tabular}{l | l | l}
-
-Sterne  & Zeit Vorher   & Zeit Nachher \\ \hline\hline
-1e5     & 2.93 sek.     & k.A. \\
-1e6     & 29.38 sek.    & k.A. \\
-1e7     & 315.67 sek.   & k.A. \\
-1e9     & 9h            & k.A. \\
-
-\end{tabular}
-
-Aus 1e9 Sternen werden vorher letztendlich 45000 Sterne generiert.
+    Sterne  & Zeit (30.10.2017)  & Zeit (\today) \\ \hline\hline
+    45000     & ca. 9h            & ca. 4h \\
+  \end{tabular}
 
-Pro MegaByte können die Koordinaten von 10000 Sternen gespeichert werden.
+  \item Pro MegaByte können die Koordinaten von 10000 Sternen gespeichert werden.
 
-\subsection{Spiral Galaxies}
+  \item Die Nutzung von Lookuptabellen ist unglaublich sinnvoll
+\end{itemize}
 
-Die generierung von Spiralgalaxien gestaltet sich schweiriger als erwartet.
-
-\subsection{Lookup-Table Speed}
+\subsection{Lookuptabellen Geschwindigkeit}
 
 \begin{tabular}{l | l | l}
-rho-values  & step  & time (in seconds) \\ \hline\hline
+Rho-werte  & Schrittweite & Zeit zum einlesen (in sekunden) \\ \hline\hline
 1500000     & 1     & 8.07  \\
 750000      & 2     & 4.4   \\
 375000      & 4     & 2.26  \\
@@ -33,21 +26,16 @@ rho-values  & step  & time (in seconds) \\ \hline\hline
 93750       & 16    & 0.76  \\
 \end{tabular}
 
-The correlation between the number of stars generated and the time needed ist
-clearly linear.
-
-\paragraph{Python script} ~\\
-\lstset{language=Python}
-\begin{lstlisting}[frame = single]
-import matplotlib.pyplot as plt
-
-list_time = [8.07, 4.4, 2.26, 1.35, 0.76]
-list_rho_values = [1500000, 750000, 375000, 187500, 93750]
-
-plt.plot(list_time, list_rho_values, '-ro')
-plt.show()
-\end{lstlisting}
+Hier ist klar zu sehen, dass es eine lineare korrelation zwischen der Anzahl
+an generierten Werten und der Zeit gibt.
 
-\subsection{Distortion of Galaxies}
+\subsection{Fazit}
 
-Galaxien verformen dinge
+Insgesamt betrachtet kann ich behaupten das das Projekt ein voller Erfolg war:
+Ich habe unglaublich viele neue sachen gelernt und dabei ein Funktionierendes
+Program zur visualisierung von Galaxien und DUnkler Materie Gebaut. Dabei bekam
+ich einblicke in die verschiedensten Teilgebiete der Physik, AstroPhysik, Matematik
+und Informatik. Viele dieser Themen konnte ich jedoch aufgrund ihrer Komplexität
+nur in geringen maßen nutzen, weshalb ich mich in der Zukunft gerne damit
+auseinander setzen würde. Ein Beispiel hierfür sind die Neuronalen Netze welche
+ein enormes Potential haben welches ich unbedingt nutzen möchte.
diff --git a/langfassung/docs/5_quellen.tex b/langfassung/docs/5_quellen.tex
index f928fa3..9932028 100644
--- a/langfassung/docs/5_quellen.tex
+++ b/langfassung/docs/5_quellen.tex
@@ -1,5 +1,3 @@
-Quellen
-
 \begin{center}
  \textbf{
   Das Python-Programm sowie die Blender Darstellungen wurden vollständig ohne fremde Hilfe selber erstellt.
@@ -9,12 +7,14 @@ Quellen
 \par Das Programieren in der Programiersprache Python habe ich während meines Jugen-Forscht Projektes im letztem Jahr (2017) gelernt. Mit dem Umgang des 3D-Programms Blender
 bin ich schon vertraut gewesen. Die Grundlagen für \LaTeX, in dem diese Langfassung geschrieben wurde, erlernte ich durch das Studieren diverser Beiträge in Foren und der Einsicht
 in das Jugend Forscht Projekt von Konstantin Bosbach, Tilman Hoffbauer und Steffen Ritsche (2016, Underwater Accoustic Communication).
-
+Die Einführung in die Mathematik bekam ich während meines Praktikums im Zentrum Für Astronomie in Heidelberg durch Tim Tugendhat.
 \raggedleft
 \section*{Dank gilt...}
 \paragraph{Herrn Jörg Thar} meinem Betreuer
+\paragraph{Tim Tugendhat} der mir es ermöglichte ein Praktikum im Astronomischen Recheninstitut zu machen.
 \paragraph{Konstantin Bosbach} welcher mir eine Möglichkeit gab für 2 Wochen in Heidelberg zu wohnen.
-\paragraph{Tilman Hoffbauer} der bei problemen bereit war Licht ins Dunkle zu bringen.
+\paragraph{Tilman Hoffbauer} der bei Problemen bereit war Licht ins Dunkle zu bringen.
+
 
 \centering
 \vspace{0.5cm} \textbf{Außerdem gilt mein Dank allen, die mich auf jede nur erdenkliche Weise unterstützt haben.}