
\begin{ger}
\section*{Vorwort}
In Version 3.0 wurde ein neuer Formalismus dem \FAFormalism-Plugin hinzugef\"ugt, der \FAAutomatonCompiler.
Der bereits existierende Formalismus wurde zu \FANetCompiler~umbenannt.
Beide Formalismen werden in ihren jeweiligen Kapiteln beschrieben.
Beide Formalismen simulieren \textit{fa}-Zeichnungen, die vom \FA-Plugin erzeugt wurden.
\end{ger}

\begin{eng}
\section*{Preamble}

In version 3.0, a new formalism was added to the \FAFormalism ~plugin, the \FAAutomatonCompiler.
The existing formalism was renamed to \FANetCompiler.
Each formalism is described in its own section.
Both formalisms allow for simulating \textit{fa}-drawings created by the \FA~plugin.
\end{eng}

\begin{ger}
	\section*{\FANetCompiler}
\end{ger}

\begin{eng}
	\section*{\FANetCompiler}
\end{eng}

\begin{ger}
\subsection*{Einleitung}

In den folgenden Seiten wird die Benutzung des \FANetCompiler s beschrieben.
Dieser Formalismus interpretiert Kantenanschriften als Java-Ausdr\"ucke, \textit{guards}, Up- oder Downlinks.
Andere Anschriften haben keine Bedeutung f\"ur die Simulation.
Eine Zeichnung mit Beispielen f\"ur die verschiedenen Anschriften befindet sich im \textit{samples}-Ordner des \FA-Plugins.

Mit dem \FANetCompiler~ k\"onnen einfache Automatenmodelle
\footnote{Einfache Automatenmodelle sind hier diese, die keine Sprachen akzeptieren, sondern nur Zustandswechsel unabh\"angig von W\"ortern oder Kantenanschriften visualisieren.}
und Automaten im Multi-Formalismus simuliert werden.

Im Folgenden wird der Ablauf des Erstellens eines simulierf\"ahigen \emph{multiformalismen} Systems
\footnote{Mit \emph{multiformalismen System} sei hier eine Menge zusammenarbeitender Modelle gemeint, die mehr als einen Formalismus verwenden.}
beschrieben.
Das anschlie\ss ende Starten der Simulation ist ebenfalls Bestandteil dieses Kapitels.
Die Anleitung beschreibt das Vorgehen anhand eines multiformalismen Systems bestehend aus Modellen, die den Automaten- und den Referenznetzformalismus verwenden.

Die Durchf\"uhrung der Simulation einfacher Automatenmodelle wird nicht thematisiert.
Eine Anleitung zum Zeichnen von Automatenmodellen findet sich in dem Handbuch des zugeh\"origen \FA~Plugins.
\end{ger}

\begin{eng}
\subsection*{Introduction}

On the following pages, you will learn about the usage of the \FANetCompiler.
This formalism interprets arcs as Java-expressions, \textit{guards}, up- or downlinks.
Other arc inscriptions have no effect on the simulation.
A drawing with examples for the different kinds of arc inscriptions can be found within the \textit{samples}-directory of
the \FA~plugin.

The \FANetCompiler~allows the simulation of simple automaton
\footnote{Simple automaton refers to automaton which do not accept a language, but only visualize state transitions, regardless of arc inscriptions.}
and automaton in a multi-formalism setting.

The following subsections describe the creation of a simulatable \emph{multiformalism} system
\footnote{With \emph{multiformalism system} a set of cooperating models that use more than one formalism is meant.}
.
Also, the subsequent start of a simulation thereof is covered.
All explanations are given with an example of a multiformalism system which consists of models using the reference net and the finite automata formalism.

Simulations of simple automata models are not part of this user guide.
A comprehensive guide on drawing automata models can be found in the user guide of the corresponding \FA~plugin.
\end{eng}

%----

\begin{ger}
\subsection*{Simulationsvorbereitung}

\begin{enumerate}
  \item Zeichnen der Diagramme
    \begin{itemize}
      \item Automatenmodell(e)
      \item Referenznetzmodell(e)
    \end{itemize}

  \item Speichern der Diagramme

  \item W\"ahlen des Referenznetz-Compilers
    \begin{itemize}
      \item W\"ahlen des JavaNetCompilers unter \begin{snugshade*}\texttt{Simulation $\blacktriangleright$ Formalism}\end{snugshade*}
    \end{itemize}

\begin{minipage}{\textwidth}
  \item Exportieren des/der Referenznetzes/Referenznetze zu ShadowNetSystem
    \begin{itemize}
      \item \"uber~\begin{snugshade*}\texttt{File $\blacktriangleright$ Export $\blacktriangleright$ Export current drawing $\blacktriangleright$ ShadowNetSystem \newline
          current drawing} \end{snugshade*}
    \end{itemize}
