{"id":22105162,"url":"https://github.com/ghackenberg/kurs-computer-simulation","last_synced_at":"2025-07-04T01:04:57.045Z","repository":{"id":257971781,"uuid":"867124177","full_name":"ghackenberg/kurs-computer-simulation","owner":"ghackenberg","description":"Unterlagen für meinen Kurs in Computer-Simulation an der Fakultät für Technik und angewandte Naturwissenschaften der FH OÖ.","archived":false,"fork":false,"pushed_at":"2024-11-13T12:32:22.000Z","size":1943,"stargazers_count":6,"open_issues_count":0,"forks_count":2,"subscribers_count":1,"default_branch":"main","last_synced_at":"2025-07-04T01:04:30.210Z","etag":null,"topics":["computer-simulation","course","course-material","simulation"],"latest_commit_sha":null,"homepage":"","language":"C#","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"other","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/ghackenberg.png","metadata":{"files":{"readme":"README.md","changelog":"CHANGELOG.md","contributing":"CONTRIBUTING.md","funding":null,"license":"LICENSE.md","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null}},"created_at":"2024-10-03T13:47:24.000Z","updated_at":"2024-11-25T09:53:13.000Z","dependencies_parsed_at":"2024-10-28T08:55:58.697Z","dependency_job_id":"e8564d20-f387-4131-8e36-09baa41155b9","html_url":"https://github.com/ghackenberg/kurs-computer-simulation","commit_stats":null,"previous_names":["ghackenberg/kurs-computer-simulation"],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/ghackenberg/kurs-computer-simulation","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/ghackenberg%2Fkurs-computer-simulation","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/ghackenberg%2Fkurs-computer-simulation/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/ghackenberg%2Fkurs-computer-simulation/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/ghackenberg%2Fkurs-computer-simulation/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/ghackenberg","download_url":"https://codeload.github.com/ghackenberg/kurs-computer-simulation/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/ghackenberg%2Fkurs-computer-simulation/sbom","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":263427303,"owners_count":23464842,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["computer-simulation","course","course-material","simulation"],"created_at":"2024-12-01T06:39:01.311Z","updated_at":"2025-07-04T01:04:56.962Z","avatar_url":"https://github.com/ghackenberg.png","language":"C#","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Kurs in Computer-Simulation\n\n![](./Grafiken/Social-Preview.png)\n\nDieses Repository enthält Beispiele zum Thema Computer-Simulation, welche an der [Fakultät für Technik und angewandte Naturwissenschaften](https://fh-ooe.at/campus-wels) (engl. *School of Engineering*) der [Fachhochschule Oberösterreich](https://www.fh-ooe.at/) entwickelt wurden. Die Beispiele verwenden\n\n* die Programmiersprache **C#** für die Umsetzung der Datenstrukturen und Algorithmen sowie\n* das Framework **Windows Presentation Foundation (WPF)** für die Erstellung grafischer Benutzerschnittstellen.\n\nDes Weiteren verwenden wir für die Umsetzung der Beispiele einige vorgefertigte Bibliotheken, welche **grundlegende Funktionen für Berechnung** bereistellen. Die wichtigsten Bibliotheken sind\n\n* **Math.NET Numerics** für die Lösung linearer Gleichungssysteme,\n* **SimSharp** für die Simulation ereignisdiskreter Modelle,\n\nSchließlich nutzen wir auch einige vorgefertige Bibliotheken für die **Visualisierung der Daten**, welche durch die Simulationsprogramme verwaltet und berechnet werden. Die wichtigsten Bibliotheken sind\n\n* **ScottPlott** für die Erstellung von Diagrammen, und\n* **SharpGL** für die Erstellung von 3D-Visualisierungen.\n\nDer folgende Inhalt ist in drei Abschnitte untergliedert:\n\n1. **Modelle** (Übersicht die Simulationsmodelle und -programme)\n1. **Vorlagen** (Übersicht der Vorlagen für 2D- und 3D-Visualisierung)\n1. **Dokumente** (Übersicht der Dokumente rund um das Repository und den Quelltext)\n\n## 1. Modelle\n\nGrundsätzlich kann man zwischen statischen und dynamischen Modellen unterscheiden:\n\n1. **Statische Modelle** (Betrachtung eines einzelnen stabilen Systemzustands)\n1. **Dynamische Modelle** (Betrachtung der Änderung des Systemzustands über die Zeit)\n\n### 1.1. Statische Modelle\n\nStatische Modelle betrachten Systemzustände, bei denen es ohne externe Einwirkung zu keiner Zustandsänderung kommt.\nBei solchen Modellen sind typischerweise einige Zustandseigenschaften bekannt, andere jedoch nicht.\nDas Systemmodell beschreibt dann den Zusammenhang zwischen den bekannten und den unbekannten Zustandseigenschaften.\nSimulationsprogramme sind nun dafür verantwortlich, die *unbekannten* Zustandseigenschaften aus den bekannten zu berechnen.\n\nAls Beispiel für statische Modelle betrachten wir im Folgenden das Konzept der **Fachwerke** aus der Bautechnik.\nEin Fachwerk ist ein System bestehend aus Knoten, die über Stäbe miteinander verbunden sind.\nDes Weiteren sind einige der Knoten gelagert, d.h. deren Position im Raum ist fixiert.\nDabei können entweder alle Richtungungen oder nur eine Teilmenge der Richtungen fixiert sein.\nSchließlich wirken auf die Knoten noch externe Kräfte in eine oder mehrere Richtungen.\n\nIm Folgenden betrachten wir zwei Arten, wie Fachwerke modelliert werden können:\n\n1. **Ideales 2D-Fachwerk** (die Länge der Stäbe ändert sich *nicht* unter Druck/Zug)\n1. **Elastisches 2D-Fachwerk** (die Länge der Stäbe ändert sich unter Druck/Zug)\n\n#### [Ideales 2D-Fachwerk](./Quellen/StatischFachwerkIdeal2D/)\n\nBei einem idealen Fachwerk ist die Annahme, dass es durch externe Kräfte zu *keiner* Verformung des Fachwerks kommt.\nDas heißt anders ausgedrückt, dass die Positionen der Knoten und die Längen der Stäbe unveränderlich sind.\nDie unbekannten Zustandseigenschaften sind somit die Stab- und Lagerkräfte, welche auf Stäbe und gelagerte Knoten wirken.\nDer Zusammenhang zwischen Stab- bzw. Lagerkräften und externen Kräften kann als lineares Gleichungssystem ausgedrückt werden.\nDas lineare Gleichungssystem kann mit Hilfe der Matrixinversion gelöst werden, welche z.B. die Bibliothek [Math.NET Numerics](https://numerics.mathdotnet.com/) implementiert.\n\n![](./Quellen/StatischFachwerkIdeal2D/Screenshot.png)\n\nDie folgende Grafik zeigt das Datenmodell des Programms für die Berechnung der Lager- und Stabkräfte eines einfachen zweidimensionalen Fachwerks.\nÜber die Klasse ``Truss`` können Fachwerke inklusive der darin enthaltenen Knoten, Stäbe, Lager, und externen Kräfte definiert werden.\nDes Weiteren bietet die Klasse ``Truss`` die Methode ``Solve``, welche mittels der Matrixinversion die Stab- und Lagerkräfte berechnet.\nDie Visualisierung erfolgt schließlich mit einem ``DataGrid`` sowie einem ``Canvas``, welche die Windows Presentation Foundation (WPF) bereitstellt.\n\n![](./Quellen/StatischFachwerkIdeal2D/Model.svg)\n\n#### [Elastisches 2D-Fachwerk](./Quellen/StatischFachwerkElastisch2D/)\n\nBei einem elastischen Fachwerk kann sich die Länge der Stäbe durch die Einwirkung einer externen Kraft verändern. Das Modell muss dafür um die Elastizität sowie die Querschnittfläche der Stäbe erweitert werden. Die unbekannten Zustandseigenschaften sind in diesem Fall die Verschiebungen der ungelagerten Knoten sowie die Lagerkräfte, welche an den gelagerten Knoten wirken. Der Zusammenhang zwischen Verschiebungen bzw. Lagerkräften und externen Kräften kann wieder vereinfacht als lineares Gleichungssystem ausgedrückt werden. Die Lösung erfolgt auch wieder mittels Matrixinversion.\n\n![](./Quellen/StatischFachwerkElastisch2D/Screenshot.png)\n\nDie folgende Grafik zeigt das Datenmodell des Simulationsprogramms. Die Klasse `Truss` kann verwendet werden, um Fachwerke zu definieren. Mit der Methode `AddNode(...)` können dem Fachwerk neue Knoten hinzugefügt werden. Dabei müssen die initiale Knotenposition sowie die Lagerung und externe Kräfte angegeben werden. Mit der Methode `AddRod(...)` können dem Fachwerk hingegen neue Stäbe hinzugefügt werden. Dabei müssen die beiden verbundenen Knoten sowie die Elastizität und die Querschnittsfläche angegeben werden. Die Methode `Solve()` berechnet schließlich die Lagerkräfte und Knotenverschiebungen.\n\n![](./Quellen/StatischFachwerkElastisch2D/Model.svg)\n\n### 1.2. Dynamische Modelle\n\nDynamische Modelle betrachten *nicht* einen einzelen stabilen Systemzustand, sondern die Änderung des Systemzustands über die Zeit.\nDafür muss in der Regel ein Startzustand sowie eine Zustandsübergangsfunktion gegeben sein.\nDie Simulation rechnet dann den Zustand des Systems gemäß der Zustandsübergangsfunktion weiter.\nMan kann grundsätzlich zwischen zwei Arten von Modellen unterschieden werden:\n\n1. **Zeitkontinuierliche Modelle** (Modell beschreibt Zustand zu jedem Zeitpunkt)\n1. **Zeitdiskrete Modelle** (Modell beschreibt Zustands nur zu ausgewählten Zeitpunkten)\n\n#### 1.2.1. Zeitkontinuierliche Modelle\n\nZeitkontinuierliche Modelle beschreiben den Zustand des Systems als kontinuierliche (d.h. stetige) Funktion über der Zeitdomäne.\nIn der Regel sind bei dieser Art von Modellen der Startzustand (d.h. Konstanten) sowie die Veränderung des Zustands über die Zeit (d.h. dessen Ableitung nach der Zeit) bekannt.\nUm nun den Zustand des Systems zu einem gewissen Zeitpunkt zu berechnen, muss die Ableitung des Zustands folglich über die Zeit integriert werden.\n\nIn Ausnahmefällen können das Integral dabei analyntisch bestimmt und somit der Systemzustand exakt berechnet werden.\nIm Regelfall ist dies jedoch nicht möglich und das Integral muss näherungsweise mit numerischen Verfahren bestimmt werden.\nDie einfachsten numerischen Verfahren sind das explizite und das implizite Eulerverfahren, welche mit einer festen Schrittweite arbeiten.\nDie Größe dieser Schrittweite wirkt sich dabei direkt auf die Genauigkeit der Schätzung bzw. den numerischen Fehler aus.\n\nIm Folgenden betrachten wir zwei Anwendungsbeispiele, die sich in ihrer Komplexität leicht unterscheiden und für welche die analytischen Lösungen bereits bekannt sind:\n\n1. **1D-Ballwurf** (Anfangsgeschwindigkeit, Anfangsposition und Erdbeschleunigung)\n1. **1D-Federpendel** (Federkonstante, Anfangsbeschleinigung, Anfangsgeschwindigkeit und Anfangsposition)\n\n##### [1D-Ballwurf](./Quellen/DynamischBallwurf1D/)\n\nBeim ersten Beispiel betrachten wir den senkrechten Wurf eines Balles. Die Zustandseigenschaften sind dabei die Position und die Geschwindigkeit des Balles.\nDie Beschleunigung des Balles ist hingegen konstant (und gleich der Erdbeschleunigung).\nDie Geschwindigkeit des Balles ergibt sich somit aus der Anfangsgeschwindigkeit sowie der Integration der Beschleunigung über die Zeit.\nDie Position des Balles ergibt sich hingegen aus der Anfangsposition sowie der Integration der Geschwindigkeit über die Zeit.\n\n![](./Quellen/DynamischBallwurf1D/Screenshot.png)\n\n##### [1D-Federpendel](./Quellen/DynamischFederpendel1D/)\n\nBeim zweiten Beispiel betrachten wird die Schwingung einer gefederten Masse.\nDie Zustandseigenschaften sind dabei die Position, die Beschleunigung, und die Geschwindigkeit der Masse sowie die auf die Masse einwirkende Federkraft.\nDie Masse selbst sowie die Federkonstante sind hingegen unveränderlich.\nDie numerische Integration mit dem expliziten Eulerverfahren erfolgt analog zum vorigen Beispiel.\nDie numerische Integration mit dem impliziten Eulerverfahren ist hingegen etwas komplizierter, weil die Geschwindigkeit von der Position und die Position von der Geschgwindigkeit abhängen.\nAus diesem Grund muss für das implizite Eulerverfahren ein lineares Gleichungssystem gelöst werden, welches Position, Federkraft, Beschleunigung, und Geschwindigkeit in Beziehung setzt.\n\n![](./Quellen/DynamischFederpendel1D/Screenshot.png)\n\n#### 1.2.2. Zeitdiskrete Modelle\n\nBei den zeitdiskreten Modellen können wieder zwei Arten unterschieden werden, die diskreten Zeitschritte durchzuführen:\n\n1. **Fester Zeitschritt** (TODO)\n1. **Variabler Zeitschritt** (TODO)\n\n##### 1.2.2.1. Fester Zeitschritt\n\n*Kommt demnächst.*\n\n##### 1.2.2.2. Variabler Zeitschritt\n\nTODO\n\n1. **Warteschlange** (TODO)\n\n###### [Warteschlange](./Quellen/DynamischWarteschlange/)\n\nTODO\n\n![](./Quellen/DynamischWarteschlange/Screenshot.png)\n\n## 2. Vorlagen\n\nDas Repository enthält auch ein paar Vorlagen, welche du für die Entwicklung deiner eigenen Simulationsprogramme verwenden und auf deine Bedürfnisse anpassen kannst:\n\n* 2D-Visualisierung mit WPF und ScottPlot\n* 3D-Visualisierung mit WPF und SharpGL\n\n### 2.1. [2D-Visualisierung mit **WPF und ScottPlot**](./Quellen/VorlageVisualisierung2D/)\n\nDieses Beispiel zeigt dir, wie du einfache 2D-Diagramme in deinen Simulationsprogrammen erstellen und anzeigen kannst.\nDas Beispiel nutzt dafür das Microsoft WPF Framework für allgemeine grafische Benutzeroberflächen sowie ScottPlot für Diagrammvisualisierungen.\n\n![](./Quellen/VorlageVisualisierung2D/Screenshot.png)\n\n### 2.2. [3D-Visualisierung mit **WPF und SharpGL**](./Quellen/VorlageVisualisierung3D/)\n\nManchmal kann es auch hilfreich sein, 3D-Visualisierungen (z.B. des Systemzustands) in deine Simulationsprogramme zu integrieren.\nDieses Beispiel zeigt dir, wie du solche Visualisierungen mit SharpGL in deine WPF-Anwendungen einfach integrieren kannst.\n\n![](./Quellen/VorlageVisualisierung3D/Screenshot.png)\n\nBei SharpGL kannst du die 3D-Visualisierungen in Form eines Szenengraphen einfach definieren.\nEin Szenengraph beschreibt den Inhalt einer 3D-Visualisierung in Form von Objekten und deren Zusammenhängen.\nDie folgende Grafik zeigt die Klassen, aus welchen sich ein Szenengraph bei SharpGL zusammensetzt, und deren Beziehungen.\n\n![](./Grafiken/SharpGL.SceneGraph.svg)\n\n## 3. Dokumente\n\nHier sind noch ein paar wichtige Dokumente für jeden, der die Beispiele aus diesem Repository gerne nutzen möchte:\n\n* [Änderungen](./CHANGELOG.md)\n* [Beitragen](./CONTRIBUTING.md)\n* [Lizenz](./LICENSE.md)","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fghackenberg%2Fkurs-computer-simulation","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fghackenberg%2Fkurs-computer-simulation","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fghackenberg%2Fkurs-computer-simulation/lists"}