\end{minipage}

  \item Vorbereiten der Simulation
    \begin{itemize}
      \item Schlie\ss en des/der Referenznetzes/Referenznetze
      \item W\"ahlen des \FANetCompiler s unter \begin{snugshade*}\texttt{Simulation $\blacktriangleright$ Formalism}\end{snugshade*}
    \end{itemize}
\end{enumerate}
\end{ger}

\begin{eng}
\subsection*{Simulation setup}

\begin{enumerate}
  \item Draw the diagrams
    \begin{itemize}
      \item Automata model(s)
      \item Reference net model(s)
    \end{itemize}

  \item Save the diagrams

  \item Select the reference net compiler
    \begin{itemize}
      \item Select the JavaNetCompiler via \begin{snugshade*}\texttt{Simulation $\blacktriangleright$ Formalism}\end{snugshade*}
    \end{itemize}

\begin{minipage}{\textwidth}
  \item Export the reference net(s) to ShadowNetSystem
    \begin{itemize}
      \item Via~\begin{snugshade*}\texttt{File $\blacktriangleright$ Export $\blacktriangleright$ Export current drawing $\blacktriangleright$ ShadowNetSystem \newline
          current drawing} \end{snugshade*}
    \end{itemize}
\end{minipage}

  \item Prepare the simulation
    \begin{itemize}
      \item Close the reference net(s)
      \item Choose the \FANetCompiler ~via \begin{snugshade*}\texttt{Simulation $\blacktriangleright$ Formalism}\end{snugshade*}
    \end{itemize}
\end{enumerate}
\end{eng}

%----

%----

\begin{ger}
\subsection*{Starten der Simulation}

\begin{itemize}
  \item Starten der Simulation
    \begin{itemize}
      \item Ausf\"uhren des \Renew-Kommandos \texttt{startsimulation}
      \item \begin{snugshade*}\texttt{startsimulation~ pfad/zum/shadowNetSystem.sns \newline referenznetzname -i}\end{snugshade*}
      \item Angabe vom Pfad zur \texttt{.sns} Datei, dem Referenznetznamen und einem optionalen \texttt{-i} Argument
      \item \texttt{-i} bewirkt, dass die Simulation nur initialisiert wird; anschlie\ss end kann die Simulation schrittweise oder vollst\"andig durchlaufen werden
    \end{itemize}
\end{itemize}
\end{ger}

\begin{eng}
\subsection*{Simulation start}
  \begin{itemize}
    \item Execute the \Renew command \texttt{startsimulation}
    \item \begin{snugshade*}\texttt{startsimulation~ pfad/zum/shadowNetSystem.sns \newline referenznetzname -i}\end{snugshade*}
    \item Supply the command with the path to the \texttt{.sns} file, the reference nets name and the optional \texttt{-i} option
    \item Option \texttt{-i} causes the simulation to be initialized; it can then subsequently be stepped through or run through in a whole step
  \end{itemize}
\end{eng}

%----

\begin{ger}
\subsection*{Betrachten der Modelle w\"ahrend der Simulation}
Das soeben geschilderte Vorgehen f\"uhrt zur Simulation ohne graphische Darstellung.
M\"ochte man den Ablauf der Simulation ansehen, dann sind folgende Schritte im Anschluss an das obige Vorgehen durchzuf\"uhren.

\begin{enumerate}
  \item \"Offnen des Referenznetzes zur graphischen Darstellung
  \item Anzeigen des Simulation Logs
    \begin{itemize}
      \item \"Uber das Tastenk\"urzel \texttt{Ctrl+L} ist dies m\"oglich
      \item Alternativ \"uber \begin{snugshade*}\texttt{Simulation $\blacktriangleright$ show simulation trace}\end{snugshade*}
    \end{itemize}
  \item Anzeigen einer Netzinstanz/Automateninstanz
    \begin{itemize}
      \item \"Uber einen Rechtsklick auf die Zeile \texttt{New net instance \dots created} und W\"ahlen von \texttt{show net instance}
      \item Alternativ \"uber Doppelklick auf eine Referenz im graphischen Modell
    \end{itemize}
\end{enumerate}
\end{ger}

\begin{eng}
\subsection*{View the simulation while running}
The previously explained actions let you simulate your models without a graphical representation.
To be able to view the simulation while its running, you need to do the following steps after starting the simulation as explained before.

\begin{enumerate}
  \item Open the reference net in \Renew
  \item View the simulation log
    \begin{itemize}
      \item Via hot key \texttt{Ctrl+L}
      \item Alternatively via \begin{snugshade*}\texttt{Simulation $\blacktriangleright$ show simulation trace}\end{snugshade*}
    \end{itemize}
  \item View the net or automata instance
    \begin{itemize}
      \item Via right clicking on the line \texttt{New net instance \dots created} and selecting \texttt{show net instance}
      \item Alternatively via double clicking on a reference in a diagram of the simulation
    \end{itemize}
\end{enumerate}
\end{eng}

\newpage

\begin{ger}
\section*{\FAAutomatonCompiler}
\end{ger}

\begin{eng}
\section*{\FAAutomatonCompiler}
\end{eng}

\begin{ger}
\subsection*{Einleitung}
Dieses Kapitel beschreibt die Benutzung des \FAAutomatonCompiler s.
In diesem Formalismus werden Kantenanschriften als Buchstaben interpretiert.
Kanten k\"onnen dementsprechend nur mit einzelnen Buchstaben beschriftet werden, wobei mehrere einzelne Buchstaben mit einem Komma getrennt werden m\"ussen.
Kanten ohne Anschriften werden als $\varepsilon$-Kanten interpretiert.
F\"ur PDAs ist die Syntax wie folgt: "x,y->z", wobei x, y und z einzelne Buchstaben oder Ziffern sind.
Mehrere Zustands\"uberf\"uhrungen werden in einer neuen Zeile notiert.
Sind Symbole nicht angegeben, wird stattdessen ein $\varepsilon$ genommen.
F\"ur PDAs ist eine minimale Anschrift somit ",->".

Die simulierten Automaten k\"onnen sowohl W\"orter verarbeiten, als auch aufbauen.
Zum jetzigen Zeitpunkt wird die Simulation von NFAs und B\"uchi-Automaten unterst\"utzt.
Die Simulation kann sowohl automatisch, als auch manuell erfolgen.
Die n\"achsten Unterkapitel erkl\"aren diese verschiedenen Optionen und wie sie eingestellt werden k\"onnen.
\end{ger}

\begin{eng}
\subsection*{Introduction}
This chapter describes the usage of the \FAAutomatonCompiler.
In this formalism, arc inscriptions are interpreted as letters.
Arcs, therefore, can only be inscribed with single letters, which may be separated with commas.
If no letters are specified, epsilon is assumed.
For PDAs, the syntax is of the form "x,y->z", where x, y and z are single letters or numbers.
Multiple rules are expected to be separated by a new line.
A space or the empty string '' is considered as an epsilon.
For PDAs, the minimal inscription is therefore ",->".
Arcs without any inscriptions are interpreted as $\varepsilon$-arcs.


The simulated automaton can process words, or build them up.
As of this release, the simulation of NFAs and Buechi-automatons is supported.
The simulation may be automatic or manual.
The next subsections will explain the effect of these different options and how they can be selected.
\end{eng}

\begin{ger}
	\subsection*{Syntax von Ausdr\"ucken}
	Der Nutzer kann einem Startzustand einen ($\omega$-)regul\"aren Ausdruck hinzuf\"ugen.
	Dieser muss einer gewissen Syntax folgen.
	Ein syntaktisch korrekter Ausdruck $r$ is dabei wie folgt definiert:
	\begin{itemize}
		\item $r$ besteht aus einem einzelnen Buchstaben [0-9a-zA-Z] oder ist der leere String "".\\
		Beispiel: $r = a$
		\item $r$ besteht aus einer Aneinanderreihung von regul\"aren Ausdr\"ucken $r_1$ und $r_2$.\\
		Beispiel: $r=r_1r_2$
		\item $r$ beschreibt eine Kleenesche H\"ulle.\\
		Beispiel: $r\textasciicircum ^*$ oder $r^*$
		\item $r$ beschreibt eine positive H\"ulle.\\
		Beispiel: $r\textasciicircum +$
		\item $r$ beschreibt einen $\omega$-Abschluss.\\
		Beispiel: $r\textasciicircum ^\circ$ oder $r^\circ$
		\item $r$ ist die Vereinigung zweier regul\"arer Ausdr\"ucke $r_1$ und $r_2$.\\
		Beispiel: $r=r_1+r_2$ oder $r=r_1\vert r_2$
		\item $r$ kann geklammert sein.\\
		Beispiel: $(r)$
	\end{itemize}
\end{ger}

\begin{eng}
	\subsection*{Syntax of Expressions}
	The user can add a ($\omega$-)regular expression to a start state.
	This expression must be syntactically correct.
	A correct expression $r$ is defined as:
	\begin{itemize}
		\item $r$ is a single letter [0-9a-zA-Z] oder the empty string $\grqq\grqq$.\\
		Example: $r=a$
		\item $r$ is a concatenation of regular expressions $r_1$ and $r_2$.\\
		Example: $r=r_1r_2$
		\item $r$ describes a Kleene star.\\
		Example: $r\textasciicircum *$ or $r*$
		\item $r$ describes a Kleene plus.\\
		Example: $r\textasciicircum +$
		\item $r$ describes an $\omega$-closure.\\
		Example: $r\textasciicircum ^\circ$ or $r^\circ$
		\item $r$ is a union over two regular expressions $r_1$ and $r_2$.\\
		Example: $r=r_1+r_2$ or $r=r_1\vert r_2$
		\item $r$ is bracketed.\\
		Example: $(r)$
	\end{itemize}
\end{eng}

\begin{ger}
\subsection*{Einstellungen}
Einstellungen, die den \FAAutomatonCompiler~betreffen, k\"onnen nur get\"atigt werden, wenn dieser als Formalismus gesetzt ist und keine Simulation l\"auft.
\begin{enumerate}
	\item W\"ahle den \FAAutomatonCompiler~aus unter \\
	\begin{snugshade*}\texttt{Simulation $\blacktriangleright$ Formalisms $\blacktriangleright$ FA Automaton Compiler}\end{snugshade*}
	\item \"Offne die Einstellungen unter\\
	\begin{snugshade*}\texttt{Tools $\blacktriangleright$ FA Drawing Tools $\blacktriangleright$ FA Simulation Settings}\end{snugshade*}
\end{enumerate}
Hierdurch wird ein neues Fenster ge\"offnet, in welchem die Einstellungen get\"atigt werden k\"onnen.
Das Ausw\"ahlen der Einstellungen setzt diese sofort, ein "Speichern" der Einstellungen ist nicht notwendig.
\end{ger}

\begin{eng}
\subsection*{Settings}
Settings regarding the \FAAutomatonCompiler~can only be chosen, if the correct formalism is set and no simulation is running.
\begin{enumerate}
	\item Select the \FAAutomatonCompiler~via \\
	\begin{snugshade*}\texttt{Simulation $\blacktriangleright$ Formalisms $\blacktriangleright$ FA Automaton Compiler}\end{snugshade*}
	\item Open the settings menu via\\
	\begin{snugshade*}\texttt{Tools $\blacktriangleright$ FA Drawing Tools $\blacktriangleright$ FA Simulation Settings}\end{snugshade*}
\end{enumerate}
A new window has opened, which allows the selection of different options and settings.
Selecting an option automatically sets it, "saving" the options is not nessecary.
\end{eng}

\begin{ger}
\subsection*{Verarbeitung vs. Aufbau eines Ausdruckes}
In dem Settings-Men\"u kann zwischen zwei verschiedenen Modi gewechselt werden.
Im \textit{Simulate Word} Modus verarbeitet der Automat einen vom Nutzer hinzugef\"ugten ($\omega$-)regul\"aren Ausdruck.
Kanten k\"onnen nur traversiert werden, wenn der Ausdruck ein Wort enth\"alt, welches mit dem Buchstaben der Kantenbeschriftung beginnt.
F\"ur PDAs muss zudem das oberste Element des Stacks dem Buchstaben in der Inschrift \"ubereinstimmen, wenn dieser nicht leer ist.
Beim Zustandswechsel wird dieser Buchstabe konsumiert, wodurch sich der Ausdruck \"andern kann und der Stack wird entsprechend der Inschrift aktualisiert.
Ein Beispiel hierf\"ur w\"are der regul\"are Ausdruck $(a+b)\textasciicircum +$.
Mit diesem k\"onnen Kanten traversiert werden, die entweder keine Anschrift haben ($\varepsilon$-Kanten), ein $a$, ein $b$, oder $a, b$ als Anschrift haben.
Wenn die Kante keine $\varepsilon$-Kante ist, wird der Ausdruck entweder als $a(a+b)\textasciicircum ^*$ oder $b(a+b)\textasciicircum ^*$ interpretiert.
Der erste Buchstabe wird beim Zustandswechsel konsumiert, der resultierende Ausdruck w\"are also $(a+b)\textasciicircum ^*$.
Wenn der Ausdruck das leere Wort enth\"alt und ein Endzustand erreicht wurde, wird in gr\"uner Farbe signalisiert, dass der Automat den Ausdruck akzeptiert.

Im \textit{Build Word} Modus kann jede Kante immer traversiert werden.
Bei PDAs kann nur jede Kante traversiert werden, die den Stack richtig aktualisiert.
Die Kantenanschrift wird dabei dem bestehenden Wort angef\"ugt und f\"ur PDAs wird der Stack aktualisiert".
\end{ger}

\begin{eng}
\subsection*{Simulate vs Build Word Mode}
In the settings menu, one of two modes may be chosen.
In the \textit{Simulate Word} mode, the automaton processes an expression that was added by the user.
Arcs may only be traversed if the expression contains a word that starts with the same letter as the arc is inscribed with.
Additionally, for PDAs, the element on the top of the stack needs to be the same letter as the arc's inscription's stack instruction.
By changing the state, the first letter of the expression is consumed, thereby possibly changing the expression and the stack is updated accordingly.
An example of this would be $(a+b)\textasciicircum +$.
This expression makes it possible to traverse arcs without an inscription ($\varepsilon$-arcs), or arcs inscribed with $a$, $b$, or $a,b$.
If the arc is not $\varepsilon$-arc, the expression will be interpreted as either $a(a+b)\textasciicircum ^*$ or $b(a+b)\textasciicircum ^*$.
The first letter is consumed when traversing the arc, the resulting expression is $(a+b)\textasciicircum ^*$.
If the expression contains the empty string and an end state has been reached, the state is highlighted in green to signal the acceptance of the expression by the automaton.

In the \textit{Build Word}, every arcs can always be traversed.
For PDAs, every arc can only be traversed if the stack can be updated correctly according to the inscription.
The arc's inscription will be concatenated to the existing word and for PDAs the stack is updated.
\end{eng}

\begin{ger}
\subsection*{Selektion des Automaten}
Das Settings-Men\"u erlaubt es dem Nutzer, den gew\"unschten Automatentypen auszuw\"ahlen.
Zum jetzigen Zeitpunkt werden NFAs, PDAs und B\"uchi-Automaten unterst\"utzt.

Die Syntaxpr\"ufung der Ausdr\"ucke orientiert sich an dem selektierten Automatenmodell.
Wird der Automat als NFA interpretiert, darf der hinzugef\"ugte Ausdruck keinen $\omega$-Abschluss enthalten.
Wird der Automat hingegen als B\"uchi-Automat interpretiert, muss jedes durch den Ausdruck beschriebene Wort auf einen $\omega$-Abschluss enden.
\end{ger}

\begin{eng}
\subsection*{Selection of the automaton}
The settings menu allows the user to select which automaton model the drawing is to be interpreted as.
Currently, NFAs and Buechi automatons are supported.

The syntax check of the expressions takes the selected automaton type into account.
If the drawing is interpreted as an NFA, the expression may not contain an $\omega$ closure.
If, on the contrary, the Buechi model is chosen, every word described by the expression must end on an $\omega$ closure.
\end{eng}

\begin{ger}
\subsection*{Manuelle Simulation}
Der Nutzer kann in dem Settings-Men\"u zwischen einer manuellen und automatischen Simulation w\"ahlen.
Beide Simulationsarten k\"onnen \"uber \Renew s Simulationsmen\"u mit \textit{Run Simulation} (\textit{Strg + R}) oder \textit{Simulation (Net) Step} (Strg (+ Umschalt) + I) gestartet werden.

Bei der manuellen Simulation m\"ussen Kanten per Rechtsklick aktiviert werden, um einen Zustandswechsel hervorzurufen, unabh\"angig von \Renew s gew\"ahlter Simulation.
Bei der automatischen Simulation mit \textit{Run Simulation} werden Kanten automatisch und zuf\"allig durchlaufen, solange es m\"oglich ist.
Wird die Simulation als \textit{Simulation (Net) Step} gestartet, k\"onnen die Kanten per Rechtsklick gezielt traversiert werden, oder zuf\"allig und einzeln mit \textit{Strg + I}.

Die automatische Simulation ist nur f\"ur den \textit{Simulate Word} Modus m\"oglich.
F\"ur den \textit{Build Word} Modus kann nur eine manuelle Simulation gestartet werden, da eine automatische Simulation nach kurzer Zeit zu einem Stack-Overflow f\"uhren w\"urde.
\end{ger}

\begin{eng}
\subsection*{Manual simulation}
In the settings menu, the user can choose between a manual or automatic simulation.
Both types of simulation can be initialized via \Renew's simulation menu with \textit{Run simulation} (Ctrl + R) or \textit{Simulation (Net) Step} (Ctrl (+ Shift) + I).

In the manual simulation, the user has to activate and traverse arcs by selecting them with a right click, independent of \Renew's chosen simulation.
If an automatic simulation is chosen and started with \textit{Run simulation}, the arcs are traversed randomly and as long as possible.
If the automatic simulation is started as \textit{Simulation (Net) Step}, the arcs can be traversed both by right clicking them and \textit{Crtl + I}.

The automatic simulation is only enabled for the \textit{Simulate Word} mode.
The \textit{Build Word} mode only allows for manual simulations, since an automatic simulation would quickly lead to a stack overflow (due to the length of the word).
\end{eng}